Change is-a.h to support typedefs of pointers

gcc/
	* is-a.h: Update comments to reflect the following changes to the
	"pointerness" of the API, making the template parameter match the
	return type, allowing use of is-a.h with typedefs of pointers.
	(is_a_helper::cast): Return a T rather then a pointer to a T, so
	that the return type matches the parameter to the is_a_helper.
	(as_a): Likewise.
	(dyn_cast): Likewise.

	* cgraph.c (cgraph_node_for_asm): Update for removal of implicit
	pointer from the is-a.h API.

	* cgraph.h (is_a_helper <cgraph_node>::test): Convert to...
	(is_a_helper <cgraph_node *>::test): ...this, matching change to
	is-a.h API.
	(is_a_helper <varpool_node>::test): Likewise, convert to...
	(is_a_helper <varpool_node *>::test): ...this.

	(varpool_first_variable): Update for removal of implicit pointer
	from the is-a.h API.
	(varpool_next_variable): Likewise.
	(varpool_first_static_initializer): Likewise.
	(varpool_next_static_initializer): Likewise.
	(varpool_first_defined_variable): Likewise.
	(varpool_next_defined_variable): Likewise.
	(cgraph_first_defined_function): Likewise.
	(cgraph_next_defined_function): Likewise.
	(cgraph_first_function): Likewise.
	(cgraph_next_function): Likewise.
	(cgraph_first_function_with_gimple_body): Likewise.
	(cgraph_next_function_with_gimple_body): Likewise.
	(cgraph_alias_target): Likewise.
	(varpool_alias_target): Likewise.
	(cgraph_function_or_thunk_node): Likewise.
	(varpool_variable_node): Likewise.
	(symtab_real_symbol_p): Likewise.
	* cgraphunit.c (referred_to_p): Likewise.
	(analyze_functions): Likewise.
	(handle_alias_pairs): Likewise.
	* gimple-fold.c (can_refer_decl_in_current_unit_p): Likewise.
	* gimple-ssa.h (gimple_vuse_op): Likewise.
	(gimple_vdef_op): Likewise.
	* gimple-streamer-in.c (input_gimple_stmt): Likewise.
	* gimple.c (gimple_build_asm_1): Likewise.
	(gimple_build_try): Likewise.
	(gimple_build_resx): Likewise.
	(gimple_build_eh_dispatch): Likewise.
	(gimple_build_omp_for): Likewise.
	(gimple_omp_for_set_clauses): Likewise.

	* gimple.h (is_a_helper <gimple_statement_asm>::test): Convert to...
	(is_a_helper <gimple_statement_asm *>::test): ...this.
	(is_a_helper <gimple_statement_bind>::test): Convert to...
	(is_a_helper <gimple_statement_bind *>::test): ...this.
	(is_a_helper <gimple_statement_call>::test): Convert to...
	(is_a_helper <gimple_statement_call *>::test): ...this.
	(is_a_helper <gimple_statement_catch>::test): Convert to...
	(is_a_helper <gimple_statement_catch *>::test): ...this.
	(is_a_helper <gimple_statement_resx>::test): Convert to...
	(is_a_helper <gimple_statement_resx *>::test): ...this.
	(is_a_helper <gimple_statement_eh_dispatch>::test): Convert to...
	(is_a_helper <gimple_statement_eh_dispatch *>::test): ...this.
	(is_a_helper <gimple_statement_eh_else>::test): Convert to...
	(is_a_helper <gimple_statement_eh_else *>::test): ...this.
	(is_a_helper <gimple_statement_eh_filter>::test): Convert to...
	(is_a_helper <gimple_statement_eh_filter *>::test): ...this.
	(is_a_helper <gimple_statement_eh_mnt>::test): Convert to...
	(is_a_helper <gimple_statement_eh_mnt *>::test): ...this.
	(is_a_helper <gimple_statement_omp_atomic_load>::test): Convert to...
	(is_a_helper <gimple_statement_omp_atomic_load *>::test): ...this.
	(is_a_helper <gimple_statement_omp_atomic_store>::test): Convert to...
	(is_a_helper <gimple_statement_omp_atomic_store *>::test): ...this.
	(is_a_helper <gimple_statement_omp_return>::test): Convert to...
	(is_a_helper <gimple_statement_omp_return *>::test): ...this.
	(is_a_helper <gimple_statement_omp_continue>::test): Convert to...
	(is_a_helper <gimple_statement_omp_continue *>::test): ...this.
	(is_a_helper <gimple_statement_omp_critical>::test): Convert to...
	(is_a_helper <gimple_statement_omp_critical *>::test): ...this.
	(is_a_helper <gimple_statement_omp_for>::test): Convert to...
	(is_a_helper <gimple_statement_omp_for *>::test): ...this.
	(is_a_helper <gimple_statement_omp_taskreg>::test): Convert to...
	(is_a_helper <gimple_statement_omp_taskreg *>::test): ...this.
	(is_a_helper <gimple_statement_omp_parallel>::test): Convert to...
	(is_a_helper <gimple_statement_omp_parallel *>::test): ...this.
	(is_a_helper <gimple_statement_omp_target>::test): Convert to...
	(is_a_helper <gimple_statement_omp_target *>::test): ...this.
	(is_a_helper <gimple_statement_omp_sections>::test): Convert to...
	(is_a_helper <gimple_statement_omp_sections *>::test): ...this.
	(is_a_helper <gimple_statement_omp_single>::test): Convert to...
	(is_a_helper <gimple_statement_omp_single *>::test): ...this.
	(is_a_helper <gimple_statement_omp_teams>::test): Convert to...
	(is_a_helper <gimple_statement_omp_teams *>::test): ...this.
	(is_a_helper <gimple_statement_omp_task>::test): Convert to...
	(is_a_helper <gimple_statement_omp_task *>::test): ...this.
	(is_a_helper <gimple_statement_phi>::test): Convert to...
	(is_a_helper <gimple_statement_phi *>::test): ...this.
	(is_a_helper <gimple_statement_transaction>::test): Convert to...
	(is_a_helper <gimple_statement_transaction *>::test): ...this.
	(is_a_helper <gimple_statement_try>::test): Convert to...
	(is_a_helper <gimple_statement_try *>::test): ...this.
	(is_a_helper <gimple_statement_wce>::test): Convert to...
	(is_a_helper <gimple_statement_wce *>::test): ...this.
	(is_a_helper <const gimple_statement_asm>::test): Convert to...
	(is_a_helper <const gimple_statement_asm *>::test): ...this.
	(is_a_helper <const gimple_statement_bind>::test): Convert to...
	(is_a_helper <const gimple_statement_bind *>::test): ...this.
	(is_a_helper <const gimple_statement_call>::test): Convert to...
	(is_a_helper <const gimple_statement_call *>::test): ...this.
	(is_a_helper <const gimple_statement_catch>::test): Convert to...
	(is_a_helper <const gimple_statement_catch *>::test): ...this.
	(is_a_helper <const gimple_statement_resx>::test): Convert to...
	(is_a_helper <const gimple_statement_resx *>::test): ...this.
	(is_a_helper <const gimple_statement_eh_dispatch>::test):
	Convert to...
	(is_a_helper <const gimple_statement_eh_dispatch *>::test):
	...this.
	(is_a_helper <const gimple_statement_eh_filter>::test): Convert
	to...
	(is_a_helper <const gimple_statement_eh_filter *>::test): ...this.
	(is_a_helper <const gimple_statement_omp_atomic_load>::test):
	Convert to...
	(is_a_helper <const gimple_statement_omp_atomic_load *>::test):
	...this.
	(is_a_helper <const gimple_statement_omp_atomic_store>::test):
	Convert to...
	(is_a_helper <const gimple_statement_omp_atomic_store *>::test):
	...this.
	(is_a_helper <const gimple_statement_omp_return>::test): Convert
	to...
	(is_a_helper <const gimple_statement_omp_return *>::test): ...this.
	(is_a_helper <const gimple_statement_omp_continue>::test): Convert
	to...
	(is_a_helper <const gimple_statement_omp_continue *>::test): ...this.
	(is_a_helper <const gimple_statement_omp_critical>::test): Convert
	to...
	(is_a_helper <const gimple_statement_omp_critical *>::test): ...this.
	(is_a_helper <const gimple_statement_omp_for>::test): Convert to...
	(is_a_helper <const gimple_statement_omp_for *>::test): ...this.
	(is_a_helper <const gimple_statement_omp_taskreg>::test): Convert
	to...
	(is_a_helper <const gimple_statement_omp_taskreg *>::test): ...this.
	(is_a_helper <const gimple_statement_omp_parallel>::test): Convert
	to...
	(is_a_helper <const gimple_statement_omp_parallel *>::test): ...this.
	(is_a_helper <const gimple_statement_omp_target>::test): Convert
	to...
	(is_a_helper <const gimple_statement_omp_target *>::test): ...this.
	(is_a_helper <const gimple_statement_omp_sections>::test): Convert
	to...
	(is_a_helper <const gimple_statement_omp_sections *>::test): ...this.
	(is_a_helper <const gimple_statement_omp_single>::test): Convert
	to...
	(is_a_helper <const gimple_statement_omp_single *>::test): ...this.
	(is_a_helper <const gimple_statement_omp_teams>::test): Convert
	to...
	(is_a_helper <const gimple_statement_omp_teams *>::test): ...this.
	(is_a_helper <const gimple_statement_omp_task>::test): Convert
	to...
	(is_a_helper <const gimple_statement_omp_task *>::test): ...this.
	(is_a_helper <const gimple_statement_phi>::test): Convert to...
	(is_a_helper <const gimple_statement_phi *>::test): ...this.
	(is_a_helper <const gimple_statement_transaction>::test): Convert
	to...
	(is_a_helper <const gimple_statement_transaction *>::test): ...this.
	(is_a_helper <const gimple_statement_with_ops>::test): Convert
	to...
	(is_a_helper <const gimple_statement_with_ops *>::test): ...this.
	(is_a_helper <gimple_statement_with_ops>::test): Convert to...
	(is_a_helper <gimple_statement_with_ops *>::test): ...this.
	(is_a_helper <const gimple_statement_with_memory_ops>::test):
	Convert to...
	(is_a_helper <const gimple_statement_with_memory_ops *>::test):
	...this.
	(is_a_helper <gimple_statement_with_memory_ops>::test): Convert
	to...
	(is_a_helper <gimple_statement_with_memory_ops *>::test): ...this.

	(gimple_use_ops): Update for removal of implicit pointer from the
	is-a.h API.
	(gimple_set_use_ops): Likewise.
	(gimple_vuse): Likewise.
	(gimple_vdef): 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_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_body_ptr): Likewise.
	(gimple_bind_set_body): Likewise.
	(gimple_bind_add_stmt): 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_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): Likewise.
	(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_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.

	* ipa-devirt.c (build_type_inheritance_graph): Likewise.
	* ipa-inline-analysis.c (inline_write_summary): Likewise.
	* ipa-ref.c (ipa_record_reference): Likewise.
	* ipa-reference.c (analyze_function): Likewise.
	(ipa_reference_write_optimization_summary): Likewise.
	* ipa.c (symtab_remove_unreachable_nodes): Likewise.
	(address_taken_from_non_vtable_p): Likewise.
	(comdat_can_be_unshared_p_1): Likewise.
	* lto-cgraph.c (lto_output_ref): Likewise.
	(add_references): Likewise.
	(compute_ltrans_boundary): Likewise.
	(output_symtab): Likewise.
	(input_ref): Likewise.
	(input_cgraph_1): Likewise.
	(output_cgraph_opt_summary): Likewise.
	* lto-streamer-out.c (lto_output): Likewise.
	(output_symbol_p): Likewise.
	* lto-streamer.h (lsei_next_function_in_partition): Likewise.
	(lsei_start_function_in_partition): Likewise.
	(lsei_next_variable_in_partition): Likewise.
	(lsei_start_variable_in_partition): Likewise.
	* symtab.c (insert_to_assembler_name_hash): Likewise.
	(unlink_from_assembler_name_hash): Likewise.
	(symtab_unregister_node): Likewise.
	(symtab_remove_node): Likewise.
	(dump_symtab_node): Likewise.
	(verify_symtab_base): Likewise.
	(verify_symtab_node): Likewise.
	(symtab_make_decl_local): Likewise.
	(symtab_alias_ultimate_target): Likewise.
	(symtab_resolve_alias): Likewise.
	(symtab_get_symbol_partitioning_class): Likewise.
	* tree-phinodes.c (allocate_phi_node): Likewise.
	(reserve_phi_args_for_new_edge): Likewise.
	(remove_phi_args): Likewise.
	* varpool.c (varpool_node_for_asm): Likewise.
	(varpool_remove_unreferenced_decls): Likewise.

gcc/lto/
	* lto-partition.c (add_references_to_partition): Update for
	removal of implicit pointer from the is-a.h API.
	(add_symbol_to_partition_1): Likewise.
	(contained_in_symbol): Likewise.
	(undo_partition): Likewise.
	(lto_balanced_map): Likewise.
	(promote_symbol): Likewise.
	* lto-symtab.c (lto_symtab_merge_symbols_1): Likewise.
	(lto_symtab_merge_symbols): Likewise.
	* lto.c (lto_wpa_write_files): Likewise.

From-SVN: r209719

25 files changed, 756 insertions, 355 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index ddebba7..117cdd0 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,391 @@
+2014-04-23  David Malcolm  <dmalcolm@redhat.com>
+
+	* is-a.h: Update comments to reflect the following changes to the
+	"pointerness" of the API, making the template parameter match the
+	return type, allowing use of is-a.h with typedefs of pointers.
+	(is_a_helper::cast): Return a T rather then a pointer to a T, so
+	that the return type matches the parameter to the is_a_helper.
+	(as_a): Likewise.
+	(dyn_cast): Likewise.
+
+	* cgraph.c (cgraph_node_for_asm): Update for removal of implicit
+	pointer from the is-a.h API.
+
+	* cgraph.h (is_a_helper <cgraph_node>::test): Convert to...
+	(is_a_helper <cgraph_node *>::test): ...this, matching change to
+	is-a.h API.
+	(is_a_helper <varpool_node>::test): Likewise, convert to...
+	(is_a_helper <varpool_node *>::test): ...this.
+
+	(varpool_first_variable): Update for removal of implicit pointer
+	from the is-a.h API.
+	(varpool_next_variable): Likewise.
+	(varpool_first_static_initializer): Likewise.
+	(varpool_next_static_initializer): Likewise.
+	(varpool_first_defined_variable): Likewise.
+	(varpool_next_defined_variable): Likewise.
+	(cgraph_first_defined_function): Likewise.
+	(cgraph_next_defined_function): Likewise.
+	(cgraph_first_function): Likewise.
+	(cgraph_next_function): Likewise.
+	(cgraph_first_function_with_gimple_body): Likewise.
+	(cgraph_next_function_with_gimple_body): Likewise.
+	(cgraph_alias_target): Likewise.
+	(varpool_alias_target): Likewise.
+	(cgraph_function_or_thunk_node): Likewise.
+	(varpool_variable_node): Likewise.
+	(symtab_real_symbol_p): Likewise.
+	* cgraphunit.c (referred_to_p): Likewise.
+	(analyze_functions): Likewise.
+	(handle_alias_pairs): Likewise.
+	* gimple-fold.c (can_refer_decl_in_current_unit_p): Likewise.
+	* gimple-ssa.h (gimple_vuse_op): Likewise.
+	(gimple_vdef_op): Likewise.
+	* gimple-streamer-in.c (input_gimple_stmt): Likewise.
+	* gimple.c (gimple_build_asm_1): Likewise.
+	(gimple_build_try): Likewise.
+	(gimple_build_resx): Likewise.
+	(gimple_build_eh_dispatch): Likewise.
+	(gimple_build_omp_for): Likewise.
+	(gimple_omp_for_set_clauses): Likewise.
+
+	* gimple.h (is_a_helper <gimple_statement_asm>::test): Convert to...
+	(is_a_helper <gimple_statement_asm *>::test): ...this.
+	(is_a_helper <gimple_statement_bind>::test): Convert to...
+	(is_a_helper <gimple_statement_bind *>::test): ...this.
+	(is_a_helper <gimple_statement_call>::test): Convert to...
+	(is_a_helper <gimple_statement_call *>::test): ...this.
+	(is_a_helper <gimple_statement_catch>::test): Convert to...
+	(is_a_helper <gimple_statement_catch *>::test): ...this.
+	(is_a_helper <gimple_statement_resx>::test): Convert to...
+	(is_a_helper <gimple_statement_resx *>::test): ...this.
+	(is_a_helper <gimple_statement_eh_dispatch>::test): Convert to...
+	(is_a_helper <gimple_statement_eh_dispatch *>::test): ...this.
+	(is_a_helper <gimple_statement_eh_else>::test): Convert to...
+	(is_a_helper <gimple_statement_eh_else *>::test): ...this.
+	(is_a_helper <gimple_statement_eh_filter>::test): Convert to...
+	(is_a_helper <gimple_statement_eh_filter *>::test): ...this.
+	(is_a_helper <gimple_statement_eh_mnt>::test): Convert to...
+	(is_a_helper <gimple_statement_eh_mnt *>::test): ...this.
+	(is_a_helper <gimple_statement_omp_atomic_load>::test): Convert to...
+	(is_a_helper <gimple_statement_omp_atomic_load *>::test): ...this.
+	(is_a_helper <gimple_statement_omp_atomic_store>::test): Convert to...
+	(is_a_helper <gimple_statement_omp_atomic_store *>::test): ...this.
+	(is_a_helper <gimple_statement_omp_return>::test): Convert to...
+	(is_a_helper <gimple_statement_omp_return *>::test): ...this.
+	(is_a_helper <gimple_statement_omp_continue>::test): Convert to...
+	(is_a_helper <gimple_statement_omp_continue *>::test): ...this.
+	(is_a_helper <gimple_statement_omp_critical>::test): Convert to...
+	(is_a_helper <gimple_statement_omp_critical *>::test): ...this.
+	(is_a_helper <gimple_statement_omp_for>::test): Convert to...
+	(is_a_helper <gimple_statement_omp_for *>::test): ...this.
+	(is_a_helper <gimple_statement_omp_taskreg>::test): Convert to...
+	(is_a_helper <gimple_statement_omp_taskreg *>::test): ...this.
+	(is_a_helper <gimple_statement_omp_parallel>::test): Convert to...
+	(is_a_helper <gimple_statement_omp_parallel *>::test): ...this.
+	(is_a_helper <gimple_statement_omp_target>::test): Convert to...
+	(is_a_helper <gimple_statement_omp_target *>::test): ...this.
+	(is_a_helper <gimple_statement_omp_sections>::test): Convert to...
+	(is_a_helper <gimple_statement_omp_sections *>::test): ...this.
+	(is_a_helper <gimple_statement_omp_single>::test): Convert to...
+	(is_a_helper <gimple_statement_omp_single *>::test): ...this.
+	(is_a_helper <gimple_statement_omp_teams>::test): Convert to...
+	(is_a_helper <gimple_statement_omp_teams *>::test): ...this.
+	(is_a_helper <gimple_statement_omp_task>::test): Convert to...
+	(is_a_helper <gimple_statement_omp_task *>::test): ...this.
+	(is_a_helper <gimple_statement_phi>::test): Convert to...
+	(is_a_helper <gimple_statement_phi *>::test): ...this.
+	(is_a_helper <gimple_statement_transaction>::test): Convert to...
+	(is_a_helper <gimple_statement_transaction *>::test): ...this.
+	(is_a_helper <gimple_statement_try>::test): Convert to...
+	(is_a_helper <gimple_statement_try *>::test): ...this.
+	(is_a_helper <gimple_statement_wce>::test): Convert to...
+	(is_a_helper <gimple_statement_wce *>::test): ...this.
+	(is_a_helper <const gimple_statement_asm>::test): Convert to...
+	(is_a_helper <const gimple_statement_asm *>::test): ...this.
+	(is_a_helper <const gimple_statement_bind>::test): Convert to...
+	(is_a_helper <const gimple_statement_bind *>::test): ...this.
+	(is_a_helper <const gimple_statement_call>::test): Convert to...
+	(is_a_helper <const gimple_statement_call *>::test): ...this.
+	(is_a_helper <const gimple_statement_catch>::test): Convert to...
+	(is_a_helper <const gimple_statement_catch *>::test): ...this.
+	(is_a_helper <const gimple_statement_resx>::test): Convert to...
+	(is_a_helper <const gimple_statement_resx *>::test): ...this.
+	(is_a_helper <const gimple_statement_eh_dispatch>::test):
+	Convert to...
+	(is_a_helper <const gimple_statement_eh_dispatch *>::test):
+	...this.
+	(is_a_helper <const gimple_statement_eh_filter>::test): Convert
+	to...
+	(is_a_helper <const gimple_statement_eh_filter *>::test): ...this.
+	(is_a_helper <const gimple_statement_omp_atomic_load>::test):
+	Convert to...
+	(is_a_helper <const gimple_statement_omp_atomic_load *>::test):
+	...this.
+	(is_a_helper <const gimple_statement_omp_atomic_store>::test):
+	Convert to...
+	(is_a_helper <const gimple_statement_omp_atomic_store *>::test):
+	...this.
+	(is_a_helper <const gimple_statement_omp_return>::test): Convert
+	to...
+	(is_a_helper <const gimple_statement_omp_return *>::test): ...this.
+	(is_a_helper <const gimple_statement_omp_continue>::test): Convert
+	to...
+	(is_a_helper <const gimple_statement_omp_continue *>::test): ...this.
+	(is_a_helper <const gimple_statement_omp_critical>::test): Convert
+	to...
+	(is_a_helper <const gimple_statement_omp_critical *>::test): ...this.
+	(is_a_helper <const gimple_statement_omp_for>::test): Convert to...
+	(is_a_helper <const gimple_statement_omp_for *>::test): ...this.
+	(is_a_helper <const gimple_statement_omp_taskreg>::test): Convert
+	to...
+	(is_a_helper <const gimple_statement_omp_taskreg *>::test): ...this.
+	(is_a_helper <const gimple_statement_omp_parallel>::test): Convert
+	to...
+	(is_a_helper <const gimple_statement_omp_parallel *>::test): ...this.
+	(is_a_helper <const gimple_statement_omp_target>::test): Convert
+	to...
+	(is_a_helper <const gimple_statement_omp_target *>::test): ...this.
+	(is_a_helper <const gimple_statement_omp_sections>::test): Convert
+	to...
+	(is_a_helper <const gimple_statement_omp_sections *>::test): ...this.
+	(is_a_helper <const gimple_statement_omp_single>::test): Convert
+	to...
+	(is_a_helper <const gimple_statement_omp_single *>::test): ...this.
+	(is_a_helper <const gimple_statement_omp_teams>::test): Convert
+	to...
+	(is_a_helper <const gimple_statement_omp_teams *>::test): ...this.
+	(is_a_helper <const gimple_statement_omp_task>::test): Convert
+	to...
+	(is_a_helper <const gimple_statement_omp_task *>::test): ...this.
+	(is_a_helper <const gimple_statement_phi>::test): Convert to...
+	(is_a_helper <const gimple_statement_phi *>::test): ...this.
+	(is_a_helper <const gimple_statement_transaction>::test): Convert
+	to...
+	(is_a_helper <const gimple_statement_transaction *>::test): ...this.
+	(is_a_helper <const gimple_statement_with_ops>::test): Convert
+	to...
+	(is_a_helper <const gimple_statement_with_ops *>::test): ...this.
+	(is_a_helper <gimple_statement_with_ops>::test): Convert to...
+	(is_a_helper <gimple_statement_with_ops *>::test): ...this.
+	(is_a_helper <const gimple_statement_with_memory_ops>::test):
+	Convert to...
+	(is_a_helper <const gimple_statement_with_memory_ops *>::test):
+	...this.
+	(is_a_helper <gimple_statement_with_memory_ops>::test): Convert
+	to...
+	(is_a_helper <gimple_statement_with_memory_ops *>::test): ...this.
+
+	(gimple_use_ops): Update for removal of implicit pointer from the
+	is-a.h API.
+	(gimple_set_use_ops): Likewise.
+	(gimple_vuse): Likewise.
+	(gimple_vdef): 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_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_body_ptr): Likewise.
+	(gimple_bind_set_body): Likewise.
+	(gimple_bind_add_stmt): 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_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): Likewise.
+	(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_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.
+
+	* ipa-devirt.c (build_type_inheritance_graph): Likewise.
+	* ipa-inline-analysis.c (inline_write_summary): Likewise.
+	* ipa-ref.c (ipa_record_reference): Likewise.
+	* ipa-reference.c (analyze_function): Likewise.
+	(ipa_reference_write_optimization_summary): Likewise.
+	* ipa.c (symtab_remove_unreachable_nodes): Likewise.
+	(address_taken_from_non_vtable_p): Likewise.
+	(comdat_can_be_unshared_p_1): Likewise.
+	* lto-cgraph.c (lto_output_ref): Likewise.
+	(add_references): Likewise.
+	(compute_ltrans_boundary): Likewise.
+	(output_symtab): Likewise.
+	(input_ref): Likewise.
+	(input_cgraph_1): Likewise.
+	(output_cgraph_opt_summary): Likewise.
+	* lto-streamer-out.c (lto_output): Likewise.
+	(output_symbol_p): Likewise.
+	* lto-streamer.h (lsei_next_function_in_partition): Likewise.
+	(lsei_start_function_in_partition): Likewise.
+	(lsei_next_variable_in_partition): Likewise.
+	(lsei_start_variable_in_partition): Likewise.
+	* symtab.c (insert_to_assembler_name_hash): Likewise.
+	(unlink_from_assembler_name_hash): Likewise.
+	(symtab_unregister_node): Likewise.
+	(symtab_remove_node): Likewise.
+	(dump_symtab_node): Likewise.
+	(verify_symtab_base): Likewise.
+	(verify_symtab_node): Likewise.
+	(symtab_make_decl_local): Likewise.
+	(symtab_alias_ultimate_target): Likewise.
+	(symtab_resolve_alias): Likewise.
+	(symtab_get_symbol_partitioning_class): Likewise.
+	* tree-phinodes.c (allocate_phi_node): Likewise.
+	(reserve_phi_args_for_new_edge): Likewise.
+	(remove_phi_args): Likewise.
+	* varpool.c (varpool_node_for_asm): Likewise.
+	(varpool_remove_unreferenced_decls): Likewise.
+
 2014-04-23  Jeff Law  <law@redhat.com>
 
 	PR tree-optimization/60902
diff --git a/gcc/cgraph.c b/gcc/cgraph.c
index be3661a..ee192ed 100644
--- a/gcc/cgraph.c
+++ b/gcc/cgraph.c
@@ -674,7 +674,7 @@ cgraph_node_for_asm (tree asmname)
        node;
        node = node->next_sharing_asm_name)
     {
-      cgraph_node *cn = dyn_cast <cgraph_node> (node);
+      cgraph_node *cn = dyn_cast <cgraph_node *> (node);
       if (cn && !cn->global.inlined_to)
 	return cn;
     }
diff --git a/gcc/cgraph.h b/gcc/cgraph.h
index 15310d8..84fc1d9 100644
--- a/gcc/cgraph.h
+++ b/gcc/cgraph.h
@@ -661,7 +661,7 @@ struct GTY(()) asm_node {
 template <>
 template <>
 inline bool
-is_a_helper <cgraph_node>::test (symtab_node *p)
+is_a_helper <cgraph_node *>::test (symtab_node *p)
 {
   return p->type == SYMTAB_FUNCTION;
 }
@@ -671,7 +671,7 @@ is_a_helper <cgraph_node>::test (symtab_node *p)
 template <>
 template <>
 inline bool
-is_a_helper <varpool_node>::test (symtab_node *p)
+is_a_helper <varpool_node *>::test (symtab_node *p)
 {
   return p->type == SYMTAB_VARIABLE;
 }
@@ -1029,7 +1029,7 @@ varpool_first_variable (void)
 {
   symtab_node *node;
   for (node = symtab_nodes; node; node = node->next)
-    if (varpool_node *vnode = dyn_cast <varpool_node> (node))
+    if (varpool_node *vnode = dyn_cast <varpool_node *> (node))
       return vnode;
   return NULL;
 }
@@ -1040,7 +1040,7 @@ varpool_next_variable (varpool_node *node)
 {
   symtab_node *node1 = node->next;
   for (; node1; node1 = node1->next)
-    if (varpool_node *vnode1 = dyn_cast <varpool_node> (node1))
+    if (varpool_node *vnode1 = dyn_cast <varpool_node *> (node1))
       return vnode1;
   return NULL;
 }
@@ -1057,7 +1057,7 @@ varpool_first_static_initializer (void)
   symtab_node *node;
   for (node = symtab_nodes; node; node = node->next)
     {
-      varpool_node *vnode = dyn_cast <varpool_node> (node);
+      varpool_node *vnode = dyn_cast <varpool_node *> (node);
       if (vnode && DECL_INITIAL (node->decl))
 	return vnode;
     }
@@ -1071,7 +1071,7 @@ varpool_next_static_initializer (varpool_node *node)
   symtab_node *node1 = node->next;
   for (; node1; node1 = node1->next)
     {
-      varpool_node *vnode1 = dyn_cast <varpool_node> (node1);
+      varpool_node *vnode1 = dyn_cast <varpool_node *> (node1);
       if (vnode1 && DECL_INITIAL (node1->decl))
 	return vnode1;
     }
@@ -1090,7 +1090,7 @@ varpool_first_defined_variable (void)
   symtab_node *node;
   for (node = symtab_nodes; node; node = node->next)
     {
-      varpool_node *vnode = dyn_cast <varpool_node> (node);
+      varpool_node *vnode = dyn_cast <varpool_node *> (node);
       if (vnode && vnode->definition)
 	return vnode;
     }
@@ -1104,7 +1104,7 @@ varpool_next_defined_variable (varpool_node *node)
   symtab_node *node1 = node->next;
   for (; node1; node1 = node1->next)
     {
-      varpool_node *vnode1 = dyn_cast <varpool_node> (node1);
+      varpool_node *vnode1 = dyn_cast <varpool_node *> (node1);
       if (vnode1 && vnode1->definition)
 	return vnode1;
     }
@@ -1122,7 +1122,7 @@ cgraph_first_defined_function (void)
   symtab_node *node;
   for (node = symtab_nodes; node; node = node->next)
     {
-      cgraph_node *cn = dyn_cast <cgraph_node> (node);
+      cgraph_node *cn = dyn_cast <cgraph_node *> (node);
       if (cn && cn->definition)
 	return cn;
     }
@@ -1136,7 +1136,7 @@ cgraph_next_defined_function (struct cgraph_node *node)
   symtab_node *node1 = node->next;
   for (; node1; node1 = node1->next)
     {
-      cgraph_node *cn1 = dyn_cast <cgraph_node> (node1);
+      cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1);
       if (cn1 && cn1->definition)
 	return cn1;
     }
@@ -1154,7 +1154,7 @@ cgraph_first_function (void)
 {
   symtab_node *node;
   for (node = symtab_nodes; node; node = node->next)
-    if (cgraph_node *cn = dyn_cast <cgraph_node> (node))
+    if (cgraph_node *cn = dyn_cast <cgraph_node *> (node))
       return cn;
   return NULL;
 }
@@ -1165,7 +1165,7 @@ cgraph_next_function (struct cgraph_node *node)
 {
   symtab_node *node1 = node->next;
   for (; node1; node1 = node1->next)
-    if (cgraph_node *cn1 = dyn_cast <cgraph_node> (node1))
+    if (cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1))
       return cn1;
   return NULL;
 }
@@ -1193,7 +1193,7 @@ cgraph_first_function_with_gimple_body (void)
   symtab_node *node;
   for (node = symtab_nodes; node; node = node->next)
     {
-      cgraph_node *cn = dyn_cast <cgraph_node> (node);
+      cgraph_node *cn = dyn_cast <cgraph_node *> (node);
       if (cn && cgraph_function_with_gimple_body_p (cn))
 	return cn;
     }
@@ -1207,7 +1207,7 @@ cgraph_next_function_with_gimple_body (struct cgraph_node *node)
   symtab_node *node1 = node->next;
   for (; node1; node1 = node1->next)
     {
-      cgraph_node *cn1 = dyn_cast <cgraph_node> (node1);
+      cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1);
       if (cn1 && cgraph_function_with_gimple_body_p (cn1))
 	return cn1;
     }
@@ -1415,13 +1415,13 @@ symtab_alias_target (symtab_node *n)
 static inline struct cgraph_node *
 cgraph_alias_target (struct cgraph_node *n)
 {
-  return dyn_cast <cgraph_node> (symtab_alias_target (n));
+  return dyn_cast <cgraph_node *> (symtab_alias_target (n));
 }
 
 static inline varpool_node *
 varpool_alias_target (varpool_node *n)
 {
-  return dyn_cast <varpool_node> (symtab_alias_target (n));
+  return dyn_cast <varpool_node *> (symtab_alias_target (n));
 }
 
 /* Given NODE, walk the alias chain to return the function NODE is alias of.
@@ -1434,8 +1434,8 @@ cgraph_function_or_thunk_node (struct cgraph_node *node,
 {
   struct cgraph_node *n;
 
-  n = dyn_cast <cgraph_node> (symtab_alias_ultimate_target (node,
-							    availability));
+  n = dyn_cast <cgraph_node *> (symtab_alias_ultimate_target (node,
+							      availability));
   if (!n && availability)
     *availability = AVAIL_NOT_AVAILABLE;
   return n;
@@ -1451,8 +1451,8 @@ varpool_variable_node (varpool_node *node,
   varpool_node *n;
 
   if (node)
-    n = dyn_cast <varpool_node> (symtab_alias_ultimate_target (node,
-							       availability));
+    n = dyn_cast <varpool_node *> (symtab_alias_ultimate_target (node,
+								 availability));
   else
     n = NULL;
 
@@ -1502,7 +1502,7 @@ symtab_real_symbol_p (symtab_node *node)
 
   if (DECL_ABSTRACT (node->decl))
     return false;
-  if (!is_a <cgraph_node> (node))
+  if (!is_a <cgraph_node *> (node))
     return true;
   cnode = cgraph (node);
   if (cnode->global.inlined_to)
diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c
index 06283fc..7bf9a07 100644
--- a/gcc/cgraphunit.c
+++ b/gcc/cgraphunit.c
@@ -406,7 +406,7 @@ referred_to_p (symtab_node *node)
   if (ipa_ref_list_referring_iterate (&node->ref_list, 0, ref))
     return true;
   /* For functions check also calls.  */
-  cgraph_node *cn = dyn_cast <cgraph_node> (node);
+  cgraph_node *cn = dyn_cast <cgraph_node *> (node);
   if (cn && cn->callers)
     return true;
   return false;
@@ -994,7 +994,7 @@ analyze_functions (void)
 	  changed = true;
 	  node = queued_nodes;
 	  queued_nodes = (symtab_node *)queued_nodes->aux;
-	  cgraph_node *cnode = dyn_cast <cgraph_node> (node);
+	  cgraph_node *cnode = dyn_cast <cgraph_node *> (node);
 	  if (cnode && cnode->definition)
 	    {
 	      struct cgraph_edge *edge;
@@ -1045,7 +1045,7 @@ analyze_functions (void)
 	    }
 	  else
 	    {
-	      varpool_node *vnode = dyn_cast <varpool_node> (node);
+	      varpool_node *vnode = dyn_cast <varpool_node *> (node);
 	      if (vnode && vnode->definition && !vnode->analyzed)
 		varpool_analyze_node (vnode);
 	    }
@@ -1089,7 +1089,7 @@ analyze_functions (void)
 	  symtab_remove_node (node);
 	  continue;
 	}
-      if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
+      if (cgraph_node *cnode = dyn_cast <cgraph_node *> (node))
 	{
 	  tree decl = node->decl;
 
@@ -1179,7 +1179,7 @@ handle_alias_pairs (void)
 	}
 
       if (TREE_CODE (p->decl) == FUNCTION_DECL
-          && target_node && is_a <cgraph_node> (target_node))
+          && target_node && is_a <cgraph_node *> (target_node))
 	{
 	  struct cgraph_node *src_node = cgraph_get_node (p->decl);
 	  if (src_node && src_node->definition)
@@ -1188,7 +1188,7 @@ handle_alias_pairs (void)
 	  alias_pairs->unordered_remove (i);
 	}
       else if (TREE_CODE (p->decl) == VAR_DECL
-	       && target_node && is_a <varpool_node> (target_node))
+	       && target_node && is_a <varpool_node *> (target_node))
 	{
 	  varpool_create_variable_alias (p->decl, target_node->decl);
 	  alias_pairs->unordered_remove (i);
diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c
index 6402cce..8b47f51 100644
--- a/gcc/gimple-fold.c
+++ b/gcc/gimple-fold.c
@@ -96,7 +96,7 @@ can_refer_decl_in_current_unit_p (tree decl, tree from_decl)
       snode = symtab_get_node (decl);
       if (!snode)
 	return false;
-      node = dyn_cast <cgraph_node> (snode);
+      node = dyn_cast <cgraph_node *> (snode);
       return !node || !node->global.inlined_to;
     }
 
diff --git a/gcc/gimple-ssa.h b/gcc/gimple-ssa.h
index 8bcbf67..904f002 100644
--- a/gcc/gimple-ssa.h
+++ b/gcc/gimple-ssa.h
@@ -109,7 +109,7 @@ 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);
+     dyn_cast <const gimple_statement_with_memory_ops *> (g);
   if (!mem_ops_stmt)
     return NULL_USE_OPERAND_P;
   ops = mem_ops_stmt->use_ops;
@@ -125,7 +125,7 @@ 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);
+     dyn_cast <gimple_statement_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 fad04cd..f7b5d01 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);
+	gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm *> (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 2a278e4..8552a17 100644
--- a/gcc/gimple.c
+++ b/gcc/gimple.c
@@ -544,7 +544,7 @@ gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs,
      enforced by the front end.  */
   gcc_assert (nlabels == 0 || noutputs == 0);
 
-  p = as_a <gimple_statement_asm> (
+  p = as_a <gimple_statement_asm *> (
         gimple_build_with_ops (GIMPLE_ASM, ERROR_MARK,
 			       ninputs + noutputs + nclobbers + nlabels));
 
@@ -671,7 +671,7 @@ gimple_build_try (gimple_seq eval, gimple_seq cleanup,
   gimple_statement_try *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 <gimple_statement_try *> (gimple_alloc (GIMPLE_TRY, 0));
   gimple_set_subcode (p, kind);
   if (eval)
     gimple_try_set_eval (p, eval);
@@ -702,7 +702,7 @@ gimple
 gimple_build_resx (int region)
 {
   gimple_statement_resx *p =
-    as_a <gimple_statement_resx> (
+    as_a <gimple_statement_resx *> (
       gimple_build_with_ops (GIMPLE_RESX, ERROR_MARK, 0));
   p->region = region;
   return p;
@@ -752,7 +752,7 @@ gimple
 gimple_build_eh_dispatch (int region)
 {
   gimple_statement_eh_dispatch *p =
-    as_a <gimple_statement_eh_dispatch> (
+    as_a <gimple_statement_eh_dispatch *> (
       gimple_build_with_ops (GIMPLE_EH_DISPATCH, ERROR_MARK, 0));
   p->region = region;
   return p;
@@ -829,7 +829,7 @@ 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));
+    as_a <gimple_statement_omp_for *> (gimple_alloc (GIMPLE_OMP_FOR, 0));
   if (body)
     gimple_omp_set_body (p, body);
   gimple_omp_for_set_clauses (p, clauses);
@@ -1664,7 +1664,7 @@ gimple_copy (gimple stmt)
 	  gimple_omp_for_set_clauses (copy, t);
 	  {
 	    gimple_statement_omp_for *omp_for_copy =
-	      as_a <gimple_statement_omp_for> (copy);
+	      as_a <gimple_statement_omp_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 26e8627..edb4635 100644
--- a/gcc/gimple.h
+++ b/gcc/gimple.h
@@ -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 <gimple_statement_asm *>::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 <gimple_statement_bind *>::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 <gimple_statement_call *>::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 <gimple_statement_catch *>::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 <gimple_statement_resx *>::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 <gimple_statement_eh_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 <gimple_statement_eh_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 <gimple_statement_eh_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 <gimple_statement_eh_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 <gimple_statement_omp_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 <gimple_statement_omp_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 <gimple_statement_omp_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 <gimple_statement_omp_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 <gimple_statement_omp_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 <gimple_statement_omp_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 <gimple_statement_omp_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 <gimple_statement_omp_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 <gimple_statement_omp_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 <gimple_statement_omp_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 <gimple_statement_omp_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 <gimple_statement_omp_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 <gimple_statement_omp_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 <gimple_statement_phi *>::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 <gimple_statement_transaction *>::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 <gimple_statement_try *>::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 <gimple_statement_wce *>::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 gimple_statement_asm *>::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 gimple_statement_bind *>::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 gimple_statement_call *>::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 gimple_statement_catch *>::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 gimple_statement_resx *>::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 gimple_statement_eh_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 gimple_statement_eh_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 gimple_statement_omp_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 gimple_statement_omp_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 gimple_statement_omp_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 gimple_statement_omp_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 gimple_statement_omp_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 gimple_statement_omp_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 gimple_statement_omp_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 gimple_statement_omp_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 gimple_statement_omp_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 gimple_statement_omp_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 gimple_statement_omp_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 gimple_statement_omp_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 gimple_statement_omp_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 gimple_statement_phi *>::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 gimple_statement_transaction *>::test (const_gimple gs)
 {
   return gs->code == GIMPLE_TRANSACTION;
 }
@@ -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_statement_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_statement_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_statement_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_statement_with_memory_ops *>::test (gimple gs)
 {
   return gimple_has_mem_ops (gs);
 }
@@ -1690,7 +1690,7 @@ 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);
+    dyn_cast <const gimple_statement_with_ops *> (g);
   if (!ops_stmt)
     return NULL;
   return ops_stmt->use_ops;
@@ -1703,7 +1703,7 @@ 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);
+    as_a <gimple_statement_with_ops *> (g);
   ops_stmt->use_ops = use;
 }
 
@@ -1714,7 +1714,7 @@ 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);
+     dyn_cast <const gimple_statement_with_memory_ops *> (g);
   if (!mem_ops_stmt)
     return NULL_TREE;
   return mem_ops_stmt->vuse;
@@ -1726,7 +1726,7 @@ 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);
+     dyn_cast <const gimple_statement_with_memory_ops *> (g);
   if (!mem_ops_stmt)
     return NULL_TREE;
   return mem_ops_stmt->vdef;
@@ -1738,7 +1738,7 @@ static inline tree *
 gimple_vuse_ptr (gimple g)
 {
   gimple_statement_with_memory_ops *mem_ops_stmt =
-     dyn_cast <gimple_statement_with_memory_ops> (g);
+     dyn_cast <gimple_statement_with_memory_ops *> (g);
   if (!mem_ops_stmt)
     return NULL;
   return &mem_ops_stmt->vuse;
@@ -1750,7 +1750,7 @@ static inline tree *
 gimple_vdef_ptr (gimple g)
 {
   gimple_statement_with_memory_ops *mem_ops_stmt =
-     dyn_cast <gimple_statement_with_memory_ops> (g);
+     dyn_cast <gimple_statement_with_memory_ops *> (g);
   if (!mem_ops_stmt)
     return NULL;
   return &mem_ops_stmt->vdef;
@@ -1762,7 +1762,7 @@ 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);
+    as_a <gimple_statement_with_memory_ops *> (g);
   mem_ops_stmt->vuse = vuse;
 }
 
@@ -1772,7 +1772,7 @@ 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);
+    as_a <gimple_statement_with_memory_ops *> (g);
   mem_ops_stmt->vdef = vdef;
 }
 
@@ -1904,7 +1904,7 @@ 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);
+    as_a <gimple_statement_omp_return *> (g);
   omp_return_stmt->val = lhs;
 }
 
@@ -1915,7 +1915,7 @@ 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);
+    as_a <const gimple_statement_omp_return *> (g);
   return omp_return_stmt->val;
 }
 
@@ -1926,7 +1926,7 @@ static inline tree *
 gimple_omp_return_lhs_ptr (gimple g)
 {
   gimple_statement_omp_return *omp_return_stmt =
-    as_a <gimple_statement_omp_return> (g);
+    as_a <gimple_statement_omp_return *> (g);
   return &omp_return_stmt->val;
 }
 
@@ -2454,7 +2454,7 @@ static inline tree
 gimple_call_fntype (const_gimple gs)
 {
   const gimple_statement_call *call_stmt =
-    as_a <const gimple_statement_call> (gs);
+    as_a <const gimple_statement_call *> (gs);
   if (gimple_call_internal_p (gs))
     return NULL_TREE;
   return call_stmt->u.fntype;
@@ -2465,7 +2465,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);
+  gimple_statement_call *call_stmt = as_a <gimple_statement_call *> (gs);
   gcc_gimple_checking_assert (!gimple_call_internal_p (gs));
   call_stmt->u.fntype = fntype;
 }
@@ -2519,7 +2519,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);
+  gimple_statement_call *call_stmt = as_a <gimple_statement_call *> (gs);
   gcc_gimple_checking_assert (gimple_call_internal_p (gs));
   call_stmt->u.internal_fn = fn;
 }
@@ -2797,7 +2797,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);
+  gimple_statement_call *call_stmt = as_a <gimple_statement_call *> (call);
   return &call_stmt->call_used;
 }
 
@@ -2808,7 +2808,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);
+  gimple_statement_call *call_stmt = as_a <gimple_statement_call *> (call);
   return &call_stmt->call_clobbered;
 }
 
@@ -3078,7 +3078,7 @@ static inline tree
 gimple_bind_vars (const_gimple gs)
 {
   const gimple_statement_bind *bind_stmt =
-    as_a <const gimple_statement_bind> (gs);
+    as_a <const gimple_statement_bind *> (gs);
   return bind_stmt->vars;
 }
 
@@ -3089,7 +3089,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);
+  gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
   bind_stmt->vars = vars;
 }
 
@@ -3100,7 +3100,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);
+  gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
   bind_stmt->vars = chainon (bind_stmt->vars, vars);
 }
 
@@ -3108,7 +3108,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);
+  gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
   return &bind_stmt->body;
 }
 
@@ -3127,7 +3127,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);
+  gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
   bind_stmt->body = seq;
 }
 
@@ -3137,7 +3137,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);
+  gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
   gimple_seq_add_stmt (&bind_stmt->body, stmt);
 }
 
@@ -3147,7 +3147,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);
+  gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
   gimple_seq_add_seq (&bind_stmt->body, seq);
 }
 
@@ -3159,7 +3159,7 @@ static inline tree
 gimple_bind_block (const_gimple gs)
 {
   const gimple_statement_bind *bind_stmt =
-    as_a <const gimple_statement_bind> (gs);
+    as_a <const gimple_statement_bind *> (gs);
   return bind_stmt->block;
 }
 
@@ -3170,7 +3170,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);
+  gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
   gcc_gimple_checking_assert (block == NULL_TREE
 			      || TREE_CODE (block) == BLOCK);
   bind_stmt->block = block;
@@ -3183,7 +3183,7 @@ static inline unsigned
 gimple_asm_ninputs (const_gimple gs)
 {
   const gimple_statement_asm *asm_stmt =
-    as_a <const gimple_statement_asm> (gs);
+    as_a <const gimple_statement_asm *> (gs);
   return asm_stmt->ni;
 }
 
@@ -3194,7 +3194,7 @@ static inline unsigned
 gimple_asm_noutputs (const_gimple gs)
 {
   const gimple_statement_asm *asm_stmt =
-    as_a <const gimple_statement_asm> (gs);
+    as_a <const gimple_statement_asm *> (gs);
   return asm_stmt->no;
 }
 
@@ -3205,7 +3205,7 @@ static inline unsigned
 gimple_asm_nclobbers (const_gimple gs)
 {
   const gimple_statement_asm *asm_stmt =
-    as_a <const gimple_statement_asm> (gs);
+    as_a <const gimple_statement_asm *> (gs);
   return asm_stmt->nc;
 }
 
@@ -3215,7 +3215,7 @@ static inline unsigned
 gimple_asm_nlabels (const_gimple gs)
 {
   const gimple_statement_asm *asm_stmt =
-    as_a <const gimple_statement_asm> (gs);
+    as_a <const gimple_statement_asm *> (gs);
   return asm_stmt->nl;
 }
 
@@ -3225,7 +3225,7 @@ 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);
+    as_a <const gimple_statement_asm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->ni);
   return gimple_op (gs, index + asm_stmt->no);
 }
@@ -3236,7 +3236,7 @@ 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);
+    as_a <const gimple_statement_asm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->ni);
   return gimple_op_ptr (gs, index + asm_stmt->no);
 }
@@ -3247,7 +3247,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);
+  gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm *> (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);
@@ -3260,7 +3260,7 @@ 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);
+    as_a <const gimple_statement_asm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->no);
   return gimple_op (gs, index);
 }
@@ -3271,7 +3271,7 @@ 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);
+    as_a <const gimple_statement_asm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->no);
   return gimple_op_ptr (gs, index);
 }
@@ -3282,7 +3282,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);
+  gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->no
 			      && TREE_CODE (out_op) == TREE_LIST);
   gimple_set_op (gs, index, out_op);
@@ -3295,7 +3295,7 @@ 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);
+    as_a <const gimple_statement_asm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->nc);
   return gimple_op (gs, index + asm_stmt->ni + asm_stmt->no);
 }
@@ -3306,7 +3306,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);
+  gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm *> (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);
@@ -3318,7 +3318,7 @@ 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);
+    as_a <const gimple_statement_asm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->nl);
   return gimple_op (gs, index + asm_stmt->ni + asm_stmt->nc);
 }
@@ -3328,7 +3328,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);
+  gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm *> (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);
@@ -3341,7 +3341,7 @@ static inline const char *
 gimple_asm_string (const_gimple gs)
 {
   const gimple_statement_asm *asm_stmt =
-    as_a <const gimple_statement_asm> (gs);
+    as_a <const gimple_statement_asm *> (gs);
   return asm_stmt->string;
 }
 
@@ -3398,7 +3398,7 @@ static inline tree
 gimple_catch_types (const_gimple gs)
 {
   const gimple_statement_catch *catch_stmt =
-    as_a <const gimple_statement_catch> (gs);
+    as_a <const gimple_statement_catch *> (gs);
   return catch_stmt->types;
 }
 
@@ -3408,7 +3408,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);
+  gimple_statement_catch *catch_stmt = as_a <gimple_statement_catch *> (gs);
   return &catch_stmt->types;
 }
 
@@ -3419,7 +3419,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);
+  gimple_statement_catch *catch_stmt = as_a <gimple_statement_catch *> (gs);
   return &catch_stmt->handler;
 }
 
@@ -3439,7 +3439,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);
+  gimple_statement_catch *catch_stmt = as_a <gimple_statement_catch *> (gs);
   catch_stmt->types = t;
 }
 
@@ -3449,7 +3449,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);
+  gimple_statement_catch *catch_stmt = as_a <gimple_statement_catch *> (gs);
   catch_stmt->handler = handler;
 }
 
@@ -3460,7 +3460,7 @@ 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);
+    as_a <const gimple_statement_eh_filter *> (gs);
   return eh_filter_stmt->types;
 }
 
@@ -3472,7 +3472,7 @@ static inline tree *
 gimple_eh_filter_types_ptr (gimple gs)
 {
   gimple_statement_eh_filter *eh_filter_stmt =
-    as_a <gimple_statement_eh_filter> (gs);
+    as_a <gimple_statement_eh_filter *> (gs);
   return &eh_filter_stmt->types;
 }
 
@@ -3484,7 +3484,7 @@ 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);
+    as_a <gimple_statement_eh_filter *> (gs);
   return &eh_filter_stmt->failure;
 }
 
@@ -3505,7 +3505,7 @@ 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);
+    as_a <gimple_statement_eh_filter *> (gs);
   eh_filter_stmt->types = types;
 }
 
@@ -3517,7 +3517,7 @@ 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);
+    as_a <gimple_statement_eh_filter *> (gs);
   eh_filter_stmt->failure = failure;
 }
 
@@ -3526,7 +3526,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);
+  gimple_statement_eh_mnt *eh_mnt_stmt = as_a <gimple_statement_eh_mnt *> (gs);
   return eh_mnt_stmt->fndecl;
 }
 
@@ -3535,7 +3535,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);
+  gimple_statement_eh_mnt *eh_mnt_stmt = as_a <gimple_statement_eh_mnt *> (gs);
   eh_mnt_stmt->fndecl = decl;
 }
 
@@ -3545,7 +3545,7 @@ 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);
+    as_a <gimple_statement_eh_else *> (gs);
   return &eh_else_stmt->n_body;
 }
 
@@ -3559,7 +3559,7 @@ 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);
+    as_a <gimple_statement_eh_else *> (gs);
   return &eh_else_stmt->e_body;
 }
 
@@ -3573,7 +3573,7 @@ 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);
+    as_a <gimple_statement_eh_else *> (gs);
   eh_else_stmt->n_body = seq;
 }
 
@@ -3581,7 +3581,7 @@ 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);
+    as_a <gimple_statement_eh_else *> (gs);
   eh_else_stmt->e_body = seq;
 }
 
@@ -3627,7 +3627,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);
+  gimple_statement_try *try_stmt = as_a <gimple_statement_try *> (gs);
   return &try_stmt->eval;
 }
 
@@ -3647,7 +3647,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);
+  gimple_statement_try *try_stmt = as_a <gimple_statement_try *> (gs);
   return &try_stmt->cleanup;
 }
 
@@ -3681,7 +3681,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);
+  gimple_statement_try *try_stmt = as_a <gimple_statement_try *> (gs);
   try_stmt->eval = eval;
 }
 
@@ -3692,7 +3692,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);
+  gimple_statement_try *try_stmt = as_a <gimple_statement_try *> (gs);
   try_stmt->cleanup = cleanup;
 }
 
@@ -3702,7 +3702,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);
+  gimple_statement_wce *wce_stmt = as_a <gimple_statement_wce *> (gs);
   return &wce_stmt->cleanup;
 }
 
@@ -3721,7 +3721,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);
+  gimple_statement_wce *wce_stmt = as_a <gimple_statement_wce *> (gs);
   wce_stmt->cleanup = cleanup;
 }
 
@@ -3752,7 +3752,7 @@ static inline unsigned
 gimple_phi_capacity (const_gimple gs)
 {
   const gimple_statement_phi *phi_stmt =
-    as_a <const gimple_statement_phi> (gs);
+    as_a <const gimple_statement_phi *> (gs);
   return phi_stmt->capacity;
 }
 
@@ -3765,7 +3765,7 @@ static inline unsigned
 gimple_phi_num_args (const_gimple gs)
 {
   const gimple_statement_phi *phi_stmt =
-    as_a <const gimple_statement_phi> (gs);
+    as_a <const gimple_statement_phi *> (gs);
   return phi_stmt->nargs;
 }
 
@@ -3776,7 +3776,7 @@ static inline tree
 gimple_phi_result (const_gimple gs)
 {
   const gimple_statement_phi *phi_stmt =
-    as_a <const gimple_statement_phi> (gs);
+    as_a <const gimple_statement_phi *> (gs);
   return phi_stmt->result;
 }
 
@@ -3785,7 +3785,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);
+  gimple_statement_phi *phi_stmt = as_a <gimple_statement_phi *> (gs);
   return &phi_stmt->result;
 }
 
@@ -3794,7 +3794,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);
+  gimple_statement_phi *phi_stmt = as_a <gimple_statement_phi *> (gs);
   phi_stmt->result = result;
   if (result && TREE_CODE (result) == SSA_NAME)
     SSA_NAME_DEF_STMT (result) = gs;
@@ -3807,7 +3807,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);
+  gimple_statement_phi *phi_stmt = as_a <gimple_statement_phi *> (gs);
   gcc_gimple_checking_assert (index <= phi_stmt->capacity);
   return &(phi_stmt->args[index]);
 }
@@ -3818,7 +3818,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);
+  gimple_statement_phi *phi_stmt = as_a <gimple_statement_phi *> (gs);
   gcc_gimple_checking_assert (index <= phi_stmt->nargs);
   phi_stmt->args[index] = *phiarg;
 }
@@ -3906,7 +3906,7 @@ static inline int
 gimple_resx_region (const_gimple gs)
 {
   const gimple_statement_resx *resx_stmt =
-    as_a <const gimple_statement_resx> (gs);
+    as_a <const gimple_statement_resx *> (gs);
   return resx_stmt->region;
 }
 
@@ -3915,7 +3915,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);
+  gimple_statement_resx *resx_stmt = as_a <gimple_statement_resx *> (gs);
   resx_stmt->region = region;
 }
 
@@ -3925,7 +3925,7 @@ 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);
+    as_a <const gimple_statement_eh_dispatch *> (gs);
   return eh_dispatch_stmt->region;
 }
 
@@ -3935,7 +3935,7 @@ 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);
+    as_a <gimple_statement_eh_dispatch *> (gs);
   eh_dispatch_stmt->region = region;
 }
 
@@ -4247,7 +4247,7 @@ 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);
+    as_a <const gimple_statement_omp_critical *> (gs);
   return omp_critical_stmt->name;
 }
 
@@ -4258,7 +4258,7 @@ static inline tree *
 gimple_omp_critical_name_ptr (gimple gs)
 {
   gimple_statement_omp_critical *omp_critical_stmt =
-    as_a <gimple_statement_omp_critical> (gs);
+    as_a <gimple_statement_omp_critical *> (gs);
   return &omp_critical_stmt->name;
 }
 
@@ -4269,7 +4269,7 @@ 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);
+    as_a <gimple_statement_omp_critical *> (gs);
   omp_critical_stmt->name = name;
 }
 
@@ -4351,7 +4351,7 @@ 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);
+    as_a <const gimple_statement_omp_for *> (gs);
   return omp_for_stmt->clauses;
 }
 
@@ -4362,7 +4362,7 @@ static inline tree *
 gimple_omp_for_clauses_ptr (gimple gs)
 {
   gimple_statement_omp_for *omp_for_stmt =
-    as_a <gimple_statement_omp_for> (gs);
+    as_a <gimple_statement_omp_for *> (gs);
   return &omp_for_stmt->clauses;
 }
 
@@ -4373,7 +4373,7 @@ 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);
+    as_a <gimple_statement_omp_for *> (gs);
   omp_for_stmt->clauses = clauses;
 }
 
@@ -4384,7 +4384,7 @@ static inline size_t
 gimple_omp_for_collapse (gimple gs)
 {
   gimple_statement_omp_for *omp_for_stmt =
-    as_a <gimple_statement_omp_for> (gs);
+    as_a <gimple_statement_omp_for *> (gs);
   return omp_for_stmt->collapse;
 }
 
@@ -4395,7 +4395,7 @@ 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);
+    as_a <const gimple_statement_omp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   return omp_for_stmt->iter[i].index;
 }
@@ -4407,7 +4407,7 @@ 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);
+    as_a <gimple_statement_omp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   return &omp_for_stmt->iter[i].index;
 }
@@ -4419,7 +4419,7 @@ 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);
+    as_a <gimple_statement_omp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   omp_for_stmt->iter[i].index = index;
 }
@@ -4431,7 +4431,7 @@ 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);
+    as_a <const gimple_statement_omp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   return omp_for_stmt->iter[i].initial;
 }
@@ -4443,7 +4443,7 @@ 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);
+    as_a <gimple_statement_omp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   return &omp_for_stmt->iter[i].initial;
 }
@@ -4455,7 +4455,7 @@ 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);
+    as_a <gimple_statement_omp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   omp_for_stmt->iter[i].initial = initial;
 }
@@ -4467,7 +4467,7 @@ 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);
+    as_a <const gimple_statement_omp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   return omp_for_stmt->iter[i].final;
 }
@@ -4479,7 +4479,7 @@ 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);
+    as_a <gimple_statement_omp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   return &omp_for_stmt->iter[i].final;
 }
@@ -4491,7 +4491,7 @@ 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);
+    as_a <gimple_statement_omp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   omp_for_stmt->iter[i].final = final;
 }
@@ -4503,7 +4503,7 @@ 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);
+    as_a <const gimple_statement_omp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   return omp_for_stmt->iter[i].incr;
 }
@@ -4515,7 +4515,7 @@ 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);
+    as_a <gimple_statement_omp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   return &omp_for_stmt->iter[i].incr;
 }
@@ -4527,7 +4527,7 @@ 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);
+    as_a <gimple_statement_omp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   omp_for_stmt->iter[i].incr = incr;
 }
@@ -4540,7 +4540,7 @@ 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);
+    as_a <gimple_statement_omp_for *> (gs);
   return &omp_for_stmt->pre_body;
 }
 
@@ -4562,7 +4562,7 @@ 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);
+    as_a <gimple_statement_omp_for *> (gs);
   omp_for_stmt->pre_body = pre_body;
 }
 
@@ -4573,7 +4573,7 @@ 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);
+    as_a <const gimple_statement_omp_parallel *> (gs);
   return omp_parallel_stmt->clauses;
 }
 
@@ -4584,7 +4584,7 @@ static inline tree *
 gimple_omp_parallel_clauses_ptr (gimple gs)
 {
   gimple_statement_omp_parallel *omp_parallel_stmt =
-    as_a <gimple_statement_omp_parallel> (gs);
+    as_a <gimple_statement_omp_parallel *> (gs);
   return &omp_parallel_stmt->clauses;
 }
 
@@ -4596,7 +4596,7 @@ 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);
+    as_a <gimple_statement_omp_parallel *> (gs);
   omp_parallel_stmt->clauses = clauses;
 }
 
@@ -4607,7 +4607,7 @@ 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);
+    as_a <const gimple_statement_omp_parallel *> (gs);
   return omp_parallel_stmt->child_fn;
 }
 
@@ -4618,7 +4618,7 @@ 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);
+    as_a <gimple_statement_omp_parallel *> (gs);
   return &omp_parallel_stmt->child_fn;
 }
 
@@ -4629,7 +4629,7 @@ 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);
+    as_a <gimple_statement_omp_parallel *> (gs);
   omp_parallel_stmt->child_fn = child_fn;
 }
 
@@ -4641,7 +4641,7 @@ 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);
+    as_a <const gimple_statement_omp_parallel *> (gs);
   return omp_parallel_stmt->data_arg;
 }
 
@@ -4652,7 +4652,7 @@ 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);
+    as_a <gimple_statement_omp_parallel *> (gs);
   return &omp_parallel_stmt->data_arg;
 }
 
@@ -4663,7 +4663,7 @@ 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);
+    as_a <gimple_statement_omp_parallel *> (gs);
   omp_parallel_stmt->data_arg = data_arg;
 }
 
@@ -4674,7 +4674,7 @@ 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);
+    as_a <const gimple_statement_omp_task *> (gs);
   return omp_task_stmt->clauses;
 }
 
@@ -4685,7 +4685,7 @@ static inline tree *
 gimple_omp_task_clauses_ptr (gimple gs)
 {
   gimple_statement_omp_task *omp_task_stmt =
-    as_a <gimple_statement_omp_task> (gs);
+    as_a <gimple_statement_omp_task *> (gs);
   return &omp_task_stmt->clauses;
 }
 
@@ -4697,7 +4697,7 @@ 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);
+    as_a <gimple_statement_omp_task *> (gs);
   omp_task_stmt->clauses = clauses;
 }
 
@@ -4708,7 +4708,7 @@ 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);
+    as_a <const gimple_statement_omp_task *> (gs);
   return omp_task_stmt->child_fn;
 }
 
@@ -4719,7 +4719,7 @@ 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);
+    as_a <gimple_statement_omp_task *> (gs);
   return &omp_task_stmt->child_fn;
 }
 
@@ -4730,7 +4730,7 @@ 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);
+    as_a <gimple_statement_omp_task *> (gs);
   omp_task_stmt->child_fn = child_fn;
 }
 
@@ -4742,7 +4742,7 @@ 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);
+    as_a <const gimple_statement_omp_task *> (gs);
   return omp_task_stmt->data_arg;
 }
 
@@ -4753,7 +4753,7 @@ 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);
+    as_a <gimple_statement_omp_task *> (gs);
   return &omp_task_stmt->data_arg;
 }
 
@@ -4764,7 +4764,7 @@ 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);
+    as_a <gimple_statement_omp_task *> (gs);
   omp_task_stmt->data_arg = data_arg;
 }
 
@@ -4775,7 +4775,7 @@ 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);
+    as_a <const gimple_statement_omp_taskreg *> (gs);
   return omp_taskreg_stmt->clauses;
 }
 
@@ -4786,7 +4786,7 @@ static inline tree *
 gimple_omp_taskreg_clauses_ptr (gimple gs)
 {
   gimple_statement_omp_taskreg *omp_taskreg_stmt =
-    as_a <gimple_statement_omp_taskreg> (gs);
+    as_a <gimple_statement_omp_taskreg *> (gs);
   return &omp_taskreg_stmt->clauses;
 }
 
@@ -4798,7 +4798,7 @@ 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);
+    as_a <gimple_statement_omp_taskreg *> (gs);
   omp_taskreg_stmt->clauses = clauses;
 }
 
@@ -4809,7 +4809,7 @@ 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);
+    as_a <const gimple_statement_omp_taskreg *> (gs);
   return omp_taskreg_stmt->child_fn;
 }
 
@@ -4820,7 +4820,7 @@ 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);
+    as_a <gimple_statement_omp_taskreg *> (gs);
   return &omp_taskreg_stmt->child_fn;
 }
 
@@ -4831,7 +4831,7 @@ 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);
+    as_a <gimple_statement_omp_taskreg *> (gs);
   omp_taskreg_stmt->child_fn = child_fn;
 }
 
@@ -4843,7 +4843,7 @@ 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);
+    as_a <const gimple_statement_omp_taskreg *> (gs);
   return omp_taskreg_stmt->data_arg;
 }
 
@@ -4854,7 +4854,7 @@ 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);
+    as_a <gimple_statement_omp_taskreg *> (gs);
   return &omp_taskreg_stmt->data_arg;
 }
 
@@ -4865,7 +4865,7 @@ 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);
+    as_a <gimple_statement_omp_taskreg *> (gs);
   omp_taskreg_stmt->data_arg = data_arg;
 }
 
@@ -4876,7 +4876,7 @@ 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);
+    as_a <const gimple_statement_omp_task *> (gs);
   return omp_task_stmt->copy_fn;
 }
 
@@ -4887,7 +4887,7 @@ 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);
+    as_a <gimple_statement_omp_task *> (gs);
   return &omp_task_stmt->copy_fn;
 }
 
@@ -4898,7 +4898,7 @@ 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);
+    as_a <gimple_statement_omp_task *> (gs);
   omp_task_stmt->copy_fn = copy_fn;
 }
 
@@ -4909,7 +4909,7 @@ 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);
+    as_a <const gimple_statement_omp_task *> (gs);
   return omp_task_stmt->arg_size;
 }
 
@@ -4920,7 +4920,7 @@ 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);
+    as_a <gimple_statement_omp_task *> (gs);
   return &omp_task_stmt->arg_size;
 }
 
@@ -4931,7 +4931,7 @@ 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);
+    as_a <gimple_statement_omp_task *> (gs);
   omp_task_stmt->arg_size = arg_size;
 }
 
@@ -4942,7 +4942,7 @@ 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);
+    as_a <const gimple_statement_omp_task *> (gs);
   return omp_task_stmt->arg_align;
 }
 
@@ -4953,7 +4953,7 @@ 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);
+    as_a <gimple_statement_omp_task *> (gs);
   return &omp_task_stmt->arg_align;
 }
 
@@ -4964,7 +4964,7 @@ 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);
+    as_a <gimple_statement_omp_task *> (gs);
   omp_task_stmt->arg_align = arg_align;
 }
 
@@ -4975,7 +4975,7 @@ 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);
+    as_a <const gimple_statement_omp_single *> (gs);
   return omp_single_stmt->clauses;
 }
 
@@ -4986,7 +4986,7 @@ static inline tree *
 gimple_omp_single_clauses_ptr (gimple gs)
 {
   gimple_statement_omp_single *omp_single_stmt =
-    as_a <gimple_statement_omp_single> (gs);
+    as_a <gimple_statement_omp_single *> (gs);
   return &omp_single_stmt->clauses;
 }
 
@@ -4997,7 +4997,7 @@ 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);
+    as_a <gimple_statement_omp_single *> (gs);
   omp_single_stmt->clauses = clauses;
 }
 
@@ -5008,7 +5008,7 @@ 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);
+    as_a <const gimple_statement_omp_target *> (gs);
   return omp_target_stmt->clauses;
 }
 
@@ -5019,7 +5019,7 @@ static inline tree *
 gimple_omp_target_clauses_ptr (gimple gs)
 {
   gimple_statement_omp_target *omp_target_stmt =
-    as_a <gimple_statement_omp_target> (gs);
+    as_a <gimple_statement_omp_target *> (gs);
   return &omp_target_stmt->clauses;
 }
 
@@ -5030,7 +5030,7 @@ 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);
+    as_a <gimple_statement_omp_target *> (gs);
   omp_target_stmt->clauses = clauses;
 }
 
@@ -5062,7 +5062,7 @@ 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);
+    as_a <const gimple_statement_omp_target *> (gs);
   return omp_target_stmt->child_fn;
 }
 
@@ -5073,7 +5073,7 @@ 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);
+    as_a <gimple_statement_omp_target *> (gs);
   return &omp_target_stmt->child_fn;
 }
 
@@ -5084,7 +5084,7 @@ 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);
+    as_a <gimple_statement_omp_target *> (gs);
   omp_target_stmt->child_fn = child_fn;
 }
 
@@ -5096,7 +5096,7 @@ 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);
+    as_a <const gimple_statement_omp_target *> (gs);
   return omp_target_stmt->data_arg;
 }
 
@@ -5107,7 +5107,7 @@ 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);
+    as_a <gimple_statement_omp_target *> (gs);
   return &omp_target_stmt->data_arg;
 }
 
@@ -5118,7 +5118,7 @@ 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);
+    as_a <gimple_statement_omp_target *> (gs);
   omp_target_stmt->data_arg = data_arg;
 }
 
@@ -5129,7 +5129,7 @@ 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);
+    as_a <const gimple_statement_omp_teams *> (gs);
   return omp_teams_stmt->clauses;
 }
 
@@ -5140,7 +5140,7 @@ static inline tree *
 gimple_omp_teams_clauses_ptr (gimple gs)
 {
   gimple_statement_omp_teams *omp_teams_stmt =
-    as_a <gimple_statement_omp_teams> (gs);
+    as_a <gimple_statement_omp_teams *> (gs);
   return &omp_teams_stmt->clauses;
 }
 
@@ -5151,7 +5151,7 @@ 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);
+    as_a <gimple_statement_omp_teams *> (gs);
   omp_teams_stmt->clauses = clauses;
 }
 
@@ -5162,7 +5162,7 @@ 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);
+    as_a <const gimple_statement_omp_sections *> (gs);
   return omp_sections_stmt->clauses;
 }
 
@@ -5173,7 +5173,7 @@ static inline tree *
 gimple_omp_sections_clauses_ptr (gimple gs)
 {
   gimple_statement_omp_sections *omp_sections_stmt =
-    as_a <gimple_statement_omp_sections> (gs);
+    as_a <gimple_statement_omp_sections *> (gs);
   return &omp_sections_stmt->clauses;
 }
 
@@ -5185,7 +5185,7 @@ 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);
+    as_a <gimple_statement_omp_sections *> (gs);
   omp_sections_stmt->clauses = clauses;
 }
 
@@ -5197,7 +5197,7 @@ 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);
+    as_a <const gimple_statement_omp_sections *> (gs);
   return omp_sections_stmt->control;
 }
 
@@ -5209,7 +5209,7 @@ static inline tree *
 gimple_omp_sections_control_ptr (gimple gs)
 {
   gimple_statement_omp_sections *omp_sections_stmt =
-    as_a <gimple_statement_omp_sections> (gs);
+    as_a <gimple_statement_omp_sections *> (gs);
   return &omp_sections_stmt->control;
 }
 
@@ -5221,7 +5221,7 @@ 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);
+    as_a <gimple_statement_omp_sections *> (gs);
   omp_sections_stmt->control = control;
 }
 
@@ -5232,7 +5232,7 @@ 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);
+    as_a <gimple_statement_omp_for *> (gs);
   gcc_gimple_checking_assert (TREE_CODE_CLASS (cond) == tcc_comparison
 			      && i < omp_for_stmt->collapse);
   omp_for_stmt->iter[i].cond = cond;
@@ -5245,7 +5245,7 @@ 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);
+    as_a <const gimple_statement_omp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
   return omp_for_stmt->iter[i].cond;
 }
@@ -5257,7 +5257,7 @@ 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);
+    as_a <gimple_statement_omp_atomic_store *> (g);
   omp_atomic_store_stmt->val = val;
 }
 
@@ -5268,7 +5268,7 @@ 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);
+    as_a <const gimple_statement_omp_atomic_store *> (g);
   return omp_atomic_store_stmt->val;
 }
 
@@ -5279,7 +5279,7 @@ 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);
+    as_a <gimple_statement_omp_atomic_store *> (g);
   return &omp_atomic_store_stmt->val;
 }
 
@@ -5290,7 +5290,7 @@ 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);
+    as_a <gimple_statement_omp_atomic_load *> (g);
   omp_atomic_load_stmt->lhs = lhs;
 }
 
@@ -5301,7 +5301,7 @@ 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);
+    as_a <const gimple_statement_omp_atomic_load *> (g);
   return omp_atomic_load_stmt->lhs;
 }
 
@@ -5312,7 +5312,7 @@ 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);
+    as_a <gimple_statement_omp_atomic_load *> (g);
   return &omp_atomic_load_stmt->lhs;
 }
 
@@ -5323,7 +5323,7 @@ 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);
+    as_a <gimple_statement_omp_atomic_load *> (g);
   omp_atomic_load_stmt->rhs = rhs;
 }
 
@@ -5334,7 +5334,7 @@ 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);
+    as_a <const gimple_statement_omp_atomic_load *> (g);
   return omp_atomic_load_stmt->rhs;
 }
 
@@ -5345,7 +5345,7 @@ 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);
+    as_a <gimple_statement_omp_atomic_load *> (g);
   return &omp_atomic_load_stmt->rhs;
 }
 
@@ -5356,7 +5356,7 @@ 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);
+    as_a <const gimple_statement_omp_continue *> (g);
   return omp_continue_stmt->control_def;
 }
 
@@ -5366,7 +5366,7 @@ 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);
+    as_a <gimple_statement_omp_continue *> (g);
   return &omp_continue_stmt->control_def;
 }
 
@@ -5376,7 +5376,7 @@ 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);
+    as_a <gimple_statement_omp_continue *> (g);
   omp_continue_stmt->control_def = def;
 }
 
@@ -5387,7 +5387,7 @@ 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);
+    as_a <const gimple_statement_omp_continue *> (g);
   return omp_continue_stmt->control_use;
 }
 
@@ -5398,7 +5398,7 @@ 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);
+    as_a <gimple_statement_omp_continue *> (g);
   return &omp_continue_stmt->control_use;
 }
 
@@ -5409,7 +5409,7 @@ 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);
+    as_a <gimple_statement_omp_continue *> (g);
   omp_continue_stmt->control_use = use;
 }
 
@@ -5419,7 +5419,7 @@ static inline gimple_seq *
 gimple_transaction_body_ptr (gimple gs)
 {
   gimple_statement_transaction *transaction_stmt =
-    as_a <gimple_statement_transaction> (gs);
+    as_a <gimple_statement_transaction *> (gs);
   return &transaction_stmt->body;
 }
 
@@ -5437,7 +5437,7 @@ static inline tree
 gimple_transaction_label (const_gimple gs)
 {
   const gimple_statement_transaction *transaction_stmt =
-    as_a <const gimple_statement_transaction> (gs);
+    as_a <const gimple_statement_transaction *> (gs);
   return transaction_stmt->label;
 }
 
@@ -5445,7 +5445,7 @@ static inline tree *
 gimple_transaction_label_ptr (gimple gs)
 {
   gimple_statement_transaction *transaction_stmt =
-    as_a <gimple_statement_transaction> (gs);
+    as_a <gimple_statement_transaction *> (gs);
   return &transaction_stmt->label;
 }
 
@@ -5464,7 +5464,7 @@ static inline void
 gimple_transaction_set_body (gimple gs, gimple_seq body)
 {
   gimple_statement_transaction *transaction_stmt =
-    as_a <gimple_statement_transaction> (gs);
+    as_a <gimple_statement_transaction *> (gs);
   transaction_stmt->body = body;
 }
 
@@ -5474,7 +5474,7 @@ static inline void
 gimple_transaction_set_label (gimple gs, tree label)
 {
   gimple_statement_transaction *transaction_stmt =
-    as_a <gimple_statement_transaction> (gs);
+    as_a <gimple_statement_transaction *> (gs);
   transaction_stmt->label = label;
 }
 
diff --git a/gcc/ipa-devirt.c b/gcc/ipa-devirt.c
index d484b20..4ff31fc 100644
--- a/gcc/ipa-devirt.c
+++ b/gcc/ipa-devirt.c
@@ -619,7 +619,7 @@ build_type_inheritance_graph (void)
   /* We reconstruct the graph starting of types of all methods seen in the
      the unit.  */
   FOR_EACH_SYMBOL (n)
-    if (is_a <cgraph_node> (n)
+    if (is_a <cgraph_node *> (n)
 	&& DECL_VIRTUAL_P (n->decl)
 	&& symtab_real_symbol_p (n))
       get_odr_type (method_class_type (TREE_TYPE (n->decl)), true);
@@ -643,7 +643,7 @@ build_type_inheritance_graph (void)
        assume it is called externally or C is in anonymous namespace and
        thus we will see the vtable.  */
 
-    else if (is_a <varpool_node> (n)
+    else if (is_a <varpool_node *> (n)
 	     && DECL_VIRTUAL_P (n->decl)
 	     && TREE_CODE (DECL_CONTEXT (n->decl)) == RECORD_TYPE
 	     && TYPE_BINFO (DECL_CONTEXT (n->decl))
diff --git a/gcc/ipa-inline-analysis.c b/gcc/ipa-inline-analysis.c
index dfe3058..2bb3759 100644
--- a/gcc/ipa-inline-analysis.c
+++ b/gcc/ipa-inline-analysis.c
@@ -4253,7 +4253,7 @@ inline_write_summary (void)
   for (i = 0; i < lto_symtab_encoder_size (encoder); i++)
     {
       symtab_node *snode = lto_symtab_encoder_deref (encoder, i);
-      cgraph_node *cnode = dyn_cast <cgraph_node> (snode);
+      cgraph_node *cnode = dyn_cast <cgraph_node *> (snode);
       if (cnode && cnode->definition && !cnode->alias)
 	count++;
     }
@@ -4262,7 +4262,7 @@ inline_write_summary (void)
   for (i = 0; i < lto_symtab_encoder_size (encoder); i++)
     {
       symtab_node *snode = lto_symtab_encoder_deref (encoder, i);
-      cgraph_node *cnode = dyn_cast <cgraph_node> (snode);
+      cgraph_node *cnode = dyn_cast <cgraph_node *> (snode);
       if (cnode && (node = cnode)->definition && !node->alias)
 	{
 	  struct inline_summary *info = inline_summary (node);
diff --git a/gcc/ipa-ref.c b/gcc/ipa-ref.c
index 6aa41e6..df84c9c 100644
--- a/gcc/ipa-ref.c
+++ b/gcc/ipa-ref.c
@@ -42,7 +42,7 @@ ipa_record_reference (symtab_node *referring_node,
   struct ipa_ref_list *list, *list2;
   ipa_ref_t *old_references;
 
-  gcc_checking_assert (!stmt || is_a <cgraph_node> (referring_node));
+  gcc_checking_assert (!stmt || is_a <cgraph_node *> (referring_node));
   gcc_checking_assert (use_type != IPA_REF_ALIAS || !stmt);
 
   list = &referring_node->ref_list;
diff --git a/gcc/ipa-reference.c b/gcc/ipa-reference.c
index dc1169d..ebff60c 100644
--- a/gcc/ipa-reference.c
+++ b/gcc/ipa-reference.c
@@ -466,7 +466,7 @@ analyze_function (struct cgraph_node *fn)
   local = init_function_info (fn);
   for (i = 0; ipa_ref_list_reference_iterate (&fn->ref_list, i, ref); i++)
     {
-      if (!is_a <varpool_node> (ref->referred))
+      if (!is_a <varpool_node *> (ref->referred))
 	continue;
       var = ipa_ref_varpool_node (ref)->decl;
       if (!is_proper_for_analysis (var))
@@ -973,7 +973,7 @@ ipa_reference_write_optimization_summary (void)
   for (i = 0; i < lto_symtab_encoder_size (encoder); i++)
     {
       symtab_node *snode = lto_symtab_encoder_deref (encoder, i);
-      varpool_node *vnode = dyn_cast <varpool_node> (snode);
+      varpool_node *vnode = dyn_cast <varpool_node *> (snode);
       if (vnode
 	  && bitmap_bit_p (all_module_statics, DECL_UID (vnode->decl))
 	  && referenced_from_this_partition_p (&vnode->ref_list, encoder))
@@ -991,7 +991,7 @@ ipa_reference_write_optimization_summary (void)
     for (i = 0; i < lto_symtab_encoder_size (encoder); i++)
       {
 	symtab_node *snode = lto_symtab_encoder_deref (encoder, i);
-	cgraph_node *cnode = dyn_cast <cgraph_node> (snode);
+	cgraph_node *cnode = dyn_cast <cgraph_node *> (snode);
 	if (cnode && write_node_summary_p (cnode, encoder, ltrans_statics))
 	  count++;
       }
@@ -1006,7 +1006,7 @@ ipa_reference_write_optimization_summary (void)
     for (i = 0; i < lto_symtab_encoder_size (encoder); i++)
       {
 	symtab_node *snode = lto_symtab_encoder_deref (encoder, i);
-	cgraph_node *cnode = dyn_cast <cgraph_node> (snode);
+	cgraph_node *cnode = dyn_cast <cgraph_node *> (snode);
 	if (cnode && write_node_summary_p (cnode, encoder, ltrans_statics))
 	  {
 	    ipa_reference_optimization_summary_t info;
diff --git a/gcc/ipa.c b/gcc/ipa.c
index 8b65abd..a14f024 100644
--- a/gcc/ipa.c
+++ b/gcc/ipa.c
@@ -387,7 +387,7 @@ symtab_remove_unreachable_nodes (bool before_inlining_p, FILE *file)
 			      before_inlining_p, reachable);
 	}
 
-      if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
+      if (cgraph_node *cnode = dyn_cast <cgraph_node *> (node))
 	{
 	  /* Mark the callees reachable unless they are direct calls to extern
  	     inline functions we decided to not inline.  */
@@ -465,7 +465,7 @@ symtab_remove_unreachable_nodes (bool before_inlining_p, FILE *file)
       /* When we see constructor of external variable, keep referred nodes in the
 	boundary.  This will also hold initializers of the external vars NODE
 	refers to.  */
-      varpool_node *vnode = dyn_cast <varpool_node> (node);
+      varpool_node *vnode = dyn_cast <varpool_node *> (node);
       if (vnode
 	  && DECL_EXTERNAL (node->decl)
 	  && !vnode->alias
@@ -694,7 +694,7 @@ address_taken_from_non_vtable_p (symtab_node *node)
     if (ref->use == IPA_REF_ADDR)
       {
 	varpool_node *node;
-	if (is_a <cgraph_node> (ref->referring))
+	if (is_a <cgraph_node *> (ref->referring))
 	  return true;
 	node = ipa_ref_referring_varpool_node (ref);
 	if (!DECL_VIRTUAL_P (node->decl))
@@ -732,7 +732,7 @@ comdat_can_be_unshared_p_1 (symtab_node *node)
     return false;
 
   /* Non-readonly and volatile variables can not be duplicated.  */
-  if (is_a <varpool_node> (node)
+  if (is_a <varpool_node *> (node)
       && (!TREE_READONLY (node->decl)
 	  || TREE_THIS_VOLATILE (node->decl)))
     return false;
diff --git a/gcc/is-a.h b/gcc/is-a.h
index bc756b1..a14e344 100644
--- a/gcc/is-a.h
+++ b/gcc/is-a.h
@@ -34,21 +34,21 @@ bool is_a <TYPE> (pointer)
     Suppose you have a symtab_node *ptr, AKA symtab_node *ptr.  You can test
     whether it points to a 'derived' cgraph_node as follows.
 
-      if (is_a <cgraph_node> (ptr))
+      if (is_a <cgraph_node *> (ptr))
         ....
 
 
-TYPE *as_a <TYPE> (pointer)
+TYPE as_a <TYPE> (pointer)
 
-    Converts pointer to a TYPE*.
+    Converts pointer to a TYPE.
 
     You can just assume that it is such a node.
 
-      do_something_with (as_a <cgraph_node> *ptr);
+      do_something_with (as_a <cgraph_node *> *ptr);
 
-TYPE *dyn_cast <TYPE> (pointer)
+TYPE dyn_cast <TYPE> (pointer)
 
-    Converts pointer to TYPE* if and only if "is_a <TYPE> pointer".  Otherwise,
+    Converts pointer to TYPE if and only if "is_a <TYPE> pointer".  Otherwise,
     returns NULL.  This function is essentially a checked down cast.
 
     This functions reduce compile time and increase type safety when treating a
@@ -57,7 +57,7 @@ TYPE *dyn_cast <TYPE> (pointer)
     You can test and obtain a pointer to the 'derived' type in one indivisible
     operation.
 
-      if (cgraph_node *cptr = dyn_cast <cgraph_node> (ptr))
+      if (cgraph_node *cptr = dyn_cast <cgraph_node *> (ptr))
         ....
 
     As an example, the code change is from
@@ -70,7 +70,7 @@ TYPE *dyn_cast <TYPE> (pointer)
 
     to
 
-      if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
+      if (cgraph_node *cnode = dyn_cast <cgraph_node *> (node))
         {
           ....
         }
@@ -88,7 +88,7 @@ TYPE *dyn_cast <TYPE> (pointer)
 
     becomes
 
-      varpool_node *vnode = dyn_cast <varpool_node> (node);
+      varpool_node *vnode = dyn_cast <varpool_node *> (node);
       if (vnode && vnode->finalized)
         varpool_analyze_node (vnode);
 
@@ -110,7 +110,7 @@ example,
   template <>
   template <>
   inline bool
-  is_a_helper <cgraph_node>::test (symtab_node *p)
+  is_a_helper <cgraph_node *>::test (symtab_node *p)
   {
     return p->type == SYMTAB_FUNCTION;
   }
@@ -122,7 +122,7 @@ when needed may result in a crash.  For example,
   template <>
   template <>
   inline bool
-  is_a_helper <cgraph_node>::cast (symtab_node *p)
+  is_a_helper <cgraph_node *>::cast (symtab_node *p)
   {
     return &p->x_function;
   }
@@ -140,7 +140,7 @@ struct is_a_helper
   template <typename U>
   static inline bool test (U *p);
   template <typename U>
-  static inline T *cast (U *p);
+  static inline T cast (U *p);
 };
 
 /* Note that we deliberately do not define the 'test' member template.  Not
@@ -154,10 +154,10 @@ struct is_a_helper
 
 template <typename T>
 template <typename U>
-inline T *
+inline T
 is_a_helper <T>::cast (U *p)
 {
-  return reinterpret_cast <T *> (p);
+  return reinterpret_cast <T> (p);
 }
 
 
@@ -178,7 +178,7 @@ is_a (U *p)
    discussion above for when to use this function.  */
 
 template <typename T, typename U>
-inline T *
+inline T
 as_a (U *p)
 {
   gcc_checking_assert (is_a <T> (p));
@@ -189,13 +189,13 @@ as_a (U *p)
    the discussion above for when to use this function.  */
 
 template <typename T, typename U>
-inline T *
+inline T
 dyn_cast (U *p)
 {
   if (is_a <T> (p))
     return is_a_helper <T>::cast (p);
   else
-    return static_cast <T *> (0);
+    return static_cast <T> (0);
 }
 
 #endif  /* GCC_IS_A_H  */
diff --git a/gcc/lto-cgraph.c b/gcc/lto-cgraph.c
index 173067f..58084cd 100644
--- a/gcc/lto-cgraph.c
+++ b/gcc/lto-cgraph.c
@@ -619,7 +619,7 @@ lto_output_ref (struct lto_simple_output_block *ob, struct ipa_ref *ref,
   gcc_assert (nref != LCC_NOT_FOUND);
   streamer_write_hwi_stream (ob->main_stream, nref);
   
-  node = dyn_cast <cgraph_node> (ref->referring);
+  node = dyn_cast <cgraph_node *> (ref->referring);
   if (node)
     {
       if (ref->stmt)
@@ -753,7 +753,7 @@ add_references (lto_symtab_encoder_t encoder,
   int i;
   struct ipa_ref *ref;
   for (i = 0; ipa_ref_list_reference_iterate (list, i, ref); i++)
-    if (is_a <cgraph_node> (ref->referred))
+    if (is_a <cgraph_node *> (ref->referred))
       add_node_to (encoder, ipa_ref_node (ref), false);
     else
       lto_symtab_encoder_encode (encoder, ref->referred);
@@ -819,7 +819,7 @@ compute_ltrans_boundary (lto_symtab_encoder_t in_encoder)
   for (i = 0; i < lto_symtab_encoder_size (encoder); i++)
     {
       symtab_node *node = lto_symtab_encoder_deref (encoder, i);
-      if (varpool_node *vnode = dyn_cast <varpool_node> (node))
+      if (varpool_node *vnode = dyn_cast <varpool_node *> (node))
 	{
 	  if (!lto_symtab_encoder_encode_initializer_p (encoder,
 							vnode)
@@ -913,7 +913,7 @@ output_symtab (void)
   for (i = 0; i < n_nodes; i++)
     {
       symtab_node *node = lto_symtab_encoder_deref (encoder, i);
-      if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
+      if (cgraph_node *cnode = dyn_cast <cgraph_node *> (node))
         lto_output_node (ob, cnode, encoder);
       else
         lto_output_varpool_node (ob, varpool (node), encoder);
@@ -1199,7 +1199,7 @@ input_ref (struct lto_input_block *ib,
   node = nodes[streamer_read_hwi (ib)];
   ref = ipa_record_reference (referring_node, node, use, NULL);
   ref->speculative = speculative;
-  if (is_a <cgraph_node> (referring_node))
+  if (is_a <cgraph_node *> (referring_node))
     ref->lto_stmt_uid = streamer_read_hwi (ib);
 }
 
@@ -1316,12 +1316,12 @@ input_cgraph_1 (struct lto_file_decl_data *file_data,
   /* AUX pointers should be all non-zero for function nodes read from the stream.  */
 #ifdef ENABLE_CHECKING
   FOR_EACH_VEC_ELT (nodes, i, node)
-    gcc_assert (node->aux || !is_a <cgraph_node> (node));
+    gcc_assert (node->aux || !is_a <cgraph_node *> (node));
 #endif
   FOR_EACH_VEC_ELT (nodes, i, node)
     {
       int ref;
-      if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
+      if (cgraph_node *cnode = dyn_cast <cgraph_node *> (node))
 	{
 	  ref = (int) (intptr_t) cnode->global.inlined_to;
 
@@ -1346,7 +1346,7 @@ input_cgraph_1 (struct lto_file_decl_data *file_data,
 	node->same_comdat_group = NULL;
     }
   FOR_EACH_VEC_ELT (nodes, i, node)
-    node->aux = is_a <cgraph_node> (node) ? (void *)1 : NULL;
+    node->aux = is_a <cgraph_node *> (node) ? (void *)1 : NULL;
   return nodes;
 }
 
@@ -1696,7 +1696,7 @@ output_cgraph_opt_summary (void)
   for (i = 0; i < n_nodes; i++)
     {
       symtab_node *node = lto_symtab_encoder_deref (encoder, i);
-      cgraph_node *cnode = dyn_cast <cgraph_node> (node);
+      cgraph_node *cnode = dyn_cast <cgraph_node *> (node);
       if (cnode && output_cgraph_opt_summary_p (cnode))
 	count++;
     }
@@ -1704,7 +1704,7 @@ output_cgraph_opt_summary (void)
   for (i = 0; i < n_nodes; i++)
     {
       symtab_node *node = lto_symtab_encoder_deref (encoder, i);
-      cgraph_node *cnode = dyn_cast <cgraph_node> (node);
+      cgraph_node *cnode = dyn_cast <cgraph_node *> (node);
       if (cnode && output_cgraph_opt_summary_p (cnode))
 	{
 	  streamer_write_uhwi (ob, i);
diff --git a/gcc/lto-streamer-out.c b/gcc/lto-streamer-out.c
index 55bcffe..a40fd19 100644
--- a/gcc/lto-streamer-out.c
+++ b/gcc/lto-streamer-out.c
@@ -2067,7 +2067,7 @@ lto_output (void)
   for (i = 0; i < n_nodes; i++)
     {
       symtab_node *snode = lto_symtab_encoder_deref (encoder, i);
-      if (cgraph_node *node = dyn_cast <cgraph_node> (snode))
+      if (cgraph_node *node = dyn_cast <cgraph_node *> (snode))
 	{
 	  if (lto_symtab_encoder_encode_body_p (encoder, node)
 	      && !node->alias)
@@ -2087,7 +2087,7 @@ lto_output (void)
 	      lto_record_function_out_decl_state (node->decl, decl_state);
 	    }
 	}
-      else if (varpool_node *node = dyn_cast <varpool_node> (snode))
+      else if (varpool_node *node = dyn_cast <varpool_node *> (snode))
 	{
 	  /* Wrap symbol references inside the ctor in a type
 	     preserving MEM_REF.  */
@@ -2344,7 +2344,7 @@ output_symbol_p (symtab_node *node)
   /* We keep external functions in symtab for sake of inlining
      and devirtualization.  We do not want to see them in symbol table as
      references unless they are really used.  */
-  cnode = dyn_cast <cgraph_node> (node);
+  cnode = dyn_cast <cgraph_node *> (node);
   if (cnode && (!node->definition || DECL_EXTERNAL (cnode->decl))
       && cnode->callers)
     return true;
@@ -2362,7 +2362,7 @@ output_symbol_p (symtab_node *node)
 	{
 	  if (ref->use == IPA_REF_ALIAS)
 	    continue;
-          if (is_a <cgraph_node> (ref->referring))
+          if (is_a <cgraph_node *> (ref->referring))
 	    return true;
 	  if (!DECL_EXTERNAL (ref->referring->decl))
 	    return true;
diff --git a/gcc/lto-streamer.h b/gcc/lto-streamer.h
index be0c782..ca66465 100644
--- a/gcc/lto-streamer.h
+++ b/gcc/lto-streamer.h
@@ -1139,7 +1139,7 @@ lsei_next_function_in_partition (lto_symtab_encoder_iterator *lsei)
 {
   lsei_next (lsei);
   while (!lsei_end_p (*lsei)
-	 && (!is_a <cgraph_node> (lsei_node (*lsei))
+	 && (!is_a <cgraph_node *> (lsei_node (*lsei))
 	     || !lto_symtab_encoder_in_partition_p (lsei->encoder, lsei_node (*lsei))))
     lsei_next (lsei);
 }
@@ -1152,7 +1152,7 @@ lsei_start_function_in_partition (lto_symtab_encoder_t encoder)
 
   if (lsei_end_p (lsei))
     return lsei;
-  if (!is_a <cgraph_node> (lsei_node (lsei))
+  if (!is_a <cgraph_node *> (lsei_node (lsei))
       || !lto_symtab_encoder_in_partition_p (encoder, lsei_node (lsei)))
     lsei_next_function_in_partition (&lsei);
 
@@ -1165,7 +1165,7 @@ lsei_next_variable_in_partition (lto_symtab_encoder_iterator *lsei)
 {
   lsei_next (lsei);
   while (!lsei_end_p (*lsei)
-	 && (!is_a <varpool_node> (lsei_node (*lsei))
+	 && (!is_a <varpool_node *> (lsei_node (*lsei))
 	     || !lto_symtab_encoder_in_partition_p (lsei->encoder, lsei_node (*lsei))))
     lsei_next (lsei);
 }
@@ -1178,7 +1178,7 @@ lsei_start_variable_in_partition (lto_symtab_encoder_t encoder)
 
   if (lsei_end_p (lsei))
     return lsei;
-  if (!is_a <varpool_node> (lsei_node (lsei))
+  if (!is_a <varpool_node *> (lsei_node (lsei))
       || !lto_symtab_encoder_in_partition_p (encoder, lsei_node (lsei)))
     lsei_next_variable_in_partition (&lsei);
 
diff --git a/gcc/lto/ChangeLog b/gcc/lto/ChangeLog
index d0e14c1..f1ecec9 100644
--- a/gcc/lto/ChangeLog
+++ b/gcc/lto/ChangeLog
@@ -1,3 +1,16 @@
+2014-04-23  David Malcolm  <dmalcolm@redhat.com>
+
+	* lto-partition.c (add_references_to_partition): Update for
+	removal of implicit pointer from the is-a.h API.
+	(add_symbol_to_partition_1): Likewise.
+	(contained_in_symbol): Likewise.
+	(undo_partition): Likewise.
+	(lto_balanced_map): Likewise.
+	(promote_symbol): Likewise.
+	* lto-symtab.c (lto_symtab_merge_symbols_1): Likewise.
+	(lto_symtab_merge_symbols): Likewise.
+	* lto.c (lto_wpa_write_files): Likewise.
+
 2014-04-15  Richard Biener  <rguenther@suse.de>
 
 	* lto.c: Include params.h.
diff --git a/gcc/lto/lto-partition.c b/gcc/lto/lto-partition.c
index bb59434..5a8c843 100644
--- a/gcc/lto/lto-partition.c
+++ b/gcc/lto/lto-partition.c
@@ -95,7 +95,7 @@ add_references_to_partition (ltrans_partition part, symtab_node *node)
     /* References to a readonly variable may be constant foled into its value.
        Recursively look into the initializers of the constant variable and add
        references, too.  */
-    else if (is_a <varpool_node> (ref->referred)
+    else if (is_a <varpool_node *> (ref->referred)
 	     && ctor_for_folding (ref->referred->decl) != error_mark_node
 	     && !lto_symtab_encoder_in_partition_p (part->encoder, ref->referred))
       {
@@ -146,7 +146,7 @@ add_symbol_to_partition_1 (ltrans_partition part, symtab_node *node)
     }
   node->aux = (void *)((size_t)node->aux + 1);
 
-  if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
+  if (cgraph_node *cnode = dyn_cast <cgraph_node *> (node))
     {
       struct cgraph_edge *e;
       if (!node->alias)
@@ -194,14 +194,14 @@ contained_in_symbol (symtab_node *node)
   /* Weakrefs are never contained in anything.  */
   if (node->weakref)
     return node;
-  if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
+  if (cgraph_node *cnode = dyn_cast <cgraph_node *> (node))
     {
       cnode = cgraph_function_node (cnode, NULL);
       if (cnode->global.inlined_to)
 	cnode = cnode->global.inlined_to;
       return cnode;
     }
-  else if (varpool_node *vnode = dyn_cast <varpool_node> (node))
+  else if (varpool_node *vnode = dyn_cast <varpool_node *> (node))
     return varpool_variable_node (vnode, NULL);
   return node;
 }
@@ -252,7 +252,7 @@ undo_partition (ltrans_partition partition, unsigned int n_nodes)
 	pointer_set_destroy (partition->initializers_visited);
       partition->initializers_visited = NULL;
 
-      if (!node->alias && (cnode = dyn_cast <cgraph_node> (node)))
+      if (!node->alias && (cnode = dyn_cast <cgraph_node *> (node)))
         partition->insns -= inline_summary (cnode)->self_size;
       lto_symtab_encoder_delete_node (partition->encoder, node);
       node->aux = (void *)((size_t)node->aux - 1);
@@ -522,7 +522,7 @@ lto_balanced_map (int n_lto_partitions)
 	  symtab_node *snode = lto_symtab_encoder_deref (partition->encoder,
 							last_visited_node);
 
-	  if (cgraph_node *node = dyn_cast <cgraph_node> (snode))
+	  if (cgraph_node *node = dyn_cast <cgraph_node *> (snode))
 	    {
 	      struct cgraph_edge *edge;
 
@@ -577,7 +577,7 @@ lto_balanced_map (int n_lto_partitions)
 	  /* Compute boundary cost of IPA REF edges and at the same time look into
 	     variables referenced from current partition and try to add them.  */
 	  for (j = 0; ipa_ref_list_reference_iterate (refs, j, ref); j++)
-	    if (is_a <varpool_node> (ref->referred))
+	    if (is_a <varpool_node *> (ref->referred))
 	      {
 		int index;
 
@@ -611,7 +611,7 @@ lto_balanced_map (int n_lto_partitions)
 		  cost++;
 	      }
 	  for (j = 0; ipa_ref_list_referring_iterate (refs, j, ref); j++)
-	    if (is_a <varpool_node> (ref->referring))
+	    if (is_a <varpool_node *> (ref->referring))
 	      {
 		int index;
 
@@ -811,7 +811,7 @@ promote_symbol (symtab_node *node)
 static bool
 may_need_named_section_p (lto_symtab_encoder_t encoder, symtab_node *node)
 {
-  struct cgraph_node *cnode = dyn_cast <cgraph_node> (node);
+  struct cgraph_node *cnode = dyn_cast <cgraph_node *> (node);
   if (!cnode)
     return false;
   if (symtab_real_symbol_p (node))
diff --git a/gcc/lto/lto-symtab.c b/gcc/lto/lto-symtab.c
index 8c83d3c..5486e73 100644
--- a/gcc/lto/lto-symtab.c
+++ b/gcc/lto/lto-symtab.c
@@ -560,10 +560,10 @@ lto_symtab_merge_symbols_1 (symtab_node *prevailing)
 
       if (!lto_symtab_symbol_p (e))
 	continue;
-      cgraph_node *ce = dyn_cast <cgraph_node> (e);
+      cgraph_node *ce = dyn_cast <cgraph_node *> (e);
       if (ce && !DECL_BUILT_IN (e->decl))
 	lto_cgraph_replace_node (ce, cgraph (prevailing));
-      if (varpool_node *ve = dyn_cast <varpool_node> (e))
+      if (varpool_node *ve = dyn_cast <varpool_node *> (e))
 	lto_varpool_replace_node (ve, varpool (prevailing));
     }
 
@@ -609,7 +609,7 @@ lto_symtab_merge_symbols (void)
 	    }
 	  node->aux = NULL;
 
-	  if (!(cnode = dyn_cast <cgraph_node> (node))
+	  if (!(cnode = dyn_cast <cgraph_node *> (node))
 	      || !cnode->clone_of
 	      || cnode->clone_of->decl != cnode->decl)
 	    {
@@ -624,11 +624,11 @@ lto_symtab_merge_symbols (void)
 	      /* The user defined assembler variables are also not unified by their
 		 symbol name (since it is irrelevant), but we need to unify symbol
 		 nodes if tree merging occured.  */
-	      if ((vnode = dyn_cast <varpool_node> (node))
+	      if ((vnode = dyn_cast <varpool_node *> (node))
 		  && DECL_HARD_REGISTER (vnode->decl)
 		  && (node2 = symtab_get_node (vnode->decl))
 		  && node2 != node)
-		lto_varpool_replace_node (dyn_cast <varpool_node> (node2),
+		lto_varpool_replace_node (dyn_cast <varpool_node *> (node2),
 					  vnode);
 	  
 
diff --git a/gcc/lto/lto.c b/gcc/lto/lto.c
index ec711ce..5f4478a 100644
--- a/gcc/lto/lto.c
+++ b/gcc/lto/lto.c
@@ -2625,13 +2625,13 @@ lto_wpa_write_files (void)
 	      if (!lto_symtab_encoder_in_partition_p (part->encoder, node))
 		{
 	          fprintf (cgraph_dump_file, "%s ", node->asm_name ());
-		  cgraph_node *cnode = dyn_cast <cgraph_node> (node);
+		  cgraph_node *cnode = dyn_cast <cgraph_node *> (node);
 		  if (cnode
 		      && lto_symtab_encoder_encode_body_p (part->encoder, cnode))
 		    fprintf (cgraph_dump_file, "(body included)");
 		  else
 		    {
-		      varpool_node *vnode = dyn_cast <varpool_node> (node);
+		      varpool_node *vnode = dyn_cast <varpool_node *> (node);
 		      if (vnode
 			  && lto_symtab_encoder_encode_initializer_p (part->encoder, vnode))
 			fprintf (cgraph_dump_file, "(initializer included)");
diff --git a/gcc/symtab.c b/gcc/symtab.c
index 4db4870..f948e77 100644
--- a/gcc/symtab.c
+++ b/gcc/symtab.c
@@ -192,7 +192,7 @@ eq_assembler_name (const void *p1, const void *p2)
 static void
 insert_to_assembler_name_hash (symtab_node *node, bool with_clones)
 {
-  if (is_a <varpool_node> (node) && DECL_HARD_REGISTER (node->decl))
+  if (is_a <varpool_node *> (node) && DECL_HARD_REGISTER (node->decl))
     return;
   gcc_checking_assert (!node->previous_sharing_asm_name
 		       && !node->next_sharing_asm_name);
@@ -214,7 +214,7 @@ insert_to_assembler_name_hash (symtab_node *node, bool with_clones)
       *aslot = node;
 
       /* Update also possible inline clones sharing a decl.  */
-      cnode = dyn_cast <cgraph_node> (node);
+      cnode = dyn_cast <cgraph_node *> (node);
       if (cnode && cnode->clones && with_clones)
 	for (cnode = cnode->clones; cnode; cnode = cnode->next_sibling_clone)
 	  if (cnode->decl == decl)
@@ -258,7 +258,7 @@ unlink_from_assembler_name_hash (symtab_node *node, bool with_clones)
       node->previous_sharing_asm_name = NULL;
 
       /* Update also possible inline clones sharing a decl.  */
-      cnode = dyn_cast <cgraph_node> (node);
+      cnode = dyn_cast <cgraph_node *> (node);
       if (cnode && cnode->clones && with_clones)
 	for (cnode = cnode->clones; cnode; cnode = cnode->next_sibling_clone)
 	  if (cnode->decl == decl)
@@ -364,14 +364,14 @@ symtab_unregister_node (symtab_node *node)
   if (slot && *slot && *slot == node)
     {
       symtab_node *replacement_node = NULL;
-      if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
+      if (cgraph_node *cnode = dyn_cast <cgraph_node *> (node))
 	replacement_node = cgraph_find_replacement_node (cnode);
       if (!replacement_node)
 	htab_clear_slot (symtab_hash, slot);
       else
 	*slot = replacement_node;
     }
-  if (!is_a <varpool_node> (node) || !DECL_HARD_REGISTER (node->decl))
+  if (!is_a <varpool_node *> (node) || !DECL_HARD_REGISTER (node->decl))
     unlink_from_assembler_name_hash (node, false);
 }
 
@@ -411,9 +411,9 @@ symtab_get_node (const_tree decl)
 void
 symtab_remove_node (symtab_node *node)
 {
-  if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
+  if (cgraph_node *cnode = dyn_cast <cgraph_node *> (node))
     cgraph_remove_node (cnode);
-  else if (varpool_node *vnode = dyn_cast <varpool_node> (node))
+  else if (varpool_node *vnode = dyn_cast <varpool_node *> (node))
     varpool_remove_node (vnode);
 }
 
@@ -690,9 +690,9 @@ dump_symtab_base (FILE *f, symtab_node *node)
 void
 dump_symtab_node (FILE *f, symtab_node *node)
 {
-  if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
+  if (cgraph_node *cnode = dyn_cast <cgraph_node *> (node))
     dump_cgraph_node (f, cnode);
-  else if (varpool_node *vnode = dyn_cast <varpool_node> (node))
+  else if (varpool_node *vnode = dyn_cast <varpool_node *> (node))
     dump_varpool_node (f, vnode);
 }
 
@@ -731,7 +731,7 @@ verify_symtab_base (symtab_node *node)
   bool error_found = false;
   symtab_node *hashed_node;
 
-  if (is_a <cgraph_node> (node))
+  if (is_a <cgraph_node *> (node))
     {
       if (TREE_CODE (node->decl) != FUNCTION_DECL)
 	{
@@ -739,7 +739,7 @@ verify_symtab_base (symtab_node *node)
           error_found = true;
 	}
     }
-  else if (is_a <varpool_node> (node))
+  else if (is_a <varpool_node *> (node))
     {
       if (TREE_CODE (node->decl) != VAR_DECL)
 	{
@@ -762,9 +762,9 @@ verify_symtab_base (symtab_node *node)
 	  error_found = true;
 	}
       if (hashed_node != node
-	  && (!is_a <cgraph_node> (node)
-	      || !dyn_cast <cgraph_node> (node)->clone_of
-	      || dyn_cast <cgraph_node> (node)->clone_of->decl
+	  && (!is_a <cgraph_node *> (node)
+	      || !dyn_cast <cgraph_node *> (node)->clone_of
+	      || dyn_cast <cgraph_node *> (node)->clone_of->decl
 		 != node->decl))
 	{
 	  error ("node differs from symtab decl hashtable");
@@ -786,7 +786,7 @@ verify_symtab_base (symtab_node *node)
 	  hashed_node = hashed_node->next_sharing_asm_name;
 	}
       if (!hashed_node
-          && !(is_a <varpool_node> (node)
+          && !(is_a <varpool_node *> (node)
 	       || DECL_HARD_REGISTER (node->decl)))
 	{
           error ("node not found in symtab assembler name hash");
@@ -878,7 +878,7 @@ verify_symtab_node (symtab_node *node)
     return;
 
   timevar_push (TV_CGRAPH_VERIFY);
-  if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
+  if (cgraph_node *cnode = dyn_cast <cgraph_node *> (node))
     verify_cgraph_node (cnode);
   else
     if (verify_symtab_base (node))
@@ -973,7 +973,7 @@ symtab_make_decl_local (tree decl)
 enum availability
 symtab_node_availability (symtab_node *node)
 {
-  if (is_a <cgraph_node> (node))
+  if (is_a <cgraph_node *> (node))
     return cgraph_function_body_availability (cgraph (node));
   else
     return cgraph_variable_initializer_availability (varpool (node));
@@ -1061,7 +1061,7 @@ symtab_alias_ultimate_target (symtab_node *node, enum availability *availability
 void
 fixup_same_cpp_alias_visibility (symtab_node *node, symtab_node *target)
 {
-  if (is_a <cgraph_node> (node))
+  if (is_a <cgraph_node *> (node))
     {
       DECL_DECLARED_INLINE_P (node->decl)
 	 = DECL_DECLARED_INLINE_P (target->decl);
@@ -1108,9 +1108,9 @@ symtab_resolve_alias (symtab_node *node, symtab_node *target)
        n = n->analyzed ? symtab_alias_target (n) : NULL)
     if (n == node)
        {
-	 if (is_a <cgraph_node> (node))
+	 if (is_a <cgraph_node *> (node))
            error ("function %q+D part of alias cycle", node->decl);
-         else if (is_a <varpool_node> (node))
+         else if (is_a <varpool_node *> (node))
            error ("variable %q+D part of alias cycle", node->decl);
 	 else
 	   gcc_unreachable ();
@@ -1277,7 +1277,7 @@ symtab_get_symbol_partitioning_class (symtab_node *node)
 {
   /* Inline clones are always duplicated.
      This include external delcarations.   */
-  cgraph_node *cnode = dyn_cast <cgraph_node> (node);
+  cgraph_node *cnode = dyn_cast <cgraph_node *> (node);
 
   if (DECL_ABSTRACT (node->decl))
     return SYMBOL_EXTERNAL;
@@ -1293,7 +1293,7 @@ symtab_get_symbol_partitioning_class (symtab_node *node)
   if (DECL_EXTERNAL (node->decl))
     return SYMBOL_EXTERNAL;
 
-  if (varpool_node *vnode = dyn_cast <varpool_node> (node))
+  if (varpool_node *vnode = dyn_cast <varpool_node *> (node))
     {
       /* Constant pool references use local symbol names that can not
          be promoted global.  We should never put into a constant pool
diff --git a/gcc/tree-phinodes.c b/gcc/tree-phinodes.c
index 9dff6ad..0be431e 100644
--- a/gcc/tree-phinodes.c
+++ b/gcc/tree-phinodes.c
@@ -115,7 +115,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 <gimple_statement_phi *> (free_phinodes[bucket]->pop ());
       if (free_phinodes[bucket]->is_empty ())
 	vec_free (free_phinodes[bucket]);
       if (GATHER_STATISTICS)
@@ -297,7 +297,7 @@ 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));
+	as_a <gimple_statement_phi *> (gsi_stmt (gsi));
 
       if (len > gimple_phi_capacity (stmt))
 	{
@@ -436,7 +436,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 <gimple_statement_phi *> (gsi_stmt (gsi)),
 			e->dest_idx);
 }
 
diff --git a/gcc/varpool.c b/gcc/varpool.c
index b5493ab..69172c6 100644
--- a/gcc/varpool.c
+++ b/gcc/varpool.c
@@ -238,7 +238,7 @@ varpool_node *
 varpool_node_for_asm (tree asmname)
 {
   if (symtab_node *node = symtab_node_for_asm (asmname))
-    return dyn_cast <varpool_node> (node);
+    return dyn_cast <varpool_node *> (node);
   else
     return NULL;
 }
@@ -521,14 +521,14 @@ varpool_remove_unreferenced_decls (void)
 	       next != node;
 	       next = next->same_comdat_group)
 	    {
-	      varpool_node *vnext = dyn_cast <varpool_node> (next);
+	      varpool_node *vnext = dyn_cast <varpool_node *> (next);
 	      if (vnext && vnext->analyzed && !symtab_comdat_local_p (next))
 		enqueue_node (vnext, &first);
 	    }
 	}
       for (i = 0; ipa_ref_list_reference_iterate (&node->ref_list, i, ref); i++)
 	{
-	  varpool_node *vnode = dyn_cast <varpool_node> (ref->referred);
+	  varpool_node *vnode = dyn_cast <varpool_node *> (ref->referred);
 	  if (vnode
 	      && !vnode->in_other_partition
 	      && (!DECL_EXTERNAL (ref->referred->decl)