From 9e6709cbdd8c2bfa20b55a3532a3922ffa527342 Mon Sep 17 00:00:00 2001
From: David Malcolm <dmalcolm@redhat.com>
Date: Tue, 13 May 2014 13:12:39 -0400
Subject: [PATCH 02/29] Autogenerated part of conversion of "gimple" to "gimple
 *"

gcc/

	Patch autogenerated by rename_gimple.py from
	https://github.com/davidmalcolm/gcc-refactoring-scripts
	revision d0dcc1bc64a800765492e0c76ba714090414f555

	* asan.c (has_mem_ref_been_instrumented): Replace "gimple" typedef
	with "gimple *".
	(get_mem_ref_of_assignment): Likewise.
	(get_mem_refs_of_builtin_call): Likewise.
	(create_cond_insert_point): Likewise.
	(build_check_stmt): Likewise.
	(instrument_mem_region_access): Likewise.
	(instrument_strlen_call): Likewise.
	(instrument_builtin_call): Likewise.
	(maybe_instrument_assignment): Likewise.
	(maybe_instrument_call): Likewise.
	(transform_statements): Likewise.
	(make_pass_asan_O0): Likewise.
	* builtins.c (validate_arg): Likewise.
	(do_mpc_arg2): Likewise.
	(gimple_fold_builtin_sprintf_chk): Likewise.
	(gimple_fold_builtin_snprintf_chk): Likewise.
	(gimple_fold_builtin_varargs): Likewise.
	* builtins.h (validate_gimple_arglist): Likewise.
	* calls.c (setjmp_call_p): Likewise.
	* calls.h (gimple_alloca_call_p): Likewise.
	* cfgexpand.c (Copyright): Likewise.
	(gimple_assign_rhs_to_tree): Likewise.
	(stack_var_conflict_p): Likewise.
	(visit_op): Likewise.
	(add_scope_conflicts_1): Likewise.
	(stack_protect_return_slot_p): Likewise.
	(expand_used_vars): Likewise.
	(label_rtx_for_bb): Likewise.
	(maybe_cleanup_end_of_block): Likewise.
	(expand_gimple_cond): Likewise.
	(mark_transaction_restart_calls): Likewise.
	(expand_call_stmt): Likewise.
	(expand_asm_operands): Likewise.
	(expand_return): Likewise.
	(expand_gimple_stmt_1): Likewise.
	(expand_gimple_stmt): Likewise.
	(expand_debug_expr): Likewise.
	(expand_gimple_basic_block): Likewise.
	(discover_nonconstant_array_refs): Likewise.
	* cfgexpand.h (gimple_assign_rhs_to_tree): Likewise.
	* cfgloop.c (find_subloop_latch_edge_by_ivs): Likewise.
	* cfgloop.h (GTY): Likewise.
	* cfgloopmanip.c (create_empty_if_region_on_edge): Likewise.
	(create_empty_loop_on_edge): Likewise.
	* cgraph.c (cgraph_add_edge_to_call_site_hash): Likewise.
	(cgraph_edge): Likewise.
	(cgraph_set_call_stmt): Likewise.
	(cgraph_create_edge_1): Likewise.
	(cgraph_allocate_init_indirect_info): Likewise.
	(cgraph_make_edge_direct): Likewise.
	(cgraph_redirect_edge_call_stmt_to_callee): Likewise.
	(cgraph_update_edges_for_call_stmt_node): Likewise.
	(verify_edge_count_and_frequency): Likewise.
	(verify_cgraph_node): Likewise.
	(cgraph_get_body): Likewise.
	(gimple_check_call_args): Likewise.
	* cgraph.h (delete_function_version): Likewise.
	(cgraph_create_edge): Likewise.
	(cgraph_create_indirect_edge): Likewise.
	(cgraph_edge): Likewise.
	(cgraph_set_call_stmt): Likewise.
	(cgraph_update_edges_for_call_stmt): Likewise.
	(cgraph_remove_node_duplication_hook): Likewise.
	(cgraph_turn_edge_to_speculative): Likewise.
	* cgraphbuild.c (compute_call_stmt_bb_frequency): Likewise.
	(mark_address): Likewise.
	(mark_load): Likewise.
	(mark_store): Likewise.
	(ipa_record_stmt_references): Likewise.
	(rebuild_cgraph_edges): Likewise.
	* cgraphclones.c (function): Likewise.
	(cgraph_find_replacement_node): Likewise.
	(cgraph_set_call_stmt_including_clones): Likewise.
	* cgraphunit.c (thunk_adjust): Likewise.
	(expand_thunk): Likewise.
	* config/aarch64/aarch64-builtins.c (aarch64_gimple_fold_builtin):
	Likewise.
	* config/alpha/alpha.c (alpha_build_builtin_va_list): Likewise.
	(va_list_skip_additions): Likewise.
	(alpha_stdarg_optimize_hook): Likewise.
	(alpha_gimple_fold_builtin): Likewise.
	* config/i386/i386.c (add_condition_to_bb): Likewise.
	(dispatch_function_versions): Likewise.
	(ix86_expand_builtin): Likewise.
	* config/rs6000/rs6000.c (rs6000_density_test): Likewise.
	(rs6000_gimplify_va_arg): Likewise.
	* dumpfile.c (dump_loc): Likewise.
	(dump_gimple_stmt): Likewise.
	* dumpfile.h (dump_gimple_stmt_loc): Likewise.
	(dump_gimple_stmt): Likewise.
	* except.h (finish_eh_generation): Likewise.
	* expr.c (use_group_regs): Likewise.
	(get_def_for_expr): Likewise.
	(get_def_for_expr_class): Likewise.
	(optimize_bitfield_assignment_op): Likewise.
	(store_field): Likewise.
	(expand_cond_expr_using_cmove): Likewise.
	(expand_expr_real_2): Likewise.
	(expand_expr_real_1): Likewise.
	(do_store_flag): Likewise.
	* expr.h (expand_normal): Likewise.
	* fold-const.c (fold_defer_overflow_warnings): Likewise.
	* fold-const.h (fold_undefer_overflow_warnings): Likewise.
	* ggc.h (ggc_alloc_cleared_tree_node_stat): Likewise.
	(ggc_alloc_cleared_gimple_stat): Likewise.
	* gimple-builder.c (get_expr_type): Likewise.
	(build_assign): Likewise.
	(build_type_cast): Likewise.
	* gimple-builder.h (Copyright): Likewise.
	(build_assign): Likewise.
	(build_type_cast): Likewise.
	* gimple-fold.c (fold_gimple_assign): Likewise.
	(gimplify_and_update_call_from_tree): Likewise.
	(get_maxval_strlen): Likewise.
	(gimple_fold_call): Likewise.
	(fold_stmt_1): Likewise.
	(fold_stmt_inplace): Likewise.
	(same_bool_comparison_p): Likewise.
	(and_var_with_comparison): Likewise.
	(and_var_with_comparison_1): Likewise.
	(and_comparisons_1): Likewise.
	(or_var_with_comparison): Likewise.
	(or_var_with_comparison_1): Likewise.
	(or_comparisons_1): Likewise.
	(maybe_fold_or_comparisons): Likewise.
	(gimple_fold_stmt_to_constant_1): Likewise.
	(gimple_val_nonnegative_real_p): Likewise.
	(arith_code_with_undefined_signed_overflow): Likewise.
	(rewrite_to_defined_overflow): Likewise.
	* gimple-fold.h (gimple_fold_builtin): Likewise.
	(gimple_fold_stmt_to_constant_1): Likewise.
	(gimple_fold_stmt_to_constant): Likewise.
	(rewrite_to_defined_overflow): Likewise.
	* gimple-iterator.c (update_modified_stmt): Likewise.
	(gsi_split_seq_after): Likewise.
	(gsi_set_stmt): Likewise.
	(gsi_split_seq_before): Likewise.
	(gsi_replace): Likewise.
	(gsi_replace_with_seq): Likewise.
	(gsi_insert_before_without_update): Likewise.
	(gsi_insert_before): Likewise.
	(gsi_insert_after_without_update): Likewise.
	(gsi_remove): Likewise.
	(gsi_move_after): Likewise.
	(gsi_move_before): Likewise.
	(gsi_move_to_bb_end): Likewise.
	(gimple_find_edge_insert_loc): Likewise.
	* gimple-iterator.h (gsi_set_stmt): Likewise.
	(gsi_replace): Likewise.
	(gsi_insert_before_without_update): Likewise.
	(gsi_insert_before): Likewise.
	(gsi_insert_after_without_update): Likewise.
	(gsi_insert_after): Likewise.
	(gsi_for_stmt): Likewise.
	(gsi_insert_on_edge): Likewise.
	(gsi_insert_on_edge_immediate): Likewise.
	(gsi_prev): Likewise.
	* gimple-low.c (hierarchy): Likewise.
	(lower_function_body): Likewise.
	(lower_omp_directive): Likewise.
	(lower_stmt): Likewise.
	(lower_gimple_bind): Likewise.
	(lower_try_catch): Likewise.
	(gimple_try_catch_may_fallthru): Likewise.
	(lower_gimple_return): Likewise.
	(lower_builtin_setjmp): Likewise.
	(lower_builtin_posix_memalign): Likewise.
	* gimple-low.h (gimple_stmt_may_fallthru): Likewise.
	* gimple-pretty-print.c (do_niy): Likewise.
	(newline_and_indent): Likewise.
	(debug_gimple_stmt): Likewise.
	(debug): Likewise.
	(dump_gimple_seq): Likewise.
	(dump_gimple_fmt): Likewise.
	(dump_unary_rhs): Likewise.
	(dump_binary_rhs): Likewise.
	(dump_ternary_rhs): Likewise.
	(dump_gimple_assign): Likewise.
	(dump_gimple_return): Likewise.
	(pp_points_to_solution): Likewise.
	(dump_gimple_call): Likewise.
	(dump_gimple_switch): Likewise.
	(dump_gimple_cond): Likewise.
	(dump_gimple_label): Likewise.
	(dump_gimple_goto): Likewise.
	(dump_gimple_bind): Likewise.
	(dump_gimple_try): Likewise.
	(dump_gimple_catch): Likewise.
	(dump_gimple_eh_filter): Likewise.
	(dump_gimple_eh_must_not_throw): Likewise.
	(dump_gimple_eh_else): Likewise.
	(dump_gimple_resx): Likewise.
	(dump_gimple_eh_dispatch): Likewise.
	(dump_gimple_debug): Likewise.
	(dump_gimple_omp_for): Likewise.
	(dump_gimple_omp_continue): Likewise.
	(dump_gimple_omp_single): Likewise.
	(dump_gimple_omp_target): Likewise.
	(dump_gimple_omp_teams): Likewise.
	(dump_gimple_omp_sections): Likewise.
	(dump_gimple_omp_block): Likewise.
	(dump_gimple_omp_critical): Likewise.
	(dump_gimple_omp_return): Likewise.
	(dump_gimple_transaction): Likewise.
	(dump_ssaname_info): Likewise.
	(dump_gimple_phi): Likewise.
	(dump_gimple_omp_parallel): Likewise.
	(dump_gimple_omp_task): Likewise.
	(dump_gimple_omp_atomic_load): Likewise.
	(dump_gimple_omp_atomic_store): Likewise.
	(dump_gimple_mem_ops): Likewise.
	(dump_gimple_bb_header): Likewise.
	(dump_phi_nodes): Likewise.
	(pp_cfg_jump): Likewise.
	(dump_implicit_edges): Likewise.
	(gimple_dump_bb_buff): Likewise.
	(gimple_dump_bb_for_graph): Likewise.
	* gimple-pretty-print.h (debug_gimple_stmt): Likewise.
	(print_gimple_stmt): Likewise.
	(print_gimple_expr): Likewise.
	(pp_gimple_stmt_1): Likewise.
	* gimple-ssa-isolate-paths.c (check_loadstore): Likewise.
	(insert_trap_and_remove_trailing_statements): Likewise.
	(find_implicit_erroneous_behaviour): Likewise.
	(find_explicit_erroneous_behaviour): Likewise.
	* gimple-ssa-strength-reduction.c (of): Likewise.
	(record_potential_basis): Likewise.
	(alloc_cand_and_find_basis): Likewise.
	(base_cand_from_table): Likewise.
	(add_cand_for_stmt): Likewise.
	(slsr_process_phi): Likewise.
	(restructure_reference): Likewise.
	(slsr_process_ref): Likewise.
	(create_mul_ssa_cand): Likewise.
	(create_mul_imm_cand): Likewise.
	(slsr_process_mul): Likewise.
	(create_add_ssa_cand): Likewise.
	(create_add_imm_cand): Likewise.
	(slsr_process_add): Likewise.
	(legal_cast_p_1): Likewise.
	(legal_cast_p): Likewise.
	(slsr_process_cast): Likewise.
	(slsr_process_copy): Likewise.
	(replace_mult_candidate): Likewise.
	(create_add_on_incoming_edge): Likewise.
	(create_phi_basis): Likewise.
	(replace_conditional_candidate): Likewise.
	(phi_add_costs): Likewise.
	(replace_uncond_cands_and_profitable_phis): Likewise.
	(record_increment): Likewise.
	(record_phi_increments): Likewise.
	(record_increments): Likewise.
	(phi_incr_cost): Likewise.
	(lowest_cost_path): Likewise.
	(total_savings): Likewise.
	(ncd_for_two_cands): Likewise.
	(ncd_with_phi): Likewise.
	(insert_initializers): Likewise.
	(all_phi_incrs_profitable): Likewise.
	(introduce_cast_before_cand): Likewise.
	(replace_one_candidate): Likewise.
	(replace_profitable_candidates): Likewise.
	* gimple-ssa.h (gimple_vop): Likewise.
	(Copyright): Likewise.
	(gimple_vuse_op): Likewise.
	(gimple_vdef_op): Likewise.
	(update_stmt): Likewise.
	(update_stmt_if_modified): Likewise.
	* gimple-streamer-in.c (Copyright): Likewise.
	(input_phi): Likewise.
	(input_gimple_stmt): Likewise.
	(input_bb): Likewise.
	* gimple-streamer-out.c (output_phi): Likewise.
	(output_bb): Likewise.
	* gimple-walk.c (callback): Likewise.
	(walk_gimple_seq_mod): Likewise.
	(walk_gimple_seq): Likewise.
	(walk_gimple_asm): Likewise.
	(walk_gimple_stmt): Likewise.
	(get_base_loadstore): Likewise.
	(walk_stmt_load_store_addr_ops): Likewise.
	* gimple-walk.h (tree): Likewise.
	(walk_gimple_seq_mod): Likewise.
	(walk_gimple_op): Likewise.
	(bool): Likewise.
	(walk_stmt_load_store_addr_ops): Likewise.
	(walk_stmt_load_store_ops): Likewise.
	* gimple.c (gimple_call_same_target_p): Likewise.
	(gimple_call_flags): Likewise.
	(gimple_call_fnspec): Likewise.
	(gimple_call_arg_flags): Likewise.
	(validate_type): Likewise.
	(gimple_builtin_call_types_compatible_p): Likewise.
	(gimple_call_builtin_p): Likewise.
	(gimple_set_code): Likewise.
	(gimple_size): Likewise.
	(gimple_alloc_stat): Likewise.
	(gimple_set_subcode): Likewise.
	(gimple_build_with_ops_stat): Likewise.
	(gimple_build_return): Likewise.
	(gimple_call_reset_alias_info): Likewise.
	(gimple_build_call_1): Likewise.
	(gimple_build_call_vec): Likewise.
	(gimple_build_call): Likewise.
	(gimple_build_call_valist): Likewise.
	(gimple_build_call_internal_1): Likewise.
	(gimple_build_call_internal): Likewise.
	(gimple_build_call_internal_vec): Likewise.
	(gimple_build_call_from_tree): Likewise.
	(gimple_build_assign_stat): Likewise.
	(gimple_build_assign_with_ops): Likewise.
	(gimple_build_cond): Likewise.
	(gimple_build_cond_from_tree): Likewise.
	(gimple_cond_set_condition_from_tree): Likewise.
	(gimple_build_label): Likewise.
	(gimple_build_goto): Likewise.
	(gimple_build_nop): Likewise.
	(gimple_build_bind): Likewise.
	(gimple_build_asm_1): Likewise.
	(gimple_build_asm_vec): Likewise.
	(gimple_build_catch): Likewise.
	(gimple_build_eh_filter): Likewise.
	(gimple_build_eh_must_not_throw): Likewise.
	(gimple_build_eh_else): Likewise.
	(gimple_build_try): Likewise.
	(gimple_build_wce): Likewise.
	(gimple_build_resx): Likewise.
	(gimple_build_switch_nlabels): Likewise.
	(gimple_build_switch): Likewise.
	(gimple_build_eh_dispatch): Likewise.
	(gimple_build_debug_bind_stat): Likewise.
	(gimple_build_debug_source_bind_stat): Likewise.
	(gimple_build_omp_critical): Likewise.
	(gimple_build_omp_for): Likewise.
	(gimple_build_omp_parallel): Likewise.
	(gimple_build_omp_task): Likewise.
	(gimple_build_omp_section): Likewise.
	(gimple_build_omp_master): Likewise.
	(gimple_build_omp_taskgroup): Likewise.
	(gimple_build_omp_continue): Likewise.
	(gimple_build_omp_ordered): Likewise.
	(gimple_build_omp_return): Likewise.
	(gimple_build_omp_sections): Likewise.
	(gimple_build_omp_sections_switch): Likewise.
	(gimple_build_omp_single): Likewise.
	(gimple_build_omp_target): Likewise.
	(gimple_build_omp_teams): Likewise.
	(gimple_build_omp_atomic_load): Likewise.
	(gimple_build_omp_atomic_store): Likewise.
	(gimple_build_transaction): Likewise.
	(gimple_build_predict): Likewise.
	(gimple_check_failed): Likewise.
	(gimple_seq_add_stmt): Likewise.
	(gimple_seq_add_seq): Likewise.
	(should_carry_location_p): Likewise.
	(annotate_all_with_location): Likewise.
	(gimple_seq_copy): Likewise.
	(gimple_call_return_flags): Likewise.
	(gimple_assign_copy_p): Likewise.
	(gimple_assign_ssa_name_copy_p): Likewise.
	(gimple_assign_unary_nop_p): Likewise.
	(gimple_assign_set_rhs_with_ops_1): Likewise.
	(gimple_get_lhs): Likewise.
	(gimple_set_lhs): Likewise.
	(gimple_copy): Likewise.
	(gimple_has_side_effects): Likewise.
	(gimple_could_trap_p_1): Likewise.
	(gimple_could_trap_p): Likewise.
	(canonicalize_cond_expr_cond): Likewise.
	(gimple_call_copy_skip_args): Likewise.
	(gimple_get_alias_set): Likewise.
	(gimple_ior_addresses_taken_1): Likewise.
	(dump_decl_set): Likewise.
	(nonfreeing_call_p): Likewise.
	(check_loadstore): Likewise.
	* gimple.h (gimple_call_same_target_p): Likewise.
	(gimple_call_flags): Likewise.
	(gimple_call_arg_flags): Likewise.
	(gimple_call_return_flags): Likewise.
	(gimple_get_lhs): Likewise.
	(gimple_has_side_effects): Likewise.
	(gimple_builtin_call_types_compatible_p): Likewise.
	(gimple_call_builtin_p): Likewise.
	(gimple_asm_clobbers_memory_p): Likewise.
	(set_bb_seq): Likewise.
	(gimple_has_substatements): Likewise.
	(gimple_bb): Likewise.
	(gimple_set_block): Likewise.
	(gimple_location): Likewise.
	(gimple_set_location): Likewise.
	(gimple_has_location): Likewise.
	(gimple_filename): Likewise.
	(gimple_seq_singleton_p): Likewise.
	(gimple_set_uid): Likewise.
	(gimple_init_singleton): Likewise.
	(gimple_set_use_ops): Likewise.
	(gimple_vuse): Likewise.
	(gimple_set_vdef): Likewise.
	(gimple_set_modified): Likewise.
	(gimple_expr_code): Likewise.
	(gimple_references_memory_p): Likewise.
	(gimple_omp_return_set_nowait): Likewise.
	(gimple_omp_return_set_lhs): Likewise.
	(gimple_omp_return_lhs_ptr): Likewise.
	(gimple_omp_section_set_last): Likewise.
	(gimple_omp_parallel_set_combined_p): Likewise.
	(gimple_omp_atomic_set_need_value): Likewise.
	(gimple_omp_atomic_set_seq_cst): Likewise.
	(gimple_ops): Likewise.
	(gimple_op): Likewise.
	(gimple_set_op): Likewise.
	(get_gimple_rhs_class): Likewise.
	(gimple_assign_lhs): Likewise.
	(gimple_assign_set_lhs): Likewise.
	(gimple_assign_rhs1): Likewise.
	(gimple_assign_set_rhs1): Likewise.
	(gimple_assign_rhs2): Likewise.
	(gimple_assign_set_rhs2): Likewise.
	(gimple_assign_rhs3): Likewise.
	(gimple_assign_set_rhs_with_ops): Likewise.
	(gimple_assign_set_nontemporal_move): Likewise.
	(gimple_assign_set_rhs_code): Likewise.
	(gimple_assign_rhs_class): Likewise.
	(gimple_assign_single_p): Likewise.
	(gimple_store_p): Likewise.
	(gimple_assign_load_p): Likewise.
	(gimple_assign_cast_p): Likewise.
	(gimple_clobber_p): Likewise.
	(is_gimple_call): Likewise.
	(gimple_call_lhs): Likewise.
	(gimple_call_set_lhs): Likewise.
	(gimple_call_internal_p): Likewise.
	(gimple_call_internal_fn): Likewise.
	(gimple_call_set_fntype): Likewise.
	(gimple_call_fn): Likewise.
	(gimple_call_set_internal_fn): Likewise.
	(gimple_call_fndecl): Likewise.
	(gimple_call_return_type): Likewise.
	(gimple_call_chain): Likewise.
	(gimple_call_set_chain): Likewise.
	(gimple_call_num_args): Likewise.
	(gimple_call_arg): Likewise.
	(gimple_has_lhs): Likewise.
	(gimple_cond_set_code): Likewise.
	(gimple_cond_lhs): Likewise.
	(gimple_cond_set_lhs): Likewise.
	(gimple_cond_rhs): Likewise.
	(gimple_cond_set_rhs): Likewise.
	(gimple_cond_set_false_label): Likewise.
	(gimple_cond_make_true): Likewise.
	(gimple_cond_true_p): Likewise.
	(gimple_cond_set_condition): Likewise.
	(gimple_label_set_label): Likewise.
	(gimple_goto_set_dest): Likewise.
	(gimple_bind_add_seq): 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_set_input_op): Likewise.
	(gimple_asm_output_op): Likewise.
	(gimple_asm_set_output_op): Likewise.
	(gimple_asm_set_clobber_op): Likewise.
	(gimple_asm_set_label_op): Likewise.
	(gimple_asm_string): Likewise.
	(gimple_asm_set_input): Likewise.
	(gimple_asm_input_p): Likewise.
	(gimple_catch_set_handler): Likewise.
	(gimple_eh_else_set_e_body): Likewise.
	(gimple_try_set_kind): Likewise.
	(gimple_wce_set_cleanup): Likewise.
	(gimple_wce_set_cleanup_eh_only): Likewise.
	(gimple_phi_capacity): Likewise.
	(gimple_phi_num_args): Likewise.
	(gimple_phi_arg_has_location): Likewise.
	(gimple_resx_set_region): Likewise.
	(gimple_eh_dispatch_set_region): Likewise.
	(gimple_switch_set_num_labels): Likewise.
	(gimple_switch_index): Likewise.
	(gimple_switch_set_index): Likewise.
	(gimple_switch_set_label): Likewise.
	(gimple_switch_set_default_label): Likewise.
	(is_gimple_debug): Likewise.
	(gimple_debug_bind_has_value_p): Likewise.
	(gimple_debug_source_bind_set_value): Likewise.
	(gimple_omp_set_body): Likewise.
	(gimple_omp_critical_set_name): Likewise.
	(gimple_omp_for_set_kind): Likewise.
	(gimple_omp_for_set_combined_p): Likewise.
	(gimple_omp_for_set_combined_into_p): Likewise.
	(gimple_omp_for_collapse): Likewise.
	(gimple_omp_for_set_index): Likewise.
	(gimple_omp_for_set_initial): Likewise.
	(gimple_omp_for_set_final): Likewise.
	(gimple_omp_for_set_pre_body): Likewise.
	(gimple_omp_parallel_set_clauses): Likewise.
	(gimple_omp_parallel_set_child_fn): Likewise.
	(gimple_omp_parallel_set_data_arg): Likewise.
	(gimple_omp_task_set_clauses): Likewise.
	(gimple_omp_task_set_child_fn): Likewise.
	(gimple_omp_task_set_data_arg): Likewise.
	(gimple_omp_taskreg_set_clauses): Likewise.
	(gimple_omp_taskreg_set_child_fn): Likewise.
	(gimple_omp_taskreg_set_data_arg): Likewise.
	(gimple_omp_task_set_copy_fn): Likewise.
	(gimple_omp_task_set_arg_size): Likewise.
	(gimple_omp_task_set_arg_align): Likewise.
	(gimple_omp_single_set_clauses): Likewise.
	(gimple_omp_target_set_clauses): Likewise.
	(gimple_omp_target_set_kind): Likewise.
	(gimple_omp_target_set_child_fn): Likewise.
	(gimple_omp_target_set_data_arg): Likewise.
	(gimple_omp_teams_set_clauses): Likewise.
	(gimple_omp_sections_set_clauses): Likewise.
	(gimple_omp_for_set_cond): Likewise.
	(gimple_omp_atomic_store_set_val): Likewise.
	(gimple_omp_atomic_load_set_lhs): Likewise.
	(gimple_omp_atomic_load_set_rhs): Likewise.
	(gimple_omp_atomic_load_rhs_ptr): Likewise.
	(gimple_omp_continue_set_control_def): Likewise.
	(gimple_transaction_body): Likewise.
	(gimple_transaction_label_ptr): Likewise.
	(gimple_transaction_set_subcode): Likewise.
	(gimple_return_retval_ptr): Likewise.
	(gimple_return_set_retval): Likewise.
	(is_gimple_omp): Likewise.
	(gimple_nop_p): Likewise.
	(gimple_predict_set_outcome): Likewise.
	(Copyright): Likewise.
	(gimple_check_failed): Likewise.
	(GTY): Likewise.
	(gimple_alloc_stat): Likewise.
	(gimple_call_reset_alias_info): Likewise.
	(gimple_build_call_vec): Likewise.
	(gimple_build_call): Likewise.
	(gimple_build_call_valist): Likewise.
	(gimple_build_call_internal): Likewise.
	(gimple_build_call_internal_vec): Likewise.
	(gimple_build_call_from_tree): Likewise.
	(gimple_build_assign_stat): Likewise.
	(gimple_build_assign_with_ops): Likewise.
	(gimple_build_cond): Likewise.
	(gimple_cond_set_condition_from_tree): Likewise.
	(gimple_build_label): Likewise.
	(gimple_build_goto): Likewise.
	(gimple_build_nop): Likewise.
	(gimple_build_bind): Likewise.
	(gimple_build_asm_vec): Likewise.
	(gimple_build_catch): Likewise.
	(gimple_build_eh_filter): Likewise.
	(gimple_build_eh_must_not_throw): Likewise.
	(gimple_build_try): Likewise.
	(gimple_build_wce): Likewise.
	(gimple_build_resx): Likewise.
	(gimple_build_switch_nlabels): Likewise.
	(gimple_build_switch): Likewise.
	(gimple_build_eh_dispatch): Likewise.
	(gimple_build_debug_bind_stat): Likewise.
	(gimple_build_debug_source_bind_stat): Likewise.
	(gimple_build_omp_critical): Likewise.
	(gimple_build_omp_for): Likewise.
	(gimple_build_omp_parallel): Likewise.
	(gimple_build_omp_task): Likewise.
	(gimple_build_omp_section): Likewise.
	(gimple_build_omp_master): Likewise.
	(gimple_build_omp_taskgroup): Likewise.
	(gimple_build_omp_continue): Likewise.
	(gimple_build_omp_ordered): Likewise.
	(gimple_build_omp_return): Likewise.
	(gimple_build_omp_sections): Likewise.
	(gimple_build_omp_sections_switch): Likewise.
	(gimple_build_omp_single): Likewise.
	(gimple_build_omp_target): Likewise.
	(gimple_build_omp_teams): Likewise.
	(gimple_build_omp_atomic_load): Likewise.
	(gimple_build_omp_atomic_store): Likewise.
	(gimple_build_transaction): Likewise.
	(gimple_seq_add_stmt): Likewise.
	(gimple_seq_add_stmt_without_update): Likewise.
	(gimple_assign_copy_p): Likewise.
	(gimple_assign_ssa_name_copy_p): Likewise.
	(gimple_assign_unary_nop_p): Likewise.
	(gimple_set_bb): Likewise.
	(gimple_set_lhs): Likewise.
	(gimple_copy): Likewise.
	(gimple_could_trap_p_1): Likewise.
	(gimple_could_trap_p): Likewise.
	(gimple_assign_rhs_could_trap_p): Likewise.
	(canonicalize_cond_expr_cond): Likewise.
	(gimple_call_copy_skip_args): Likewise.
	(gimple_ior_addresses_taken): Likewise.
	(nonfreeing_call_p): Likewise.
	(infer_nonnull_range): Likewise.
	(gimple_seq_first): Likewise.
	(gimple_seq_last): Likewise.
	(gimple_seq_empty_p): Likewise.
	(gss_for_code): Likewise.
	(gimple_statement_structure): Likewise.
	(gimple_block): Likewise.
	(gimple_location_ptr): Likewise.
	(gimple_no_warning_p): Likewise.
	(gimple_set_no_warning): Likewise.
	(gimple_set_visited): Likewise.
	(gimple_visited_p): Likewise.
	(gimple_set_plf): Likewise.
	(gimple_plf): Likewise.
	(gimple_uid): Likewise.
	(gimple_has_ops): Likewise.
	(gimple_has_mem_ops): Likewise.
	(gimple_use_ops): Likewise.
	(gimple_vdef): Likewise.
	(gimple_vuse_ptr): Likewise.
	(gimple_vdef_ptr): Likewise.
	(gimple_set_vuse): Likewise.
	(gimple_modified_p): Likewise.
	(gimple_has_volatile_ops): Likewise.
	(gimple_set_has_volatile_ops): Likewise.
	(gimple_in_transaction): Likewise.
	(gimple_omp_subcode): Likewise.
	(gimple_omp_set_subcode): Likewise.
	(gimple_omp_return_nowait_p): Likewise.
	(gimple_omp_return_lhs): Likewise.
	(gimple_omp_section_last_p): Likewise.
	(gimple_omp_parallel_combined_p): Likewise.
	(gimple_omp_atomic_need_value_p): Likewise.
	(gimple_omp_atomic_seq_cst_p): Likewise.
	(gimple_num_ops): Likewise.
	(gimple_set_num_ops): Likewise.
	(gimple_op_ptr): Likewise.
	(gimple_assign_lhs_ptr): Likewise.
	(gimple_assign_rhs1_ptr): Likewise.
	(gimple_assign_rhs2_ptr): Likewise.
	(gimple_assign_rhs3_ptr): Likewise.
	(gimple_assign_nontemporal_move_p): Likewise.
	(gimple_assign_rhs_code): Likewise.
	(gimple_call_lhs_ptr): Likewise.
	(gimple_call_fntype): Likewise.
	(gimple_call_fn_ptr): Likewise.
	(gimple_call_set_fn): Likewise.
	(gimple_call_set_fndecl): Likewise.
	(gimple_call_chain_ptr): Likewise.
	(gimple_call_arg_ptr): Likewise.
	(gimple_call_set_arg): Likewise.
	(gimple_call_set_tail): Likewise.
	(gimple_call_tail_p): Likewise.
	(gimple_call_set_return_slot_opt): Likewise.
	(gimple_call_return_slot_opt_p): Likewise.
	(gimple_call_set_from_thunk): Likewise.
	(gimple_call_from_thunk_p): Likewise.
	(gimple_call_set_va_arg_pack): Likewise.
	(gimple_call_va_arg_pack_p): Likewise.
	(gimple_call_noreturn_p): Likewise.
	(gimple_call_set_nothrow): Likewise.
	(gimple_call_nothrow_p): Likewise.
	(gimple_call_set_alloca_for_var): Likewise.
	(gimple_call_alloca_for_var_p): Likewise.
	(gimple_call_copy_flags): Likewise.
	(gimple_call_use_set): Likewise.
	(gimple_call_clobber_set): Likewise.
	(gimple_cond_code): Likewise.
	(gimple_cond_lhs_ptr): Likewise.
	(gimple_cond_rhs_ptr): Likewise.
	(gimple_cond_true_label): Likewise.
	(gimple_cond_set_true_label): Likewise.
	(gimple_cond_false_label): Likewise.
	(gimple_cond_make_false): Likewise.
	(gimple_cond_false_p): Likewise.
	(gimple_label_label): Likewise.
	(gimple_goto_dest): Likewise.
	(gimple_bind_vars): Likewise.
	(gimple_bind_set_vars): Likewise.
	(gimple_bind_append_vars): Likewise.
	(gimple_bind_body_ptr): Likewise.
	(gimple_bind_body): Likewise.
	(gimple_bind_set_body): Likewise.
	(gimple_bind_add_stmt): Likewise.
	(gimple_bind_block): Likewise.
	(gimple_asm_input_op_ptr): Likewise.
	(gimple_asm_output_op_ptr): Likewise.
	(gimple_asm_clobber_op): Likewise.
	(gimple_asm_label_op): Likewise.
	(gimple_asm_volatile_p): Likewise.
	(gimple_asm_set_volatile): Likewise.
	(gimple_catch_types): Likewise.
	(gimple_catch_types_ptr): Likewise.
	(gimple_catch_handler_ptr): Likewise.
	(gimple_catch_handler): Likewise.
	(gimple_catch_set_types): Likewise.
	(gimple_eh_filter_types): Likewise.
	(gimple_eh_filter_types_ptr): Likewise.
	(gimple_eh_filter_failure_ptr): Likewise.
	(gimple_eh_filter_failure): 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_n_body): Likewise.
	(gimple_eh_else_e_body_ptr): Likewise.
	(gimple_eh_else_e_body): Likewise.
	(gimple_eh_else_set_n_body): Likewise.
	(gimple_try_kind): Likewise.
	(gimple_try_catch_is_cleanup): Likewise.
	(gimple_try_eval_ptr): Likewise.
	(gimple_try_eval): Likewise.
	(gimple_try_cleanup_ptr): Likewise.
	(gimple_try_cleanup): Likewise.
	(gimple_try_set_catch_is_cleanup): Likewise.
	(gimple_try_set_eval): Likewise.
	(gimple_try_set_cleanup): Likewise.
	(gimple_wce_cleanup_ptr): Likewise.
	(gimple_wce_cleanup): Likewise.
	(gimple_wce_cleanup_eh_only): Likewise.
	(gimple_phi_result): Likewise.
	(gimple_phi_result_ptr): Likewise.
	(gimple_phi_set_result): Likewise.
	(gimple_phi_arg): Likewise.
	(phi_nodes_ptr): Likewise.
	(gimple_phi_arg_def): Likewise.
	(gimple_phi_arg_def_ptr): Likewise.
	(gimple_phi_arg_edge): Likewise.
	(gimple_phi_arg_location): Likewise.
	(gimple_phi_arg_location_from_edge): Likewise.
	(gimple_phi_arg_set_location): Likewise.
	(gimple_resx_region): Likewise.
	(gimple_eh_dispatch_region): Likewise.
	(gimple_switch_num_labels): Likewise.
	(gimple_switch_index_ptr): Likewise.
	(gimple_switch_label): Likewise.
	(gimple_switch_default_label): Likewise.
	(gimple_debug_bind_p): Likewise.
	(gimple_debug_bind_get_var): Likewise.
	(gimple_debug_bind_get_value): Likewise.
	(gimple_debug_bind_get_value_ptr): Likewise.
	(gimple_debug_bind_set_var): Likewise.
	(gimple_debug_bind_set_value): Likewise.
	(gimple_debug_bind_reset_value): Likewise.
	(gimple_debug_source_bind_p): Likewise.
	(gimple_debug_source_bind_get_var): Likewise.
	(gimple_debug_source_bind_get_value): Likewise.
	(gimple_debug_source_bind_get_value_ptr): Likewise.
	(gimple_debug_source_bind_set_var): Likewise.
	(get_lineno): Likewise.
	(gimple_omp_body_ptr): Likewise.
	(gimple_omp_body): Likewise.
	(gimple_omp_critical_name): Likewise.
	(gimple_omp_critical_name_ptr): Likewise.
	(gimple_omp_for_kind): Likewise.
	(gimple_omp_for_combined_p): Likewise.
	(gimple_omp_for_combined_into_p): Likewise.
	(gimple_omp_for_clauses): Likewise.
	(gimple_omp_for_clauses_ptr): Likewise.
	(gimple_omp_for_set_clauses): Likewise.
	(gimple_omp_for_index): Likewise.
	(gimple_omp_for_index_ptr): Likewise.
	(gimple_omp_for_initial): Likewise.
	(gimple_omp_for_initial_ptr): Likewise.
	(gimple_omp_for_final): Likewise.
	(gimple_omp_for_final_ptr): 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_pre_body): Likewise.
	(gimple_omp_parallel_clauses): Likewise.
	(gimple_omp_parallel_clauses_ptr): Likewise.
	(gimple_omp_parallel_child_fn): Likewise.
	(gimple_omp_parallel_child_fn_ptr): Likewise.
	(gimple_omp_parallel_data_arg): Likewise.
	(gimple_omp_parallel_data_arg_ptr): Likewise.
	(gimple_omp_task_clauses): Likewise.
	(gimple_omp_task_clauses_ptr): Likewise.
	(gimple_omp_task_child_fn): Likewise.
	(gimple_omp_task_child_fn_ptr): Likewise.
	(gimple_omp_task_data_arg): Likewise.
	(gimple_omp_task_data_arg_ptr): Likewise.
	(gimple_omp_taskreg_clauses): Likewise.
	(gimple_omp_taskreg_clauses_ptr): Likewise.
	(gimple_omp_taskreg_child_fn): Likewise.
	(gimple_omp_taskreg_child_fn_ptr): Likewise.
	(gimple_omp_taskreg_data_arg): Likewise.
	(gimple_omp_taskreg_data_arg_ptr): Likewise.
	(gimple_omp_task_copy_fn): Likewise.
	(gimple_omp_task_copy_fn_ptr): Likewise.
	(gimple_omp_task_arg_size): Likewise.
	(gimple_omp_task_arg_size_ptr): Likewise.
	(gimple_omp_task_arg_align): Likewise.
	(gimple_omp_task_arg_align_ptr): Likewise.
	(gimple_omp_single_clauses): Likewise.
	(gimple_omp_single_clauses_ptr): Likewise.
	(gimple_omp_target_clauses): Likewise.
	(gimple_omp_target_clauses_ptr): Likewise.
	(gimple_omp_target_kind): Likewise.
	(gimple_omp_target_child_fn): Likewise.
	(gimple_omp_target_child_fn_ptr): Likewise.
	(gimple_omp_target_data_arg): Likewise.
	(gimple_omp_target_data_arg_ptr): Likewise.
	(gimple_omp_teams_clauses): Likewise.
	(gimple_omp_teams_clauses_ptr): Likewise.
	(gimple_omp_sections_clauses): Likewise.
	(gimple_omp_sections_clauses_ptr): Likewise.
	(gimple_omp_sections_control): Likewise.
	(gimple_omp_sections_control_ptr): Likewise.
	(gimple_omp_sections_set_control): Likewise.
	(gimple_omp_for_cond): Likewise.
	(gimple_omp_atomic_store_val): Likewise.
	(gimple_omp_atomic_store_val_ptr): Likewise.
	(gimple_omp_atomic_load_lhs): Likewise.
	(gimple_omp_atomic_load_lhs_ptr): Likewise.
	(gimple_omp_atomic_load_rhs): Likewise.
	(gimple_omp_continue_control_def): Likewise.
	(gimple_omp_continue_control_def_ptr): 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_subcode): Likewise.
	(gimple_transaction_set_body): Likewise.
	(gimple_transaction_set_label): Likewise.
	(gimple_return_retval): Likewise.
	(is_gimple_resx): Likewise.
	(gimple_predict_predictor): Likewise.
	(gimple_predict_set_predictor): Likewise.
	(gimple_predict_outcome): Likewise.
	(gimple_alloc_kind): Likewise.
	(gimple_do_not_emit_location_p): Likewise.
	* gimplify-me.c (force_gimple_operand_gsi): Likewise.
	(gimple_regimplify_operands): Likewise.
	* gimplify-me.h (gimple_regimplify_operands): Likewise.
	* gimplify.c (equal): Likewise.
	(gimplify_seq_add_stmt): Likewise.
	(push_gimplify_context): Likewise.
	(pop_gimplify_context): Likewise.
	(gimple_pop_bind_expr): Likewise.
	(gimple_current_bind_expr): Likewise.
	(gimplify_and_add): Likewise.
	(get_initialized_tmp_var): Likewise.
	(voidify_wrapper_expr): Likewise.
	(gimplify_bind_expr): Likewise.
	(gimplify_return_expr): Likewise.
	(gimplify_switch_expr): Likewise.
	(gimplify_case_label_expr): Likewise.
	(gimplify_call_expr): Likewise.
	(gimplify_cond_expr): Likewise.
	(gimplify_modify_expr_to_memcpy): Likewise.
	(gimplify_modify_expr_to_memset): Likewise.
	(gimplify_init_constructor): Likewise.
	(gimplify_modify_expr): Likewise.
	(gimplify_asm_expr): Likewise.
	(gimplify_cleanup_point_expr): Likewise.
	(gimple_push_cleanup): Likewise.
	(gimplify_omp_parallel): Likewise.
	(gimplify_omp_task): Likewise.
	(gimplify_omp_for): Likewise.
	(gimplify_omp_workshare): Likewise.
	(gimplify_omp_target_update): Likewise.
	(gimplify_omp_atomic): Likewise.
	(gimplify_transaction): Likewise.
	(gimplify_expr): Likewise.
	(gimplify_one_sizepos): Likewise.
	(gimplify_body): Likewise.
	(gimplify_function_tree): Likewise.
	(gimplify_va_arg_expr): Likewise.
	* gimplify.h (pop_gimplify_context): Likewise.
	(gimple_current_bind_expr): Likewise.
	(declare_vars): Likewise.
	(gimplify_one_sizepos): Likewise.
	(gimplify_va_arg_expr): Likewise.
	* graphite-poly.c (dump_gbb_cases): Likewise.
	(dump_gbb_conditions): Likewise.
	* graphite-scop-detection.c (graphite_can_represent_expr): Likewise.
	(stmt_has_simple_data_refs_p): Likewise.
	(stmt_simple_for_scop_p): Likewise.
	(scopdet_basic_block_info): Likewise.
	(limit_scops): Likewise.
	(same_close_phi_node): Likewise.
	(remove_duplicate_close_phi): Likewise.
	(make_close_phi_nodes_unique): Likewise.
	(canonicalize_loop_closed_ssa): Likewise.
	* graphite-sese-to-poly.c (tree_int_to_gmp): Likewise.
	(remove_simple_copy_phi): Likewise.
	(remove_invariant_phi): Likewise.
	(reduction_phi_p): Likewise.
	(try_generate_gimple_bb): Likewise.
	(find_params_in_bb): Likewise.
	(create_pw_aff_from_tree): Likewise.
	(add_conditions_to_domain): Likewise.
	(add_conditions_to_constraints): Likewise.
	(single_pred_cond_non_loop_exit): Likewise.
	(build_scop_drs): Likewise.
	(gsi_for_phi_node): Likewise.
	(analyze_drs_in_stmts): Likewise.
	(insert_stmts): Likewise.
	(insert_out_of_ssa_copy): Likewise.
	(insert_out_of_ssa_copy_on_edge): Likewise.
	(create_zero_dim_array): Likewise.
	(propagate_expr_outside_region): Likewise.
	(rewrite_close_phi_out_of_ssa): Likewise.
	(rewrite_phi_out_of_ssa): Likewise.
	(rewrite_degenerate_phi): Likewise.
	(rewrite_reductions_out_of_ssa): Likewise.
	(rewrite_cross_bb_scalar_dependence): Likewise.
	(handle_scalar_deps_crossing_scop_limits): Likewise.
	(rewrite_cross_bb_scalar_deps): Likewise.
	(nb_data_writes_in_bb): Likewise.
	(split_pbb): Likewise.
	(split_reduction_stmt): Likewise.
	(is_reduction_operation_p): Likewise.
	(phi_contains_arg): Likewise.
	(follow_ssa_with_commutative_ops): Likewise.
	(detect_commutative_reduction_arg): Likewise.
	(detect_commutative_reduction_assign): Likewise.
	(follow_inital_value_to_phi): Likewise.
	(edge_initial_value_for_loop_phi): Likewise.
	(initial_value_for_loop_phi): Likewise.
	(used_outside_reduction): Likewise.
	(detect_commutative_reduction): Likewise.
	(translate_scalar_reduction_to_array_for_stmt): Likewise.
	(remove_phi): Likewise.
	(dr_indices_valid_in_loop): Likewise.
	(close_phi_written_to_memory): Likewise.
	(translate_scalar_reduction_to_array): Likewise.
	(rewrite_commutative_reductions_out_of_ssa_close_phi): Likewise.
	(scop_ivs_can_be_represented): Likewise.
	* internal-fn.c (get_multi_vector_move): Likewise.
	(expand_LOAD_LANES): Likewise.
	(expand_STORE_LANES): Likewise.
	(expand_ANNOTATE): Likewise.
	(expand_GOMP_SIMD_LANE): Likewise.
	(expand_GOMP_SIMD_VF): Likewise.
	(expand_GOMP_SIMD_LAST_LANE): Likewise.
	(expand_UBSAN_NULL): Likewise.
	(ubsan_expand_si_overflow_addsub_check): Likewise.
	(ubsan_expand_si_overflow_neg_check): Likewise.
	(ubsan_expand_si_overflow_mul_check): Likewise.
	(expand_UBSAN_CHECK_ADD): Likewise.
	(expand_UBSAN_CHECK_SUB): Likewise.
	(expand_UBSAN_CHECK_MUL): Likewise.
	(expand_LOOP_VECTORIZED): Likewise.
	(expand_MASK_LOAD): Likewise.
	(expand_MASK_STORE): Likewise.
	(expand_ABNORMAL_DISPATCHER): Likewise.
	(expand_BUILTIN_EXPECT): Likewise.
	* internal-fn.h (internal_fn_flags): Likewise.
	* ipa-inline-analysis.c (mark_modified): Likewise.
	(unmodified_parm_1): Likewise.
	(unmodified_parm): Likewise.
	(unmodified_parm_or_parm_agg_item): Likewise.
	(set_cond_stmt_execution_predicate): Likewise.
	(set_switch_stmt_execution_predicate): Likewise.
	(will_be_nonconstant_expr_predicate): Likewise.
	(will_be_nonconstant_predicate): Likewise.
	(record_modified): Likewise.
	(phi_result_unknown_predicate): Likewise.
	(array_index_predicate): Likewise.
	(find_foldable_builtin_expect): Likewise.
	(clobber_only_eh_bb_p): Likewise.
	(estimate_function_body_sizes): Likewise.
	* ipa-inline.c (inline_small_functions): Likewise.
	* ipa-profile.c (ipa_profile_generate_summary): Likewise.
	* ipa-prop.c (ipa_binfo_from_known_type_jfunc): Likewise.
	(stmt_may_be_vtbl_ptr_store): Likewise.
	(check_stmt_for_type_change): Likewise.
	(detect_type_change): Likewise.
	(mark_modified): Likewise.
	(parm_preserved_before_stmt_p): Likewise.
	(load_from_unmodified_param): Likewise.
	(parm_ref_data_preserved_p): Likewise.
	(parm_ref_data_pass_through_p): Likewise.
	(ipa_load_from_parm_agg_1): Likewise.
	(ipa_load_from_parm_agg): Likewise.
	(compute_complex_assign_jump_func): Likewise.
	(get_ancestor_addr_info): Likewise.
	(compute_complex_ancestor_jump_func): Likewise.
	(get_ssa_def_if_simple_copy): Likewise.
	(determine_known_aggregate_parts): Likewise.
	(ipa_compute_jump_functions_for_edge): Likewise.
	(ipa_compute_jump_functions): Likewise.
	(ipa_is_ssa_with_stmt_def): Likewise.
	(ipa_note_param_call): Likewise.
	(ipa_analyze_indirect_call_uses): Likewise.
	(ipa_analyze_virtual_call_uses): Likewise.
	(ipa_analyze_call_uses): Likewise.
	(ipa_analyze_stmt_uses): Likewise.
	(ipa_analyze_params_uses): Likewise.
	(ipa_analyze_node): Likewise.
	(ipa_modify_formal_parameters): Likewise.
	(ipa_modify_call_arguments): Likewise.
	(ipcp_transform_function): Likewise.
	* ipa-prop.h (ipa_get_agg_replacements_for_node): Likewise.
	* ipa-pure-const.c (special_builtin_state): Likewise.
	(check_call): Likewise.
	(check_load): Likewise.
	(check_store): Likewise.
	(check_ipa_load): Likewise.
	(check_stmt): Likewise.
	* ipa-ref.c (statement): Likewise.
	(ipa_record_reference): Likewise.
	(ipa_dump_referring): Likewise.
	(ipa_ref_has_aliases_p): Likewise.
	(ipa_find_reference): Likewise.
	* ipa-ref.h (Copyright): Likewise.
	(ENUM_BITFIELD): Likewise.
	(ipa_clone_referring): Likewise.
	(ipa_ref_has_aliases_p): Likewise.
	(ipa_remove_stmt_references): Likewise.
	* ipa-split.c (test_nonssa_use): Likewise.
	(verify_non_ssa_vars): Likewise.
	(check_forbidden_calls): Likewise.
	(consider_split): Likewise.
	(find_return_bb): Likewise.
	(find_retval): Likewise.
	(visit_bb): Likewise.
	(split_function): Likewise.
	(execute_split_functions): Likewise.
	* lto-streamer-in.c (input_ssa_names): Likewise.
	(fixup_call_stmt_edges_1): Likewise.
	(input_function): Likewise.
	* lto-streamer-out.c (output_function): Likewise.
	* omp-low.c (Copyright): Likewise.
	(is_combined_parallel): Likewise.
	(workshare_safe_to_combine_p): Likewise.
	(determine_parallel_type): Likewise.
	(free_omp_regions): Likewise.
	(new_omp_context): Likewise.
	(finalize_task_copyfn): Likewise.
	(find_combined_for): Likewise.
	(scan_omp_parallel): Likewise.
	(scan_omp_task): Likewise.
	(scan_omp_for): Likewise.
	(scan_omp_sections): Likewise.
	(scan_omp_single): Likewise.
	(scan_omp_target): Likewise.
	(scan_omp_teams): Likewise.
	(scan_omp_1_stmt): Likewise.
	(scan_omp): Likewise.
	(build_omp_barrier): Likewise.
	(lower_rec_input_clauses): Likewise.
	(lower_lastprivate_clauses): Likewise.
	(lower_reduction_clauses): Likewise.
	(lower_send_shared_vars): Likewise.
	(gimple_build_cond_empty): Likewise.
	(expand_parallel_call): Likewise.
	(maybe_catch_exception): Likewise.
	(remove_exit_barrier): Likewise.
	(remove_exit_barriers): Likewise.
	(optimize_omp_library_calls): Likewise.
	(expand_omp_build_assign): Likewise.
	(expand_omp_taskreg): Likewise.
	(expand_omp_for_init_counts): Likewise.
	(expand_omp_for_init_vars): Likewise.
	(extract_omp_for_update_vars): Likewise.
	(expand_omp_for_generic): Likewise.
	(expand_omp_for_static_nochunk): Likewise.
	(expand_omp_for_static_chunk): Likewise.
	(expand_omp_simd): Likewise.
	(expand_omp_sections): Likewise.
	(expand_omp_atomic_load): Likewise.
	(expand_omp_atomic_store): Likewise.
	(expand_omp_atomic_fetch_op): Likewise.
	(expand_omp_atomic_pipeline): Likewise.
	(expand_omp_atomic_mutex): Likewise.
	(expand_omp_atomic): Likewise.
	(expand_omp_target): Likewise.
	(expand_omp): Likewise.
	(build_omp_regions_1): Likewise.
	(maybe_add_implicit_barrier_cancel): Likewise.
	(lower_omp_sections): Likewise.
	(lower_omp_single_simple): Likewise.
	(lower_omp_single): Likewise.
	(lower_omp_master): Likewise.
	(lower_omp_taskgroup): Likewise.
	(lower_omp_ordered): Likewise.
	(lower_omp_critical): Likewise.
	(lower_omp_for): Likewise.
	(check_combined_parallel): Likewise.
	(task_copyfn_remap_type): Likewise.
	(create_task_copyfn): Likewise.
	(lower_depend_clauses): Likewise.
	(lower_omp_taskreg): Likewise.
	(lower_omp_target): Likewise.
	(lower_omp_teams): Likewise.
	(lower_omp_1): Likewise.
	(make_pass_lower_omp): Likewise.
	(diagnose_sb_1): Likewise.
	(diagnose_sb_2): Likewise.
	(make_gimple_omp_edges): Likewise.
	(simd_clone_init_simd_arrays): Likewise.
	(ipa_simd_modify_stmt_ops): Likewise.
	(ipa_simd_modify_function_body): Likewise.
	(simd_clone_adjust): Likewise.
	* passes.c (execute_ipa_pass_list): Likewise.
	(execute_ipa_stmt_fixups): Likewise.
	* predict.c (get_base_value): Likewise.
	(expr_coherent_p): Likewise.
	(predict_iv_comparison): Likewise.
	(predict_extra_loop_exits): Likewise.
	(predict_loops): Likewise.
	(expr_expected_value_1): Likewise.
	(tree_predict_by_opcode): Likewise.
	(apply_return_prediction): Likewise.
	(tree_bb_level_predictions): Likewise.
	(tree_estimate_probability_bb): Likewise.
	(make_pass_profile): Likewise.
	* profile.c (compute_value_histograms): Likewise.
	(branch_prob): Likewise.
	* sese.c (sese_build_liveouts_bb): Likewise.
	(sese_reset_debug_liveouts_bb): Likewise.
	(sese_add_exit_phis_edge): Likewise.
	(set_rename): Likewise.
	(graphite_copy_stmts_from_block): Likewise.
	(set_ifsese_condition): Likewise.
	(scalar_evolution_in_region): Likewise.
	* sese.h (bb_in_sese_p): Likewise.
	(defined_in_sese_p): Likewise.
	(recompute_all_dominators): Likewise.
	* ssa-iterators.h (single_imm_use_1): Likewise.
	(set_ssa_use_from_ptr): Likewise.
	(relink_imm_use): Likewise.
	(has_single_use): Likewise.
	(clear_and_done_ssa_iter): Likewise.
	(op_iter_init): Likewise.
	(op_iter_init_use): Likewise.
	(op_iter_init_def): Likewise.
	(op_iter_init_tree): Likewise.
	(single_ssa_tree_operand): Likewise.
	(single_ssa_use_operand): Likewise.
	(single_ssa_def_operand): Likewise.
	(zero_ssa_operands): Likewise.
	(num_ssa_operands): Likewise.
	(single_phi_def): Likewise.
	(op_iter_init_phiuse): Likewise.
	(link_use_stmts_after): Likewise.
	(first_imm_use_stmt): Likewise.
	(next_imm_use_on_stmt): Likewise.
	* stmt.c (reset_out_edges_aux): Likewise.
	(compute_cases_per_edge): Likewise.
	* tracer.c (ignore_bb_p): Likewise.
	(count_insns): Likewise.
	* trans-mem.c (is_tm_safe): Likewise.
	(is_tm_ending_fndecl): Likewise.
	(is_tm_ending): Likewise.
	(is_tm_load): Likewise.
	(is_tm_simple_load): Likewise.
	(is_tm_store): Likewise.
	(tm_malloc_replacement): Likewise.
	(diagnose_tm_1): Likewise.
	(transaction_invariant_address_p): Likewise.
	(tm_log_add): Likewise.
	(gimplify_addr): Likewise.
	(tm_log_emit_stmt): Likewise.
	(tm_log_emit): Likewise.
	(tm_log_emit_saves): Likewise.
	(tm_log_emit_restores): Likewise.
	(thread_private_new_memory): Likewise.
	(examine_assign_tm): Likewise.
	(examine_call_tm): Likewise.
	(lower_transaction): Likewise.
	(lower_sequence_tm): Likewise.
	(lower_sequence_no_tm): Likewise.
	(make_pass_lower_tm): Likewise.
	(tm_region_init_1): Likewise.
	(tm_region_init): Likewise.
	(transaction_subcode_ior): Likewise.
	(build_tm_load): Likewise.
	(build_tm_store): Likewise.
	(expand_assign_tm): Likewise.
	(expand_call_tm): Likewise.
	(expand_block_tm): Likewise.
	(expand_transaction): Likewise.
	(make_pass_tm_mark): Likewise.
	(expand_block_edges): Likewise.
	(expand_regions): Likewise.
	(tm_memopt_accumulate_memops): Likewise.
	(tm_memopt_compute_antic): Likewise.
	(dump_tm_memopt_transform): Likewise.
	(tm_memopt_transform_blocks): Likewise.
	(ipa_uninstrument_transaction): Likewise.
	(ipa_tm_scan_calls_block): Likewise.
	(ipa_tm_scan_irr_block): Likewise.
	(ipa_tm_decrement_clone_counts): Likewise.
	(ipa_tm_diagnose_transaction): Likewise.
	(ipa_tm_insert_irr_call): Likewise.
	(ipa_tm_insert_gettmclone_call): Likewise.
	(ipa_tm_transform_calls_redirect): Likewise.
	(ipa_tm_transform_calls_1): Likewise.
	* trans-mem.h (is_tm_ending): Likewise.
	* tree-affine.c (aff_combination_expand): Likewise.
	* tree-call-cdce.c (check_target_format): Likewise.
	(check_pow): Likewise.
	(check_builtin_call): Likewise.
	(is_call_dce_candidate): Likewise.
	(gen_one_condition): Likewise.
	(gen_conditions_for_domain): Likewise.
	(gen_conditions_for_pow_cst_base): Likewise.
	(gen_conditions_for_pow_int_base): Likewise.
	(get_no_error_domain): Likewise.
	(gen_shrink_wrap_conditions): Likewise.
	(shrink_wrap_one_built_in_call): Likewise.
	(shrink_wrap_conditional_dead_built_in_calls): Likewise.
	* tree-cfg.c (verify_gimple_transaction): Likewise.
	(find_case_label_for_value): Likewise.
	(replace_loop_annotate): Likewise.
	(make_pass_build_cfg): Likewise.
	(assert_unreachable_fallthru_edge_p): Likewise.
	(make_blocks): Likewise.
	(fold_cond_expr_cond): Likewise.
	(get_abnormal_succ_dispatcher): Likewise.
	(handle_abnormal_edges): Likewise.
	(make_edges): Likewise.
	(assign_discriminators): Likewise.
	(make_cond_expr_edges): Likewise.
	(end_recording_case_labels): Likewise.
	(make_gimple_switch_edges): Likewise.
	(label_to_block_fn): Likewise.
	(make_goto_expr_edges): Likewise.
	(make_gimple_asm_edges): Likewise.
	(cleanup_dead_labels): Likewise.
	(group_case_labels): Likewise.
	(gimple_can_merge_blocks_p): Likewise.
	(replace_uses_by): Likewise.
	(gimple_merge_blocks): Likewise.
	(single_noncomplex_succ): Likewise.
	(remove_bb): Likewise.
	(find_taken_edge): Likewise.
	(find_taken_edge_switch_expr): Likewise.
	(debug_cfg_stats): Likewise.
	(call_can_make_abnormal_goto): Likewise.
	(stmt_can_make_abnormal_goto): Likewise.
	(is_ctrl_stmt): Likewise.
	(is_ctrl_altering_stmt): Likewise.
	(simple_goto_p): Likewise.
	(stmt_starts_bb_p): Likewise.
	(delete_tree_cfg_annotations): Likewise.
	(first_stmt): Likewise.
	(first_non_label_stmt): Likewise.
	(last_stmt): Likewise.
	(last_and_only_stmt): Likewise.
	(reinstall_phi_args): Likewise.
	(valid_fixed_convert_types_p): Likewise.
	(verify_gimple_comparison): Likewise.
	(verify_gimple_assign_unary): Likewise.
	(verify_gimple_assign_binary): Likewise.
	(verify_gimple_assign_ternary): Likewise.
	(verify_gimple_assign_single): Likewise.
	(verify_gimple_assign): Likewise.
	(verify_gimple_return): Likewise.
	(verify_gimple_goto): Likewise.
	(verify_gimple_switch): Likewise.
	(verify_gimple_debug): Likewise.
	(verify_gimple_label): Likewise.
	(verify_gimple_stmt): Likewise.
	(verify_gimple_in_seq_2): Likewise.
	(verify_gimple_in_cfg): Likewise.
	(gimple_verify_flow_info): Likewise.
	(gimple_make_forwarder_block): Likewise.
	(gimple_block_label): Likewise.
	(gimple_try_redirect_by_replacing_jump): Likewise.
	(gimple_redirect_edge_and_branch): Likewise.
	(gimple_split_block): Likewise.
	(gimple_split_block_before_cond_jump): Likewise.
	(gimple_duplicate_bb): Likewise.
	(add_phi_args_after_copy_edge): Likewise.
	(gimple_duplicate_sese_tail): Likewise.
	(move_stmt_r): Likewise.
	(move_block_to_fn): Likewise.
	(find_outermost_region_in_block): Likewise.
	(gimple_block_ends_with_condjump_p): Likewise.
	(gimple_flow_call_edges_add): Likewise.
	(gimple_purge_dead_eh_edges): Likewise.
	(gimple_purge_dead_abnormal_call_edges): Likewise.
	(gimple_lv_adjust_loop_header_phi): Likewise.
	(gimple_lv_add_condition_to_bb): Likewise.
	(extract_true_false_edges_from_block): Likewise.
	(do_warn_unused_result): Likewise.
	(execute_fixup_cfg): Likewise.
	(make_pass_fixup_cfg): Likewise.
	(gt_ggc_mx): Likewise.
	* tree-cfg.h (group_case_labels_stmt): Likewise.
	(notice_special_calls): Likewise.
	(computed_goto_p): Likewise.
	(stmt_can_make_abnormal_goto): Likewise.
	(is_ctrl_stmt): Likewise.
	(is_ctrl_altering_stmt): Likewise.
	(simple_goto_p): Likewise.
	(stmt_ends_bb_p): Likewise.
	(delete_tree_cfg_annotations): Likewise.
	(first_stmt): Likewise.
	(last_stmt): Likewise.
	* tree-cfgcleanup.c (cleanup_control_expr_graph): Likewise.
	(cleanup_control_flow_bb): Likewise.
	(tree_forwarder_block_p): Likewise.
	(phi_alternatives_equal): Likewise.
	(remove_forwarder_block): Likewise.
	(fixup_noreturn_call): Likewise.
	(split_bbs_on_noreturn_calls): Likewise.
	(remove_forwarder_block_with_phi): Likewise.
	* tree-cfgcleanup.h (fixup_noreturn_call): Likewise.
	* tree-chrec.c (nb_vars_in_chrec): Likewise.
	(convert_affine_scev): Likewise.
	(chrec_convert_rhs): Likewise.
	(chrec_convert): Likewise.
	* tree-chrec.h (tree_is_chrec): Likewise.
	* tree-complex.c (init_dont_simulate_again): Likewise.
	(complex_visit_stmt): Likewise.
	(set_component_ssa_name): Likewise.
	(extract_component): Likewise.
	(update_complex_assignment): Likewise.
	(update_phi_components): Likewise.
	(expand_complex_move): Likewise.
	(expand_complex_libcall): Likewise.
	(expand_complex_div_wide): Likewise.
	(expand_complex_comparison): Likewise.
	(expand_complex_asm): Likewise.
	(expand_complex_operations_1): Likewise.
	* tree-core.h (GTY): Likewise.
	* tree-data-ref.c (split_constant_offset_1): Likewise.
	(dr_analyze_innermost): Likewise.
	(free_data_ref): Likewise.
	(compute_all_dependences): Likewise.
	(get_references_in_stmt): Likewise.
	(find_data_references_in_stmt): Likewise.
	(find_data_references_in_bb): Likewise.
	* tree-data-ref.h (am_vector_index_for_loop): Likewise.
	* tree-dfa.c (renumber_gimple_stmt_uids): Likewise.
	(renumber_gimple_stmt_uids_in_blocks): Likewise.
	(collect_dfa_stats): Likewise.
	(get_addr_base_and_unit_offset): Likewise.
	* tree-dfa.h (stmt_references_abnormal_ssa_name): Likewise.
	* tree-eh.c (Copyright): Likewise.
	(add_stmt_to_eh_lp_fn): Likewise.
	(add_stmt_to_eh_lp): Likewise.
	(record_stmt_eh_region): Likewise.
	(remove_stmt_from_eh_lp_fn): Likewise.
	(remove_stmt_from_eh_lp): Likewise.
	(lookup_stmt_eh_lp_fn): Likewise.
	(lookup_stmt_eh_lp): Likewise.
	(record_in_finally_tree): Likewise.
	(collect_finally_tree_1): Likewise.
	(collect_finally_tree): Likewise.
	(outside_finally_tree): Likewise.
	(replace_goto_queue_cond_clause): Likewise.
	(record_in_goto_queue_label): Likewise.
	(maybe_record_in_goto_queue): Likewise.
	(do_return_redirection): Likewise.
	(do_goto_redirection): Likewise.
	(emit_post_landing_pad): Likewise.
	(emit_resx): Likewise.
	(emit_eh_dispatch): Likewise.
	(eh_region_may_contain_throw): Likewise.
	(frob_into_branch_around): Likewise.
	(lower_try_finally_dup_block): Likewise.
	(lower_try_finally_fallthru_label): Likewise.
	(get_eh_else): Likewise.
	(honor_protect_cleanup_actions): Likewise.
	(lower_try_finally_nofallthru): Likewise.
	(lower_try_finally_onedest): Likewise.
	(lower_try_finally_copy): Likewise.
	(lower_try_finally_switch): Likewise.
	(decide_copy_try_finally): Likewise.
	(cleanup_is_dead_in): Likewise.
	(lower_try_finally): Likewise.
	(lower_catch): Likewise.
	(lower_eh_filter): Likewise.
	(lower_eh_must_not_throw): Likewise.
	(lower_cleanup): Likewise.
	(lower_eh_constructs_2): Likewise.
	(make_pass_lower_eh): Likewise.
	(make_eh_dispatch_edges): Likewise.
	(redirect_eh_edge_1): Likewise.
	(redirect_eh_edge): Likewise.
	(tree_could_trap_p): Likewise.
	(stmt_could_throw_1_p): Likewise.
	(tree_could_throw_p): Likewise.
	(stmt_can_throw_external): Likewise.
	(stmt_can_throw_internal): Likewise.
	(maybe_clean_eh_stmt_fn): Likewise.
	(maybe_clean_eh_stmt): Likewise.
	(maybe_clean_or_replace_eh_stmt): Likewise.
	(maybe_duplicate_eh_stmt_fn): Likewise.
	(same_handler_p): Likewise.
	(optimize_double_finally): Likewise.
	(refactor_eh_r): Likewise.
	(make_pass_refactor_eh): Likewise.
	(lower_resx): Likewise.
	(optimize_clobbers): Likewise.
	(sink_clobbers): Likewise.
	(lower_eh_dispatch): Likewise.
	(mark_reachable_handlers): Likewise.
	(unsplit_eh): Likewise.
	(cleanup_empty_eh_merge_phis): Likewise.
	(cleanup_empty_eh_unsplit): Likewise.
	(cleanup_empty_eh): Likewise.
	(make_pass_cleanup_eh): Likewise.
	(verify_eh_edges): Likewise.
	* tree-eh.h (add_stmt_to_eh_lp): Likewise.
	(remove_stmt_from_eh_lp_fn): Likewise.
	(remove_stmt_from_eh_lp): Likewise.
	(lookup_stmt_eh_lp_fn): Likewise.
	(lookup_stmt_eh_lp): Likewise.
	(make_eh_dispatch_edges): Likewise.
	(make_eh_edges): Likewise.
	(redirect_eh_dispatch_edge): Likewise.
	(stmt_could_throw_p): Likewise.
	(stmt_can_throw_external): Likewise.
	(stmt_can_throw_internal): Likewise.
	(maybe_clean_eh_stmt_fn): Likewise.
	(maybe_clean_eh_stmt): Likewise.
	(maybe_clean_or_replace_eh_stmt): Likewise.
	(maybe_duplicate_eh_stmt_fn): Likewise.
	(maybe_duplicate_eh_stmt): Likewise.
	(verify_eh_edges): Likewise.
	(verify_eh_dispatch_edge): Likewise.
	* tree-emutls.c (gen_emutls_addr): Likewise.
	(lower_emutls_1): Likewise.
	(lower_emutls_stmt): Likewise.
	* tree-if-conv.c (ifc_temp_var): Likewise.
	(parse_predicate): Likewise.
	(bb_with_exit_edge_p): Likewise.
	(if_convertible_phi_p): Likewise.
	(memrefs_read_or_written_unconditionally): Likewise.
	(write_memrefs_written_at_least_once): Likewise.
	(ifcvt_memrefs_wont_trap): Likewise.
	(ifcvt_could_trap_p): Likewise.
	(ifcvt_can_use_mask_load_store): Likewise.
	(if_convertible_gimple_assign_stmt_p): Likewise.
	(predicate_bbs): Likewise.
	(find_phi_replacement_condition): Likewise.
	(is_cond_scalar_reduction): Likewise.
	(convert_scalar_cond_reduction): Likewise.
	(predicate_scalar_phi): Likewise.
	(predicate_all_scalar_phis): Likewise.
	(predicate_mem_writes): Likewise.
	(version_loop_for_if_conversion): Likewise.
	* tree-inline.c (copy_decl_maybe_to_var): Likewise.
	(remap_ssa_name): Likewise.
	(remap_gimple_seq): Likewise.
	(copy_gimple_bind): Likewise.
	(remap_eh_region_tree_nr): Likewise.
	(remap_gimple_stmt): Likewise.
	(copy_bb): Likewise.
	(update_ssa_across_abnormal_edges): Likewise.
	(copy_edges_for_bb): Likewise.
	(copy_phis_for_bb): Likewise.
	(maybe_move_debug_stmts_to_successors): Likewise.
	(copy_cfg_body): Likewise.
	(copy_debug_stmts): Likewise.
	(self_inlining_addr_expr): Likewise.
	(insert_init_debug_bind): Likewise.
	(insert_init_stmt): Likewise.
	(setup_one_parameter): Likewise.
	(inline_forbidden_p_stmt): Likewise.
	(inline_forbidden_p): Likewise.
	(estimate_operator_cost): Likewise.
	(add_local_variables): Likewise.
	(expand_call_inline): Likewise.
	(gimple_expand_calls_inline): Likewise.
	(fold_marked_statements): Likewise.
	(mark_local_labels_stmt): Likewise.
	(replace_locals_stmt): Likewise.
	(tree_function_versioning): Likewise.
	* tree-inline.h (tree): Likewise.
	(void): Likewise.
	(estimate_num_insns): Likewise.
	* tree-into-ssa.c (marked_for_renaming): Likewise.
	(rewrite_uses_p): Likewise.
	(set_rewrite_uses): Likewise.
	(register_defs_p): Likewise.
	(initialize_flags_in_bb): Likewise.
	(add_new_name_mapping): Likewise.
	(find_def_blocks_for): Likewise.
	(insert_phi_nodes_for): Likewise.
	(get_reaching_def): Likewise.
	(rewrite_debug_stmt_uses): Likewise.
	(rewrite_stmt): Likewise.
	(rewrite_add_phi_arguments): Likewise.
	(maybe_replace_use_in_debug_stmt): Likewise.
	(maybe_register_def): Likewise.
	(rewrite_update_phi_arguments): Likewise.
	(make_pass_build_ssa): Likewise.
	(mark_def_interesting): Likewise.
	(prepare_block_for_update): Likewise.
	(prepare_use_sites_for): Likewise.
	(prepare_def_site_for): Likewise.
	(delete_update_ssa): Likewise.
	(mark_virtual_operand_for_renaming): Likewise.
	* tree-into-ssa.h (create_new_def_for): Likewise.
	(mark_virtual_phi_result_for_renaming): Likewise.
	* tree-loop-distribution.c (Copyright): Likewise.
	(dot_rdg): Likewise.
	(create_edge_for_control_dependence): Likewise.
	(create_rdg_cd_edges): Likewise.
	(create_rdg_vertices): Likewise.
	(stmts_from_loop): Likewise.
	(build_rdg): Likewise.
	(ssa_name_has_uses_outside_loop_p): Likewise.
	(generate_loops_for_partition): Likewise.
	(generate_memset_builtin): Likewise.
	(generate_memcpy_builtin): Likewise.
	(destroy_loop): Likewise.
	(classify_partition): Likewise.
	(similar_memory_accesses): Likewise.
	(rdg_build_partitions): Likewise.
	(pgcmp): Likewise.
	(distribute_loop): Likewise.
	* tree-nested.c (get_chain_field): Likewise.
	(init_tmp_var): Likewise.
	(save_tmp_var): Likewise.
	(walk_function): Likewise.
	(convert_nonlocal_reference_stmt): Likewise.
	(convert_local_reference_stmt): Likewise.
	(convert_nl_goto_reference): Likewise.
	(convert_nl_goto_receiver): Likewise.
	(convert_tramp_reference_op): Likewise.
	(convert_tramp_reference_stmt): Likewise.
	(convert_gimple_call): Likewise.
	(finalize_nesting_tree_1): Likewise.
	* tree-nrv.c (finalize_nrv_r): Likewise.
	(make_pass_nrv): Likewise.
	(dest_safe_for_nrv_p): Likewise.
	* tree-object-size.c (pass_through_call): Likewise.
	(addr_object_size): Likewise.
	(alloc_object_size): Likewise.
	(cond_expr_object_size): Likewise.
	(expr_object_size): Likewise.
	(merge_object_sizes): Likewise.
	(plus_stmt_object_size): Likewise.
	(collect_object_sizes_for): Likewise.
	(check_for_plus_in_loops_1): Likewise.
	(check_for_plus_in_loops): Likewise.
	(fini_object_sizes): Likewise.
	* tree-outof-ssa.c (ssa_is_replaceable_p): Likewise.
	(set_location_for_edge): Likewise.
	(eliminate_build): Likewise.
	(eliminate_phi): Likewise.
	(remove_gimple_phi_args): Likewise.
	(eliminate_useless_phis): Likewise.
	(rewrite_trees): Likewise.
	(maybe_renumber_stmts_bb): Likewise.
	(trivially_conflicts_p): Likewise.
	(insert_backedge_copies): Likewise.
	* tree-outof-ssa.h (get_rtx_for_ssa_name): Likewise.
	(get_gimple_for_ssa_name): Likewise.
	* tree-parloops.c (printf): Likewise.
	(return): Likewise.
	(take_address_of): Likewise.
	(eliminate_local_variables_stmt): Likewise.
	(separate_decls_in_region_name): Likewise.
	(separate_decls_in_region_stmt): Likewise.
	(create_phi_for_local_result): Likewise.
	(create_call_for_reduction_1): Likewise.
	(create_loads_for_reductions): Likewise.
	(create_final_loads_for_reduction): Likewise.
	(create_stores_for_reduction): Likewise.
	(create_loads_and_stores_for_name): Likewise.
	(separate_decls_in_region): Likewise.
	(transform_to_exit_first_loop): Likewise.
	(create_parallel_loop): Likewise.
	(gen_parallel_loop): Likewise.
	(loop_has_vector_phi_nodes): Likewise.
	(gather_scalar_reductions): Likewise.
	(try_create_reduction_list): Likewise.
	* tree-pass.h (void): Likewise.
	(ipa_opt_pass_d): Likewise.
	(execute_all_ipa_stmt_fixups): Likewise.
	* tree-phinodes.c (GTY): Likewise.
	(ideal_phi_node_len): Likewise.
	(make_phi_node): Likewise.
	(reserve_phi_args_for_new_edge): Likewise.
	(add_phi_node_to_bb): Likewise.
	(create_phi_node): Likewise.
	(remove_phi_node): Likewise.
	(remove_phi_nodes): Likewise.
	* tree-phinodes.h (release_phi_node): Likewise.
	(add_phi_node_to_bb): Likewise.
	(add_phi_arg): Likewise.
	(degenerate_phi_result): Likewise.
	(gimple_phi_arg_imm_use_ptr): Likewise.
	(phi_arg_index_from_use): Likewise.
	* tree-predcom.c (computations): Likewise.
	(valid_initializer_p): Likewise.
	(find_looparound_phi): Likewise.
	(add_looparound_copies): Likewise.
	(determine_roots): Likewise.
	(replace_ref_with): Likewise.
	(initialize_root_vars): Likewise.
	(initialize_root_vars_lm): Likewise.
	(execute_load_motion): Likewise.
	(single_nonlooparound_use): Likewise.
	(remove_stmt): Likewise.
	(base_names_in_chain_on): Likewise.
	(eliminate_temp_copies): Likewise.
	(chain_can_be_combined_p): Likewise.
	(find_use_stmt): Likewise.
	(may_reassociate_p): Likewise.
	(find_associative_operation_root): Likewise.
	(find_common_use_stmt): Likewise.
	(combinable_refs_p): Likewise.
	(remove_name_from_operation): Likewise.
	(reassociate_to_the_same_stmt): Likewise.
	(stmt_combining_refs): Likewise.
	(combine_chains): Likewise.
	* tree-profile.c (gimple_gen_edge_profiler): Likewise.
	(gimple_gen_interval_profiler): Likewise.
	(gimple_gen_pow2_profiler): Likewise.
	(gimple_gen_one_value_profiler): Likewise.
	(gimple_gen_ic_profiler): Likewise.
	(gimple_gen_ic_func_profiler): Likewise.
	(gimple_gen_time_profiler): Likewise.
	(gimple_gen_average_profiler): Likewise.
	(gimple_gen_ior_profiler): Likewise.
	(tree_profiling): Likewise.
	* tree-scalar-evolution.c (chrec_contains_symbols_defined_in_loop):
	Likewise.
	(get_scalar_evolution): Likewise.
	(add_to_evolution_1): Likewise.
	(add_to_evolution): Likewise.
	(get_loop_exit_condition): Likewise.
	(follow_ssa_edge_binary): Likewise.
	(follow_ssa_edge_expr): Likewise.
	(follow_ssa_edge_in_rhs): Likewise.
	(backedge_phi_arg_p): Likewise.
	(follow_ssa_edge_in_condition_phi_branch): Likewise.
	(follow_ssa_edge_in_condition_phi): Likewise.
	(follow_ssa_edge_inner_loop_phi): Likewise.
	(simplify_peeled_chrec): Likewise.
	(analyze_evolution_in_loop): Likewise.
	(analyze_initial_condition): Likewise.
	(interpret_loop_phi): Likewise.
	(interpret_condition_phi): Likewise.
	(interpret_rhs_expr): Likewise.
	(interpret_expr): Likewise.
	(analyze_scalar_evolution_1): Likewise.
	(loop_closed_phi_def): Likewise.
	(scev_const_prop): Likewise.
	* tree-scalar-evolution.h (number_of_latch_executions): Likewise.
	* tree-sra.c (representatives): Likewise.
	(get_ssa_base_param): Likewise.
	(create_access_1): Likewise.
	(disqualify_base_of_expr): Likewise.
	(build_access_from_expr_1): Likewise.
	(single_non_eh_succ): Likewise.
	(disqualify_if_bad_bb_terminating_stmt): Likewise.
	(build_accesses_from_assign): Likewise.
	(asm_visit_addr): Likewise.
	(scan_function): Likewise.
	(build_ref_for_offset): Likewise.
	(generate_subtree_copies): Likewise.
	(init_subtree_with_zero): Likewise.
	(sra_modify_expr): Likewise.
	(load_assign_lhs_subreplacements): Likewise.
	(contains_vce_or_bfcref_p): Likewise.
	(sra_modify_assign): Likewise.
	(sra_modify_function_body): Likewise.
	(ptr_parm_has_direct_uses): Likewise.
	(get_adjustment_for_base): Likewise.
	(replace_removed_params_ssa_names): Likewise.
	(sra_ipa_modify_assign): Likewise.
	(ipa_sra_modify_function_body): Likewise.
	(sra_ipa_reset_debug_stmts): Likewise.
	(convert_callers): Likewise.
	* tree-ssa-alias.c (ref_may_alias_global_p): Likewise.
	(ao_ref_init_from_ptr_and_size): Likewise.
	(refs_output_dependent_p): Likewise.
	(ref_maybe_used_by_call_p_1): Likewise.
	(ref_maybe_used_by_call_p): Likewise.
	(ref_maybe_used_by_stmt_p): Likewise.
	(call_may_clobber_ref_p_1): Likewise.
	(call_may_clobber_ref_p): Likewise.
	(stmt_may_clobber_ref_p_1): Likewise.
	(stmt_may_clobber_ref_p): Likewise.
	(stmt_kills_ref_p_1): Likewise.
	(stmt_kills_ref_p): Likewise.
	(maybe_skip_until): Likewise.
	(get_continuation_for_phi_1): Likewise.
	(walk_non_aliased_vuses): Likewise.
	(walk_aliased_vdefs_1): Likewise.
	* tree-ssa-alias.h (ref_maybe_used_by_stmt_p): Likewise.
	(stmt_may_clobber_global_p): Likewise.
	(stmt_may_clobber_ref_p): Likewise.
	(stmt_may_clobber_ref_p_1): Likewise.
	(call_may_clobber_ref_p): Likewise.
	(call_may_clobber_ref_p_1): Likewise.
	(stmt_kills_ref_p): Likewise.
	(get_continuation_for_phi): Likewise.
	* tree-ssa-ccp.c (get_default_value): Likewise.
	(get_value_for_expr): Likewise.
	(likely_value): Likewise.
	(ccp_initialize): Likewise.
	(ccp_lattice_meet): Likewise.
	(valueize_op): Likewise.
	(bit_value_binop): Likewise.
	(bit_value_assume_aligned): Likewise.
	(insert_clobber_before_stack_restore): Likewise.
	(insert_clobbers_for_var): Likewise.
	(ccp_fold_stmt): Likewise.
	(visit_assignment): Likewise.
	(visit_cond_stmt): Likewise.
	(optimize_stack_restore): Likewise.
	(optimize_unreachable): Likewise.
	* tree-ssa-coalesce.c (build_ssa_conflict_graph): Likewise.
	(create_outofssa_var_map): Likewise.
	(coalesce_partitions): Likewise.
	* tree-ssa-copy.c (stmt_may_generate_copy): Likewise.
	(dump_copy_of): Likewise.
	(copy_prop_visit_assignment): Likewise.
	(copy_prop_visit_cond_stmt): Likewise.
	(copy_prop_visit_stmt): Likewise.
	(init_copy_prop): Likewise.
	* tree-ssa-copyrename.c (copy_rename_partition_coalesce): Likewise.
	* tree-ssa-dce.c (Copyright): Likewise.
	(mark_stmt_necessary): Likewise.
	(mark_operand_necessary): Likewise.
	(mark_last_stmt_necessary): Likewise.
	(find_obviously_necessary_stmts): Likewise.
	(mark_aliased_reaching_defs_necessary_1): Likewise.
	(mark_all_reaching_defs_necessary_1): Likewise.
	(mark_all_reaching_defs_necessary): Likewise.
	(propagate_necessity): Likewise.
	(remove_dead_phis): Likewise.
	(forward_edge_to_pdom): Likewise.
	(remove_dead_stmt): Likewise.
	(eliminate_unnecessary_stmts): Likewise.
	* tree-ssa-dom.c (Copyright): Likewise.
	(target): Likewise.
	(remove): Likewise.
	(lookup_avail_expr): Likewise.
	(initialize_hash_element): Likewise.
	(iterative_hash_hashable_expr): Likewise.
	(print_expr_hash_elt): Likewise.
	(free_all_edge_infos): Likewise.
	(make_pass_dominator): Likewise.
	(restore_vars_to_original_value): Likewise.
	(record_equivalences_from_phis): Likewise.
	(record_equivalences_from_incoming_edge): Likewise.
	(loop_depth_of_name): Likewise.
	(record_equality): Likewise.
	(simple_iv_increment_p): Likewise.
	(cprop_into_successor_phis): Likewise.
	(record_edge_info): Likewise.
	(eliminate_redundant_computations): Likewise.
	(record_equivalences_from_stmt): Likewise.
	(cprop_operand): Likewise.
	(optimize_stmt): Likewise.
	(avail_expr_hash): Likewise.
	(remove_stmt_or_phi): Likewise.
	(get_rhs_or_phi_arg): Likewise.
	(get_lhs_or_phi_result): Likewise.
	(propagate_rhs_into_lhs): Likewise.
	(eliminate_const_or_copy): Likewise.
	(eliminate_degenerate_phis_1): Likewise.
	* tree-ssa-dom.h (simple_iv_increment_p): Likewise.
	* tree-ssa-dse.c (dse_possible_dead_store_p): Likewise.
	(dse_optimize_stmt): Likewise.
	* tree-ssa-forwprop.c (get_prop_dest_stmt): Likewise.
	(get_prop_source_stmt): Likewise.
	(remove_prop_source_from_use): Likewise.
	(rhs_to_tree): Likewise.
	(combine_cond_expr_cond): Likewise.
	(forward_propagate_into_comparison_1): Likewise.
	(forward_propagate_into_comparison): Likewise.
	(forward_propagate_into_cond): Likewise.
	(combine_cond_exprs): Likewise.
	(forward_propagate_addr_expr_1): Likewise.
	(forward_propagate_addr_expr): Likewise.
	(forward_propagate_comparison): Likewise.
	(simplify_conversion_from_bitmask): Likewise.
	(simplify_not_neg_expr): Likewise.
	(simplify_gimple_switch_label_vec): Likewise.
	(simplify_gimple_switch): Likewise.
	(constant_pointer_difference): Likewise.
	(simplify_builtin_call): Likewise.
	(truth_valued_ssa_name): Likewise.
	(lookup_logical_inverted_value): Likewise.
	(defcodefor_name): Likewise.
	(simplify_bitwise_binary_boolean): Likewise.
	(simplify_bitwise_binary): Likewise.
	(simplify_rotate): Likewise.
	(associate_plusminus): Likewise.
	(associate_pointerplus_align): Likewise.
	(associate_pointerplus_diff): Likewise.
	(associate_pointerplus): Likewise.
	(combine_conversions): Likewise.
	(simplify_vce): Likewise.
	(simplify_bitfield_ref): Likewise.
	(simplify_permutation): Likewise.
	(simplify_vector_constructor): Likewise.
	(simplify_mult): Likewise.
	* tree-ssa-ifcombine.c (bb_no_side_effects_p): Likewise.
	(same_phi_args_p): Likewise.
	(get_name_for_bit_test): Likewise.
	(recognize_single_bit_test): Likewise.
	(recognize_bits_test): Likewise.
	(ifcombine_ifandif): Likewise.
	(tree_ssa_ifcombine_bb): Likewise.
	* tree-ssa-live.c (clear_unused_block_pointer): Likewise.
	(remove_unused_locals): Likewise.
	(set_var_live_on_entry): Likewise.
	(calculate_live_on_exit): Likewise.
	(verify_live_on_entry): Likewise.
	* tree-ssa-loop-ch.c (should_duplicate_loop_header_p): Likewise.
	(do_while_loop_p): Likewise.
	* tree-ssa-loop-im.c (if): Likewise.
	(ref_indep_loop_p): Likewise.
	(init_lim_data): Likewise.
	(free_lim_aux_data): Likewise.
	(clear_lim_data): Likewise.
	(outermost_invariant_loop): Likewise.
	(add_dependency): Likewise.
	(outermost_indep_loop): Likewise.
	(simple_mem_ref_in_stmt): Likewise.
	(mem_ref_in_stmt): Likewise.
	(extract_true_false_args_from_phi): Likewise.
	(determine_max_movement): Likewise.
	(set_level): Likewise.
	(set_profitable_level): Likewise.
	(nonpure_call_p): Likewise.
	(rewrite_reciprocal): Likewise.
	(rewrite_bittest): Likewise.
	(force_move_till_op): Likewise.
	(mem_ref_alloc): Likewise.
	(mark_ref_stored): Likewise.
	(execute_sm_if_changed): Likewise.
	(execute_sm): Likewise.
	* tree-ssa-loop-ivcanon.c (create_canonical_iv): Likewise.
	(tree_estimate_loop_size): Likewise.
	(remove_exits_and_undefined_stmts): Likewise.
	(unloop_loops): Likewise.
	(try_unroll_loop_completely): Likewise.
	(propagate_into_all_uses): Likewise.
	(propagate_constants_for_unrolling): Likewise.
	* tree-ssa-loop-ivopts.c (avg_loop_niter): Likewise.
	(name_info): Likewise.
	(stmt_after_ip_normal_pos): Likewise.
	(stmt_after_inc_pos): Likewise.
	(get_iv): Likewise.
	(find_bivs): Likewise.
	(mark_bivs): Likewise.
	(find_givs_in_stmt_scev): Likewise.
	(find_induction_variables): Likewise.
	(find_interesting_uses_op): Likewise.
	(extract_cond_operands): Likewise.
	(expr_invariant_in_loop_p): Likewise.
	(may_be_nonaddressable_p): Likewise.
	(find_interesting_uses_address): Likewise.
	(find_invariants_stmt): Likewise.
	(find_interesting_uses_outside): Likewise.
	(find_depends): Likewise.
	(add_old_iv_candidates): Likewise.
	(computation_cost): Likewise.
	(determine_common_wider_type): Likewise.
	(get_use_type): Likewise.
	(get_loop_invariant_expr_id): Likewise.
	(determine_use_iv_cost_address): Likewise.
	(expr_equal_p): Likewise.
	(difference_cannot_overflow_p): Likewise.
	(determine_set_costs): Likewise.
	(rewrite_use_nonlinear_expr): Likewise.
	(adjust_iv_update_pos): Likewise.
	(remove_unused_ivs): Likewise.
	(loop_body_includes_call): Likewise.
	* tree-ssa-loop-manip.c (create_iv): Likewise.
	(add_exit_phi): Likewise.
	(find_uses_to_rename_use): Likewise.
	(find_uses_to_rename_bb): Likewise.
	(check_loop_closed_ssa_use): Likewise.
	(verify_loop_closed_ssa): Likewise.
	(split_loop_exit_edge): Likewise.
	(ip_normal_pos): Likewise.
	(standard_iv_increment_position): Likewise.
	(tree_transform_and_unroll_loop): Likewise.
	(rewrite_phi_with_iv): Likewise.
	(canonicalize_loop_ivs): Likewise.
	* tree-ssa-loop-niter.c (determine_value_range): Likewise.
	(bound_difference): Likewise.
	(expand_simple_operations): Likewise.
	(simplify_using_initial_conditions): Likewise.
	(loop_only_exit_p): Likewise.
	(number_of_iterations_exit): Likewise.
	(finite_loop_p): Likewise.
	(chain_of_csts_start): Likewise.
	(get_base_for): Likewise.
	(get_val_for): Likewise.
	(loop_niter_by_eval): Likewise.
	(find_loop_niter_by_eval): Likewise.
	(derive_constant_upper_bound_ops): Likewise.
	(do_warn_aggressive_loop_optimizations): Likewise.
	(record_estimate): Likewise.
	(record_nonwrapping_iv): Likewise.
	(idx_infer_loop_bounds): Likewise.
	(infer_loop_bounds_from_ref): Likewise.
	(infer_loop_bounds_from_array): Likewise.
	(infer_loop_bounds_from_pointer_arith): Likewise.
	(infer_loop_bounds_from_undefined): Likewise.
	(maybe_lower_iteration_bound): Likewise.
	(estimate_numbers_of_iterations): Likewise.
	(stmt_dominates_stmt_p): Likewise.
	(nowrap_type_p): Likewise.
	* tree-ssa-loop-niter.h (stmt_dominates_stmt_p): Likewise.
	(scev_probably_wraps_p): Likewise.
	* tree-ssa-loop-prefetch.c (then): Likewise.
	(find_or_create_group): Likewise.
	(release_mem_refs): Likewise.
	(idx_analyze_ref): Likewise.
	(analyze_ref): Likewise.
	(gather_memory_references): Likewise.
	(issue_prefetch_ref): Likewise.
	(emit_mfence_after_loop): Likewise.
	* tree-ssa-loop-unswitch.c (tree_may_unswitch_on): Likewise.
	(simplify_using_entry_checks): Likewise.
	(tree_unswitch_single_loop): Likewise.
	* tree-ssa-loop.h (tree_num_loop_insns): Likewise.
	* tree-ssa-math-opts.c (Copyright): Likewise.
	(compute_merit): Likewise.
	(insert_reciprocals): Likewise.
	(replace_reciprocal): Likewise.
	(execute_cse_reciprocals_1): Likewise.
	(make_pass_cse_reciprocals): Likewise.
	(execute_cse_sincos_1): Likewise.
	(powi_as_mults_1): Likewise.
	(powi_as_mults): Likewise.
	(build_and_insert_call): Likewise.
	(build_and_insert_binop): Likewise.
	(build_and_insert_ref): Likewise.
	(build_and_insert_cast): Likewise.
	(gimple_expand_builtin_cabs): Likewise.
	(do_shift_rotate): Likewise.
	(verify_symbolic_number_p): Likewise.
	(find_bswap_1): Likewise.
	(find_bswap): Likewise.
	(make_pass_optimize_bswap): Likewise.
	(is_widening_mult_rhs_p): Likewise.
	(is_widening_mult_p): Likewise.
	(convert_mult_to_widen): Likewise.
	(convert_plusminus_to_widen): Likewise.
	(convert_mult_to_fma): Likewise.
	* tree-ssa-operands.c (alloc_use): Likewise.
	(add_use_op): Likewise.
	(finalize_ssa_defs): Likewise.
	(cleanup_build_arrays): Likewise.
	(append_vuse): Likewise.
	(add_virtual_operand): Likewise.
	(mark_address_taken): Likewise.
	(get_mem_ref_operands): Likewise.
	(get_tmr_operands): Likewise.
	(maybe_add_call_vops): Likewise.
	(get_asm_stmt_operands): Likewise.
	(get_expr_operands): Likewise.
	(parse_ssa_operands): Likewise.
	(build_ssa_operands): Likewise.
	(verify_ssa_operands): Likewise.
	(free_stmt_operands): Likewise.
	(update_stmt_operands): Likewise.
	(debug_immediate_uses_for): Likewise.
	(unlink_stmt_vdef): Likewise.
	(has_zero_uses_1): Likewise.
	* tree-ssa-operands.h (verify_ssa_operands): Likewise.
	(free_stmt_operands): Likewise.
	(update_stmt_operands): Likewise.
	(swap_ssa_operands): Likewise.
	(unlink_stmt_vdef): Likewise.
	* tree-ssa-phiopt.c (tree_ssa_cs_elim): Likewise.
	(single_non_singleton_phi_for_edges): Likewise.
	(tree_ssa_phiopt_worker): Likewise.
	(replace_phi_edge_with_variable): Likewise.
	(conditional_replacement): Likewise.
	(rhs_is_fed_for_value_replacement): Likewise.
	(operand_equal_for_value_replacement): Likewise.
	(absorbing_element_p): Likewise.
	(value_replacement): Likewise.
	(minmax_replacement): Likewise.
	(abs_replacement): Likewise.
	(neg_replacement): Likewise.
	(add_or_mark_expr): Likewise.
	(cond_store_replacement): Likewise.
	(cond_if_else_store_replacement_1): Likewise.
	(cond_if_else_store_replacement): Likewise.
	(local_mem_dependence): Likewise.
	(hoist_adjacent_loads): Likewise.
	* tree-ssa-phiprop.c (phivn_valid_p): Likewise.
	(phiprop_insert_phi): Likewise.
	(propagate_with_phi): Likewise.
	* tree-ssa-pre.c (translate_vuse_through_block): Likewise.
	(phi_translate_1): Likewise.
	(value_dies_in_block_x): Likewise.
	(prune_clobbered_mems): Likewise.
	(create_expression_by_pieces): Likewise.
	(insert_into_preds_of_block): Likewise.
	(do_regular_insertion): Likewise.
	(compute_avail): Likewise.
	(eliminate_insert): Likewise.
	(eliminate): Likewise.
	(fini_eliminate): Likewise.
	(mark_operand_necessary): Likewise.
	(remove_dead_inserted_code): Likewise.
	* tree-ssa-propagate.c (block): Likewise.
	(reexamined): Likewise.
	(add_ssa_edge): Likewise.
	(add_control_edge): Likewise.
	(simulate_stmt): Likewise.
	(process_ssa_edge_worklist): Likewise.
	(simulate_block): Likewise.
	(valid_gimple_call_p): Likewise.
	(move_ssa_defining_stmt_for_defs): Likewise.
	(update_gimple_call): Likewise.
	(update_call_from_tree): Likewise.
	(ssa_propagate): Likewise.
	(stmt_makes_single_store): Likewise.
	(replace_uses_in): Likewise.
	(substitute_and_fold): Likewise.
	(may_propagate_copy): Likewise.
	(propagate_tree_value_into_stmt): Likewise.
	* tree-ssa-propagate.h (prop_set_simulate_again): Likewise.
	(prop_simulate_again_p): Likewise.
	* tree-ssa-reassoc.c (reassoc_remove_stmt): Likewise.
	(phi_rank): Likewise.
	(loop_carried_phi): Likewise.
	(get_rank): Likewise.
	(sort_by_operand_rank): Likewise.
	(add_repeat_to_ops_vec): Likewise.
	(get_unary_op): Likewise.
	(eliminate_using_constants): Likewise.
	(oecount_cmp): Likewise.
	(stmt_is_power_of_op): Likewise.
	(decrement_power): Likewise.
	(propagate_op_to_single_use): Likewise.
	(zero_one_operation): Likewise.
	(reassoc_stmt_dominates_stmt_p): Likewise.
	(insert_stmt_after): Likewise.
	(build_and_add_sum): Likewise.
	(undistribute_ops_list): Likewise.
	(eliminate_redundant_comparison): Likewise.
	(optimize_ops_list): Likewise.
	(update_range_test): Likewise.
	(optimize_range_tests): Likewise.
	(final_range_test_p): Likewise.
	(suitable_cond_bb): Likewise.
	(no_side_effect_bb): Likewise.
	(get_ops): Likewise.
	(update_ops): Likewise.
	(maybe_optimize_range_tests): Likewise.
	(is_phi_for_stmt): Likewise.
	(remove_visited_stmt_chain): Likewise.
	(swap_ops_for_binary_stmt): Likewise.
	(find_insert_point): Likewise.
	(rewrite_expr_tree): Likewise.
	(get_reassociation_width): Likewise.
	(rewrite_expr_tree_parallel): Likewise.
	(linearize_expr): Likewise.
	(get_single_immediate_use): Likewise.
	(negate_value): Likewise.
	(should_break_up_subtract): Likewise.
	(break_up_subtract): Likewise.
	(acceptable_pow_call): Likewise.
	(linearize_expr_tree): Likewise.
	(repropagate_negates): Likewise.
	(break_up_subtract_bb): Likewise.
	(compare_repeat_factors): Likewise.
	(attempt_builtin_powi): Likewise.
	(transform_stmt_to_copy): Likewise.
	(reassociate_bb): Likewise.
	* tree-ssa-sccvn.c (vn_get_expr_for): Likewise.
	(ao_ref_init_from_vn_reference): Likewise.
	(copy_reference_ops_from_call): Likewise.
	(vn_reference_maybe_forwprop_address): Likewise.
	(valueize_shared_reference_ops_from_ref): Likewise.
	(vn_reference_lookup_3): Likewise.
	(init_vn_nary_op_from_op): Likewise.
	(vn_nary_length_from_stmt): Likewise.
	(vn_nary_op_lookup): Likewise.
	(vn_nary_op_insert): Likewise.
	(vn_phi_eq): Likewise.
	(vn_phi_lookup): Likewise.
	(mark_use_processed): Likewise.
	(visit_copy): Likewise.
	(visit_nary_op): Likewise.
	(visit_reference_op_call): Likewise.
	(visit_reference_op_load): Likewise.
	(visit_reference_op_store): Likewise.
	(expr_has_constants): Likewise.
	(stmt_has_constants): Likewise.
	(simplify_binary_expression): Likewise.
	(simplify_unary_expression): Likewise.
	(visit_use): Likewise.
	(compare_ops): Likewise.
	(DFS): Likewise.
	* tree-ssa-sccvn.h (sizeof_vn_nary_op): Likewise.
	(vn_constant_eq_with_type): Likewise.
	* tree-ssa-sink.c (find_bb_for_arg): Likewise.
	(all_immediate_uses_same_place): Likewise.
	(nearest_common_dominator_of_uses): Likewise.
	(select_best_block): Likewise.
	(statement_sink_location): Likewise.
	(sink_code_in_bb): Likewise.
	* tree-ssa-strlen.c (literal): Likewise.
	(tree_map_base_eq): Likewise.
	(get_string_length): Likewise.
	(find_equal_ptrs): Likewise.
	(adjust_last_stmt): Likewise.
	(handle_builtin_strlen): Likewise.
	(handle_builtin_strchr): Likewise.
	(handle_builtin_strcpy): Likewise.
	(handle_builtin_memcpy): Likewise.
	(handle_builtin_strcat): Likewise.
	(handle_pointer_plus): Likewise.
	(handle_char_store): Likewise.
	(strlen_optimize_stmt): Likewise.
	(do_invalidate): Likewise.
	* tree-ssa-structalias.c (new_var_info): Likewise.
	(get_call_vi): Likewise.
	(lookup_call_use_vi): Likewise.
	(lookup_call_clobber_vi): Likewise.
	(get_call_use_vi): Likewise.
	(get_function_part_constraint): Likewise.
	(handle_rhs_call): Likewise.
	(handle_lhs_call): Likewise.
	(handle_const_call): Likewise.
	(handle_pure_call): Likewise.
	(get_fi_for_callee): Likewise.
	(find_func_aliases_for_builtin_call): Likewise.
	(find_func_aliases_for_call): Likewise.
	(find_func_aliases): Likewise.
	(process_ipa_clobber): Likewise.
	(find_func_clobbers): Likewise.
	(compute_points_to_sets): Likewise.
	(ipa_pta_execute): Likewise.
	* tree-ssa-tail-merge.c (stmt_local_def): Likewise.
	(gsi_advance_fw_nondebug_nonlocal): Likewise.
	(update_dep_bb): Likewise.
	(same_succ_hash): Likewise.
	(inverse_flags): Likewise.
	(release_last_vdef): Likewise.
	(gimple_operand_equal_value_p): Likewise.
	(gsi_advance_bw_nondebug_nonlocal): Likewise.
	(find_duplicate): Likewise.
	(same_phi_alternatives_1): Likewise.
	(bb_has_non_vop_phi): Likewise.
	(find_clusters): Likewise.
	(vop_phi): Likewise.
	(replace_block_by): Likewise.
	(apply_clusters): Likewise.
	(update_debug_stmt): Likewise.
	(update_debug_stmts): Likewise.
	* tree-ssa-ter.c (finished_with_expr): Likewise.
	(ter_is_replaceable_p): Likewise.
	(find_ssaname): Likewise.
	(find_replaceable_in_bb): Likewise.
	* tree-ssa-threadedge.c (potentially_threadable_block): Likewise.
	(lhs_of_dominating_assert): Likewise.
	(record_temporary_equivalences_from_phis): Likewise.
	(invalidate_equivalences): Likewise.
	(record_temporary_equivalences_from_stmts_at_dest): Likewise.
	(dummy_simplify): Likewise.
	(simplify_control_stmt_condition): Likewise.
	(propagate_threaded_block_debug_into): Likewise.
	(thread_around_empty_blocks): Likewise.
	(thread_through_normal_block): Likewise.
	(thread_across_edge): Likewise.
	* tree-ssa-threadedge.h (thread_across_edge): Likewise.
	* tree-ssa-threadupdate.c (copy_phi_arg_into_existing_phi): Likewise.
	(get_value_locus_in_path): Likewise.
	(copy_phi_args): Likewise.
	(phi_args_equal_on_edges): Likewise.
	(bb_ends_with_multiway_branch): Likewise.
	* tree-ssa-uncprop.c (associate_equivalences_with_edges): Likewise.
	(uncprop_into_successor_phis): Likewise.
	* tree-ssa-uninit.c (warn_uninit): Likewise.
	(warn_uninitialized_vars): Likewise.
	(can_skip_redundant_opnd): Likewise.
	(convert_control_dep_chain_into_preds): Likewise.
	(find_predicates): Likewise.
	(collect_phi_def_edges): Likewise.
	(find_def_preds): Likewise.
	(find_matching_predicate_in_rest_chains): Likewise.
	(prune_uninit_phi_opnds_in_unrealizable_paths): Likewise.
	(use_pred_not_overlap_with_undef_path_pred): Likewise.
	(simplify_pred): Likewise.
	(simplify_preds_4): Likewise.
	(push_to_worklist): Likewise.
	(get_pred_info_from_cmp): Likewise.
	(is_degenerated_phi): Likewise.
	(normalize_one_pred_1): Likewise.
	(normalize_one_pred): Likewise.
	(normalize_one_pred_chain): Likewise.
	(normalize_preds): Likewise.
	(is_use_properly_guarded): Likewise.
	(find_uninit_use): Likewise.
	(warn_uninitialized_phi): Likewise.
	(gate_warn_uninitialized): Likewise.
	* tree-ssa.c (ssa_redirect_edge): Likewise.
	(flush_pending_stmts): Likewise.
	(insert_debug_temp_for_var_def): Likewise.
	(insert_debug_temps_for_defs): Likewise.
	(reset_debug_uses): Likewise.
	(release_defs_bitset): Likewise.
	(verify_ssa_name): Likewise.
	(verify_def): Likewise.
	(verify_use): Likewise.
	(verify_ssa): Likewise.
	(ssa_undefined_value_p): Likewise.
	(execute_update_addresses_taken): Likewise.
	* tree-ssa.h (gimple_replace_ssa_lhs): Likewise.
	(reset_debug_uses): Likewise.
	* tree-ssanames.c (ssanames_print_statistics): Likewise.
	(get_ptr_info): Likewise.
	(duplicate_ssa_name_range_info): Likewise.
	(duplicate_ssa_name_fn): Likewise.
	* tree-ssanames.h (make_ssa_name_fn): Likewise.
	(copy_ssa_name_fn): Likewise.
	(duplicate_ssa_name_fn): Likewise.
	(release_defs): Likewise.
	(make_ssa_name): Likewise.
	(copy_ssa_name): Likewise.
	(release_ssa_name): Likewise.
	* tree-stdarg.c (va_list_counter_bump): Likewise.
	(check_all_va_list_escapes): Likewise.
	* tree-switch-conversion.c (hoist_edge_and_branch_if_true): Likewise.
	(case_bit_test_cmp): Likewise.
	(emit_case_bit_tests): Likewise.
	(check_final_bb): Likewise.
	(gather_default_values): Likewise.
	(build_constructors): Likewise.
	(constructor_contains_same_values_p): Likewise.
	(array_value_type): Likewise.
	(build_one_array): Likewise.
	(build_arrays): Likewise.
	(gen_def_assigns): Likewise.
	(fix_phi_nodes): Likewise.
	(gen_inbound_check): Likewise.
	(process_switch): Likewise.
	* tree-tailcall.c (suitable_for_tail_call_opt_p): Likewise.
	(independent_of_stmt_p): Likewise.
	(propagate_through_phis): Likewise.
	(find_tail_calls): Likewise.
	(adjust_return_value_with_ops): Likewise.
	(update_accumulator_with_ops): Likewise.
	(adjust_return_value): Likewise.
	(eliminate_tail_call): Likewise.
	(optimize_tail_call): Likewise.
	(create_tailcall_accumulator): Likewise.
	(tree_optimize_tail_calls_1): Likewise.
	* tree-vect-data-refs.c (vect_lanes_optab_supported_p): Likewise.
	(vect_analyze_data_ref_dependence): Likewise.
	(vect_slp_analyze_data_ref_dependence): Likewise.
	(vect_compute_data_ref_alignment): Likewise.
	(vect_verify_datarefs_alignment): Likewise.
	(vector_alignment_reachable_p): Likewise.
	(vect_get_data_access_cost): Likewise.
	(vect_peeling_hash_get_lowest_cost): Likewise.
	(vect_enhance_data_refs_alignment): Likewise.
	(vect_analyze_group_access): Likewise.
	(vect_analyze_data_ref_access): Likewise.
	(vect_prune_runtime_alias_test_list): Likewise.
	(vect_check_gather): Likewise.
	(vect_analyze_data_refs): Likewise.
	(vect_get_new_vect_var): Likewise.
	(vect_create_addr_base_for_vector_ref): Likewise.
	(vect_create_data_ref_ptr): Likewise.
	(bump_vector_ptr): Likewise.
	(vect_store_lanes_supported): Likewise.
	(vect_permute_store_chain): Likewise.
	(vect_setup_realignment): Likewise.
	(vect_load_lanes_supported): Likewise.
	(vect_permute_load_chain): Likewise.
	(vect_transform_grouped_load): Likewise.
	(vect_record_grouped_load_vectors): Likewise.
	(vect_supportable_dr_alignment): Likewise.
	* tree-vect-generic.c (expand_vector_divmod): Likewise.
	(expand_vector_condition): Likewise.
	(optimize_vector_constructor): Likewise.
	(vector_element): Likewise.
	(lower_vec_perm): Likewise.
	(expand_vector_operations_1): Likewise.
	* tree-vect-loop-manip.c (rename_variables_in_bb): Likewise.
	(adjust_debug_stmts_now): Likewise.
	(adjust_debug_stmts): Likewise.
	(slpeel_update_phi_nodes_for_guard1): Likewise.
	(slpeel_update_phi_nodes_for_guard2): Likewise.
	(slpeel_make_loop_iterate_ntimes): Likewise.
	(slpeel_duplicate_current_defs_from_edges): Likewise.
	(slpeel_tree_duplicate_loop_to_edge_cfg): Likewise.
	(slpeel_add_loop_guard): Likewise.
	(slpeel_can_duplicate_loop_p): Likewise.
	(set_prologue_iterations): Likewise.
	(slpeel_tree_peel_loop_to_edge): Likewise.
	(find_loop_location): Likewise.
	(vect_can_advance_ivs_p): Likewise.
	(vect_update_ivs_after_vectorizer): Likewise.
	(vect_gen_niters_for_prolog_loop): Likewise.
	(vect_create_cond_for_align_checks): Likewise.
	(vect_loop_versioning): Likewise.
	* tree-vect-loop.c (vect_determine_vectorization_factor): Likewise.
	(vect_analyze_scalar_cycles_1): Likewise.
	(vect_analyze_scalar_cycles): Likewise.
	(new_loop_vec_info): Likewise.
	(destroy_loop_vec_info): Likewise.
	(vect_analyze_loop_form): Likewise.
	(vect_analyze_loop_operations): Likewise.
	(reduction_code_for_scalar_code): Likewise.
	(report_vect_op): Likewise.
	(vect_is_slp_reduction): Likewise.
	(vect_is_simple_reduction_1): Likewise.
	(vect_is_simple_reduction): Likewise.
	(vect_get_single_scalar_iteration_cost): Likewise.
	(vect_model_reduction_cost): Likewise.
	(vect_model_induction_cost): Likewise.
	(get_initial_def_for_induction): Likewise.
	(get_initial_def_for_reduction): Likewise.
	(vect_create_epilog_for_reduction): Likewise.
	(vectorizable_reduction): Likewise.
	(vect_min_worthwhile_factor): Likewise.
	(vectorizable_induction): Likewise.
	(vectorizable_live_operation): Likewise.
	(vect_loop_kill_debug_uses): Likewise.
	(vect_generate_tmps_on_preheader): Likewise.
	(vect_transform_loop): Likewise.
	* tree-vect-patterns.c (Copyright): Likewise.
	(append_pattern_def_seq): Likewise.
	(new_pattern_def_seq): Likewise.
	(vect_same_loop_or_bb_p): Likewise.
	(vect_single_imm_use): Likewise.
	(type_conversion_p): Likewise.
	(vect_recog_temp_ssa_var): Likewise.
	(vect_recog_dot_prod_pattern): Likewise.
	(vect_handle_widen_op_by_const): Likewise.
	(vect_recog_widen_mult_pattern): Likewise.
	(vect_recog_pow_pattern): Likewise.
	(vect_recog_widen_sum_pattern): Likewise.
	(vect_operation_fits_smaller_type): Likewise.
	(vect_recog_over_widening_pattern): Likewise.
	(vect_recog_widen_shift_pattern): Likewise.
	(vect_recog_rotate_pattern): Likewise.
	(vect_recog_vector_vector_shift_pattern): Likewise.
	(vect_recog_divmod_pattern): Likewise.
	(vect_recog_mixed_size_cond_pattern): Likewise.
	(check_bool_pattern): Likewise.
	(adjust_bool_pattern_cast): Likewise.
	(adjust_bool_pattern): Likewise.
	(vect_recog_bool_pattern): Likewise.
	(vect_mark_pattern_stmts): Likewise.
	(vect_pattern_recog_1): Likewise.
	(vect_pattern_recog): Likewise.
	* tree-vect-slp.c (find_bb_location): Likewise.
	(vect_free_slp_instance): Likewise.
	(vect_create_new_slp_node): Likewise.
	(vect_free_oprnd_info): Likewise.
	(vect_get_place_in_interleaving_chain): Likewise.
	(vect_get_and_check_slp_defs): Likewise.
	(vect_build_slp_tree_1): Likewise.
	(vect_build_slp_tree): Likewise.
	(vect_print_slp_tree): Likewise.
	(vect_mark_slp_stmts): Likewise.
	(vect_mark_slp_stmts_relevant): Likewise.
	(vect_slp_rearrange_stmts): Likewise.
	(vect_supported_load_permutation_p): Likewise.
	(vect_find_first_load_in_slp_instance): Likewise.
	(vect_find_last_store_in_slp_instance): Likewise.
	(vect_analyze_slp_cost_1): Likewise.
	(vect_analyze_slp_cost): Likewise.
	(vect_analyze_slp_instance): Likewise.
	(vect_analyze_slp): Likewise.
	(vect_detect_hybrid_slp_stmts): Likewise.
	(new_bb_vec_info): Likewise.
	(destroy_bb_vec_info): Likewise.
	(vect_slp_analyze_node_operations): Likewise.
	(vect_bb_slp_scalar_cost): Likewise.
	(vect_slp_analyze_bb): Likewise.
	(vect_get_constant_vectors): Likewise.
	(vect_get_slp_vect_defs): Likewise.
	(vect_get_slp_defs): Likewise.
	(vect_create_mask_and_perm): Likewise.
	(vect_transform_slp_perm_load): Likewise.
	(vect_schedule_slp_instance): Likewise.
	(vect_remove_slp_scalar_calls): Likewise.
	(vect_schedule_slp): Likewise.
	(vect_slp_transform_bb): Likewise.
	* tree-vect-stmts.c (stmt_in_inner_loop_p): Likewise.
	(create_vector_array): Likewise.
	(read_vector_array): Likewise.
	(write_vector_array): Likewise.
	(create_array_ref): Likewise.
	(vect_mark_relevant): Likewise.
	(vect_stmt_relevant_p): Likewise.
	(exist_non_indexing_operands_for_use_p): Likewise.
	(process_use): Likewise.
	(vect_mark_stmts_to_be_vectorized): Likewise.
	(vect_cost_group_size): Likewise.
	(vect_model_store_cost): Likewise.
	(vect_get_store_cost): Likewise.
	(vect_model_load_cost): Likewise.
	(vect_get_load_cost): Likewise.
	(vect_init_vector_1): Likewise.
	(vect_init_vector): Likewise.
	(vect_get_vec_def_for_operand): Likewise.
	(vect_get_vec_def_for_stmt_copy): Likewise.
	(vect_get_vec_defs_for_stmt_copy): Likewise.
	(vect_get_vec_defs): Likewise.
	(vect_finish_stmt_generation): Likewise.
	(vectorizable_function): Likewise.
	(vectorizable_mask_load_store): Likewise.
	(vectorizable_call): Likewise.
	(vectorizable_simd_clone_call): Likewise.
	(vect_gen_widened_results_half): Likewise.
	(vect_get_loop_based_defs): Likewise.
	(vect_create_vectorized_demotion_stmts): Likewise.
	(vect_create_vectorized_promotion_stmts): Likewise.
	(vectorizable_conversion): Likewise.
	(vectorizable_assignment): Likewise.
	(vect_supportable_shift): Likewise.
	(vectorizable_shift): Likewise.
	(vectorizable_operation): Likewise.
	(perm_mask_for_reverse): Likewise.
	(vectorizable_store): Likewise.
	(vect_gen_perm_mask): Likewise.
	(permute_vec_elements): Likewise.
	(hoist_defs_of_uses): Likewise.
	(vectorizable_load): Likewise.
	(vect_is_simple_cond): Likewise.
	(vectorizable_condition): Likewise.
	(vect_analyze_stmt): Likewise.
	(vect_transform_stmt): Likewise.
	(vect_remove_stores): Likewise.
	(free_stmt_vec_info_vec): Likewise.
	(free_stmt_vec_info): Likewise.
	(get_same_sized_vectype): Likewise.
	(vect_is_simple_use): Likewise.
	(vect_is_simple_use_1): Likewise.
	(supportable_widening_operation): Likewise.
	* tree-vectorizer.c (adjust_simduid_builtins): Likewise.
	(note_simd_array_uses): Likewise.
	(vect_destroy_datarefs): Likewise.
	(vect_loop_vectorized_call): Likewise.
	(fold_loop_vectorized_call): Likewise.
	(vectorize_loops): Likewise.
	* tree-vectorizer.h (Copyright): Likewise.
	(add_stmt_info_to_vec): Likewise.
	(loop_vec_info_for_loop): Likewise.
	(nested_in_vect_loop_p): Likewise.
	(vec_info_for_bb): Likewise.
	(vinfo_for_stmt): Likewise.
	(set_vinfo_for_stmt): Likewise.
	(get_earlier_stmt): Likewise.
	(is_pattern_stmt_p): Likewise.
	(unlimited_cost_model): Likewise.
	* tree-vrp.c (live_on_edge): Likewise.
	(is_overflow_infinity): Likewise.
	(usable_range_p): Likewise.
	(gimple_assign_nonnegative_warnv_p): Likewise.
	(gimple_call_nonnegative_warnv_p): Likewise.
	(gimple_stmt_nonnegative_warnv_p): Likewise.
	(gimple_assign_nonzero_warnv_p): Likewise.
	(gimple_stmt_nonzero_warnv_p): Likewise.
	(extract_range_from_unary_expr): Likewise.
	(extract_range_from_comparison): Likewise.
	(extract_range_basic): Likewise.
	(extract_range_from_assignment): Likewise.
	(debug_all_value_ranges): Likewise.
	(build_assert_expr_for): Likewise.
	(fp_predicate): Likewise.
	(register_edge_assert_for_2): Likewise.
	(register_edge_assert_for_1): Likewise.
	(register_edge_assert_for): Likewise.
	(compare_case_labels): Likewise.
	(find_assert_locations_1): Likewise.
	(find_assert_locations): Likewise.
	(process_assert_insertions_for): Likewise.
	(search_for_addr_array): Likewise.
	(check_all_array_refs): Likewise.
	(all_imm_uses_in_stmt_or_feed_cond): Likewise.
	(maybe_set_nonzero_bits): Likewise.
	(remove_range_assertions): Likewise.
	(vrp_initialize): Likewise.
	(vrp_valueize): Likewise.
	(vrp_evaluate_conditional_warnv_with_ops): Likewise.
	(vrp_evaluate_conditional): Likewise.
	(vrp_visit_cond_stmt): Likewise.
	(find_case_label_index): Likewise.
	(find_case_label_range): Likewise.
	(find_case_label_ranges): Likewise.
	(vrp_visit_switch_stmt): Likewise.
	(vrp_meet): Likewise.
	(vrp_visit_phi_node): Likewise.
	(simplify_truth_ops_using_ranges): Likewise.
	(simplify_div_or_mod_using_ranges): Likewise.
	(simplify_abs_using_ranges): Likewise.
	(range_fits_type_p): Likewise.
	(simplify_cond_using_ranges): Likewise.
	(simplify_switch_using_ranges): Likewise.
	(simplify_conversion_using_ranges): Likewise.
	(simplify_float_conversion_using_ranges): Likewise.
	(simplify_internal_call_using_ranges): Likewise.
	(simplify_stmt_using_ranges): Likewise.
	(fold_predicate_in): Likewise.
	(vrp_fold_stmt): Likewise.
	(identify_jump_threads): Likewise.
	* tree.c (find_decls_types_in_node): Likewise.
	* tree.h (tree_int_cst_compare): Likewise.
	* tsan.c (get_memory_access_decl): Likewise.
	(instrument_expr): Likewise.
	(instrument_builtin_call): Likewise.
	(instrument_gimple): Likewise.
	(instrument_func_entry): Likewise.
	(instrument_func_exit): Likewise.
	* ubsan.c (ubsan_expand_null_ifn): Likewise.
	(instrument_member_call): Likewise.
	(instrument_mem_ref): Likewise.
	(instrument_null): Likewise.
	(instrument_si_overflow): Likewise.
	(instrument_bool_enum_load): Likewise.
	* value-prof.c (gimple_alloc_histogram_value): Likewise.
	(histogram_eq): Likewise.
	(set_histogram_value): Likewise.
	(gimple_histogram_value): Likewise.
	(gimple_add_histogram_value): Likewise.
	(gimple_remove_histogram_value): Likewise.
	(stream_out_histogram_value): Likewise.
	(stream_in_histogram_value): Likewise.
	(dump_histograms_for_stmt): Likewise.
	(gimple_remove_stmt_histograms): Likewise.
	(gimple_duplicate_stmt_histograms): Likewise.
	(verify_histograms): Likewise.
	(free_histograms): Likewise.
	(gimple_value_profile_transformations): Likewise.
	(gimple_divmod_fixed_value): Likewise.
	(gimple_divmod_fixed_value_transform): Likewise.
	(gimple_mod_pow2): Likewise.
	(gimple_mod_pow2_value_transform): Likewise.
	(gimple_mod_subtract): Likewise.
	(gimple_mod_subtract_transform): Likewise.
	(find_func_by_profile_id): Likewise.
	(check_ic_target): Likewise.
	(gimple_ic): Likewise.
	(gimple_ic_transform): Likewise.
	(interesting_stringop_to_profile_p): Likewise.
	(gimple_stringop_fixed_value): Likewise.
	(gimple_stringops_transform): Likewise.
	(stringop_block_profile): Likewise.
	(gimple_divmod_values_to_profile): Likewise.
	(gimple_indirect_call_to_profile): Likewise.
	(gimple_stringops_values_to_profile): Likewise.
	* value-prof.h (Copyright): Likewise.
	(gimple_histogram_value): Likewise.
	(gimple_histogram_value_of_type): Likewise.
	(gimple_add_histogram_value): Likewise.
	(dump_histograms_for_stmt): Likewise.
	(gimple_remove_histogram_value): Likewise.
	(gimple_remove_stmt_histograms): Likewise.
	(gimple_duplicate_stmt_histograms): Likewise.
	(gimple_move_stmt_histograms): Likewise.
	(stringop_block_profile): Likewise.
	(gimple_ic): Likewise.
	(stream_in_histogram_value): Likewise.
	* vtable-verify.c (find_or_create_vtbl_map_node): Likewise.
	(var_is_used_for_virtual_call_p): Likewise.
	(verify_bb_vtables): Likewise.

gcc/c-family/

	Patch autogenerated by rename_gimple.py from
	https://github.com/davidmalcolm/gcc-refactoring-scripts
	revision d0dcc1bc64a800765492e0c76ba714090414f555

	* c-gimplify.c (add_block_to_enclosing): Replace "gimple" typedef with
	"gimple *".

gcc/cp/

	Patch autogenerated by rename_gimple.py from
	https://github.com/davidmalcolm/gcc-refactoring-scripts
	revision d0dcc1bc64a800765492e0c76ba714090414f555

	* cp-gimplify.c (gimplify_must_not_throw_expr): Replace "gimple"
	typedef with "gimple *".

gcc/java/

	Patch autogenerated by rename_gimple.py from
	https://github.com/davidmalcolm/gcc-refactoring-scripts
	revision d0dcc1bc64a800765492e0c76ba714090414f555

	* java-gimplify.c (java_gimplify_block): Replace "gimple" typedef with
	"gimple *".
---
 gcc/asan.c                            |   36 +-
 gcc/builtins.c                        |   10 +-
 gcc/builtins.h                        |    2 +-
 gcc/c-family/c-gimplify.c             |    4 +-
 gcc/calls.c                           |    2 +-
 gcc/calls.h                           |    2 +-
 gcc/cfgexpand.c                       |   48 +-
 gcc/cfgexpand.h                       |    2 +-
 gcc/cfgloop.c                         |    2 +-
 gcc/cfgloop.h                         |    2 +-
 gcc/cfgloopmanip.c                    |    4 +-
 gcc/cgraph.c                          |   32 +-
 gcc/cgraph.h                          |   24 +-
 gcc/cgraphbuild.c                     |   12 +-
 gcc/cgraphclones.c                    |    8 +-
 gcc/cgraphunit.c                      |   12 +-
 gcc/config/aarch64/aarch64-builtins.c |    4 +-
 gcc/config/alpha/alpha.c              |   18 +-
 gcc/config/i386/i386.c                |   14 +-
 gcc/config/rs6000/rs6000.c            |    4 +-
 gcc/cp/cp-gimplify.c                  |    2 +-
 gcc/dumpfile.c                        |    4 +-
 gcc/dumpfile.h                        |    4 +-
 gcc/except.h                          |    2 +-
 gcc/expr.c                            |   28 +-
 gcc/expr.h                            |    2 +-
 gcc/fold-const.c                      |    2 +-
 gcc/fold-const.h                      |    2 +-
 gcc/ggc.h                             |    4 +-
 gcc/gimple-builder.c                  |   26 +-
 gcc/gimple-builder.h                  |   16 +-
 gcc/gimple-fold.c                     |   58 +-
 gcc/gimple-fold.h                     |    8 +-
 gcc/gimple-iterator.c                 |   36 +-
 gcc/gimple-iterator.h                 |   22 +-
 gcc/gimple-low.c                      |   30 +-
 gcc/gimple-low.h                      |    2 +-
 gcc/gimple-pretty-print.c             |  104 ++--
 gcc/gimple-pretty-print.h             |    8 +-
 gcc/gimple-ssa-isolate-paths.c        |   14 +-
 gcc/gimple-ssa-strength-reduction.c   |   92 +--
 gcc/gimple-ssa.h                      |   14 +-
 gcc/gimple-streamer-in.c              |   10 +-
 gcc/gimple-streamer-out.c             |    8 +-
 gcc/gimple-walk.c                     |   18 +-
 gcc/gimple-walk.h                     |   12 +-
 gcc/gimple.c                          |  284 ++++-----
 gcc/gimple.h                          | 1030 ++++++++++++++++-----------------
 gcc/gimplify-me.c                     |    4 +-
 gcc/gimplify-me.h                     |    2 +-
 gcc/gimplify.c                        |  100 ++--
 gcc/gimplify.h                        |   12 +-
 gcc/graphite-poly.c                   |    8 +-
 gcc/graphite-scop-detection.c         |   20 +-
 gcc/graphite-sese-to-poly.c           |  168 +++---
 gcc/internal-fn.c                     |   40 +-
 gcc/internal-fn.h                     |    2 +-
 gcc/ipa-inline-analysis.c             |   40 +-
 gcc/ipa-inline.c                      |    4 +-
 gcc/ipa-profile.c                     |    2 +-
 gcc/ipa-prop.c                        |   80 +--
 gcc/ipa-prop.h                        |    6 +-
 gcc/ipa-pure-const.c                  |   12 +-
 gcc/ipa-ref.c                         |   10 +-
 gcc/ipa-ref.h                         |   12 +-
 gcc/ipa-split.c                       |   40 +-
 gcc/java/java-gimplify.c              |    2 +-
 gcc/lto-streamer-in.c                 |   16 +-
 gcc/lto-streamer-out.c                |    6 +-
 gcc/omp-low.c                         |  248 ++++----
 gcc/passes.c                          |    4 +-
 gcc/predict.c                         |   32 +-
 gcc/profile.c                         |    8 +-
 gcc/sese.c                            |   18 +-
 gcc/sese.h                            |    8 +-
 gcc/ssa-iterators.h                   |   42 +-
 gcc/stmt.c                            |    4 +-
 gcc/tracer.c                          |    4 +-
 gcc/trans-mem.c                       |  114 ++--
 gcc/trans-mem.h                       |    2 +-
 gcc/tree-affine.c                     |    2 +-
 gcc/tree-call-cdce.c                  |   50 +-
 gcc/tree-cfg.c                        |  232 ++++----
 gcc/tree-cfg.h                        |   22 +-
 gcc/tree-cfgcleanup.c                 |   28 +-
 gcc/tree-cfgcleanup.h                 |    2 +-
 gcc/tree-chrec.c                      |   10 +-
 gcc/tree-chrec.h                      |    6 +-
 gcc/tree-complex.c                    |   34 +-
 gcc/tree-core.h                       |    4 +-
 gcc/tree-data-ref.c                   |   14 +-
 gcc/tree-data-ref.h                   |    8 +-
 gcc/tree-dfa.c                        |   14 +-
 gcc/tree-dfa.h                        |    2 +-
 gcc/tree-eh.c                         |  196 +++----
 gcc/tree-eh.h                         |   38 +-
 gcc/tree-emutls.c                     |    8 +-
 gcc/tree-if-conv.c                    |   46 +-
 gcc/tree-inline.c                     |   84 +--
 gcc/tree-inline.h                     |    6 +-
 gcc/tree-into-ssa.c                   |   62 +-
 gcc/tree-into-ssa.h                   |    4 +-
 gcc/tree-loop-distribution.c          |   62 +-
 gcc/tree-nested.c                     |   32 +-
 gcc/tree-nrv.c                        |    8 +-
 gcc/tree-object-size.c                |   28 +-
 gcc/tree-outof-ssa.c                  |   26 +-
 gcc/tree-outof-ssa.h                  |    4 +-
 gcc/tree-parloops.c                   |   52 +-
 gcc/tree-pass.h                       |    6 +-
 gcc/tree-phinodes.c                   |   18 +-
 gcc/tree-phinodes.h                   |   14 +-
 gcc/tree-predcom.c                    |   62 +-
 gcc/tree-profile.c                    |   32 +-
 gcc/tree-scalar-evolution.c           |   72 +--
 gcc/tree-scalar-evolution.h           |    2 +-
 gcc/tree-sra.c                        |   62 +-
 gcc/tree-ssa-alias.c                  |   38 +-
 gcc/tree-ssa-alias.h                  |   16 +-
 gcc/tree-ssa-ccp.c                    |   46 +-
 gcc/tree-ssa-coalesce.c               |   10 +-
 gcc/tree-ssa-copy.c                   |   14 +-
 gcc/tree-ssa-copyrename.c             |    2 +-
 gcc/tree-ssa-dce.c                    |   40 +-
 gcc/tree-ssa-dom.c                    |   82 +--
 gcc/tree-ssa-dom.h                    |    2 +-
 gcc/tree-ssa-dse.c                    |   10 +-
 gcc/tree-ssa-forwprop.c               |  152 ++---
 gcc/tree-ssa-ifcombine.c              |   20 +-
 gcc/tree-ssa-live.c                   |   18 +-
 gcc/tree-ssa-loop-ch.c                |    6 +-
 gcc/tree-ssa-loop-im.c                |   70 +--
 gcc/tree-ssa-loop-ivcanon.c           |   20 +-
 gcc/tree-ssa-loop-ivopts.c            |   68 +--
 gcc/tree-ssa-loop-manip.c             |   32 +-
 gcc/tree-ssa-loop-niter.c             |   56 +-
 gcc/tree-ssa-loop-niter.h             |    4 +-
 gcc/tree-ssa-loop-prefetch.c          |   16 +-
 gcc/tree-ssa-loop-unswitch.c          |    8 +-
 gcc/tree-ssa-loop.h                   |    2 +-
 gcc/tree-ssa-math-opts.c              |   90 +--
 gcc/tree-ssa-operands.c               |   42 +-
 gcc/tree-ssa-operands.h               |   10 +-
 gcc/tree-ssa-phiopt.c                 |   88 +--
 gcc/tree-ssa-phiprop.c                |   18 +-
 gcc/tree-ssa-pre.c                    |   52 +-
 gcc/tree-ssa-propagate.c              |   46 +-
 gcc/tree-ssa-propagate.h              |   14 +-
 gcc/tree-ssa-reassoc.c                |  176 +++---
 gcc/tree-ssa-sccvn.c                  |   58 +-
 gcc/tree-ssa-sccvn.h                  |    8 +-
 gcc/tree-ssa-sink.c                   |   22 +-
 gcc/tree-ssa-strlen.c                 |   42 +-
 gcc/tree-ssa-structalias.c            |   44 +-
 gcc/tree-ssa-tail-merge.c             |   40 +-
 gcc/tree-ssa-ter.c                    |   12 +-
 gcc/tree-ssa-threadedge.c             |   46 +-
 gcc/tree-ssa-threadedge.h             |    4 +-
 gcc/tree-ssa-threadupdate.c           |   12 +-
 gcc/tree-ssa-uncprop.c                |    4 +-
 gcc/tree-ssa-uninit.c                 |   78 +--
 gcc/tree-ssa.c                        |   42 +-
 gcc/tree-ssa.h                        |    4 +-
 gcc/tree-ssanames.c                   |    8 +-
 gcc/tree-ssanames.h                   |   16 +-
 gcc/tree-stdarg.c                     |   12 +-
 gcc/tree-switch-conversion.c          |   48 +-
 gcc/tree-tailcall.c                   |   30 +-
 gcc/tree-vect-data-refs.c             |  100 ++--
 gcc/tree-vect-generic.c               |   22 +-
 gcc/tree-vect-loop-manip.c            |   62 +-
 gcc/tree-vect-loop.c                  |  174 +++---
 gcc/tree-vect-patterns.c              |  194 +++----
 gcc/tree-vect-slp.c                   |  124 ++--
 gcc/tree-vect-stmts.c                 |  244 ++++----
 gcc/tree-vectorizer.c                 |   22 +-
 gcc/tree-vectorizer.h                 |  116 ++--
 gcc/tree-vrp.c                        |  142 ++---
 gcc/tree.c                            |    4 +-
 gcc/tree.h                            |    4 +-
 gcc/tsan.c                            |   12 +-
 gcc/ubsan.c                           |   20 +-
 gcc/value-prof.c                      |   96 +--
 gcc/value-prof.h                      |   26 +-
 gcc/vtable-verify.c                   |   10 +-
 185 files changed, 3838 insertions(+), 3838 deletions(-)

diff --git a/gcc/asan.c b/gcc/asan.c
index 118f9fc..6da3e68 100644
--- a/gcc/asan.c
+++ b/gcc/asan.c
@@ -434,7 +434,7 @@ has_mem_ref_been_instrumented (const asan_mem_ref *ref, tree len)
    otherwise.  */
 
 static bool
-get_mem_ref_of_assignment (const gimple assignment,
+get_mem_ref_of_assignment (const gimple *assignment,
 			   asan_mem_ref *ref,
 			   bool *ref_is_store)
 {
@@ -462,7 +462,7 @@ get_mem_ref_of_assignment (const gimple assignment,
    representing a builtin call that has to do with memory access.  */
 
 static bool
-get_mem_refs_of_builtin_call (const gimple call,
+get_mem_refs_of_builtin_call (const gimple *call,
 			      asan_mem_ref *src0,
 			      tree *src0_len,
 			      bool *src0_is_store,
@@ -794,7 +794,7 @@ get_mem_refs_of_builtin_call (const gimple call,
    contains.  */
 
 static bool
-has_stmt_been_instrumented_p (gimple stmt)
+has_stmt_been_instrumented_p (gimple *stmt)
 {
   if (gimple_assign_single_p (stmt))
     {
@@ -1434,7 +1434,7 @@ create_cond_insert_point (gimple_stmt_iterator *iter,
    pointing to initially.  */
 
 static void
-insert_if_then_before_iter (gimple cond,
+insert_if_then_before_iter (gimple *cond,
 			    gimple_stmt_iterator *iter,
 			    bool then_more_likely_p,
 			    basic_block *then_bb,
@@ -1471,7 +1471,7 @@ build_check_stmt (location_t location, tree base, gimple_stmt_iterator *iter,
   gimple_stmt_iterator gsi;
   basic_block then_bb, else_bb;
   tree t, base_addr, shadow;
-  gimple g;
+  gimple *g;
   tree shadow_ptr_type = shadow_ptr_types[size_in_bytes == 16 ? 1 : 0];
   tree shadow_type = TREE_TYPE (shadow_ptr_type);
   tree uintptr_type
@@ -1545,7 +1545,7 @@ build_check_stmt (location_t location, tree base, gimple_stmt_iterator *iter,
 	 Test (shadow != 0)
 	      & ((base_addr & 7) + (size_in_bytes - 1)) >= shadow).  */
       gimple_seq seq = NULL;
-      gimple shadow_test = build_assign (NE_EXPR, shadow, 0);
+      gimple *shadow_test = build_assign (NE_EXPR, shadow, 0);
       gimple_seq_add_stmt (&seq, shadow_test);
       gimple_seq_add_stmt (&seq, build_assign (BIT_AND_EXPR, base_addr, 7));
       gimple_seq_add_stmt (&seq, build_type_cast (shadow_type,
@@ -1720,7 +1720,7 @@ instrument_mem_region_access (tree base, tree len,
 	   }
 	   // falltrough instructions, starting with *ITER.  */
 
-      gimple g = gimple_build_cond (NE_EXPR,
+      gimple *g = gimple_build_cond (NE_EXPR,
 				    len,
 				    build_int_cst (TREE_TYPE (len), 0),
 				    NULL_TREE, NULL_TREE);
@@ -1775,7 +1775,7 @@ instrument_mem_region_access (tree base, tree len,
 			  build_int_cst (size_type_node, 1));
   else
     {
-      gimple g;
+      gimple *g;
       tree t;
 
       if (TREE_CODE (len) != SSA_NAME)
@@ -1805,7 +1805,7 @@ instrument_mem_region_access (tree base, tree len,
 
   /* _1 = base;  */
   base = unshare_expr (base);
-  gimple region_end =
+  gimple *region_end =
     gimple_build_assign_with_ops (TREE_CODE (base),
 				  make_ssa_name (TREE_TYPE (base), NULL),
 				  base, NULL);
@@ -1850,7 +1850,7 @@ instrument_mem_region_access (tree base, tree len,
 static bool
 instrument_strlen_call (gimple_stmt_iterator *iter)
 {
-  gimple call = gsi_stmt (*iter);
+  gimple *call = gsi_stmt (*iter);
   gcc_assert (is_gimple_call (call));
 
   tree callee = gimple_call_fndecl (call);
@@ -1873,7 +1873,7 @@ instrument_strlen_call (gimple_stmt_iterator *iter)
 
      _1 = str_arg; instrument (_1); */
   tree cptr_type = build_pointer_type (char_type_node);
-  gimple str_arg_ssa =
+  gimple *str_arg_ssa =
     gimple_build_assign_with_ops (NOP_EXPR,
 				  make_ssa_name (cptr_type, NULL),
 				  str_arg, NULL);
@@ -1892,7 +1892,7 @@ instrument_strlen_call (gimple_stmt_iterator *iter)
 
   /* So let's build the access to str[n] that is, access through the
      pointer_plus expr: (_1 + len).  */
-  gimple stmt =
+  gimple *stmt =
     gimple_build_assign_with_ops (POINTER_PLUS_EXPR,
 				  make_ssa_name (cptr_type, NULL),
 				  gimple_assign_lhs (str_arg_ssa),
@@ -1926,7 +1926,7 @@ instrument_builtin_call (gimple_stmt_iterator *iter)
     return false;
 
   bool iter_advanced_p = false;
-  gimple call = gsi_stmt (*iter);
+  gimple *call = gsi_stmt (*iter);
 
   gcc_checking_assert (gimple_call_builtin_p (call, BUILT_IN_NORMAL));
 
@@ -1988,7 +1988,7 @@ instrument_builtin_call (gimple_stmt_iterator *iter)
 static bool
 maybe_instrument_assignment (gimple_stmt_iterator *iter)
 {
-  gimple s = gsi_stmt (*iter);
+  gimple *s = gsi_stmt (*iter);
 
   gcc_assert (gimple_assign_single_p (s));
 
@@ -2032,7 +2032,7 @@ maybe_instrument_assignment (gimple_stmt_iterator *iter)
 static bool
 maybe_instrument_call (gimple_stmt_iterator *iter)
 {
-  gimple stmt = gsi_stmt (*iter);
+  gimple *stmt = gsi_stmt (*iter);
   bool is_builtin = gimple_call_builtin_p (stmt, BUILT_IN_NORMAL);
 
   if (is_builtin && instrument_builtin_call (iter))
@@ -2052,7 +2052,7 @@ maybe_instrument_call (gimple_stmt_iterator *iter)
 	    }
 	}
       tree decl = builtin_decl_implicit (BUILT_IN_ASAN_HANDLE_NO_RETURN);
-      gimple g = gimple_build_call (decl, 0);
+      gimple *g = gimple_build_call (decl, 0);
       gimple_set_location (g, gimple_location (stmt));
       gsi_insert_before (iter, g, GSI_SAME_STMT);
     }
@@ -2094,7 +2094,7 @@ transform_statements (void)
 
       for (i = gsi_start_bb (bb); !gsi_end_p (i);)
 	{
-	  gimple s = gsi_stmt (i);
+	  gimple *s = gsi_stmt (i);
 
 	  if (has_stmt_been_instrumented_p (s))
 	    gsi_next (&i);
@@ -2609,7 +2609,7 @@ pass_sanopt::execute (function *fun)
       gimple_stmt_iterator gsi;
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 
 	  if (!is_gimple_call (stmt))
 	    continue;
diff --git a/gcc/builtins.c b/gcc/builtins.c
index 140d6ba..c154fde 100644
--- a/gcc/builtins.c
+++ b/gcc/builtins.c
@@ -11321,7 +11321,7 @@ validate_arg (const_tree arg, enum tree_code code)
    validate_arglist will then be removed.  */
 
 bool
-validate_gimple_arglist (const_gimple call, ...)
+validate_gimple_arglist (const gimple *call, ...)
 {
   enum tree_code code;
   bool res = 0;
@@ -14058,7 +14058,7 @@ do_mpc_arg2 (tree arg0, tree arg1, tree type, int do_nonfinite,
    inline.  FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK.  */
 
 static tree
-gimple_fold_builtin_sprintf_chk (gimple stmt, enum built_in_function fcode)
+gimple_fold_builtin_sprintf_chk (gimple *stmt, enum built_in_function fcode)
 {
   int nargs = gimple_call_num_args (stmt);
 
@@ -14075,7 +14075,7 @@ gimple_fold_builtin_sprintf_chk (gimple stmt, enum built_in_function fcode)
    passed as second argument.  */
 
 tree
-gimple_fold_builtin_snprintf_chk (gimple stmt, tree maxlen,
+gimple_fold_builtin_snprintf_chk (gimple *stmt, tree maxlen,
                                   enum built_in_function fcode)
 {
   int nargs = gimple_call_num_args (stmt);
@@ -14094,7 +14094,7 @@ gimple_fold_builtin_snprintf_chk (gimple stmt, tree maxlen,
    result of the function call is ignored.  */
 
 static tree
-gimple_fold_builtin_varargs (tree fndecl, gimple stmt,
+gimple_fold_builtin_varargs (tree fndecl, gimple *stmt,
 			     bool ignore ATTRIBUTE_UNUSED)
 {
   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
@@ -14128,7 +14128,7 @@ gimple_fold_builtin_varargs (tree fndecl, gimple stmt,
    call node earlier than the warning is generated.  */
 
 tree
-fold_call_stmt (gimple stmt, bool ignore)
+fold_call_stmt (gimple *stmt, bool ignore)
 {
   tree ret = NULL_TREE;
   tree fndecl = gimple_call_fndecl (stmt);
diff --git a/gcc/builtins.h b/gcc/builtins.h
index 5eb9303..c3d10dd 100644
--- a/gcc/builtins.h
+++ b/gcc/builtins.h
@@ -44,6 +44,6 @@ extern struct target_builtins *this_target_builtins;
 #define this_target_builtins (&default_target_builtins)
 #endif
 
-extern bool validate_gimple_arglist (const_gimple, ...);
+extern bool validate_gimple_arglist (const gimple *, ...);
 
 #endif
diff --git a/gcc/c-family/c-gimplify.c b/gcc/c-family/c-gimplify.c
index 737be4d..b229f19 100644
--- a/gcc/c-family/c-gimplify.c
+++ b/gcc/c-family/c-gimplify.c
@@ -112,8 +112,8 @@ add_block_to_enclosing (tree block)
 {
   unsigned i;
   tree enclosing;
-  gimple bind;
-  vec<gimple> stack = gimple_bind_expr_stack ();
+  gimple *bind;
+  vec<gimple *> stack = gimple_bind_expr_stack ();
 
   FOR_EACH_VEC_ELT (stack, i, bind)
     if (gimple_bind_block (bind))
diff --git a/gcc/calls.c b/gcc/calls.c
index 78fe7d8..d0b22a2 100644
--- a/gcc/calls.c
+++ b/gcc/calls.c
@@ -624,7 +624,7 @@ setjmp_call_p (const_tree fndecl)
 /* Return true if STMT is an alloca call.  */
 
 bool
-gimple_alloca_call_p (const_gimple stmt)
+gimple_alloca_call_p (const gimple *stmt)
 {
   tree fndecl;
 
diff --git a/gcc/calls.h b/gcc/calls.h
index e240908..12794d8 100644
--- a/gcc/calls.h
+++ b/gcc/calls.h
@@ -23,7 +23,7 @@ along with GCC; see the file COPYING3.  If not see
 extern int flags_from_decl_or_type (const_tree);
 extern int call_expr_flags (const_tree);
 extern int setjmp_call_p (const_tree);
-extern bool gimple_alloca_call_p (const_gimple);
+extern bool gimple_alloca_call_p (const gimple *);
 extern bool alloca_call_p (const_tree);
 extern bool must_pass_in_stack_var_size (enum machine_mode, const_tree);
 extern bool must_pass_in_stack_var_size_or_pad (enum machine_mode, const_tree);
diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c
index 934f40d..ad94009 100644
--- a/gcc/cfgexpand.c
+++ b/gcc/cfgexpand.c
@@ -88,7 +88,7 @@ struct ssaexpand SA;
 
 /* This variable holds the currently expanded gimple statement for purposes
    of comminucating the profile info to the builtin expanders.  */
-gimple currently_expanding_gimple_stmt;
+gimple *currently_expanding_gimple_stmt;
 
 static rtx expand_debug_expr (tree);
 
@@ -96,7 +96,7 @@ static rtx expand_debug_expr (tree);
    statement STMT.  */
 
 tree
-gimple_assign_rhs_to_tree (gimple stmt)
+gimple_assign_rhs_to_tree (gimple *stmt)
 {
   tree t;
   enum gimple_rhs_class grhs_class;
@@ -365,7 +365,7 @@ stack_var_conflict_p (size_t x, size_t y)
    enter its partition number into bitmap DATA.  */
 
 static bool
-visit_op (gimple, tree op, tree, void *data)
+visit_op (gimple *, tree op, tree, void *data)
 {
   bitmap active = (bitmap)data;
   op = get_base_address (op);
@@ -385,7 +385,7 @@ visit_op (gimple, tree op, tree, void *data)
    from bitmap DATA.  */
 
 static bool
-visit_conflict (gimple, tree op, tree, void *data)
+visit_conflict (gimple *, tree op, tree, void *data)
 {
   bitmap active = (bitmap)data;
   op = get_base_address (op);
@@ -429,12 +429,12 @@ add_scope_conflicts_1 (basic_block bb, bitmap work, bool for_conflict)
 
   for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       walk_stmt_load_store_addr_ops (stmt, work, NULL, NULL, visit);
     }
   for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
 
       if (gimple_clobber_p (stmt))
 	{
@@ -1645,7 +1645,7 @@ stack_protect_return_slot_p ()
     for (gimple_stmt_iterator gsi = gsi_start_bb (bb);
 	 !gsi_end_p (gsi); gsi_next (&gsi))
       {
-	gimple stmt = gsi_stmt (gsi);
+	gimple *stmt = gsi_stmt (gsi);
 	/* This assumes that calls to internal-only functions never
 	   use a return slot.  */
 	if (is_gimple_call (stmt)
@@ -1941,7 +1941,7 @@ expand_used_vars (void)
    generated for STMT should have been appended.  */
 
 static void
-maybe_dump_rtl_for_gimple_stmt (gimple stmt, rtx since)
+maybe_dump_rtl_for_gimple_stmt (gimple *stmt, rtx since)
 {
   if (dump_file && (dump_flags & TDF_DETAILS))
     {
@@ -1965,7 +1965,7 @@ label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED)
 {
   gimple_stmt_iterator gsi;
   tree lab;
-  gimple lab_stmt;
+  gimple *lab_stmt;
   void **elt;
 
   if (bb->flags & BB_RTL)
@@ -2053,7 +2053,7 @@ maybe_cleanup_end_of_block (edge e, rtx last)
    block and created a new one.  */
 
 static basic_block
-expand_gimple_cond (basic_block bb, gimple stmt)
+expand_gimple_cond (basic_block bb, gimple *stmt)
 {
   basic_block new_bb, dest;
   edge new_edge;
@@ -2084,7 +2084,7 @@ expand_gimple_cond (basic_block bb, gimple stmt)
 	      && integer_onep (op1)))
       && bitmap_bit_p (SA.values, SSA_NAME_VERSION (op0)))
     {
-      gimple second = SSA_NAME_DEF_STMT (op0);
+      gimple *second = SSA_NAME_DEF_STMT (op0);
       if (gimple_code (second) == GIMPLE_ASSIGN)
 	{
 	  enum tree_code code2 = gimple_assign_rhs_code (second);
@@ -2192,7 +2192,7 @@ expand_gimple_cond (basic_block bb, gimple stmt)
 /* Mark all calls that can have a transaction restart.  */
 
 static void
-mark_transaction_restart_calls (gimple stmt)
+mark_transaction_restart_calls (gimple *stmt)
 {
   struct tm_restart_node dummy;
   void **slot;
@@ -2225,7 +2225,7 @@ mark_transaction_restart_calls (gimple stmt)
    statement STMT.  */
 
 static void
-expand_call_stmt (gimple stmt)
+expand_call_stmt (gimple *stmt)
 {
   tree exp, decl, lhs;
   bool builtin_p;
@@ -2256,7 +2256,7 @@ expand_call_stmt (gimple stmt)
   for (i = 0; i < gimple_call_num_args (stmt); i++)
     {
       tree arg = gimple_call_arg (stmt, i);
-      gimple def;
+      gimple *def;
       /* TER addresses into arguments of builtin functions so we have a
 	 chance to infer more correct alignment information.  See PR39954.  */
       if (builtin_p
@@ -2911,7 +2911,7 @@ expand_asm_operands (tree string, tree outputs, tree inputs,
 
 
 static void
-expand_asm_stmt (gimple stmt)
+expand_asm_stmt (gimple *stmt)
 {
   int noutputs;
   tree outputs, tail, t;
@@ -3171,7 +3171,7 @@ expand_return (tree retval)
    is no tailcalls and no GIMPLE_COND.  */
 
 static void
-expand_gimple_stmt_1 (gimple stmt)
+expand_gimple_stmt_1 (gimple *stmt)
 {
   tree op0;
 
@@ -3336,7 +3336,7 @@ expand_gimple_stmt_1 (gimple stmt)
    location for diagnostics.  */
 
 static rtx
-expand_gimple_stmt (gimple stmt)
+expand_gimple_stmt (gimple *stmt)
 {
   location_t saved_location = input_location;
   rtx last = get_last_insn ();
@@ -3390,7 +3390,7 @@ expand_gimple_stmt (gimple stmt)
    tailcall) and the normal result happens via a sqrt instruction.  */
 
 static basic_block
-expand_gimple_tailcall (basic_block bb, gimple stmt, bool *can_fallthru)
+expand_gimple_tailcall (basic_block bb, gimple *stmt, bool *can_fallthru)
 {
   rtx last2, last;
   edge e;
@@ -4531,7 +4531,7 @@ expand_debug_expr (tree exp)
 
     case SSA_NAME:
       {
-	gimple g = get_gimple_for_ssa_name (exp);
+	gimple *g = get_gimple_for_ssa_name (exp);
 	if (g)
 	  {
 	    op0 = expand_debug_expr (gimple_assign_rhs_to_tree (g));
@@ -4876,7 +4876,7 @@ expand_gimple_basic_block (basic_block bb, bool disable_tail_calls)
 {
   gimple_stmt_iterator gsi;
   gimple_seq stmts;
-  gimple stmt = NULL;
+  gimple *stmt = NULL;
   rtx note, last;
   edge e;
   edge_iterator ei;
@@ -4903,7 +4903,7 @@ expand_gimple_basic_block (basic_block bb, bool disable_tail_calls)
   if (!gsi_end_p (gsi)
       && gimple_code (gsi_stmt (gsi)) == GIMPLE_RETURN)
     {
-      gimple ret_stmt = gsi_stmt (gsi);
+      gimple *ret_stmt = gsi_stmt (gsi);
 
       gcc_assert (single_succ_p (bb));
       gcc_assert (single_succ (bb) == EXIT_BLOCK_PTR_FOR_FN (cfun));
@@ -4989,7 +4989,7 @@ expand_gimple_basic_block (basic_block bb, bool disable_tail_calls)
 	{
 	  ssa_op_iter iter;
 	  tree op;
-	  gimple def;
+	  gimple *def;
 
 	  location_t sloc = curr_insn_location ();
 
@@ -5018,7 +5018,7 @@ expand_gimple_basic_block (basic_block bb, bool disable_tail_calls)
 		       instructions.  Generate a debug temporary, and
 		       replace all uses of OP in debug insns with that
 		       temporary.  */
-		    gimple debugstmt;
+		    gimple *debugstmt;
 		    tree value = gimple_assign_rhs_to_tree (def);
 		    tree vexpr = make_node (DEBUG_EXPR_DECL);
 		    rtx val;
@@ -5442,7 +5442,7 @@ discover_nonconstant_array_refs (void)
   FOR_EACH_BB_FN (bb, cfun)
     for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
       {
-	gimple stmt = gsi_stmt (gsi);
+	gimple *stmt = gsi_stmt (gsi);
 	if (!is_gimple_debug (stmt))
 	  walk_gimple_op (stmt, discover_nonconstant_array_refs_r, NULL);
       }
diff --git a/gcc/cfgexpand.h b/gcc/cfgexpand.h
index 6314b83..7839435 100644
--- a/gcc/cfgexpand.h
+++ b/gcc/cfgexpand.h
@@ -20,7 +20,7 @@ along with GCC; see the file COPYING3.  If not see
 #ifndef GCC_CFGEXPAND_H
 #define GCC_CFGEXPAND_H
 
-extern tree gimple_assign_rhs_to_tree (gimple);
+extern tree gimple_assign_rhs_to_tree (gimple *);
 extern HOST_WIDE_INT estimated_stack_frame_size (struct cgraph_node *);
 
 #endif /* GCC_CFGEXPAND_H */
diff --git a/gcc/cfgloop.c b/gcc/cfgloop.c
index 91e8800..8113ebc 100644
--- a/gcc/cfgloop.c
+++ b/gcc/cfgloop.c
@@ -578,7 +578,7 @@ find_subloop_latch_edge_by_ivs (struct loop *loop ATTRIBUTE_UNUSED, vec<edge> la
 {
   edge e, latch = latches[0];
   unsigned i;
-  gimple phi;
+  gimple *phi;
   gimple_stmt_iterator psi;
   tree lop;
   basic_block bb;
diff --git a/gcc/cfgloop.h b/gcc/cfgloop.h
index 62a656a..873f52b 100644
--- a/gcc/cfgloop.h
+++ b/gcc/cfgloop.h
@@ -54,7 +54,7 @@ enum iv_extend_code
 
 struct GTY ((chain_next ("%h.next"))) nb_iter_bound {
   /* The statement STMT is executed at most ...  */
-  gimple stmt;
+  gimple *stmt;
 
   /* ... BOUND + 1 times (BOUND must be an unsigned constant).
      The + 1 is added for the following reasons:
diff --git a/gcc/cfgloopmanip.c b/gcc/cfgloopmanip.c
index 83a0d51..660704b 100644
--- a/gcc/cfgloopmanip.c
+++ b/gcc/cfgloopmanip.c
@@ -690,7 +690,7 @@ create_empty_if_region_on_edge (edge entry_edge, tree condition)
 
   basic_block cond_bb, true_bb, false_bb, join_bb;
   edge e_true, e_false, exit_edge;
-  gimple cond_stmt;
+  gimple *cond_stmt;
   tree simple_cond;
   gimple_stmt_iterator gsi;
 
@@ -776,7 +776,7 @@ create_empty_loop_on_edge (edge entry_edge,
   struct loop *loop;
   gimple_stmt_iterator gsi;
   gimple_seq stmts;
-  gimple cond_expr;
+  gimple *cond_expr;
   tree exit_test;
   edge exit_e;
   int prob;
diff --git a/gcc/cgraph.c b/gcc/cgraph.c
index 2b4ce81..9391e63 100644
--- a/gcc/cgraph.c
+++ b/gcc/cgraph.c
@@ -738,7 +738,7 @@ cgraph_add_edge_to_call_site_hash (struct cgraph_edge *e)
    CALL_STMT.  */
 
 struct cgraph_edge *
-cgraph_edge (struct cgraph_node *node, gimple call_stmt)
+cgraph_edge (struct cgraph_node *node, gimple *call_stmt)
 {
   struct cgraph_edge *e, *e2;
   int n = 0;
@@ -786,7 +786,7 @@ cgraph_edge (struct cgraph_node *node, gimple call_stmt)
    edge, then update all components.  */
 
 void
-cgraph_set_call_stmt (struct cgraph_edge *e, gimple new_stmt,
+cgraph_set_call_stmt (struct cgraph_edge *e, gimple *new_stmt,
 		      bool update_speculative)
 {
   tree decl;
@@ -839,7 +839,7 @@ cgraph_set_call_stmt (struct cgraph_edge *e, gimple new_stmt,
 
 static struct cgraph_edge *
 cgraph_create_edge_1 (struct cgraph_node *caller, struct cgraph_node *callee,
-		       gimple call_stmt, gcov_type count, int freq,
+		       gimple *call_stmt, gcov_type count, int freq,
 		       bool indir_unknown_callee)
 {
   struct cgraph_edge *edge;
@@ -911,7 +911,7 @@ cgraph_create_edge_1 (struct cgraph_node *caller, struct cgraph_node *callee,
 
 struct cgraph_edge *
 cgraph_create_edge (struct cgraph_node *caller, struct cgraph_node *callee,
-		    gimple call_stmt, gcov_type count, int freq)
+		    gimple *call_stmt, gcov_type count, int freq)
 {
   struct cgraph_edge *edge = cgraph_create_edge_1 (caller, callee, call_stmt,
 						   count, freq, false);
@@ -947,7 +947,7 @@ cgraph_allocate_init_indirect_info (void)
    PARAM_INDEX. */
 
 struct cgraph_edge *
-cgraph_create_indirect_edge (struct cgraph_node *caller, gimple call_stmt,
+cgraph_create_indirect_edge (struct cgraph_node *caller, gimple *call_stmt,
 			     int ecf_flags,
 			     gcov_type count, int freq)
 {
@@ -1326,12 +1326,12 @@ cgraph_make_edge_direct (struct cgraph_edge *edge, struct cgraph_node *callee)
 /* If necessary, change the function declaration in the call statement
    associated with E so that it corresponds to the edge callee.  */
 
-gimple
+gimple *
 cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *e)
 {
   tree decl = gimple_call_fndecl (e->call_stmt);
   tree lhs = gimple_call_lhs (e->call_stmt);
-  gimple new_stmt;
+  gimple *new_stmt;
   gimple_stmt_iterator gsi;
 #ifdef ENABLE_CHECKING
   struct cgraph_node *node;
@@ -1340,7 +1340,7 @@ cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *e)
   if (e->speculative)
     {
       struct cgraph_edge *e2;
-      gimple new_stmt;
+      gimple *new_stmt;
       struct ipa_ref *ref;
 
       cgraph_speculative_call_info (e, e, e2, ref);
@@ -1482,7 +1482,7 @@ cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *e)
 					TREE_TYPE (lhs), NULL);
 	  var = get_or_create_ssa_default_def
 		  (DECL_STRUCT_FUNCTION (e->caller->decl), var);
-	  gimple set_stmt = gimple_build_assign (lhs, var);
+	  gimple *set_stmt = gimple_build_assign (lhs, var);
           gsi = gsi_for_stmt (new_stmt);
 	  gsi_insert_before_without_update (&gsi, set_stmt, GSI_SAME_STMT);
 	  update_stmt_fn (DECL_STRUCT_FUNCTION (e->caller->decl), set_stmt);
@@ -1516,8 +1516,8 @@ cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *e)
 
 static void
 cgraph_update_edges_for_call_stmt_node (struct cgraph_node *node,
-					gimple old_stmt, tree old_call,
-					gimple new_stmt)
+					gimple *old_stmt, tree old_call,
+					gimple *new_stmt)
 {
   tree new_call = (new_stmt && is_gimple_call (new_stmt))
 		  ? gimple_call_fndecl (new_stmt) : 0;
@@ -1590,7 +1590,7 @@ cgraph_update_edges_for_call_stmt_node (struct cgraph_node *node,
    of OLD_STMT before it was updated (updating can happen inplace).  */
 
 void
-cgraph_update_edges_for_call_stmt (gimple old_stmt, tree old_decl, gimple new_stmt)
+cgraph_update_edges_for_call_stmt (gimple *old_stmt, tree old_decl, gimple *new_stmt)
 {
   struct cgraph_node *orig = cgraph_get_node (cfun->decl);
   struct cgraph_node *node;
@@ -2621,7 +2621,7 @@ verify_edge_count_and_frequency (struct cgraph_edge *e)
 
 /* Switch to THIS_CFUN if needed and print STMT to stderr.  */
 static void
-cgraph_debug_gimple_stmt (struct function *this_cfun, gimple stmt)
+cgraph_debug_gimple_stmt (struct function *this_cfun, gimple *stmt)
 {
   bool fndecl_was_null = false;
   /* debug_gimple_stmt needs correct cfun */
@@ -2907,7 +2907,7 @@ verify_cgraph_node (struct cgraph_node *node)
 		   !gsi_end_p (gsi);
 		   gsi_next (&gsi))
 		{
-		  gimple stmt = gsi_stmt (gsi);
+		  gimple *stmt = gsi_stmt (gsi);
 		  pointer_set_insert (stmts, stmt);
 		  if (is_gimple_call (stmt))
 		    {
@@ -3083,7 +3083,7 @@ cgraph_get_body (struct cgraph_node *node)
    return false.  */
 
 static bool
-gimple_check_call_args (gimple stmt, tree fndecl, bool args_count_match)
+gimple_check_call_args (gimple *stmt, tree fndecl, bool args_count_match)
 {
   tree parms, p;
   unsigned int i, nargs;
@@ -3158,7 +3158,7 @@ gimple_check_call_args (gimple stmt, tree fndecl, bool args_count_match)
    If we cannot verify this or there is a mismatch, return false.  */
 
 bool
-gimple_check_call_matching_types (gimple call_stmt, tree callee,
+gimple_check_call_matching_types (gimple *call_stmt, tree callee,
 				  bool args_count_match)
 {
   tree lhs;
diff --git a/gcc/cgraph.h b/gcc/cgraph.h
index 84fc1d9..9a15a99 100644
--- a/gcc/cgraph.h
+++ b/gcc/cgraph.h
@@ -579,7 +579,7 @@ struct GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"))) cgrap
   struct cgraph_edge *next_caller;
   struct cgraph_edge *prev_callee;
   struct cgraph_edge *next_callee;
-  gimple call_stmt;
+  gimple *call_stmt;
   /* Additional information about an indirect call.  Not cleared when an edge
      becomes direct.  */
   struct cgraph_indirect_call_info *indirect_info;
@@ -764,8 +764,8 @@ void release_function_body (tree);
 void cgraph_node_remove_callees (struct cgraph_node *node);
 struct cgraph_edge *cgraph_create_edge (struct cgraph_node *,
 					struct cgraph_node *,
-					gimple, gcov_type, int);
-struct cgraph_edge *cgraph_create_indirect_edge (struct cgraph_node *, gimple,
+					gimple *, gcov_type, int);
+struct cgraph_edge *cgraph_create_indirect_edge (struct cgraph_node *, gimple *,
 						 int, gcov_type, int);
 struct cgraph_indirect_call_info *cgraph_allocate_init_indirect_info (void);
 struct cgraph_node * cgraph_create_node (tree);
@@ -775,9 +775,9 @@ struct cgraph_node * cgraph_same_body_alias (struct cgraph_node *, tree, tree);
 struct cgraph_node * cgraph_add_thunk (struct cgraph_node *, tree, tree, bool, HOST_WIDE_INT,
 				       HOST_WIDE_INT, tree, tree);
 struct cgraph_node *cgraph_node_for_asm (tree);
-struct cgraph_edge *cgraph_edge (struct cgraph_node *, gimple);
-void cgraph_set_call_stmt (struct cgraph_edge *, gimple, bool update_speculative = true);
-void cgraph_update_edges_for_call_stmt (gimple, tree, gimple);
+struct cgraph_edge *cgraph_edge (struct cgraph_node *, gimple *);
+void cgraph_set_call_stmt (struct cgraph_edge *, gimple *, bool update_speculative = true);
+void cgraph_update_edges_for_call_stmt (gimple *, tree, gimple *);
 struct cgraph_local_info *cgraph_local_info (tree);
 struct cgraph_global_info *cgraph_global_info (tree);
 struct cgraph_rtl_info *cgraph_rtl_info (tree);
@@ -853,7 +853,7 @@ struct cgraph_2edge_hook_list *cgraph_add_edge_duplication_hook (cgraph_2edge_ho
 void cgraph_remove_edge_duplication_hook (struct cgraph_2edge_hook_list *);
 struct cgraph_2node_hook_list *cgraph_add_node_duplication_hook (cgraph_2node_hook, void *);
 void cgraph_remove_node_duplication_hook (struct cgraph_2node_hook_list *);
-gimple cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *);
+gimple *cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *);
 struct cgraph_node * cgraph_function_node (struct cgraph_node *,
 					   enum availability *avail = NULL);
 bool cgraph_get_body (struct cgraph_node *node);
@@ -865,7 +865,7 @@ void cgraph_speculative_call_info (struct cgraph_edge *,
 				   struct cgraph_edge *&,
 				   struct cgraph_edge *&,
 				   struct ipa_ref *&);
-extern bool gimple_check_call_matching_types (gimple, tree, bool);
+extern bool gimple_check_call_matching_types (gimple *, tree, bool);
 
 /* In cgraphunit.c  */
 struct asm_node *add_asm_node (tree);
@@ -886,7 +886,7 @@ bool expand_thunk (struct cgraph_node *, bool);
 /* In cgraphclones.c  */
 
 struct cgraph_edge * cgraph_clone_edge (struct cgraph_edge *,
-					struct cgraph_node *, gimple,
+					struct cgraph_node *, gimple *,
 					unsigned, gcov_type, int, bool);
 struct cgraph_node * cgraph_clone_node (struct cgraph_node *, tree, gcov_type,
 					int, bool, vec<cgraph_edge_p>,
@@ -899,11 +899,11 @@ struct cgraph_node * cgraph_create_virtual_clone (struct cgraph_node *old_node,
 						  const char *clone_name);
 struct cgraph_node *cgraph_find_replacement_node (struct cgraph_node *);
 bool cgraph_remove_node_and_inline_clones (struct cgraph_node *, struct cgraph_node *);
-void cgraph_set_call_stmt_including_clones (struct cgraph_node *, gimple, gimple,
+void cgraph_set_call_stmt_including_clones (struct cgraph_node *, gimple *, gimple *,
 					    bool update_speculative = true);
 void cgraph_create_edge_including_clones (struct cgraph_node *,
 					  struct cgraph_node *,
-					  gimple, gimple, gcov_type, int,
+					  gimple *, gimple *, gcov_type, int,
 					  cgraph_inline_failed_t);
 void cgraph_materialize_all_clones (void);
 struct cgraph_node * cgraph_copy_node_for_versioning (struct cgraph_node *,
@@ -922,7 +922,7 @@ unsigned int rebuild_cgraph_edges (void);
 void cgraph_rebuild_references (void);
 int compute_call_stmt_bb_frequency (tree, basic_block bb);
 void record_references_in_initializer (tree, bool);
-void ipa_record_stmt_references (struct cgraph_node *, gimple);
+void ipa_record_stmt_references (struct cgraph_node *, gimple *);
 
 /* In ipa.c  */
 bool symtab_remove_unreachable_nodes (bool, FILE *);
diff --git a/gcc/cgraphbuild.c b/gcc/cgraphbuild.c
index 6bdc8ca..e9f0ff0 100644
--- a/gcc/cgraphbuild.c
+++ b/gcc/cgraphbuild.c
@@ -224,7 +224,7 @@ compute_call_stmt_bb_frequency (tree decl, basic_block bb)
 /* Mark address taken in STMT.  */
 
 static bool
-mark_address (gimple stmt, tree addr, tree, void *data)
+mark_address (gimple *stmt, tree addr, tree, void *data)
 {
   addr = get_base_address (addr);
   if (TREE_CODE (addr) == FUNCTION_DECL)
@@ -251,7 +251,7 @@ mark_address (gimple stmt, tree addr, tree, void *data)
 /* Mark load of T.  */
 
 static bool
-mark_load (gimple stmt, tree t, tree, void *data)
+mark_load (gimple *stmt, tree t, tree, void *data)
 {
   t = get_base_address (t);
   if (t && TREE_CODE (t) == FUNCTION_DECL)
@@ -279,7 +279,7 @@ mark_load (gimple stmt, tree t, tree, void *data)
 /* Mark store of T.  */
 
 static bool
-mark_store (gimple stmt, tree t, tree, void *data)
+mark_store (gimple *stmt, tree t, tree, void *data)
 {
   t = get_base_address (t);
   if (t && TREE_CODE (t) == VAR_DECL
@@ -296,7 +296,7 @@ mark_store (gimple stmt, tree t, tree, void *data)
 
 /* Record all references from NODE that are taken in statement STMT.  */
 void
-ipa_record_stmt_references (struct cgraph_node *node, gimple stmt)
+ipa_record_stmt_references (struct cgraph_node *node, gimple *stmt)
 {
   walk_stmt_load_store_addr_ops (stmt, node, mark_load, mark_store,
 				 mark_address);
@@ -349,7 +349,7 @@ pass_build_cgraph_edges::execute (function *fun)
     {
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  tree decl;
 
 	  if (is_gimple_debug (stmt))
@@ -454,7 +454,7 @@ rebuild_cgraph_edges (void)
     {
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  tree decl;
 
 	  if (is_gimple_call (stmt))
diff --git a/gcc/cgraphclones.c b/gcc/cgraphclones.c
index 48b5379..4b2e7ae 100644
--- a/gcc/cgraphclones.c
+++ b/gcc/cgraphclones.c
@@ -105,7 +105,7 @@ along with GCC; see the file COPYING3.  If not see
 /* Create clone of E in the node N represented by CALL_EXPR the callgraph.  */
 struct cgraph_edge *
 cgraph_clone_edge (struct cgraph_edge *e, struct cgraph_node *n,
-		   gimple call_stmt, unsigned stmt_uid, gcov_type count_scale,
+		   gimple *call_stmt, unsigned stmt_uid, gcov_type count_scale,
 		   int freq_scale, bool update_original)
 {
   struct cgraph_edge *new_edge;
@@ -703,7 +703,7 @@ cgraph_find_replacement_node (struct cgraph_node *node)
 
 void
 cgraph_set_call_stmt_including_clones (struct cgraph_node *orig,
-				       gimple old_stmt, gimple new_stmt,
+				       gimple *old_stmt, gimple *new_stmt,
 				       bool update_speculative)
 {
   struct cgraph_node *node;
@@ -759,8 +759,8 @@ cgraph_set_call_stmt_including_clones (struct cgraph_node *orig,
 void
 cgraph_create_edge_including_clones (struct cgraph_node *orig,
 				     struct cgraph_node *callee,
-				     gimple old_stmt,
-				     gimple stmt, gcov_type count,
+				     gimple *old_stmt,
+				     gimple *stmt, gcov_type count,
 				     int freq,
 				     cgraph_inline_failed_t reason)
 {
diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c
index 9b51135..bea278f 100644
--- a/gcc/cgraphunit.c
+++ b/gcc/cgraphunit.c
@@ -1360,7 +1360,7 @@ thunk_adjust (gimple_stmt_iterator * bsi,
 	      tree ptr, bool this_adjusting,
 	      HOST_WIDE_INT fixed_offset, tree virtual_offset)
 {
-  gimple stmt;
+  gimple *stmt;
   tree ret;
 
   if (this_adjusting
@@ -1531,8 +1531,8 @@ expand_thunk (struct cgraph_node *node, bool output_asm_thunks)
       tree resdecl;
       tree restmp = NULL;
 
-      gimple call;
-      gimple ret;
+      gimple *call;
+      gimple *ret;
 
       if (in_lto_p)
 	cgraph_get_body (node);
@@ -1598,7 +1598,7 @@ expand_thunk (struct cgraph_node *node, bool output_asm_thunks)
 	      {
 		tmp = create_tmp_reg (TYPE_MAIN_VARIANT
 				      (TREE_TYPE (arg)), "arg");
-		gimple stmt = gimple_build_assign (tmp, arg);
+		gimple *stmt = gimple_build_assign (tmp, arg);
 		gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
 	      }
 	    vargs.quick_push (tmp);
@@ -1622,7 +1622,7 @@ expand_thunk (struct cgraph_node *node, bool output_asm_thunks)
 
 	      if (TREE_CODE (TREE_TYPE (restmp)) == POINTER_TYPE)
 		{
-		  gimple stmt;
+		  gimple *stmt;
 		  /* If the return type is a pointer, we need to
 		     protect against NULL.  We know there will be an
 		     adjustment, because that's why we're emitting a
@@ -1651,7 +1651,7 @@ expand_thunk (struct cgraph_node *node, bool output_asm_thunks)
 				     fixed_offset, virtual_offset);
 	      if (true_label)
 		{
-		  gimple stmt;
+		  gimple *stmt;
 		  bsi = gsi_last_bb (else_bb);
 		  stmt = gimple_build_assign (restmp,
 					      build_zero_cst (TREE_TYPE (restmp)));
diff --git a/gcc/config/aarch64/aarch64-builtins.c b/gcc/config/aarch64/aarch64-builtins.c
index a301982..1de601c 100644
--- a/gcc/config/aarch64/aarch64-builtins.c
+++ b/gcc/config/aarch64/aarch64-builtins.c
@@ -1206,10 +1206,10 @@ bool
 aarch64_gimple_fold_builtin (gimple_stmt_iterator *gsi)
 {
   bool changed = false;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   tree call = gimple_call_fn (stmt);
   tree fndecl;
-  gimple new_stmt = NULL;
+  gimple *new_stmt = NULL;
   if (call)
     {
       fndecl = gimple_call_fndecl (stmt);
diff --git a/gcc/config/alpha/alpha.c b/gcc/config/alpha/alpha.c
index dc07a02..03422be 100644
--- a/gcc/config/alpha/alpha.c
+++ b/gcc/config/alpha/alpha.c
@@ -5852,10 +5852,10 @@ alpha_build_builtin_va_list (void)
 /* Helper function for alpha_stdarg_optimize_hook.  Skip over casts
    and constant additions.  */
 
-static gimple
+static gimple *
 va_list_skip_additions (tree lhs)
 {
-  gimple stmt;
+  gimple *stmt;
 
   for (;;)
     {
@@ -5902,11 +5902,11 @@ va_list_skip_additions (tree lhs)
    current statement.  */
 
 static bool
-alpha_stdarg_optimize_hook (struct stdarg_info *si, const_gimple stmt)
+alpha_stdarg_optimize_hook (struct stdarg_info *si, const gimple *stmt)
 {
   tree base, offset, rhs;
   int offset_arg = 1;
-  gimple base_stmt;
+  gimple *base_stmt;
 
   if (get_gimple_rhs_class (gimple_assign_rhs_code (stmt))
       != GIMPLE_SINGLE_RHS)
@@ -5963,13 +5963,13 @@ alpha_stdarg_optimize_hook (struct stdarg_info *si, const_gimple stmt)
   offset = gimple_op (stmt, 1 + offset_arg);
   if (TREE_CODE (offset) == SSA_NAME)
     {
-      gimple offset_stmt = va_list_skip_additions (offset);
+      gimple *offset_stmt = va_list_skip_additions (offset);
 
       if (offset_stmt
 	  && gimple_code (offset_stmt) == GIMPLE_PHI)
 	{
 	  HOST_WIDE_INT sub;
-	  gimple arg1_stmt, arg2_stmt;
+	  gimple *arg1_stmt, *arg2_stmt;
 	  tree arg1, arg2;
 	  enum tree_code code1, code2;
 
@@ -5994,7 +5994,7 @@ alpha_stdarg_optimize_hook (struct stdarg_info *si, const_gimple stmt)
 	  else if (code2 == COMPONENT_REF
 		   && (code1 == MINUS_EXPR || code1 == PLUS_EXPR))
 	    {
-	      gimple tem = arg1_stmt;
+	      gimple *tem = arg1_stmt;
 	      code2 = code1;
 	      arg1_stmt = arg2_stmt;
 	      arg2_stmt = tem;
@@ -7097,9 +7097,9 @@ bool
 alpha_gimple_fold_builtin (gimple_stmt_iterator *gsi)
 {
   bool changed = false;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   tree call = gimple_call_fn (stmt);
-  gimple new_stmt = NULL;
+  gimple *new_stmt = NULL;
 
   if (call)
     {
diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c
index 99f0657..dc35f98 100644
--- a/gcc/config/i386/i386.c
+++ b/gcc/config/i386/i386.c
@@ -31172,11 +31172,11 @@ static basic_block
 add_condition_to_bb (tree function_decl, tree version_decl,
 		     tree predicate_chain, basic_block new_bb)
 {
-  gimple return_stmt;
+  gimple *return_stmt;
   tree convert_expr, result_var;
-  gimple convert_stmt;
-  gimple call_cond_stmt;
-  gimple if_else_stmt;
+  gimple *convert_stmt;
+  gimple *call_cond_stmt;
+  gimple *if_else_stmt;
 
   basic_block bb1, bb2, bb3;
   edge e12, e23;
@@ -31227,7 +31227,7 @@ add_condition_to_bb (tree function_decl, tree version_decl,
         and_expr_var = cond_var;
       else
 	{
-	  gimple assign_stmt;
+	  gimple *assign_stmt;
 	  /* Use MIN_EXPR to check if any integer is zero?.
 	     and_expr_var = min_expr <cond_var, and_expr_var>  */
 	  assign_stmt = gimple_build_assign (and_expr_var,
@@ -31578,7 +31578,7 @@ dispatch_function_versions (tree dispatch_decl,
 			    basic_block *empty_bb)
 {
   tree default_decl;
-  gimple ifunc_cpu_init_stmt;
+  gimple *ifunc_cpu_init_stmt;
   gimple_seq gseq;
   int ix;
   tree ele;
@@ -35885,7 +35885,7 @@ addcarryx:
 		 as that is a cheaper way to load all ones into
 		 a register than having to load a constant from
 		 memory.  */
-	      gimple def_stmt = SSA_NAME_DEF_STMT (arg3);
+	      gimple *def_stmt = SSA_NAME_DEF_STMT (arg3);
 	      if (is_gimple_call (def_stmt))
 		{
 		  tree fndecl = gimple_call_fndecl (def_stmt);
diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c
index 7b19b42..5d0d69f 100644
--- a/gcc/config/rs6000/rs6000.c
+++ b/gcc/config/rs6000/rs6000.c
@@ -4357,7 +4357,7 @@ rs6000_density_test (rs6000_cost_data *data)
 
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
 
 	  if (!STMT_VINFO_RELEVANT_P (stmt_info)
@@ -10902,7 +10902,7 @@ rs6000_gimplify_va_arg (tree valist, tree type, gimple_seq *pre_p,
   int align;
   tree ptrtype = build_pointer_type_for_mode (type, ptr_mode, true);
   int regalign = 0;
-  gimple stmt;
+  gimple *stmt;
 
   if (pass_by_reference (NULL, TYPE_MODE (type), type, false))
     {
diff --git a/gcc/cp/cp-gimplify.c b/gcc/cp/cp-gimplify.c
index ef4b043..2c41568 100644
--- a/gcc/cp/cp-gimplify.c
+++ b/gcc/cp/cp-gimplify.c
@@ -507,7 +507,7 @@ gimplify_must_not_throw_expr (tree *expr_p, gimple_seq *pre_p)
   tree body = TREE_OPERAND (stmt, 0);
   gimple_seq try_ = NULL;
   gimple_seq catch_ = NULL;
-  gimple mnt;
+  gimple *mnt;
 
   gimplify_and_add (body, &try_);
   mnt = gimple_build_eh_must_not_throw (terminate_node);
diff --git a/gcc/dumpfile.c b/gcc/dumpfile.c
index fd630a6..ff1e6ca 100644
--- a/gcc/dumpfile.c
+++ b/gcc/dumpfile.c
@@ -281,7 +281,7 @@ dump_loc (int dump_kind, FILE *dfile, source_location loc)
    EXTRA_DUMP_FLAGS on the dump streams if DUMP_KIND is enabled.  */
 
 void
-dump_gimple_stmt (int dump_kind, int extra_dump_flags, gimple gs, int spc)
+dump_gimple_stmt (int dump_kind, int extra_dump_flags, gimple *gs, int spc)
 {
   if (dump_file && (dump_kind & pflags))
     print_gimple_stmt (dump_file, gs, spc, dump_flags | extra_dump_flags);
@@ -294,7 +294,7 @@ dump_gimple_stmt (int dump_kind, int extra_dump_flags, gimple gs, int spc)
 
 void
 dump_gimple_stmt_loc (int dump_kind, source_location loc, int extra_dump_flags,
-                      gimple gs, int spc)
+                      gimple *gs, int spc)
 {
   if (dump_file && (dump_kind & pflags))
     {
diff --git a/gcc/dumpfile.h b/gcc/dumpfile.h
index 75949b7..845a41d 100644
--- a/gcc/dumpfile.h
+++ b/gcc/dumpfile.h
@@ -131,8 +131,8 @@ extern void dump_printf_loc (int, source_location,
 extern void dump_basic_block (int, basic_block, int);
 extern void dump_generic_expr_loc (int, source_location, int, tree);
 extern void dump_generic_expr (int, int, tree);
-extern void dump_gimple_stmt_loc (int, source_location, int, gimple, int);
-extern void dump_gimple_stmt (int, int, gimple, int);
+extern void dump_gimple_stmt_loc (int, source_location, int, gimple *, int);
+extern void dump_gimple_stmt (int, int, gimple *, int);
 extern void print_combine_total_stats (void);
 extern bool enable_rtl_dump_file (void);
 
diff --git a/gcc/except.h b/gcc/except.h
index bab13e1..0bf7012 100644
--- a/gcc/except.h
+++ b/gcc/except.h
@@ -287,7 +287,7 @@ extern eh_landing_pad get_eh_landing_pad_from_rtx (const_rtx);
 extern void finish_eh_generation (void);
 
 struct GTY(()) throw_stmt_node {
-  gimple stmt;
+  gimple *stmt;
   int lp_nr;
 };
 
diff --git a/gcc/expr.c b/gcc/expr.c
index 2868d9d..eec6d86 100644
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -2400,10 +2400,10 @@ use_group_regs (rtx *call_fusage, rtx regs)
    assigment and the code of the expresion on the RHS is CODE.  Return
    NULL otherwise.  */
 
-static gimple
+static gimple *
 get_def_for_expr (tree name, enum tree_code code)
 {
-  gimple def_stmt;
+  gimple *def_stmt;
 
   if (TREE_CODE (name) != SSA_NAME)
     return NULL;
@@ -2421,10 +2421,10 @@ get_def_for_expr (tree name, enum tree_code code)
    assigment and the class of the expresion on the RHS is CLASS.  Return
    NULL otherwise.  */
 
-static gimple
+static gimple *
 get_def_for_expr_class (tree name, enum tree_code_class tclass)
 {
-  gimple def_stmt;
+  gimple *def_stmt;
 
   if (TREE_CODE (name) != SSA_NAME)
     return NULL;
@@ -4423,7 +4423,7 @@ optimize_bitfield_assignment_op (unsigned HOST_WIDE_INT bitsize,
   tree op0, op1;
   rtx value, result;
   optab binop;
-  gimple srcstmt;
+  gimple *srcstmt;
   enum tree_code code;
 
   if (mode1 != VOIDmode
@@ -4453,7 +4453,7 @@ optimize_bitfield_assignment_op (unsigned HOST_WIDE_INT bitsize,
      be from a bitfield load.  */
   if (TREE_CODE (op0) == SSA_NAME)
     {
-      gimple op0stmt = get_gimple_for_ssa_name (op0);
+      gimple *op0stmt = get_gimple_for_ssa_name (op0);
 
       /* We want to eventually have OP0 be the same as TO, which
 	 should be a bitfield.  */
@@ -6497,7 +6497,7 @@ store_field (rtx target, HOST_WIDE_INT bitsize, HOST_WIDE_INT bitpos,
 	  && DECL_MODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)) != BLKmode))
     {
       rtx temp;
-      gimple nop_def;
+      gimple *nop_def;
 
       /* If EXP is a NOP_EXPR of precision less than its mode, then that
 	 implies a mask operation.  If the precision is the same size as
@@ -7923,7 +7923,7 @@ expand_cond_expr_using_cmove (tree treeop0 ATTRIBUTE_UNUSED,
   rtx op00, op01, op1, op2;
   enum rtx_code comparison_code;
   enum machine_mode comparison_mode;
-  gimple srcstmt;
+  gimple *srcstmt;
   rtx temp;
   tree type = TREE_TYPE (treeop1);
   int unsignedp = TYPE_UNSIGNED (type);
@@ -8321,7 +8321,7 @@ expand_expr_real_2 (sepops ops, rtx target, enum machine_mode tmode,
 	  && TYPE_MODE (TREE_TYPE (treeop0))
 	     == TYPE_MODE (TREE_TYPE (treeop1)))
 	{
-	  gimple def = get_def_for_expr (treeop1, NEGATE_EXPR);
+	  gimple *def = get_def_for_expr (treeop1, NEGATE_EXPR);
 	  if (def)
 	    {
 	      treeop1 = gimple_assign_rhs1 (def);
@@ -8513,7 +8513,7 @@ expand_expr_real_2 (sepops ops, rtx target, enum machine_mode tmode,
     case FMA_EXPR:
       {
 	optab opt = fma_optab;
-	gimple def0, def2;
+	gimple *def0, *def2;
 
 	/* If there is no insn for FMA, emit it as __builtin_fma{,f,l}
 	   call.  */
@@ -9201,7 +9201,7 @@ expand_expr_real_2 (sepops ops, rtx target, enum machine_mode tmode,
    into constant expressions.  */
 
 static bool
-stmt_is_replaceable_p (gimple stmt)
+stmt_is_replaceable_p (gimple *stmt)
 {
   if (ssa_is_replaceable_p (stmt))
     {
@@ -9231,7 +9231,7 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
   struct separate_ops ops;
   tree treeop0, treeop1, treeop2;
   tree ssa_name = NULL_TREE;
-  gimple g;
+  gimple *g;
 
   type = TREE_TYPE (exp);
   mode = TYPE_MODE (type);
@@ -9693,7 +9693,7 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
 	  = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))));
 	enum machine_mode address_mode;
 	tree base = TREE_OPERAND (exp, 0);
-	gimple def_stmt;
+	gimple *def_stmt;
 	enum insn_code icode;
 	unsigned align;
 	/* Handle expansion of non-aliased memory with non-BLKmode.  That
@@ -10965,7 +10965,7 @@ do_store_flag (sepops ops, rtx target, enum machine_mode mode)
       && integer_zerop (arg1)
       && (TYPE_PRECISION (ops->type) != 1 || TYPE_UNSIGNED (ops->type)))
     {
-      gimple srcstmt = get_def_for_expr (arg0, BIT_AND_EXPR);
+      gimple *srcstmt = get_def_for_expr (arg0, BIT_AND_EXPR);
       if (srcstmt
 	  && integer_pow2p (gimple_assign_rhs2 (srcstmt)))
 	{
diff --git a/gcc/expr.h b/gcc/expr.h
index 1823feb..43cd3c9 100644
--- a/gcc/expr.h
+++ b/gcc/expr.h
@@ -777,7 +777,7 @@ rtx get_personality_function (tree);
 /* In stmt.c */
 
 /* Expand a GIMPLE_SWITCH statement.  */
-extern void expand_case (gimple);
+extern void expand_case (gimple *);
 
 /* Like expand_case but special-case for SJLJ exception dispatching.  */
 extern void expand_sjlj_dispatch_table (rtx, vec<tree> );
diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 5e064df..85728c1 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -230,7 +230,7 @@ fold_defer_overflow_warnings (void)
    deferred code.  */
 
 void
-fold_undefer_overflow_warnings (bool issue, const_gimple stmt, int code)
+fold_undefer_overflow_warnings (bool issue, const gimple *stmt, int code)
 {
   const char *warnmsg;
   location_t locus;
diff --git a/gcc/fold-const.h b/gcc/fold-const.h
index 023f043..ccf5d19 100644
--- a/gcc/fold-const.h
+++ b/gcc/fold-const.h
@@ -82,7 +82,7 @@ extern tree fold_ignored_result (tree);
 extern tree fold_abs_const (tree, tree);
 extern tree fold_indirect_ref_1 (location_t, tree, tree);
 extern void fold_defer_overflow_warnings (void);
-extern void fold_undefer_overflow_warnings (bool, const_gimple, int);
+extern void fold_undefer_overflow_warnings (bool, const gimple *, int);
 extern void fold_undefer_and_ignore_overflow_warnings (void);
 extern bool fold_deferring_overflow_warnings_p (void);
 extern tree fold_fma (location_t, tree, tree, tree, tree);
diff --git a/gcc/ggc.h b/gcc/ggc.h
index 337d222..370b625 100644
--- a/gcc/ggc.h
+++ b/gcc/ggc.h
@@ -270,10 +270,10 @@ ggc_alloc_cleared_tree_node_stat (size_t s MEM_STAT_DECL)
   return (union tree_node *) ggc_internal_cleared_alloc_stat (s PASS_MEM_STAT);
 }
 
-static inline gimple
+static inline gimple *
 ggc_alloc_cleared_gimple_stat (size_t s MEM_STAT_DECL)
 {
-  return (gimple)
+  return (gimple *)
     ggc_internal_cleared_alloc_stat (s PASS_MEM_STAT);
 }
 
diff --git a/gcc/gimple-builder.c b/gcc/gimple-builder.c
index ba4be26..5a03bf0 100644
--- a/gcc/gimple-builder.c
+++ b/gcc/gimple-builder.c
@@ -51,7 +51,7 @@ get_expr_type (enum tree_code code, tree op)
    the expression code for the RHS.  OP1 is the first operand and VAL
    is an integer value to be used as the second operand.  */
 
-gimple
+gimple *
 build_assign (enum tree_code code, tree op1, int val, tree lhs)
 {
   tree op2 = build_int_cst (TREE_TYPE (op1), val);
@@ -60,8 +60,8 @@ build_assign (enum tree_code code, tree op1, int val, tree lhs)
   return gimple_build_assign_with_ops (code, lhs, op1, op2);
 }
 
-gimple
-build_assign (enum tree_code code, gimple g, int val, tree lhs )
+gimple *
+build_assign (enum tree_code code, gimple *g, int val, tree lhs )
 {
   return build_assign (code, gimple_assign_lhs (g), val, lhs);
 }
@@ -75,7 +75,7 @@ build_assign (enum tree_code code, gimple g, int val, tree lhs )
    in normal form depending on the type of builder invoking this
    function.  */
 
-gimple
+gimple *
 build_assign (enum tree_code code, tree op1, tree op2, tree lhs)
 {
   if (lhs == NULL_TREE)
@@ -83,20 +83,20 @@ build_assign (enum tree_code code, tree op1, tree op2, tree lhs)
   return gimple_build_assign_with_ops (code, lhs, op1, op2);
 }
 
-gimple
-build_assign (enum tree_code code, gimple op1, tree op2, tree lhs)
+gimple *
+build_assign (enum tree_code code, gimple *op1, tree op2, tree lhs)
 {
   return build_assign (code, gimple_assign_lhs (op1), op2, lhs);
 }
 
-gimple
-build_assign (enum tree_code code, tree op1, gimple op2, tree lhs)
+gimple *
+build_assign (enum tree_code code, tree op1, gimple *op2, tree lhs)
 {
   return build_assign (code, op1, gimple_assign_lhs (op2), lhs);
 }
 
-gimple
-build_assign (enum tree_code code, gimple op1, gimple op2, tree lhs)
+gimple *
+build_assign (enum tree_code code, gimple *op1, gimple *op2, tree lhs)
 {
   return build_assign (code, gimple_assign_lhs (op1), gimple_assign_lhs (op2),
                        lhs);
@@ -106,7 +106,7 @@ build_assign (enum tree_code code, gimple op1, gimple op2, tree lhs)
 /* Create and return a type cast assignment. This creates a NOP_EXPR
    that converts OP to TO_TYPE.  */
 
-gimple
+gimple *
 build_type_cast (tree to_type, tree op, tree lhs)
 {
   if (lhs == NULL_TREE)
@@ -114,8 +114,8 @@ build_type_cast (tree to_type, tree op, tree lhs)
   return gimple_build_assign_with_ops (NOP_EXPR, lhs, op, NULL_TREE);
 }
 
-gimple
-build_type_cast (tree to_type, gimple op, tree lhs)
+gimple *
+build_type_cast (tree to_type, gimple *op, tree lhs)
 {
   return build_type_cast (to_type, gimple_assign_lhs (op), lhs);
 }
diff --git a/gcc/gimple-builder.h b/gcc/gimple-builder.h
index 1b5afdc..61ccd47 100644
--- a/gcc/gimple-builder.h
+++ b/gcc/gimple-builder.h
@@ -21,13 +21,13 @@ along with GCC; see the file COPYING3.  If not see
 #ifndef GCC_GIMPLE_BUILDER_H
 #define GCC_GIMPLE_BUILDER_H
 
-gimple build_assign (enum tree_code, tree, int, tree lhs = NULL_TREE);
-gimple build_assign (enum tree_code, gimple, int, tree lhs = NULL_TREE);
-gimple build_assign (enum tree_code, tree, tree, tree lhs = NULL_TREE);
-gimple build_assign (enum tree_code, gimple, tree, tree lhs = NULL_TREE);
-gimple build_assign (enum tree_code, tree, gimple, tree lhs = NULL_TREE);
-gimple build_assign (enum tree_code, gimple, gimple, tree lhs = NULL_TREE);
-gimple build_type_cast (tree, tree, tree lhs = NULL_TREE);
-gimple build_type_cast (tree, gimple, tree lhs = NULL_TREE);
+gimple *build_assign (enum tree_code, tree, int, tree lhs = NULL_TREE);
+gimple *build_assign (enum tree_code, gimple *, int, tree lhs = NULL_TREE);
+gimple *build_assign (enum tree_code, tree, tree, tree lhs = NULL_TREE);
+gimple *build_assign (enum tree_code, gimple *, tree, tree lhs = NULL_TREE);
+gimple *build_assign (enum tree_code, tree, gimple *, tree lhs = NULL_TREE);
+gimple *build_assign (enum tree_code, gimple *, gimple *, tree lhs = NULL_TREE);
+gimple *build_type_cast (tree, tree, tree lhs = NULL_TREE);
+gimple *build_type_cast (tree, gimple *, tree lhs = NULL_TREE);
 
 #endif /* GCC_GIMPLE_BUILDER_H */
diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c
index 264356f..b64e779 100644
--- a/gcc/gimple-fold.c
+++ b/gcc/gimple-fold.c
@@ -361,7 +361,7 @@ maybe_fold_reference (tree expr, bool is_lhs)
 static tree
 fold_gimple_assign (gimple_stmt_iterator *si)
 {
-  gimple stmt = gsi_stmt (*si);
+  gimple *stmt = gsi_stmt (*si);
   enum tree_code subcode = gimple_assign_rhs_code (stmt);
   location_t loc = gimple_location (stmt);
 
@@ -602,7 +602,7 @@ fold_gimple_assign (gimple_stmt_iterator *si)
    assumed that the operands have been previously folded.  */
 
 static bool
-fold_gimple_cond (gimple stmt)
+fold_gimple_cond (gimple *stmt)
 {
   tree result = fold_binary_loc (gimple_location (stmt),
 			     gimple_cond_code (stmt),
@@ -637,10 +637,10 @@ void
 gimplify_and_update_call_from_tree (gimple_stmt_iterator *si_p, tree expr)
 {
   tree lhs;
-  gimple stmt, new_stmt;
+  gimple *stmt, *new_stmt;
   gimple_stmt_iterator i;
   gimple_seq stmts = NULL;
-  gimple laststore;
+  gimple *laststore;
   tree reaching_vuse;
 
   stmt = gsi_stmt (*si_p);
@@ -751,7 +751,7 @@ static bool
 get_maxval_strlen (tree arg, tree *length, bitmap visited, int type)
 {
   tree var, val;
-  gimple def_stmt;
+  gimple *def_stmt;
 
   if (TREE_CODE (arg) != SSA_NAME)
     {
@@ -871,7 +871,7 @@ get_maxval_strlen (tree arg, tree *length, bitmap visited, int type)
    be valid in GIMPLE.  Callers must take care.  */
 
 tree
-gimple_fold_builtin (gimple stmt)
+gimple_fold_builtin (gimple *stmt)
 {
   tree result, val[3];
   tree callee, a;
@@ -1080,7 +1080,7 @@ gimple_fold_builtin (gimple stmt)
 static bool
 gimple_fold_call (gimple_stmt_iterator *gsi, bool inplace)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   tree callee;
   bool changed = false;
   unsigned i;
@@ -1138,7 +1138,7 @@ gimple_fold_call (gimple_stmt_iterator *gsi, bool inplace)
 			{
 			  tree var = create_tmp_var (TREE_TYPE (lhs), NULL);
 			  tree def = get_or_create_ssa_default_def (cfun, var);
-			  gimple new_stmt = gimple_build_assign (lhs, def);
+			  gimple *new_stmt = gimple_build_assign (lhs, def);
 			  gsi_insert_before (gsi, new_stmt, GSI_SAME_STMT);
 			}
 		      gimple_call_set_lhs (stmt, NULL_TREE);
@@ -1147,7 +1147,7 @@ gimple_fold_call (gimple_stmt_iterator *gsi, bool inplace)
 	      else
 		{
 		  tree fndecl = builtin_decl_implicit (BUILT_IN_UNREACHABLE);
-		  gimple new_stmt = gimple_build_call (fndecl, 0);
+		  gimple *new_stmt = gimple_build_call (fndecl, 0);
 		  gimple_set_location (new_stmt, gimple_location (stmt));
 		  if (lhs && TREE_CODE (lhs) == SSA_NAME)
 		    {
@@ -1254,7 +1254,7 @@ static bool
 fold_stmt_1 (gimple_stmt_iterator *gsi, bool inplace)
 {
   bool changed = false;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   unsigned i;
 
   /* Fold the main computation performed by the statement.  */
@@ -1420,7 +1420,7 @@ fold_stmt (gimple_stmt_iterator *gsi)
 bool
 fold_stmt_inplace (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   bool changed = fold_stmt_1 (gsi, true);
   gcc_assert (gsi_stmt (*gsi) == stmt);
   return changed;
@@ -1481,7 +1481,7 @@ static bool
 same_bool_comparison_p (const_tree expr, enum tree_code code,
 			const_tree op1, const_tree op2)
 {
-  gimple s;
+  gimple *s;
 
   /* The obvious case.  */
   if (TREE_CODE (expr) == code
@@ -1568,7 +1568,7 @@ static tree
 and_var_with_comparison (tree var, bool invert,
 			 enum tree_code code2, tree op2a, tree op2b);
 static tree
-and_var_with_comparison_1 (gimple stmt, 
+and_var_with_comparison_1 (gimple *stmt, 
 			   enum tree_code code2, tree op2a, tree op2b);
 static tree
 or_comparisons_1 (enum tree_code code1, tree op1a, tree op1b,
@@ -1577,7 +1577,7 @@ static tree
 or_var_with_comparison (tree var, bool invert,
 			enum tree_code code2, tree op2a, tree op2b);
 static tree
-or_var_with_comparison_1 (gimple stmt, 
+or_var_with_comparison_1 (gimple *stmt, 
 			  enum tree_code code2, tree op2a, tree op2b);
 
 /* Helper function for and_comparisons_1:  try to simplify the AND of the
@@ -1590,7 +1590,7 @@ and_var_with_comparison (tree var, bool invert,
 			 enum tree_code code2, tree op2a, tree op2b)
 {
   tree t;
-  gimple stmt = SSA_NAME_DEF_STMT (var);
+  gimple *stmt = SSA_NAME_DEF_STMT (var);
 
   /* We can only deal with variables whose definitions are assignments.  */
   if (!is_gimple_assign (stmt))
@@ -1613,7 +1613,7 @@ and_var_with_comparison (tree var, bool invert,
    Return NULL_EXPR if we can't simplify this to a single expression.  */
 
 static tree
-and_var_with_comparison_1 (gimple stmt,
+and_var_with_comparison_1 (gimple *stmt,
 			   enum tree_code code2, tree op2a, tree op2b)
 {
   tree var = gimple_assign_lhs (stmt);
@@ -1661,7 +1661,7 @@ and_var_with_comparison_1 (gimple stmt,
     {
       tree inner1 = gimple_assign_rhs1 (stmt);
       tree inner2 = gimple_assign_rhs2 (stmt);
-      gimple s;
+      gimple *s;
       tree t;
       tree partial = NULL_TREE;
       bool is_and = (innercode == BIT_AND_EXPR);
@@ -1948,7 +1948,7 @@ and_comparisons_1 (enum tree_code code1, tree op1a, tree op1b,
     {
       bool invert = ((code1 == EQ_EXPR && integer_zerop (op1b))
 		     || (code1 == NE_EXPR && integer_onep (op1b)));
-      gimple stmt = SSA_NAME_DEF_STMT (op1a);
+      gimple *stmt = SSA_NAME_DEF_STMT (op1a);
       switch (gimple_code (stmt))
 	{
 	case GIMPLE_ASSIGN:
@@ -1993,7 +1993,7 @@ and_comparisons_1 (enum tree_code code1, tree op1a, tree op1b,
 			   && !SSA_NAME_IS_DEFAULT_DEF (arg))
 		    {
 		      tree temp;
-		      gimple def_stmt = SSA_NAME_DEF_STMT (arg);
+		      gimple *def_stmt = SSA_NAME_DEF_STMT (arg);
 		      /* In simple cases we can look through PHI nodes,
 			 but we have to be careful with loops.
 			 See PR49073.  */
@@ -2053,7 +2053,7 @@ or_var_with_comparison (tree var, bool invert,
 			enum tree_code code2, tree op2a, tree op2b)
 {
   tree t;
-  gimple stmt = SSA_NAME_DEF_STMT (var);
+  gimple *stmt = SSA_NAME_DEF_STMT (var);
 
   /* We can only deal with variables whose definitions are assignments.  */
   if (!is_gimple_assign (stmt))
@@ -2076,7 +2076,7 @@ or_var_with_comparison (tree var, bool invert,
    Return NULL_EXPR if we can't simplify this to a single expression.  */
 
 static tree
-or_var_with_comparison_1 (gimple stmt,
+or_var_with_comparison_1 (gimple *stmt,
 			  enum tree_code code2, tree op2a, tree op2b)
 {
   tree var = gimple_assign_lhs (stmt);
@@ -2124,7 +2124,7 @@ or_var_with_comparison_1 (gimple stmt,
     {
       tree inner1 = gimple_assign_rhs1 (stmt);
       tree inner2 = gimple_assign_rhs2 (stmt);
-      gimple s;
+      gimple *s;
       tree t;
       tree partial = NULL_TREE;
       bool is_or = (innercode == BIT_IOR_EXPR);
@@ -2412,7 +2412,7 @@ or_comparisons_1 (enum tree_code code1, tree op1a, tree op1b,
     {
       bool invert = ((code1 == EQ_EXPR && integer_zerop (op1b))
 		     || (code1 == NE_EXPR && integer_onep (op1b)));
-      gimple stmt = SSA_NAME_DEF_STMT (op1a);
+      gimple *stmt = SSA_NAME_DEF_STMT (op1a);
       switch (gimple_code (stmt))
 	{
 	case GIMPLE_ASSIGN:
@@ -2457,7 +2457,7 @@ or_comparisons_1 (enum tree_code code1, tree op1a, tree op1b,
 			   && !SSA_NAME_IS_DEFAULT_DEF (arg))
 		    {
 		      tree temp;
-		      gimple def_stmt = SSA_NAME_DEF_STMT (arg);
+		      gimple *def_stmt = SSA_NAME_DEF_STMT (arg);
 		      /* In simple cases we can look through PHI nodes,
 			 but we have to be careful with loops.
 			 See PR49073.  */
@@ -2518,7 +2518,7 @@ maybe_fold_or_comparisons (enum tree_code code1, tree op1a, tree op1b,
    to avoid the indirect function call overhead.  */
 
 tree
-gimple_fold_stmt_to_constant_1 (gimple stmt, tree (*valueize) (tree))
+gimple_fold_stmt_to_constant_1 (gimple *stmt, tree (*valueize) (tree))
 {
   location_t loc = gimple_location (stmt);
   switch (gimple_code (stmt))
@@ -2786,7 +2786,7 @@ gimple_fold_stmt_to_constant_1 (gimple stmt, tree (*valueize) (tree))
    returns a constant according to is_gimple_min_invariant.  */
 
 tree
-gimple_fold_stmt_to_constant (gimple stmt, tree (*valueize) (tree))
+gimple_fold_stmt_to_constant (gimple *stmt, tree (*valueize) (tree))
 {
   tree res = gimple_fold_stmt_to_constant_1 (stmt, valueize);
   if (res && is_gimple_min_invariant (res))
@@ -3383,7 +3383,7 @@ gimple_get_virt_method_for_binfo (HOST_WIDE_INT token, tree known_binfo,
 bool
 gimple_val_nonnegative_real_p (tree val)
 {
-  gimple def_stmt;
+  gimple *def_stmt;
 
   gcc_assert (val && SCALAR_FLOAT_TYPE_P (TREE_TYPE (val)));
 
@@ -3657,7 +3657,7 @@ arith_code_with_undefined_signed_overflow (tree_code code)
    a modified form of STMT itself.  */
 
 gimple_seq
-rewrite_to_defined_overflow (gimple stmt)
+rewrite_to_defined_overflow (gimple *stmt)
 {
   if (dump_file && (dump_flags & TDF_DETAILS))
     {
@@ -3682,7 +3682,7 @@ rewrite_to_defined_overflow (gimple stmt)
   if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR)
     gimple_assign_set_rhs_code (stmt, PLUS_EXPR);
   gimple_seq_add_stmt (&stmts, stmt);
-  gimple cvt = gimple_build_assign_with_ops
+  gimple *cvt = gimple_build_assign_with_ops
       (NOP_EXPR, lhs, gimple_assign_lhs (stmt), NULL_TREE);
   gimple_seq_add_stmt (&stmts, cvt);
 
diff --git a/gcc/gimple-fold.h b/gcc/gimple-fold.h
index 6b43066..961b783 100644
--- a/gcc/gimple-fold.h
+++ b/gcc/gimple-fold.h
@@ -25,15 +25,15 @@ along with GCC; see the file COPYING3.  If not see
 extern tree canonicalize_constructor_val (tree, tree);
 extern tree get_symbol_constant_value (tree);
 extern void gimplify_and_update_call_from_tree (gimple_stmt_iterator *, tree);
-extern tree gimple_fold_builtin (gimple);
+extern tree gimple_fold_builtin (gimple *);
 extern bool fold_stmt (gimple_stmt_iterator *);
 extern bool fold_stmt_inplace (gimple_stmt_iterator *);
 extern tree maybe_fold_and_comparisons (enum tree_code, tree, tree, 
 					enum tree_code, tree, tree);
 extern tree maybe_fold_or_comparisons (enum tree_code, tree, tree,
 				       enum tree_code, tree, tree);
-extern tree gimple_fold_stmt_to_constant_1 (gimple, tree (*) (tree));
-extern tree gimple_fold_stmt_to_constant (gimple, tree (*) (tree));
+extern tree gimple_fold_stmt_to_constant_1 (gimple *, tree (*) (tree));
+extern tree gimple_fold_stmt_to_constant (gimple *, tree (*) (tree));
 extern tree fold_const_aggregate_ref_1 (tree, tree (*) (tree));
 extern tree fold_const_aggregate_ref (tree);
 extern tree gimple_get_virt_method_for_binfo (HOST_WIDE_INT, tree,
@@ -44,6 +44,6 @@ extern tree gimple_get_virt_method_for_vtable (HOST_WIDE_INT, tree,
 extern bool gimple_val_nonnegative_real_p (tree);
 extern tree gimple_fold_indirect_ref (tree);
 extern bool arith_code_with_undefined_signed_overflow (tree_code);
-extern gimple_seq rewrite_to_defined_overflow (gimple);
+extern gimple_seq rewrite_to_defined_overflow (gimple *);
 
 #endif  /* GCC_GIMPLE_FOLD_H */
diff --git a/gcc/gimple-iterator.c b/gcc/gimple-iterator.c
index 8a1ec53..a1bc469 100644
--- a/gcc/gimple-iterator.c
+++ b/gcc/gimple-iterator.c
@@ -43,7 +43,7 @@ along with GCC; see the file COPYING3.  If not see
 /* Mark the statement STMT as modified, and update it.  */
 
 static inline void
-update_modified_stmt (gimple stmt)
+update_modified_stmt (gimple *stmt)
 {
   if (!ssa_operands_active (cfun))
     return;
@@ -372,10 +372,10 @@ gsi_split_seq_after (gimple_stmt_iterator i)
    of gsi_replace.  */
 
 void
-gsi_set_stmt (gimple_stmt_iterator *gsi, gimple stmt)
+gsi_set_stmt (gimple_stmt_iterator *gsi, gimple *stmt)
 {
-  gimple orig_stmt = gsi_stmt (*gsi);
-  gimple prev, next;
+  gimple *orig_stmt = gsi_stmt (*gsi);
+  gimple *prev, *next;
 
   stmt->next = next = orig_stmt->next;
   stmt->prev = prev = orig_stmt->prev;
@@ -432,9 +432,9 @@ gsi_split_seq_before (gimple_stmt_iterator *i, gimple_seq *pnew_seq)
    replaced with assignments to the same LHS.  */
 
 void
-gsi_replace (gimple_stmt_iterator *gsi, gimple stmt, bool update_eh_info)
+gsi_replace (gimple_stmt_iterator *gsi, gimple *stmt, bool update_eh_info)
 {
-  gimple orig_stmt = gsi_stmt (*gsi);
+  gimple *orig_stmt = gsi_stmt (*gsi);
 
   if (stmt == orig_stmt)
     return;
@@ -475,7 +475,7 @@ gsi_replace_with_seq (gimple_stmt_iterator *gsi, gimple_seq seq,
 		      bool update_eh_info)
 {
   gimple_stmt_iterator seqi;
-  gimple last;
+  gimple *last;
   if (gimple_seq_empty_p (seq))
     {
       gsi_remove (gsi, true);
@@ -499,7 +499,7 @@ gsi_replace_with_seq (gimple_stmt_iterator *gsi, gimple_seq seq,
    should use gsi_insert_before.  */
 
 void
-gsi_insert_before_without_update (gimple_stmt_iterator *i, gimple stmt,
+gsi_insert_before_without_update (gimple_stmt_iterator *i, gimple *stmt,
                                   enum gsi_iterator_update m)
 {
   gsi_insert_seq_nodes_before (i, stmt, stmt, m);
@@ -511,7 +511,7 @@ gsi_insert_before_without_update (gimple_stmt_iterator *i, gimple stmt,
    gsi_iterator_update).  */
 
 void
-gsi_insert_before (gimple_stmt_iterator *i, gimple stmt,
+gsi_insert_before (gimple_stmt_iterator *i, gimple *stmt,
                    enum gsi_iterator_update m)
 {
   update_modified_stmt (stmt);
@@ -529,7 +529,7 @@ gsi_insert_before (gimple_stmt_iterator *i, gimple stmt,
    should use gsi_insert_after.  */
 
 void
-gsi_insert_after_without_update (gimple_stmt_iterator *i, gimple stmt,
+gsi_insert_after_without_update (gimple_stmt_iterator *i, gimple *stmt,
                                  enum gsi_iterator_update m)
 {
   gsi_insert_seq_nodes_after (i, stmt, stmt, m);
@@ -542,7 +542,7 @@ gsi_insert_after_without_update (gimple_stmt_iterator *i, gimple stmt,
    gsi_iterator_update).  */
 
 void
-gsi_insert_after (gimple_stmt_iterator *i, gimple stmt,
+gsi_insert_after (gimple_stmt_iterator *i, gimple *stmt,
 		  enum gsi_iterator_update m)
 {
   update_modified_stmt (stmt);
@@ -563,7 +563,7 @@ bool
 gsi_remove (gimple_stmt_iterator *i, bool remove_permanently)
 {
   gimple_seq_node cur, next, prev;
-  gimple stmt = gsi_stmt (*i);
+  gimple *stmt = gsi_stmt (*i);
   bool require_eh_edge_purge = false;
 
   if (gimple_code (stmt) != GIMPLE_PHI)
@@ -609,7 +609,7 @@ gsi_remove (gimple_stmt_iterator *i, bool remove_permanently)
 /* Finds iterator for STMT.  */
 
 gimple_stmt_iterator
-gsi_for_stmt (gimple stmt)
+gsi_for_stmt (gimple *stmt)
 {
   gimple_stmt_iterator i;
   basic_block bb = gimple_bb (stmt);
@@ -629,7 +629,7 @@ gsi_for_stmt (gimple stmt)
 void
 gsi_move_after (gimple_stmt_iterator *from, gimple_stmt_iterator *to)
 {
-  gimple stmt = gsi_stmt (*from);
+  gimple *stmt = gsi_stmt (*from);
   gsi_remove (from, false);
 
   /* We must have GSI_NEW_STMT here, as gsi_move_after is sometimes used to
@@ -644,7 +644,7 @@ gsi_move_after (gimple_stmt_iterator *from, gimple_stmt_iterator *to)
 void
 gsi_move_before (gimple_stmt_iterator *from, gimple_stmt_iterator *to)
 {
-  gimple stmt = gsi_stmt (*from);
+  gimple *stmt = gsi_stmt (*from);
   gsi_remove (from, false);
 
   /* For consistency with gsi_move_after, it might be better to have
@@ -674,7 +674,7 @@ gsi_move_to_bb_end (gimple_stmt_iterator *from, basic_block bb)
    made until a call to gsi_commit_edge_inserts () is made.  */
 
 void
-gsi_insert_on_edge (edge e, gimple stmt)
+gsi_insert_on_edge (edge e, gimple *stmt)
 {
   gimple_seq_add_stmt (&PENDING_STMT (e), stmt);
 }
@@ -714,7 +714,7 @@ gimple_find_edge_insert_loc (edge e, gimple_stmt_iterator *gsi,
 			     basic_block *new_bb)
 {
   basic_block dest, src;
-  gimple tmp;
+  gimple *tmp;
 
   dest = e->dest;
 
@@ -792,7 +792,7 @@ gimple_find_edge_insert_loc (edge e, gimple_stmt_iterator *gsi,
    block has to be created, it is returned.  */
 
 basic_block
-gsi_insert_on_edge_immediate (edge e, gimple stmt)
+gsi_insert_on_edge_immediate (edge e, gimple *stmt)
 {
   gimple_stmt_iterator gsi;
   basic_block new_bb = NULL;
diff --git a/gcc/gimple-iterator.h b/gcc/gimple-iterator.h
index 909d58b..ff2c1a4 100644
--- a/gcc/gimple-iterator.h
+++ b/gcc/gimple-iterator.h
@@ -56,26 +56,26 @@ extern void gsi_insert_seq_after_without_update (gimple_stmt_iterator *,
 extern void gsi_insert_seq_after (gimple_stmt_iterator *, gimple_seq,
 				  enum gsi_iterator_update);
 extern gimple_seq gsi_split_seq_after (gimple_stmt_iterator);
-extern void gsi_set_stmt (gimple_stmt_iterator *, gimple);
+extern void gsi_set_stmt (gimple_stmt_iterator *, gimple *);
 extern void gsi_split_seq_before (gimple_stmt_iterator *, gimple_seq *);
-extern void gsi_replace (gimple_stmt_iterator *, gimple, bool);
+extern void gsi_replace (gimple_stmt_iterator *, gimple *, bool);
 extern void gsi_replace_with_seq (gimple_stmt_iterator *, gimple_seq, bool);
-extern void gsi_insert_before_without_update (gimple_stmt_iterator *, gimple,
+extern void gsi_insert_before_without_update (gimple_stmt_iterator *, gimple *,
 					      enum gsi_iterator_update);
-extern void gsi_insert_before (gimple_stmt_iterator *, gimple,
+extern void gsi_insert_before (gimple_stmt_iterator *, gimple *,
 			       enum gsi_iterator_update);
-extern void gsi_insert_after_without_update (gimple_stmt_iterator *, gimple,
+extern void gsi_insert_after_without_update (gimple_stmt_iterator *, gimple *,
 					     enum gsi_iterator_update);
-extern void gsi_insert_after (gimple_stmt_iterator *, gimple,
+extern void gsi_insert_after (gimple_stmt_iterator *, gimple *,
 			      enum gsi_iterator_update);
 extern bool gsi_remove (gimple_stmt_iterator *, bool);
-extern gimple_stmt_iterator gsi_for_stmt (gimple);
+extern gimple_stmt_iterator gsi_for_stmt (gimple *);
 extern void gsi_move_after (gimple_stmt_iterator *, gimple_stmt_iterator *);
 extern void gsi_move_before (gimple_stmt_iterator *, gimple_stmt_iterator *);
 extern void gsi_move_to_bb_end (gimple_stmt_iterator *, basic_block);
-extern void gsi_insert_on_edge (edge, gimple);
+extern void gsi_insert_on_edge (edge, gimple *);
 extern void gsi_insert_seq_on_edge (edge, gimple_seq);
-extern basic_block gsi_insert_on_edge_immediate (edge, gimple);
+extern basic_block gsi_insert_on_edge_immediate (edge, gimple *);
 extern basic_block gsi_insert_seq_on_edge_immediate (edge, gimple_seq);
 extern void gsi_commit_edge_inserts (void);
 extern void gsi_commit_one_edge_insert (edge, basic_block *);
@@ -186,7 +186,7 @@ gsi_next (gimple_stmt_iterator *i)
 static inline void
 gsi_prev (gimple_stmt_iterator *i)
 {
-  gimple prev = i->ptr->prev;
+  gimple *prev = i->ptr->prev;
   if (prev->next)
     i->ptr = prev;
   else
@@ -195,7 +195,7 @@ gsi_prev (gimple_stmt_iterator *i)
 
 /* Return the current stmt.  */
 
-static inline gimple
+static inline gimple *
 gsi_stmt (gimple_stmt_iterator i)
 {
   return i.ptr;
diff --git a/gcc/gimple-low.c b/gcc/gimple-low.c
index eff4b4f..092efa7 100644
--- a/gcc/gimple-low.c
+++ b/gcc/gimple-low.c
@@ -60,7 +60,7 @@ along with GCC; see the file COPYING3.  If not see
 struct return_statements_t
 {
   tree label;
-  gimple stmt;
+  gimple *stmt;
 };
 typedef struct return_statements_t return_statements_t;
 
@@ -96,8 +96,8 @@ lower_function_body (void)
   gimple_seq body = gimple_body (current_function_decl);
   gimple_seq lowered_body;
   gimple_stmt_iterator i;
-  gimple bind;
-  gimple x;
+  gimple *bind;
+  gimple *x;
 
   /* The gimplifier should've left a body of exactly one statement,
      namely a GIMPLE_BIND.  */
@@ -212,7 +212,7 @@ lower_sequence (gimple_seq *seq, struct lower_data *data)
 static void
 lower_omp_directive (gimple_stmt_iterator *gsi, struct lower_data *data)
 {
-  gimple stmt;
+  gimple *stmt;
 
   stmt = gsi_stmt (*gsi);
 
@@ -233,7 +233,7 @@ lower_omp_directive (gimple_stmt_iterator *gsi, struct lower_data *data)
 static void
 lower_stmt (gimple_stmt_iterator *gsi, struct lower_data *data)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
 
   gimple_set_block (stmt, data->block);
 
@@ -379,7 +379,7 @@ static void
 lower_gimple_bind (gimple_stmt_iterator *gsi, struct lower_data *data)
 {
   tree old_block = data->block;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   tree new_block = gimple_bind_block (stmt);
 
   if (new_block)
@@ -433,7 +433,7 @@ static void
 lower_try_catch (gimple_stmt_iterator *gsi, struct lower_data *data)
 {
   bool cannot_fallthru;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   gimple_stmt_iterator i;
 
   /* We don't handle GIMPLE_TRY_FINALLY.  */
@@ -493,7 +493,7 @@ lower_try_catch (gimple_stmt_iterator *gsi, struct lower_data *data)
    This is a subroutine of gimple_stmt_may_fallthru.  */
 
 static bool
-gimple_try_catch_may_fallthru (gimple stmt)
+gimple_try_catch_may_fallthru (gimple *stmt)
 {
   gimple_stmt_iterator i;
 
@@ -548,7 +548,7 @@ gimple_try_catch_may_fallthru (gimple stmt)
    we'll just delete the extra code later.  */
 
 bool
-gimple_stmt_may_fallthru (gimple stmt)
+gimple_stmt_may_fallthru (gimple *stmt)
 {
   if (!stmt)
     return true;
@@ -619,8 +619,8 @@ gimple_seq_may_fallthru (gimple_seq seq)
 static void
 lower_gimple_return (gimple_stmt_iterator *gsi, struct lower_data *data)
 {
-  gimple stmt = gsi_stmt (*gsi);
-  gimple t;
+  gimple *stmt = gsi_stmt (*gsi);
+  gimple *t;
   int i;
   return_statements_t tmp_rs;
 
@@ -710,12 +710,12 @@ lower_gimple_return (gimple_stmt_iterator *gsi, struct lower_data *data)
 static void
 lower_builtin_setjmp (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   location_t loc = gimple_location (stmt);
   tree cont_label = create_artificial_label (loc);
   tree next_label = create_artificial_label (loc);
   tree dest, t, arg;
-  gimple g;
+  gimple *g;
 
   /* __builtin_setjmp_{setup,receiver} aren't ECF_RETURNS_TWICE and for RTL
      these builtins are modelled as non-local label jumps to the label
@@ -795,7 +795,7 @@ lower_builtin_setjmp (gimple_stmt_iterator *gsi)
 static void
 lower_builtin_posix_memalign (gimple_stmt_iterator *gsi)
 {
-  gimple stmt, call = gsi_stmt (*gsi);
+  gimple *stmt, *call = gsi_stmt (*gsi);
   tree pptr = gimple_call_arg (call, 0);
   tree align = gimple_call_arg (call, 1);
   tree res = gimple_call_lhs (call);
@@ -818,7 +818,7 @@ lower_builtin_posix_memalign (gimple_stmt_iterator *gsi)
     }
   tree align_label = create_artificial_label (UNKNOWN_LOCATION);
   tree noalign_label = create_artificial_label (UNKNOWN_LOCATION);
-  gimple cond = gimple_build_cond (EQ_EXPR, res, integer_zero_node,
+  gimple *cond = gimple_build_cond (EQ_EXPR, res, integer_zero_node,
 				   align_label, noalign_label);
   gsi_insert_after (gsi, cond, GSI_NEW_STMT);
   gsi_insert_after (gsi, gimple_build_label (align_label), GSI_NEW_STMT);
diff --git a/gcc/gimple-low.h b/gcc/gimple-low.h
index a4efa50..f48d131 100644
--- a/gcc/gimple-low.h
+++ b/gcc/gimple-low.h
@@ -20,7 +20,7 @@ along with GCC; see the file COPYING3.  If not see
 #ifndef GCC_GIMPLE_LOW_H
 #define GCC_GIMPLE_LOW_H
 
-extern bool gimple_stmt_may_fallthru (gimple);
+extern bool gimple_stmt_may_fallthru (gimple *);
 extern bool gimple_seq_may_fallthru (gimple_seq);
 extern void record_vars_into (tree, tree);
 extern void record_vars (tree);
diff --git a/gcc/gimple-pretty-print.c b/gcc/gimple-pretty-print.c
index b80ae72..205cccb 100644
--- a/gcc/gimple-pretty-print.c
+++ b/gcc/gimple-pretty-print.c
@@ -54,7 +54,7 @@ along with GCC; see the file COPYING3.  If not see
    gimple statement GS.  */
 
 static void
-do_niy (pretty_printer *buffer, gimple gs)
+do_niy (pretty_printer *buffer, gimple *gs)
 {
   pp_printf (buffer, "<<< Unknown GIMPLE statement: %s >>>\n",
 	     gimple_code_name[(int) gimple_code (gs)]);
@@ -74,7 +74,7 @@ newline_and_indent (pretty_printer *buffer, int spc)
 /* Print the GIMPLE statement GS on stderr.  */
 
 DEBUG_FUNCTION void
-debug_gimple_stmt (gimple gs)
+debug_gimple_stmt (gimple *gs)
 {
   print_gimple_stmt (stderr, gs, 0, TDF_VOPS|TDF_MEMSYMS);
 }
@@ -84,7 +84,7 @@ debug_gimple_stmt (gimple gs)
    FLAGS as in pp_gimple_stmt_1.  */
 
 void
-print_gimple_stmt (FILE *file, gimple g, int spc, int flags)
+print_gimple_stmt (FILE *file, gimple *g, int spc, int flags)
 {
   pretty_printer buffer;
   pp_needs_newline (&buffer) = true;
@@ -114,7 +114,7 @@ debug (gimple *ptr)
    of the statement.  */
 
 void
-print_gimple_expr (FILE *file, gimple g, int spc, int flags)
+print_gimple_expr (FILE *file, gimple *g, int spc, int flags)
 {
   flags |= TDF_RHS_ONLY;
   pretty_printer buffer;
@@ -137,7 +137,7 @@ dump_gimple_seq (pretty_printer *buffer, gimple_seq seq, int spc, int flags)
 
   for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
     {
-      gimple gs = gsi_stmt (i);
+      gimple *gs = gsi_stmt (i);
       INDENT (spc);
       pp_gimple_stmt_1 (buffer, gs, spc, flags);
       if (!gsi_one_before_end_p (i))
@@ -196,11 +196,11 @@ dump_gimple_fmt (pretty_printer *buffer, int spc, int flags,
         {
           gimple_seq seq;
           tree t;
-          gimple g;
+          gimple *g;
           switch (*++c)
             {
               case 'G':
-                g = va_arg (args, gimple);
+                g = va_arg (args, gimple *);
                 tmp = gimple_code_name[gimple_code (g)];
                 pp_string (buffer, tmp);
                 break;
@@ -261,7 +261,7 @@ dump_gimple_fmt (pretty_printer *buffer, int spc, int flags,
    assignment GS.  BUFFER, SPC and FLAGS are as in pp_gimple_stmt_1.  */
 
 static void
-dump_unary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_unary_rhs (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   enum tree_code rhs_code = gimple_assign_rhs_code (gs);
   tree lhs = gimple_assign_lhs (gs);
@@ -345,7 +345,7 @@ dump_unary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
    assignment GS.  BUFFER, SPC and FLAGS are as in pp_gimple_stmt_1.  */
 
 static void
-dump_binary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_binary_rhs (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   const char *p;
   enum tree_code code = gimple_assign_rhs_code (gs);
@@ -401,7 +401,7 @@ dump_binary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
    assignment GS.  BUFFER, SPC and FLAGS are as in pp_gimple_stmt_1.  */
 
 static void
-dump_ternary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_ternary_rhs (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   const char *p;
   enum tree_code code = gimple_assign_rhs_code (gs);
@@ -486,7 +486,7 @@ dump_ternary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
    pp_gimple_stmt_1.  */
 
 static void
-dump_gimple_assign (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_assign (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   if (flags & TDF_RAW)
     {
@@ -545,7 +545,7 @@ dump_gimple_assign (pretty_printer *buffer, gimple gs, int spc, int flags)
    pp_gimple_stmt_1.  */
 
 static void
-dump_gimple_return (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_return (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   tree t;
 
@@ -569,7 +569,7 @@ dump_gimple_return (pretty_printer *buffer, gimple gs, int spc, int flags)
    dump_gimple_call.  */
 
 static void
-dump_gimple_call_args (pretty_printer *buffer, gimple gs, int flags)
+dump_gimple_call_args (pretty_printer *buffer, gimple *gs, int flags)
 {
   size_t i;
 
@@ -642,7 +642,7 @@ pp_points_to_solution (pretty_printer *buffer, struct pt_solution *pt)
    pp_gimple_stmt_1.  */
 
 static void
-dump_gimple_call (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_call (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   tree lhs = gimple_call_lhs (gs);
   tree fn = gimple_call_fn (gs);
@@ -775,7 +775,7 @@ dump_gimple_call (pretty_printer *buffer, gimple gs, int spc, int flags)
    pp_gimple_stmt_1.  */
 
 static void
-dump_gimple_switch (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_switch (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   unsigned int i;
 
@@ -808,7 +808,7 @@ dump_gimple_switch (pretty_printer *buffer, gimple gs, int spc, int flags)
    pp_gimple_stmt_1.  */
 
 static void
-dump_gimple_cond (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_cond (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   if (flags & TDF_RAW)
     dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T, %T, %T, %T>", gs,
@@ -852,7 +852,7 @@ dump_gimple_cond (pretty_printer *buffer, gimple gs, int spc, int flags)
    TDF_* in dumpfils.h).  */
 
 static void
-dump_gimple_label (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_label (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   tree label = gimple_label_label (gs);
   if (flags & TDF_RAW)
@@ -873,7 +873,7 @@ dump_gimple_label (pretty_printer *buffer, gimple gs, int spc, int flags)
    TDF_* in dumpfile.h).  */
 
 static void
-dump_gimple_goto (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_goto (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   tree label = gimple_goto_dest (gs);
   if (flags & TDF_RAW)
@@ -888,7 +888,7 @@ dump_gimple_goto (pretty_printer *buffer, gimple gs, int spc, int flags)
    TDF_* in dumpfile.h).  */
 
 static void
-dump_gimple_bind (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_bind (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   if (flags & TDF_RAW)
     dump_gimple_fmt (buffer, spc, flags, "%G <", gs);
@@ -921,7 +921,7 @@ dump_gimple_bind (pretty_printer *buffer, gimple gs, int spc, int flags)
    dumpfile.h).  */
 
 static void
-dump_gimple_try (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_try (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   if (flags & TDF_RAW)
     {
@@ -977,7 +977,7 @@ dump_gimple_try (pretty_printer *buffer, gimple gs, int spc, int flags)
    dumpfile.h).  */
 
 static void
-dump_gimple_catch (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_catch (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   if (flags & TDF_RAW)
       dump_gimple_fmt (buffer, spc, flags, "%G <%T, %+CATCH <%S>%->", gs,
@@ -993,7 +993,7 @@ dump_gimple_catch (pretty_printer *buffer, gimple gs, int spc, int flags)
    dumpfile.h).  */
 
 static void
-dump_gimple_eh_filter (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_eh_filter (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   if (flags & TDF_RAW)
     dump_gimple_fmt (buffer, spc, flags, "%G <%T, %+FAILURE <%S>%->", gs,
@@ -1009,7 +1009,7 @@ dump_gimple_eh_filter (pretty_printer *buffer, gimple gs, int spc, int flags)
 /* Dump a GIMPLE_EH_MUST_NOT_THROW tuple.  */
 
 static void
-dump_gimple_eh_must_not_throw (pretty_printer *buffer, gimple gs,
+dump_gimple_eh_must_not_throw (pretty_printer *buffer, gimple *gs,
 			       int spc, int flags)
 {
   if (flags & TDF_RAW)
@@ -1026,7 +1026,7 @@ dump_gimple_eh_must_not_throw (pretty_printer *buffer, gimple gs,
    dumpfile.h).  */
 
 static void
-dump_gimple_eh_else (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_eh_else (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   if (flags & TDF_RAW)
     dump_gimple_fmt (buffer, spc, flags,
@@ -1044,7 +1044,7 @@ dump_gimple_eh_else (pretty_printer *buffer, gimple gs, int spc, int flags)
    dumpfile.h).  */
 
 static void
-dump_gimple_resx (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_resx (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   if (flags & TDF_RAW)
     dump_gimple_fmt (buffer, spc, flags, "%G <%d>", gs,
@@ -1056,7 +1056,7 @@ dump_gimple_resx (pretty_printer *buffer, gimple gs, int spc, int flags)
 /* Dump a GIMPLE_EH_DISPATCH tuple on the pretty_printer BUFFER.  */
 
 static void
-dump_gimple_eh_dispatch (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_eh_dispatch (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   if (flags & TDF_RAW)
     dump_gimple_fmt (buffer, spc, flags, "%G <%d>", gs,
@@ -1071,7 +1071,7 @@ dump_gimple_eh_dispatch (pretty_printer *buffer, gimple gs, int spc, int flags)
    in dumpfile.h).  */
 
 static void
-dump_gimple_debug (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_debug (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   switch (gs->subcode)
     {
@@ -1104,7 +1104,7 @@ dump_gimple_debug (pretty_printer *buffer, gimple gs, int spc, int flags)
 
 /* Dump a GIMPLE_OMP_FOR tuple on the pretty_printer BUFFER.  */
 static void
-dump_gimple_omp_for (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_omp_for (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   size_t i;
 
@@ -1224,7 +1224,7 @@ dump_gimple_omp_for (pretty_printer *buffer, gimple gs, int spc, int flags)
 /* Dump a GIMPLE_OMP_CONTINUE tuple on the pretty_printer BUFFER.  */
 
 static void
-dump_gimple_omp_continue (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_omp_continue (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   if (flags & TDF_RAW)
     {
@@ -1248,7 +1248,7 @@ dump_gimple_omp_continue (pretty_printer *buffer, gimple gs, int spc, int flags)
 /* Dump a GIMPLE_OMP_SINGLE tuple on the pretty_printer BUFFER.  */
 
 static void
-dump_gimple_omp_single (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_omp_single (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   if (flags & TDF_RAW)
     {
@@ -1276,7 +1276,7 @@ dump_gimple_omp_single (pretty_printer *buffer, gimple gs, int spc, int flags)
 /* Dump a GIMPLE_OMP_TARGET tuple on the pretty_printer BUFFER.  */
 
 static void
-dump_gimple_omp_target (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_omp_target (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   const char *kind;
   switch (gimple_omp_target_kind (gs))
@@ -1327,7 +1327,7 @@ dump_gimple_omp_target (pretty_printer *buffer, gimple gs, int spc, int flags)
 /* Dump a GIMPLE_OMP_TEAMS tuple on the pretty_printer BUFFER.  */
 
 static void
-dump_gimple_omp_teams (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_omp_teams (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   if (flags & TDF_RAW)
     {
@@ -1355,7 +1355,7 @@ dump_gimple_omp_teams (pretty_printer *buffer, gimple gs, int spc, int flags)
 /* Dump a GIMPLE_OMP_SECTIONS tuple on the pretty_printer BUFFER.  */
 
 static void
-dump_gimple_omp_sections (pretty_printer *buffer, gimple gs, int spc,
+dump_gimple_omp_sections (pretty_printer *buffer, gimple *gs, int spc,
 			  int flags)
 {
   if (flags & TDF_RAW)
@@ -1392,7 +1392,7 @@ dump_gimple_omp_sections (pretty_printer *buffer, gimple gs, int spc,
    pretty_printer BUFFER.  */
 
 static void
-dump_gimple_omp_block (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_omp_block (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   if (flags & TDF_RAW)
     dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S> >", gs,
@@ -1431,7 +1431,7 @@ dump_gimple_omp_block (pretty_printer *buffer, gimple gs, int spc, int flags)
 /* Dump a GIMPLE_OMP_CRITICAL tuple on the pretty_printer BUFFER.  */
 
 static void
-dump_gimple_omp_critical (pretty_printer *buffer, gimple gs, int spc,
+dump_gimple_omp_critical (pretty_printer *buffer, gimple *gs, int spc,
 			  int flags)
 {
   if (flags & TDF_RAW)
@@ -1462,7 +1462,7 @@ dump_gimple_omp_critical (pretty_printer *buffer, gimple gs, int spc,
 /* Dump a GIMPLE_OMP_RETURN tuple on the pretty_printer BUFFER.  */
 
 static void
-dump_gimple_omp_return (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_omp_return (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   if (flags & TDF_RAW)
     {
@@ -1492,7 +1492,7 @@ dump_gimple_omp_return (pretty_printer *buffer, gimple gs, int spc, int flags)
 /* Dump a GIMPLE_TRANSACTION tuple on the pretty_printer BUFFER.  */
 
 static void
-dump_gimple_transaction (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_transaction (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   unsigned subcode = gimple_transaction_subcode (gs);
 
@@ -1579,7 +1579,7 @@ dump_gimple_transaction (pretty_printer *buffer, gimple gs, int spc, int flags)
    dumpfile.h).  */
 
 static void
-dump_gimple_asm (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_asm (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   unsigned int i, n, f, fields;
 
@@ -1785,7 +1785,7 @@ dump_ssaname_info (pretty_printer *buffer, tree node, int spc)
    pretty printer.  If COMMENT is true, print this after #.  */
 
 static void
-dump_gimple_phi (pretty_printer *buffer, gimple phi, int spc, bool comment,
+dump_gimple_phi (pretty_printer *buffer, gimple *phi, int spc, bool comment,
 		 int flags)
 {
   size_t i;
@@ -1840,7 +1840,7 @@ dump_gimple_phi (pretty_printer *buffer, gimple phi, int spc, bool comment,
    dumpfile.h).  */
 
 static void
-dump_gimple_omp_parallel (pretty_printer *buffer, gimple gs, int spc,
+dump_gimple_omp_parallel (pretty_printer *buffer, gimple *gs, int spc,
                           int flags)
 {
   if (flags & TDF_RAW)
@@ -1894,7 +1894,7 @@ dump_gimple_omp_parallel (pretty_printer *buffer, gimple gs, int spc,
    dumpfile.h).  */
 
 static void
-dump_gimple_omp_task (pretty_printer *buffer, gimple gs, int spc,
+dump_gimple_omp_task (pretty_printer *buffer, gimple *gs, int spc,
 		      int flags)
 {
   if (flags & TDF_RAW)
@@ -1951,7 +1951,7 @@ dump_gimple_omp_task (pretty_printer *buffer, gimple gs, int spc,
    in dumpfile.h).  */
 
 static void
-dump_gimple_omp_atomic_load (pretty_printer *buffer, gimple gs, int spc,
+dump_gimple_omp_atomic_load (pretty_printer *buffer, gimple *gs, int spc,
                              int flags)
 {
   if (flags & TDF_RAW)
@@ -1984,7 +1984,7 @@ dump_gimple_omp_atomic_load (pretty_printer *buffer, gimple gs, int spc,
    in dumpfile.h).  */
 
 static void
-dump_gimple_omp_atomic_store (pretty_printer *buffer, gimple gs, int spc,
+dump_gimple_omp_atomic_store (pretty_printer *buffer, gimple *gs, int spc,
                              int flags)
 {
   if (flags & TDF_RAW)
@@ -2011,7 +2011,7 @@ dump_gimple_omp_atomic_store (pretty_printer *buffer, gimple gs, int spc,
    FLAGS are as in pp_gimple_stmt_1.  */
 
 static void
-dump_gimple_mem_ops (pretty_printer *buffer, gimple gs, int spc, int flags)
+dump_gimple_mem_ops (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   tree vdef = gimple_vdef (gs);
   tree vuse = gimple_vuse (gs);
@@ -2041,7 +2041,7 @@ dump_gimple_mem_ops (pretty_printer *buffer, gimple gs, int spc, int flags)
    pp_flush on BUFFER to finalize the pretty printer.  */
 
 void
-pp_gimple_stmt_1 (pretty_printer *buffer, gimple gs, int spc, int flags)
+pp_gimple_stmt_1 (pretty_printer *buffer, gimple *gs, int spc, int flags)
 {
   if (!gs)
     return;
@@ -2269,7 +2269,7 @@ dump_gimple_bb_header (FILE *outf, basic_block bb, int indent, int flags)
     }
   else
     {
-      gimple stmt = first_stmt (bb);
+      gimple *stmt = first_stmt (bb);
       if (!stmt || gimple_code (stmt) != GIMPLE_LABEL)
 	fprintf (outf, "%*s<bb %d>:\n", indent, "", bb->index);
     }
@@ -2300,7 +2300,7 @@ dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
 
   for (i = gsi_start_phis (bb); !gsi_end_p (i); gsi_next (&i))
     {
-      gimple phi = gsi_stmt (i);
+      gimple *phi = gsi_stmt (i);
       if (!virtual_operand_p (gimple_phi_result (phi)) || (flags & TDF_VOPS))
         {
           INDENT (indent);
@@ -2317,7 +2317,7 @@ dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
 static void
 pp_cfg_jump (pretty_printer *buffer, basic_block bb)
 {
-  gimple stmt;
+  gimple *stmt;
 
   stmt = first_stmt (bb);
 
@@ -2344,7 +2344,7 @@ dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
 		     int flags)
 {
   edge e;
-  gimple stmt;
+  gimple *stmt;
 
   stmt = last_stmt (bb);
 
@@ -2409,7 +2409,7 @@ gimple_dump_bb_buff (pretty_printer *buffer, basic_block bb, int indent,
 		     int flags)
 {
   gimple_stmt_iterator gsi;
-  gimple stmt;
+  gimple *stmt;
   int label_indent = indent - 2;
 
   if (label_indent < 0)
@@ -2470,7 +2470,7 @@ gimple_dump_bb_for_graph (pretty_printer *pp, basic_block bb)
 
   for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple phi = gsi_stmt (gsi);
+      gimple *phi = gsi_stmt (gsi);
       if (!virtual_operand_p (gimple_phi_result (phi))
 	  || (dump_flags & TDF_VOPS))
 	{
@@ -2485,7 +2485,7 @@ gimple_dump_bb_for_graph (pretty_printer *pp, basic_block bb)
 
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       pp_bar (pp);
       pp_write_text_to_stream (pp);
       pp_gimple_stmt_1 (pp, stmt, 0, dump_flags);
diff --git a/gcc/gimple-pretty-print.h b/gcc/gimple-pretty-print.h
index 82ef760..9c11c57 100644
--- a/gcc/gimple-pretty-print.h
+++ b/gcc/gimple-pretty-print.h
@@ -25,14 +25,14 @@ along with GCC; see the file COPYING3.  If not see
 #include "tree-pretty-print.h"
 
 /* In gimple-pretty-print.c  */
-extern void debug_gimple_stmt (gimple);
+extern void debug_gimple_stmt (gimple *);
 extern void debug_gimple_seq (gimple_seq);
 extern void print_gimple_seq (FILE *, gimple_seq, int, int);
-extern void print_gimple_stmt (FILE *, gimple, int, int);
+extern void print_gimple_stmt (FILE *, gimple *, int, int);
 extern void debug (gimple &ref);
 extern void debug (gimple *ptr);
-extern void print_gimple_expr (FILE *, gimple, int, int);
-extern void pp_gimple_stmt_1 (pretty_printer *, gimple, int, int);
+extern void print_gimple_expr (FILE *, gimple *, int, int);
+extern void pp_gimple_stmt_1 (pretty_printer *, gimple *, int, int);
 extern void gimple_dump_bb (FILE *, basic_block, int, int);
 extern void gimple_dump_bb_for_graph (pretty_printer *, basic_block);
 
diff --git a/gcc/gimple-ssa-isolate-paths.c b/gcc/gimple-ssa-isolate-paths.c
index 298e14c..d263e68 100644
--- a/gcc/gimple-ssa-isolate-paths.c
+++ b/gcc/gimple-ssa-isolate-paths.c
@@ -54,7 +54,7 @@ static bool cfg_altered;
    This routine only makes a superficial check for a dereference.  Thus,
    it must only be used if it is safe to return a false negative.  */
 static bool
-check_loadstore (gimple stmt, tree op, tree, void *data)
+check_loadstore (gimple *stmt, tree op, tree, void *data)
 {
   if ((TREE_CODE (op) == MEM_REF || TREE_CODE (op) == TARGET_MEM_REF)
       && operand_equal_p (TREE_OPERAND (op, 0), (tree)data, 0))
@@ -81,7 +81,7 @@ insert_trap_and_remove_trailing_statements (gimple_stmt_iterator *si_p, tree op)
      If the dereference is a store and we can easily transform the RHS,
      then simplify the RHS to enable more DCE.   Note that we require the
      statement to be a GIMPLE_ASSIGN which filters out calls on the RHS.  */
-  gimple stmt = gsi_stmt (*si_p);
+  gimple *stmt = gsi_stmt (*si_p);
   if (walk_stmt_load_store_ops (stmt, (void *)op, NULL, check_loadstore)
       && is_gimple_assign (stmt)
       && INTEGRAL_TYPE_P (TREE_TYPE (gimple_assign_lhs (stmt))))
@@ -94,7 +94,7 @@ insert_trap_and_remove_trailing_statements (gimple_stmt_iterator *si_p, tree op)
       update_stmt (stmt);
     }
 
-  gimple new_stmt
+  gimple *new_stmt
     = gimple_build_call (builtin_decl_explicit (BUILT_IN_TRAP), 0);
   gimple_seq seq = NULL;
   gimple_seq_add_stmt (&seq, new_stmt);
@@ -138,7 +138,7 @@ insert_trap_and_remove_trailing_statements (gimple_stmt_iterator *si_p, tree op)
 
 basic_block
 isolate_path (basic_block bb, basic_block duplicate,
-	      edge e, gimple stmt, tree op)
+	      edge e, gimple *stmt, tree op)
 {
   gimple_stmt_iterator si, si2;
   edge_iterator ei;
@@ -236,7 +236,7 @@ find_implicit_erroneous_behaviour (void)
 	 cases.   */
       for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
 	{
-	  gimple phi = gsi_stmt (si);
+	  gimple *phi = gsi_stmt (si);
 	  tree lhs = gimple_phi_result (phi);
 
 	  /* If the result is not a pointer, then there is no need to
@@ -263,7 +263,7 @@ find_implicit_erroneous_behaviour (void)
 
 	      edge e = gimple_phi_arg_edge (phi, i);
 	      imm_use_iterator iter;
-	      gimple use_stmt;
+	      gimple *use_stmt;
 
 	      /* We've got a NULL PHI argument.  Now see if the
  	         PHI's result is dereferenced within BB.  */
@@ -323,7 +323,7 @@ find_explicit_erroneous_behaviour (void)
 	 because of jump threading and constant propagation.  */
       for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
 	{
-	  gimple stmt = gsi_stmt (si);
+	  gimple *stmt = gsi_stmt (si);
 
 	  /* By passing null_pointer_node, we can use infer_nonnull_range
 	     to detect explicit NULL pointer dereferences and other uses
diff --git a/gcc/gimple-ssa-strength-reduction.c b/gcc/gimple-ssa-strength-reduction.c
index a41d972..9a53ad7 100644
--- a/gcc/gimple-ssa-strength-reduction.c
+++ b/gcc/gimple-ssa-strength-reduction.c
@@ -236,7 +236,7 @@ enum cand_kind
 struct slsr_cand_d
 {
   /* The candidate statement S1.  */
-  gimple cand_stmt;
+  gimple *cand_stmt;
 
   /* The base expression B:  often an SSA name, but not always.  */
   tree base_expr;
@@ -627,7 +627,7 @@ record_potential_basis (slsr_cand_t c, tree base)
      a2[i + 20][j] = 2;  */
 
 static slsr_cand_t
-alloc_cand_and_find_basis (enum cand_kind kind, gimple gs, tree base,
+alloc_cand_and_find_basis (enum cand_kind kind, gimple *gs, tree base,
 			   const widest_int &index, tree stride, tree ctype,
 			   unsigned savings)
 {
@@ -668,7 +668,7 @@ alloc_cand_and_find_basis (enum cand_kind kind, gimple gs, tree base,
    to SPEED.  */
 
 static int
-stmt_cost (gimple gs, bool speed)
+stmt_cost (gimple *gs, bool speed)
 {
   tree lhs, rhs1, rhs2;
   enum machine_mode lhs_mode;
@@ -719,7 +719,7 @@ base_cand_from_table (tree base_in)
 {
   slsr_cand_t *result;
 
-  gimple def = SSA_NAME_DEF_STMT (base_in);
+  gimple *def = SSA_NAME_DEF_STMT (base_in);
   if (!def)
     return (slsr_cand_t) NULL;
 
@@ -734,7 +734,7 @@ base_cand_from_table (tree base_in)
 /* Add an entry to the statement-to-candidate mapping.  */
 
 static void
-add_cand_for_stmt (gimple gs, slsr_cand_t c)
+add_cand_for_stmt (gimple *gs, slsr_cand_t c)
 {
   void **slot = pointer_map_insert (stmt_cand_map, gs);
   gcc_assert (!*slot);
@@ -747,7 +747,7 @@ add_cand_for_stmt (gimple gs, slsr_cand_t c)
    is used to help find a basis for subsequent candidates.  */
 
 static void
-slsr_process_phi (gimple phi, bool speed)
+slsr_process_phi (gimple *phi, bool speed)
 {
   unsigned i;
   tree arg0_base = NULL_TREE, base_type;
@@ -766,7 +766,7 @@ slsr_process_phi (gimple phi, bool speed)
       slsr_cand_t arg_cand;
       tree arg = gimple_phi_arg_def (phi, i);
       tree derived_base_name = NULL_TREE;
-      gimple arg_stmt = NULL;
+      gimple *arg_stmt = NULL;
       basic_block arg_bb = NULL;
 
       if (TREE_CODE (arg) != SSA_NAME)
@@ -983,7 +983,7 @@ restructure_reference (tree *pbase, tree *poffset, widest_int *pindex,
    the candidate table and attempt to find a basis.  */
 
 static void
-slsr_process_ref (gimple gs)
+slsr_process_ref (gimple *gs)
 {
   tree ref_expr, base, offset, type;
   HOST_WIDE_INT bitsize, bitpos;
@@ -1022,7 +1022,7 @@ slsr_process_ref (gimple gs)
    candidate.  */
 
 static slsr_cand_t
-create_mul_ssa_cand (gimple gs, tree base_in, tree stride_in, bool speed)
+create_mul_ssa_cand (gimple *gs, tree base_in, tree stride_in, bool speed)
 {
   tree base = NULL_TREE, stride = NULL_TREE, ctype = NULL_TREE;
   widest_int index;
@@ -1092,7 +1092,7 @@ create_mul_ssa_cand (gimple gs, tree base_in, tree stride_in, bool speed)
    candidate.  */
 
 static slsr_cand_t
-create_mul_imm_cand (gimple gs, tree base_in, tree stride_in, bool speed)
+create_mul_imm_cand (gimple *gs, tree base_in, tree stride_in, bool speed)
 {
   tree base = NULL_TREE, stride = NULL_TREE, ctype = NULL_TREE;
   widest_int index, temp;
@@ -1182,7 +1182,7 @@ create_mul_imm_cand (gimple gs, tree base_in, tree stride_in, bool speed)
    find a basis.  */
 
 static void
-slsr_process_mul (gimple gs, tree rhs1, tree rhs2, bool speed)
+slsr_process_mul (gimple *gs, tree rhs1, tree rhs2, bool speed)
 {
   slsr_cand_t c, c2;
 
@@ -1224,7 +1224,7 @@ slsr_process_mul (gimple gs, tree rhs1, tree rhs2, bool speed)
    Return the new candidate.  */
 
 static slsr_cand_t
-create_add_ssa_cand (gimple gs, tree base_in, tree addend_in,
+create_add_ssa_cand (gimple *gs, tree base_in, tree addend_in,
 		     bool subtract_p, bool speed)
 {
   tree base = NULL_TREE, stride = NULL_TREE, ctype = NULL;
@@ -1339,7 +1339,7 @@ create_add_ssa_cand (gimple gs, tree base_in, tree addend_in,
    about BASE_IN into the new candidate.  Return the new candidate.  */
 
 static slsr_cand_t
-create_add_imm_cand (gimple gs, tree base_in, const widest_int &index_in,
+create_add_imm_cand (gimple *gs, tree base_in, const widest_int &index_in,
 		     bool speed)
 {
   enum cand_kind kind = CAND_ADD;
@@ -1402,7 +1402,7 @@ create_add_imm_cand (gimple gs, tree base_in, const widest_int &index_in,
    make at least one appropriate entry in the candidate table.  */
 
 static void
-slsr_process_add (gimple gs, tree rhs1, tree rhs2, bool speed)
+slsr_process_add (gimple *gs, tree rhs1, tree rhs2, bool speed)
 {
   bool subtract_p = gimple_assign_rhs_code (gs) == MINUS_EXPR;
   slsr_cand_t c = NULL, c2;
@@ -1457,7 +1457,7 @@ slsr_process_add (gimple gs, tree rhs1, tree rhs2, bool speed)
    by -1.  */
 
 static void
-slsr_process_neg (gimple gs, tree rhs1, bool speed)
+slsr_process_neg (gimple *gs, tree rhs1, bool speed)
 {
   /* Record a CAND_MULT interpretation for the multiply by -1.  */
   slsr_cand_t c = create_mul_imm_cand (gs, rhs1, integer_minus_one_node, speed);
@@ -1530,7 +1530,7 @@ legal_cast_p_1 (tree lhs, tree rhs)
    have different semantics.  */
 
 static bool
-legal_cast_p (gimple gs, tree rhs)
+legal_cast_p (gimple *gs, tree rhs)
 {
   if (!is_gimple_assign (gs)
       || !CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs)))
@@ -1544,7 +1544,7 @@ legal_cast_p (gimple gs, tree rhs)
    appropriate entry in the candidate table.  */
 
 static void
-slsr_process_cast (gimple gs, tree rhs1, bool speed)
+slsr_process_cast (gimple *gs, tree rhs1, bool speed)
 {
   tree lhs, ctype;
   slsr_cand_t base_cand, c, c2;
@@ -1609,7 +1609,7 @@ slsr_process_cast (gimple gs, tree rhs1, bool speed)
    propagation, such as DOM.  */
 
 static void
-slsr_process_copy (gimple gs, tree rhs1, bool speed)
+slsr_process_copy (gimple *gs, tree rhs1, bool speed)
 {
   slsr_cand_t base_cand, c, c2;
   unsigned savings = 0;
@@ -1679,7 +1679,7 @@ find_candidates_dom_walker::before_dom_children (basic_block bb)
 
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple gs = gsi_stmt (gsi);
+      gimple *gs = gsi_stmt (gsi);
 
       if (gimple_vuse (gs) && gimple_assign_single_p (gs))
 	slsr_process_ref (gs);
@@ -2033,7 +2033,7 @@ replace_mult_candidate (slsr_cand_t c, tree basis_name, widest_int bump)
     {
       enum tree_code code = PLUS_EXPR;
       tree bump_tree;
-      gimple stmt_to_print = NULL;
+      gimple *stmt_to_print = NULL;
 
       /* If the basis name and the candidate's LHS have incompatible
 	 types, introduce a cast.  */
@@ -2056,7 +2056,7 @@ replace_mult_candidate (slsr_cand_t c, tree basis_name, widest_int bump)
       if (bump == 0)
 	{
 	  tree lhs = gimple_assign_lhs (c->cand_stmt);
-	  gimple copy_stmt = gimple_build_assign (lhs, basis_name);
+	  gimple *copy_stmt = gimple_build_assign (lhs, basis_name);
 	  gimple_stmt_iterator gsi = gsi_for_stmt (c->cand_stmt);
 	  gimple_set_location (copy_stmt, gimple_location (c->cand_stmt));
 	  gsi_replace (&gsi, copy_stmt, false);
@@ -2155,7 +2155,7 @@ create_add_on_incoming_edge (slsr_cand_t c, tree basis_name,
   basic_block insert_bb;
   gimple_stmt_iterator gsi;
   tree lhs, basis_type;
-  gimple new_stmt;
+  gimple *new_stmt;
 
   /* If the add candidate along this incoming edge has the same
      index as C's hidden basis, the hidden basis represents this
@@ -2234,12 +2234,12 @@ create_add_on_incoming_edge (slsr_cand_t c, tree basis_name,
    constant.  */
 
 static tree
-create_phi_basis (slsr_cand_t c, gimple from_phi, tree basis_name,
+create_phi_basis (slsr_cand_t c, gimple *from_phi, tree basis_name,
 		  location_t loc, bool known_stride)
 {
   int i;
   tree name, phi_arg;
-  gimple phi;
+  gimple *phi;
   vec<tree> phi_args;
   slsr_cand_t basis = lookup_cand (c->basis);
   int nargs = gimple_phi_num_args (from_phi);
@@ -2268,7 +2268,7 @@ create_phi_basis (slsr_cand_t c, gimple from_phi, tree basis_name,
 	  }
       else
 	{
-	  gimple arg_def = SSA_NAME_DEF_STMT (arg);
+	  gimple *arg_def = SSA_NAME_DEF_STMT (arg);
 
 	  /* If there is another phi along this incoming edge, we must
 	     process it in the same fashion to ensure that all basis
@@ -2349,7 +2349,7 @@ replace_conditional_candidate (slsr_cand_t c)
    for those phis as well.  */
 
 static int
-phi_add_costs (gimple phi, slsr_cand_t c, int one_add_cost)
+phi_add_costs (gimple *phi, slsr_cand_t c, int one_add_cost)
 {
   unsigned i;
   int cost = 0;
@@ -2373,7 +2373,7 @@ phi_add_costs (gimple phi, slsr_cand_t c, int one_add_cost)
 
       if (arg != phi_cand->base_expr)
 	{
-	  gimple arg_def = SSA_NAME_DEF_STMT (arg);
+	  gimple *arg_def = SSA_NAME_DEF_STMT (arg);
 
 	  if (gimple_code (arg_def) == GIMPLE_PHI)
 	    cost += phi_add_costs (arg_def, c, one_add_cost);
@@ -2410,7 +2410,7 @@ replace_uncond_cands_and_profitable_phis (slsr_cand_t c)
 	     savings to determine profitability.  */
 	  bool speed = optimize_bb_for_speed_p (gimple_bb (c->cand_stmt));
 	  int mult_savings = stmt_cost (c->cand_stmt, speed);
-	  gimple phi = lookup_cand (c->def_phi)->cand_stmt;
+	  gimple *phi = lookup_cand (c->def_phi)->cand_stmt;
 	  tree phi_result = gimple_phi_result (phi);
 	  int one_add_cost = add_cost (speed, 
 				       TYPE_MODE (TREE_TYPE (phi_result)));
@@ -2561,7 +2561,7 @@ record_increment (slsr_cand_t c, widest_int increment, bool is_phi_adjust)
    index of the basis.  */
 
 static void
-record_phi_increments (slsr_cand_t basis, gimple phi)
+record_phi_increments (slsr_cand_t basis, gimple *phi)
 {
   unsigned i;
   slsr_cand_t phi_cand = base_cand_from_table (gimple_phi_result (phi));
@@ -2572,7 +2572,7 @@ record_phi_increments (slsr_cand_t basis, gimple phi)
 
       if (!operand_equal_p (arg, phi_cand->base_expr, 0))
 	{
-	  gimple arg_def = SSA_NAME_DEF_STMT (arg);
+	  gimple *arg_def = SSA_NAME_DEF_STMT (arg);
 
 	  if (gimple_code (arg_def) == GIMPLE_PHI)
 	    record_phi_increments (basis, arg_def);
@@ -2630,7 +2630,7 @@ record_increments (slsr_cand_t c)
    uses.  */
 
 static int
-phi_incr_cost (slsr_cand_t c, const widest_int &incr, gimple phi, int *savings)
+phi_incr_cost (slsr_cand_t c, const widest_int &incr, gimple *phi, int *savings)
 {
   unsigned i;
   int cost = 0;
@@ -2643,7 +2643,7 @@ phi_incr_cost (slsr_cand_t c, const widest_int &incr, gimple phi, int *savings)
 
       if (!operand_equal_p (arg, phi_cand->base_expr, 0))
 	{
-	  gimple arg_def = SSA_NAME_DEF_STMT (arg);
+	  gimple *arg_def = SSA_NAME_DEF_STMT (arg);
       
 	  if (gimple_code (arg_def) == GIMPLE_PHI)
 	    {
@@ -2736,7 +2736,7 @@ lowest_cost_path (int cost_in, int repl_savings, slsr_cand_t c,
       && phi_dependent_cand_p (c)
       && !cand_already_replaced (c))
     {
-      gimple phi = lookup_cand (c->def_phi)->cand_stmt;
+      gimple *phi = lookup_cand (c->def_phi)->cand_stmt;
       local_cost += phi_incr_cost (c, incr, phi, &savings);
 
       if (has_single_use (gimple_phi_result (phi)))
@@ -2780,7 +2780,7 @@ total_savings (int repl_savings, slsr_cand_t c, const widest_int &incr,
       && !cand_already_replaced (c))
     {
       int phi_savings = 0;
-      gimple phi = lookup_cand (c->def_phi)->cand_stmt;
+      gimple *phi = lookup_cand (c->def_phi)->cand_stmt;
       savings -= phi_incr_cost (c, incr, phi, &phi_savings);
 
       if (has_single_use (gimple_phi_result (phi)))
@@ -2974,7 +2974,7 @@ ncd_for_two_cands (basic_block bb1, basic_block bb2,
    candidates, return the earliest candidate in the block in *WHERE.  */
 
 static basic_block
-ncd_with_phi (slsr_cand_t c, const widest_int &incr, gimple phi,
+ncd_with_phi (slsr_cand_t c, const widest_int &incr, gimple *phi,
 	      basic_block ncd, slsr_cand_t *where)
 {
   unsigned i;
@@ -2987,7 +2987,7 @@ ncd_with_phi (slsr_cand_t c, const widest_int &incr, gimple phi,
 
       if (!operand_equal_p (arg, phi_cand->base_expr, 0))
 	{
-	  gimple arg_def = SSA_NAME_DEF_STMT (arg);
+	  gimple *arg_def = SSA_NAME_DEF_STMT (arg);
 
 	  if (gimple_code (arg_def) == GIMPLE_PHI)
 	    ncd = ncd_with_phi (c, incr, arg_def, ncd, where);
@@ -3112,7 +3112,7 @@ insert_initializers (slsr_cand_t c)
     {
       basic_block bb;
       slsr_cand_t where = NULL;
-      gimple init_stmt;
+      gimple *init_stmt;
       tree stride_type, new_name, incr_tree;
       widest_int incr = incr_vec[i].incr;
 
@@ -3161,7 +3161,7 @@ insert_initializers (slsr_cand_t c)
       else
 	{
 	  gimple_stmt_iterator gsi = gsi_last_bb (bb);
-	  gimple basis_stmt = lookup_cand (c->basis)->cand_stmt;
+	  gimple *basis_stmt = lookup_cand (c->basis)->cand_stmt;
 
 	  if (!gsi_end_p (gsi) && is_ctrl_stmt (gsi_stmt (gsi)))
 	    gsi_insert_before (&gsi, init_stmt, GSI_SAME_STMT);
@@ -3183,7 +3183,7 @@ insert_initializers (slsr_cand_t c)
    are profitable to replace on behalf of candidate C.  */
 
 static bool
-all_phi_incrs_profitable (slsr_cand_t c, gimple phi)
+all_phi_incrs_profitable (slsr_cand_t c, gimple *phi)
 {
   unsigned i;
   slsr_cand_t basis = lookup_cand (c->basis);
@@ -3195,7 +3195,7 @@ all_phi_incrs_profitable (slsr_cand_t c, gimple phi)
 
       if (!operand_equal_p (arg, phi_cand->base_expr, 0))
 	{
-	  gimple arg_def = SSA_NAME_DEF_STMT (arg);
+	  gimple *arg_def = SSA_NAME_DEF_STMT (arg);
 
 	  if (gimple_code (arg_def) == GIMPLE_PHI)
 	    {
@@ -3250,7 +3250,7 @@ static tree
 introduce_cast_before_cand (slsr_cand_t c, tree to_type, tree from_expr)
 {
   tree cast_lhs;
-  gimple cast_stmt;
+  gimple *cast_stmt;
   gimple_stmt_iterator gsi = gsi_for_stmt (c->cand_stmt);
 
   cast_lhs = make_temp_ssa_name (to_type, NULL, "slsr");
@@ -3275,7 +3275,7 @@ introduce_cast_before_cand (slsr_cand_t c, tree to_type, tree from_expr)
    If the replacement was made and we are doing a details dump,
    return the revised statement, else NULL.  */
 
-static gimple
+static gimple *
 replace_rhs_if_not_dup (enum tree_code new_code, tree new_rhs1, tree new_rhs2,
 			enum tree_code old_code, tree old_rhs1, tree old_rhs2,
 			slsr_cand_t c)
@@ -3310,7 +3310,7 @@ replace_rhs_if_not_dup (enum tree_code new_code, tree new_rhs1, tree new_rhs2,
 static void
 replace_one_candidate (slsr_cand_t c, unsigned i, tree basis_name)
 {
-  gimple stmt_to_print = NULL;
+  gimple *stmt_to_print = NULL;
   tree orig_rhs1, orig_rhs2;
   tree rhs2;
   enum tree_code orig_code, repl_code;
@@ -3412,7 +3412,7 @@ replace_one_candidate (slsr_cand_t c, unsigned i, tree basis_name)
       
       if (types_compatible_p (lhs_type, basis_type))
 	{
-	  gimple copy_stmt = gimple_build_assign (lhs, basis_name);
+	  gimple *copy_stmt = gimple_build_assign (lhs, basis_name);
 	  gimple_stmt_iterator gsi = gsi_for_stmt (c->cand_stmt);
 	  gimple_set_location (copy_stmt, gimple_location (c->cand_stmt));
 	  gsi_replace (&gsi, copy_stmt, false);
@@ -3424,7 +3424,7 @@ replace_one_candidate (slsr_cand_t c, unsigned i, tree basis_name)
       else
 	{
 	  gimple_stmt_iterator gsi = gsi_for_stmt (c->cand_stmt);
-	  gimple cast_stmt = gimple_build_assign_with_ops (NOP_EXPR, lhs,
+	  gimple *cast_stmt = gimple_build_assign_with_ops (NOP_EXPR, lhs,
 							   basis_name,
 							   NULL_TREE);
 	  gimple_set_location (cast_stmt, gimple_location (c->cand_stmt));
@@ -3469,7 +3469,7 @@ replace_profitable_candidates (slsr_cand_t c)
 	{
 	  if (phi_dependent_cand_p (c))
 	    {
-	      gimple phi = lookup_cand (c->def_phi)->cand_stmt;
+	      gimple *phi = lookup_cand (c->def_phi)->cand_stmt;
 
 	      if (all_phi_incrs_profitable (c, phi))
 		{
diff --git a/gcc/gimple-ssa.h b/gcc/gimple-ssa.h
index 21d6426..0c7ebc4 100644
--- a/gcc/gimple-ssa.h
+++ b/gcc/gimple-ssa.h
@@ -27,7 +27,7 @@ along with GCC; see the file COPYING3.  If not see
    or list of labels to represent transaction restart.  */
 
 struct GTY(()) tm_restart_node {
-  gimple stmt;
+  gimple *stmt;
   tree label_or_list;
 };
 
@@ -40,7 +40,7 @@ struct GTY(()) gimple_df {
      indirect call has been turned into a noreturn call.  When this
      happens, all the instructions after the call are no longer
      reachable and must be deleted as dead.  */
-  vec<gimple, va_gc> *modified_noreturn_calls;
+  vec<gimple *, va_gc> *modified_noreturn_calls;
 
   /* Array of all SSA_NAMEs used in the function.  */
   vec<tree, va_gc> *ssa_names;
@@ -105,7 +105,7 @@ gimple_vop (const struct function *fun)
 /* Return the set of VUSE operand for statement G.  */
 
 static inline use_operand_p
-gimple_vuse_op (const_gimple g)
+gimple_vuse_op (const gimple *g)
 {
   struct use_optype_d *ops;
   const gimple_with_memory_ops *mem_ops_stmt =
@@ -122,7 +122,7 @@ gimple_vuse_op (const_gimple g)
 /* Return the set of VDEF operand for statement G.  */
 
 static inline def_operand_p
-gimple_vdef_op (gimple g)
+gimple_vdef_op (gimple *g)
 {
   gimple_with_memory_ops *mem_ops_stmt =
      dyn_cast <gimple_with_memory_ops *> (g);
@@ -136,7 +136,7 @@ gimple_vdef_op (gimple g)
 /* Mark statement S as modified, and update it.  */
 
 static inline void
-update_stmt (gimple s)
+update_stmt (gimple *s)
 {
   if (gimple_has_ops (s))
     {
@@ -148,7 +148,7 @@ update_stmt (gimple s)
 /* Update statement S if it has been optimized.  */
 
 static inline void
-update_stmt_if_modified (gimple s)
+update_stmt_if_modified (gimple *s)
 {
   if (gimple_modified_p (s))
     update_stmt_operands (cfun, s);
@@ -157,7 +157,7 @@ update_stmt_if_modified (gimple s)
 /* Mark statement S as modified, and update it.  */
 
 static inline void
-update_stmt_fn (struct function *fn, gimple s)
+update_stmt_fn (struct function *fn, gimple *s)
 {
   if (gimple_has_ops (s))
     {
diff --git a/gcc/gimple-streamer-in.c b/gcc/gimple-streamer-in.c
index 5c685f4..1e79ff8 100644
--- a/gcc/gimple-streamer-in.c
+++ b/gcc/gimple-streamer-in.c
@@ -44,14 +44,14 @@ along with GCC; see the file COPYING3.  If not see
 /* Read a PHI function for basic block BB in function FN.  DATA_IN is
    the file being read.  IB is the input block to use for reading.  */
 
-static gimple
+static gimple *
 input_phi (struct lto_input_block *ib, basic_block bb, struct data_in *data_in,
 	   struct function *fn)
 {
   unsigned HOST_WIDE_INT ix;
   tree phi_result;
   int i, len;
-  gimple result;
+  gimple *result;
 
   ix = streamer_read_uhwi (ib);
   phi_result = (*SSANAMES (fn))[ix];
@@ -89,11 +89,11 @@ input_phi (struct lto_input_block *ib, basic_block bb, struct data_in *data_in,
 /* Read a statement with tag TAG in function FN from block IB using
    descriptors in DATA_IN.  */
 
-static gimple
+static gimple *
 input_gimple_stmt (struct lto_input_block *ib, struct data_in *data_in,
 		   enum LTO_tags tag)
 {
-  gimple stmt;
+  gimple *stmt;
   enum gimple_code code;
   unsigned HOST_WIDE_INT num_ops;
   size_t i;
@@ -273,7 +273,7 @@ input_bb (struct lto_input_block *ib, enum LTO_tags tag,
   tag = streamer_read_record_start (ib);
   while (tag)
     {
-      gimple stmt = input_gimple_stmt (ib, data_in, tag);
+      gimple *stmt = input_gimple_stmt (ib, data_in, tag);
       gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
 
       /* After the statement, expect a 0 delimiter or the EH region
diff --git a/gcc/gimple-streamer-out.c b/gcc/gimple-streamer-out.c
index 85a7966..5750d5f 100644
--- a/gcc/gimple-streamer-out.c
+++ b/gcc/gimple-streamer-out.c
@@ -41,7 +41,7 @@ along with GCC; see the file COPYING3.  If not see
 /* Output PHI function PHI to the main stream in OB.  */
 
 static void
-output_phi (struct output_block *ob, gimple phi)
+output_phi (struct output_block *ob, gimple *phi)
 {
   unsigned i, len = gimple_phi_num_args (phi);
 
@@ -62,7 +62,7 @@ output_phi (struct output_block *ob, gimple phi)
 /* Emit statement STMT on the main stream of output block OB.  */
 
 static void
-output_gimple_stmt (struct output_block *ob, gimple stmt)
+output_gimple_stmt (struct output_block *ob, gimple *stmt)
 {
   unsigned i;
   enum gimple_code code;
@@ -210,7 +210,7 @@ output_bb (struct output_block *ob, basic_block bb, struct function *fn)
       for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
 	{
 	  int region;
-	  gimple stmt = gsi_stmt (bsi);
+	  gimple *stmt = gsi_stmt (bsi);
 
 	  output_gimple_stmt (ob, stmt);
 
@@ -229,7 +229,7 @@ output_bb (struct output_block *ob, basic_block bb, struct function *fn)
 
       for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
 	{
-	  gimple phi = gsi_stmt (bsi);
+	  gimple *phi = gsi_stmt (bsi);
 
 	  /* Only emit PHIs for gimple registers.  PHI nodes for .MEM
 	     will be filled in on reading when the SSA form is
diff --git a/gcc/gimple-walk.c b/gcc/gimple-walk.c
index b6f0495..60df505 100644
--- a/gcc/gimple-walk.c
+++ b/gcc/gimple-walk.c
@@ -47,7 +47,7 @@ along with GCC; see the file COPYING3.  If not see
 
    Otherwise, all the statements are walked and NULL returned.  */
 
-gimple
+gimple *
 walk_gimple_seq_mod (gimple_seq *pseq, walk_stmt_fn callback_stmt,
 		     walk_tree_fn callback_op, struct walk_stmt_info *wi)
 {
@@ -80,12 +80,12 @@ walk_gimple_seq_mod (gimple_seq *pseq, walk_stmt_fn callback_stmt,
 /* Like walk_gimple_seq_mod, but ensure that the head of SEQ isn't
    changed by the callbacks.  */
 
-gimple
+gimple *
 walk_gimple_seq (gimple_seq seq, walk_stmt_fn callback_stmt,
 		 walk_tree_fn callback_op, struct walk_stmt_info *wi)
 {
   gimple_seq seq2 = seq;
-  gimple ret = walk_gimple_seq_mod (&seq2, callback_stmt, callback_op, wi);
+  gimple *ret = walk_gimple_seq_mod (&seq2, callback_stmt, callback_op, wi);
   gcc_assert (seq2 == seq);
   return ret;
 }
@@ -94,7 +94,7 @@ walk_gimple_seq (gimple_seq seq, walk_stmt_fn callback_stmt,
 /* Helper function for walk_gimple_stmt.  Walk operands of a GIMPLE_ASM.  */
 
 static tree
-walk_gimple_asm (gimple stmt, walk_tree_fn callback_op,
+walk_gimple_asm (gimple *stmt, walk_tree_fn callback_op,
 		 struct walk_stmt_info *wi)
 {
   tree ret, op;
@@ -177,7 +177,7 @@ walk_gimple_asm (gimple stmt, walk_tree_fn callback_op,
    NULL_TREE if no CALLBACK_OP is specified.  */
 
 tree
-walk_gimple_op (gimple stmt, walk_tree_fn callback_op,
+walk_gimple_op (gimple *stmt, walk_tree_fn callback_op,
 		struct walk_stmt_info *wi)
 {
   struct pointer_set_t *pset = (wi) ? wi->pset : NULL;
@@ -494,9 +494,9 @@ tree
 walk_gimple_stmt (gimple_stmt_iterator *gsi, walk_stmt_fn callback_stmt,
 		  walk_tree_fn callback_op, struct walk_stmt_info *wi)
 {
-  gimple ret;
+  gimple *ret;
   tree tree_ret;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
 
   if (wi)
     {
@@ -656,7 +656,7 @@ get_base_loadstore (tree op)
    Returns the results of these callbacks or'ed.  */
 
 bool
-walk_stmt_load_store_addr_ops (gimple stmt, void *data,
+walk_stmt_load_store_addr_ops (gimple *stmt, void *data,
 			       walk_stmt_load_store_addr_fn visit_load,
 			       walk_stmt_load_store_addr_fn visit_store,
 			       walk_stmt_load_store_addr_fn visit_addr)
@@ -874,7 +874,7 @@ walk_stmt_load_store_addr_ops (gimple stmt, void *data,
    should make a faster clone for this case.  */
 
 bool
-walk_stmt_load_store_ops (gimple stmt, void *data,
+walk_stmt_load_store_ops (gimple *stmt, void *data,
 			  walk_stmt_load_store_addr_fn visit_load,
 			  walk_stmt_load_store_addr_fn visit_store)
 {
diff --git a/gcc/gimple-walk.h b/gcc/gimple-walk.h
index 555eb18..9337249 100644
--- a/gcc/gimple-walk.h
+++ b/gcc/gimple-walk.h
@@ -82,19 +82,19 @@ struct walk_stmt_info
 typedef tree (*walk_stmt_fn) (gimple_stmt_iterator *, bool *,
 			      struct walk_stmt_info *);
 
-extern gimple walk_gimple_seq_mod (gimple_seq *, walk_stmt_fn, walk_tree_fn,
+extern gimple *walk_gimple_seq_mod (gimple_seq *, walk_stmt_fn, walk_tree_fn,
 				   struct walk_stmt_info *);
-extern gimple walk_gimple_seq (gimple_seq, walk_stmt_fn, walk_tree_fn,
+extern gimple *walk_gimple_seq (gimple_seq, walk_stmt_fn, walk_tree_fn,
 			       struct walk_stmt_info *);
-extern tree walk_gimple_op (gimple, walk_tree_fn, struct walk_stmt_info *);
+extern tree walk_gimple_op (gimple *, walk_tree_fn, struct walk_stmt_info *);
 extern tree walk_gimple_stmt (gimple_stmt_iterator *, walk_stmt_fn,
 			      walk_tree_fn, struct walk_stmt_info *);
-typedef bool (*walk_stmt_load_store_addr_fn) (gimple, tree, tree, void *);
-extern bool walk_stmt_load_store_addr_ops (gimple, void *,
+typedef bool (*walk_stmt_load_store_addr_fn) (gimple *, tree, tree, void *);
+extern bool walk_stmt_load_store_addr_ops (gimple *, void *,
 					   walk_stmt_load_store_addr_fn,
 					   walk_stmt_load_store_addr_fn,
 					   walk_stmt_load_store_addr_fn);
-extern bool walk_stmt_load_store_ops (gimple, void *,
+extern bool walk_stmt_load_store_ops (gimple *, void *,
 				      walk_stmt_load_store_addr_fn,
 				      walk_stmt_load_store_addr_fn);
 #endif /* GCC_GIMPLE_WALK_H */
diff --git a/gcc/gimple.c b/gcc/gimple.c
index cba2d1b..281815c 100644
--- a/gcc/gimple.c
+++ b/gcc/gimple.c
@@ -98,7 +98,7 @@ static const char * const gimple_alloc_kind_names[] = {
 /* Set the code for statement G to CODE.  */
 
 static inline void
-gimple_set_code (gimple g, enum gimple_code code)
+gimple_set_code (gimple *g, enum gimple_code code)
 {
   g->code = code;
 }
@@ -115,11 +115,11 @@ gimple_size (enum gimple_code code)
 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
    operands.  */
 
-gimple
+gimple *
 gimple_alloc_stat (enum gimple_code code, unsigned num_ops MEM_STAT_DECL)
 {
   size_t size;
-  gimple stmt;
+  gimple *stmt;
 
   size = gimple_size (code);
   if (num_ops > 0)
@@ -147,7 +147,7 @@ gimple_alloc_stat (enum gimple_code code, unsigned num_ops MEM_STAT_DECL)
 /* Set SUBCODE to be the code of the expression computed by statement G.  */
 
 static inline void
-gimple_set_subcode (gimple g, unsigned subcode)
+gimple_set_subcode (gimple *g, unsigned subcode)
 {
   /* We only have 16 bits for the RHS code.  Assert that we are not
      overflowing it.  */
@@ -164,11 +164,11 @@ gimple_set_subcode (gimple g, unsigned subcode)
 #define gimple_build_with_ops(c, s, n) \
   gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
 
-static gimple
+static gimple *
 gimple_build_with_ops_stat (enum gimple_code code, unsigned subcode,
 		            unsigned num_ops MEM_STAT_DECL)
 {
-  gimple s = gimple_alloc_stat (code, num_ops PASS_MEM_STAT);
+  gimple *s = gimple_alloc_stat (code, num_ops PASS_MEM_STAT);
   gimple_set_subcode (s, subcode);
 
   return s;
@@ -177,10 +177,10 @@ gimple_build_with_ops_stat (enum gimple_code code, unsigned subcode,
 
 /* Build a GIMPLE_RETURN statement returning RETVAL.  */
 
-gimple
+gimple *
 gimple_build_return (tree retval)
 {
-  gimple s = gimple_build_with_ops (GIMPLE_RETURN, ERROR_MARK, 1);
+  gimple *s = gimple_build_with_ops (GIMPLE_RETURN, ERROR_MARK, 1);
   if (retval)
     gimple_return_set_retval (s, retval);
   return s;
@@ -189,7 +189,7 @@ gimple_build_return (tree retval)
 /* Reset alias information on call S.  */
 
 void
-gimple_call_reset_alias_info (gimple s)
+gimple_call_reset_alias_info (gimple *s)
 {
   if (gimple_call_flags (s) & ECF_CONST)
     memset (gimple_call_use_set (s), 0, sizeof (struct pt_solution));
@@ -206,10 +206,10 @@ gimple_call_reset_alias_info (gimple s)
    components of a GIMPLE_CALL statement to function FN with NARGS
    arguments.  */
 
-static inline gimple
+static inline gimple *
 gimple_build_call_1 (tree fn, unsigned nargs)
 {
-  gimple s = gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK, nargs + 3);
+  gimple *s = gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK, nargs + 3);
   if (TREE_CODE (fn) == FUNCTION_DECL)
     fn = build_fold_addr_expr (fn);
   gimple_set_op (s, 1, fn);
@@ -222,12 +222,12 @@ gimple_build_call_1 (tree fn, unsigned nargs)
 /* Build a GIMPLE_CALL statement to function FN with the arguments
    specified in vector ARGS.  */
 
-gimple
+gimple *
 gimple_build_call_vec (tree fn, vec<tree> args)
 {
   unsigned i;
   unsigned nargs = args.length ();
-  gimple call = gimple_build_call_1 (fn, nargs);
+  gimple *call = gimple_build_call_1 (fn, nargs);
 
   for (i = 0; i < nargs; i++)
     gimple_call_set_arg (call, i, args[i]);
@@ -239,11 +239,11 @@ gimple_build_call_vec (tree fn, vec<tree> args)
 /* Build a GIMPLE_CALL statement to function FN.  NARGS is the number of
    arguments.  The ... are the arguments.  */
 
-gimple
+gimple *
 gimple_build_call (tree fn, unsigned nargs, ...)
 {
   va_list ap;
-  gimple call;
+  gimple *call;
   unsigned i;
 
   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
@@ -262,10 +262,10 @@ gimple_build_call (tree fn, unsigned nargs, ...)
 /* Build a GIMPLE_CALL statement to function FN.  NARGS is the number of
    arguments.  AP contains the arguments.  */
 
-gimple
+gimple *
 gimple_build_call_valist (tree fn, unsigned nargs, va_list ap)
 {
-  gimple call;
+  gimple *call;
   unsigned i;
 
   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
@@ -283,10 +283,10 @@ gimple_build_call_valist (tree fn, unsigned nargs, va_list ap)
    Build the basic components of a GIMPLE_CALL statement to internal
    function FN with NARGS arguments.  */
 
-static inline gimple
+static inline gimple *
 gimple_build_call_internal_1 (enum internal_fn fn, unsigned nargs)
 {
-  gimple s = gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK, nargs + 3);
+  gimple *s = gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK, nargs + 3);
   s->subcode |= GF_CALL_INTERNAL;
   gimple_call_set_internal_fn (s, fn);
   gimple_call_reset_alias_info (s);
@@ -297,11 +297,11 @@ gimple_build_call_internal_1 (enum internal_fn fn, unsigned nargs)
 /* Build a GIMPLE_CALL statement to internal function FN.  NARGS is
    the number of arguments.  The ... are the arguments.  */
 
-gimple
+gimple *
 gimple_build_call_internal (enum internal_fn fn, unsigned nargs, ...)
 {
   va_list ap;
-  gimple call;
+  gimple *call;
   unsigned i;
 
   call = gimple_build_call_internal_1 (fn, nargs);
@@ -317,11 +317,11 @@ gimple_build_call_internal (enum internal_fn fn, unsigned nargs, ...)
 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
    specified in vector ARGS.  */
 
-gimple
+gimple *
 gimple_build_call_internal_vec (enum internal_fn fn, vec<tree> args)
 {
   unsigned i, nargs;
-  gimple call;
+  gimple *call;
 
   nargs = args.length ();
   call = gimple_build_call_internal_1 (fn, nargs);
@@ -336,11 +336,11 @@ gimple_build_call_internal_vec (enum internal_fn fn, vec<tree> args)
    assumed to be in GIMPLE form already.  Minimal checking is done of
    this fact.  */
 
-gimple
+gimple *
 gimple_build_call_from_tree (tree t)
 {
   unsigned i, nargs;
-  gimple call;
+  gimple *call;
   tree fndecl = get_callee_fndecl (t);
 
   gcc_assert (TREE_CODE (t) == CALL_EXPR);
@@ -377,7 +377,7 @@ gimple_build_call_from_tree (tree t)
    LHS of the assignment.
    RHS of the assignment which can be unary or binary.  */
 
-gimple
+gimple *
 gimple_build_assign_stat (tree lhs, tree rhs MEM_STAT_DECL)
 {
   enum tree_code subcode;
@@ -393,12 +393,12 @@ gimple_build_assign_stat (tree lhs, tree rhs MEM_STAT_DECL)
    OP1 and OP2.  If OP2 is NULL then SUBCODE must be of class
    GIMPLE_UNARY_RHS or GIMPLE_SINGLE_RHS.  */
 
-gimple
+gimple *
 gimple_build_assign_with_ops (enum tree_code subcode, tree lhs, tree op1,
 			      tree op2, tree op3 MEM_STAT_DECL)
 {
   unsigned num_ops;
-  gimple p;
+  gimple *p;
 
   /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
      code).  */
@@ -423,7 +423,7 @@ gimple_build_assign_with_ops (enum tree_code subcode, tree lhs, tree op1,
   return p;
 }
 
-gimple
+gimple *
 gimple_build_assign_with_ops (enum tree_code subcode, tree lhs, tree op1,
 			      tree op2 MEM_STAT_DECL)
 {
@@ -438,11 +438,11 @@ gimple_build_assign_with_ops (enum tree_code subcode, tree lhs, tree op1,
    T_LABEL is the label to jump to if the condition is true.
    F_LABEL is the label to jump to otherwise.  */
 
-gimple
+gimple *
 gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs,
 		   tree t_label, tree f_label)
 {
-  gimple p;
+  gimple *p;
 
   gcc_assert (TREE_CODE_CLASS (pred_code) == tcc_comparison);
   p = gimple_build_with_ops (GIMPLE_COND, pred_code, 4);
@@ -456,7 +456,7 @@ gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs,
 /* Build a GIMPLE_COND statement from the conditional expression tree
    COND.  T_LABEL and F_LABEL are as in gimple_build_cond.  */
 
-gimple
+gimple *
 gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
 {
   enum tree_code code;
@@ -470,7 +470,7 @@ gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
    boolean expression tree COND.  */
 
 void
-gimple_cond_set_condition_from_tree (gimple stmt, tree cond)
+gimple_cond_set_condition_from_tree (gimple *stmt, tree cond)
 {
   enum tree_code code;
   tree lhs, rhs;
@@ -481,20 +481,20 @@ gimple_cond_set_condition_from_tree (gimple stmt, tree cond)
 
 /* Build a GIMPLE_LABEL statement for LABEL.  */
 
-gimple
+gimple *
 gimple_build_label (tree label)
 {
-  gimple p = gimple_build_with_ops (GIMPLE_LABEL, ERROR_MARK, 1);
+  gimple *p = gimple_build_with_ops (GIMPLE_LABEL, ERROR_MARK, 1);
   gimple_label_set_label (p, label);
   return p;
 }
 
 /* Build a GIMPLE_GOTO statement to label DEST.  */
 
-gimple
+gimple *
 gimple_build_goto (tree dest)
 {
-  gimple p = gimple_build_with_ops (GIMPLE_GOTO, ERROR_MARK, 1);
+  gimple *p = gimple_build_with_ops (GIMPLE_GOTO, ERROR_MARK, 1);
   gimple_goto_set_dest (p, dest);
   return p;
 }
@@ -502,7 +502,7 @@ gimple_build_goto (tree dest)
 
 /* Build a GIMPLE_NOP statement.  */
 
-gimple
+gimple *
 gimple_build_nop (void)
 {
   return gimple_alloc (GIMPLE_NOP, 0);
@@ -513,10 +513,10 @@ gimple_build_nop (void)
    VARS are the variables in BODY.
    BLOCK is the containing block.  */
 
-gimple
+gimple *
 gimple_build_bind (tree vars, gimple_seq body, tree block)
 {
-  gimple p = gimple_alloc (GIMPLE_BIND, 0);
+  gimple *p = gimple_alloc (GIMPLE_BIND, 0);
   gimple_bind_set_vars (p, vars);
   if (body)
     gimple_bind_set_body (p, body);
@@ -533,7 +533,7 @@ gimple_build_bind (tree vars, gimple_seq body, tree block)
    NCLOBBERS is the number of clobbered registers.
    */
 
-static inline gimple
+static inline gimple *
 gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs,
                     unsigned nclobbers, unsigned nlabels)
 {
@@ -571,12 +571,12 @@ gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs,
    CLOBBERS is a vector of the clobbered register parameters.
    LABELS is a vector of destination labels.  */
 
-gimple
+gimple *
 gimple_build_asm_vec (const char *string, vec<tree, va_gc> *inputs,
                       vec<tree, va_gc> *outputs, vec<tree, va_gc> *clobbers,
 		      vec<tree, va_gc> *labels)
 {
-  gimple p;
+  gimple *p;
   unsigned i;
 
   p = gimple_build_asm_1 (string,
@@ -605,10 +605,10 @@ gimple_build_asm_vec (const char *string, vec<tree, va_gc> *inputs,
   TYPES are the catch types.
   HANDLER is the exception handler.  */
 
-gimple
+gimple *
 gimple_build_catch (tree types, gimple_seq handler)
 {
-  gimple p = gimple_alloc (GIMPLE_CATCH, 0);
+  gimple *p = gimple_alloc (GIMPLE_CATCH, 0);
   gimple_catch_set_types (p, types);
   if (handler)
     gimple_catch_set_handler (p, handler);
@@ -621,10 +621,10 @@ gimple_build_catch (tree types, gimple_seq handler)
    TYPES are the filter's types.
    FAILURE is the filter's failure action.  */
 
-gimple
+gimple *
 gimple_build_eh_filter (tree types, gimple_seq failure)
 {
-  gimple p = gimple_alloc (GIMPLE_EH_FILTER, 0);
+  gimple *p = gimple_alloc (GIMPLE_EH_FILTER, 0);
   gimple_eh_filter_set_types (p, types);
   if (failure)
     gimple_eh_filter_set_failure (p, failure);
@@ -634,10 +634,10 @@ gimple_build_eh_filter (tree types, gimple_seq failure)
 
 /* Build a GIMPLE_EH_MUST_NOT_THROW statement.  */
 
-gimple
+gimple *
 gimple_build_eh_must_not_throw (tree decl)
 {
-  gimple p = gimple_alloc (GIMPLE_EH_MUST_NOT_THROW, 0);
+  gimple *p = gimple_alloc (GIMPLE_EH_MUST_NOT_THROW, 0);
 
   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
   gcc_assert (flags_from_decl_or_type (decl) & ECF_NORETURN);
@@ -648,10 +648,10 @@ gimple_build_eh_must_not_throw (tree decl)
 
 /* Build a GIMPLE_EH_ELSE statement.  */
 
-gimple
+gimple *
 gimple_build_eh_else (gimple_seq n_body, gimple_seq e_body)
 {
-  gimple p = gimple_alloc (GIMPLE_EH_ELSE, 0);
+  gimple *p = gimple_alloc (GIMPLE_EH_ELSE, 0);
   gimple_eh_else_set_n_body (p, n_body);
   gimple_eh_else_set_e_body (p, e_body);
   return p;
@@ -685,10 +685,10 @@ gimple_build_try (gimple_seq eval, gimple_seq cleanup,
 
    CLEANUP is the cleanup expression.  */
 
-gimple
+gimple *
 gimple_build_wce (gimple_seq cleanup)
 {
-  gimple p = gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR, 0);
+  gimple *p = gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR, 0);
   if (cleanup)
     gimple_wce_set_cleanup (p, cleanup);
 
@@ -698,7 +698,7 @@ gimple_build_wce (gimple_seq cleanup)
 
 /* Build a GIMPLE_RESX statement.  */
 
-gimple
+gimple *
 gimple_build_resx (int region)
 {
   gresx *p =
@@ -714,12 +714,12 @@ gimple_build_resx (int region)
    NLABELS is the number of labels in the switch excluding the default.
    DEFAULT_LABEL is the default label for the switch statement.  */
 
-gimple
+gimple *
 gimple_build_switch_nlabels (unsigned nlabels, tree index, tree default_label)
 {
   /* nlabels + 1 default label + 1 index.  */
   gcc_checking_assert (default_label);
-  gimple p = gimple_build_with_ops (GIMPLE_SWITCH, ERROR_MARK,
+  gimple *p = gimple_build_with_ops (GIMPLE_SWITCH, ERROR_MARK,
 				    1 + 1 + nlabels);
   gimple_switch_set_index (p, index);
   gimple_switch_set_default_label (p, default_label);
@@ -732,12 +732,12 @@ gimple_build_switch_nlabels (unsigned nlabels, tree index, tree default_label)
    DEFAULT_LABEL is the default label
    ARGS is a vector of labels excluding the default.  */
 
-gimple
+gimple *
 gimple_build_switch (tree index, tree default_label, vec<tree> args)
 {
   unsigned i, nlabels = args.length ();
 
-  gimple p = gimple_build_switch_nlabels (nlabels, index, default_label);
+  gimple *p = gimple_build_switch_nlabels (nlabels, index, default_label);
 
   /* Copy the labels from the vector to the switch statement.  */
   for (i = 0; i < nlabels; i++)
@@ -748,7 +748,7 @@ gimple_build_switch (tree index, tree default_label, vec<tree> args)
 
 /* Build a GIMPLE_EH_DISPATCH statement.  */
 
-gimple
+gimple *
 gimple_build_eh_dispatch (int region)
 {
   geh_dispatch *p =
@@ -762,10 +762,10 @@ gimple_build_eh_dispatch (int region)
 
    VAR is bound to VALUE; block and location are taken from STMT.  */
 
-gimple
-gimple_build_debug_bind_stat (tree var, tree value, gimple stmt MEM_STAT_DECL)
+gimple *
+gimple_build_debug_bind_stat (tree var, tree value, gimple *stmt MEM_STAT_DECL)
 {
-  gimple p = gimple_build_with_ops_stat (GIMPLE_DEBUG,
+  gimple *p = gimple_build_with_ops_stat (GIMPLE_DEBUG,
 					 (unsigned)GIMPLE_DEBUG_BIND, 2
 					 PASS_MEM_STAT);
 
@@ -782,11 +782,11 @@ gimple_build_debug_bind_stat (tree var, tree value, gimple stmt MEM_STAT_DECL)
 
    VAR is bound to VALUE; block and location are taken from STMT.  */
 
-gimple
+gimple *
 gimple_build_debug_source_bind_stat (tree var, tree value,
-				     gimple stmt MEM_STAT_DECL)
+				     gimple *stmt MEM_STAT_DECL)
 {
-  gimple p = gimple_build_with_ops_stat (GIMPLE_DEBUG,
+  gimple *p = gimple_build_with_ops_stat (GIMPLE_DEBUG,
 					 (unsigned)GIMPLE_DEBUG_SOURCE_BIND, 2
 					 PASS_MEM_STAT);
 
@@ -804,10 +804,10 @@ gimple_build_debug_source_bind_stat (tree var, tree value,
    BODY is the sequence of statements for which only one thread can execute.
    NAME is optional identifier for this critical block.  */
 
-gimple
+gimple *
 gimple_build_omp_critical (gimple_seq body, tree name)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_CRITICAL, 0);
+  gimple *p = gimple_alloc (GIMPLE_OMP_CRITICAL, 0);
   gimple_omp_critical_set_name (p, name);
   if (body)
     gimple_omp_set_body (p, body);
@@ -824,7 +824,7 @@ gimple_build_omp_critical (gimple_seq body, tree name)
    COLLAPSE is the collapse count.
    PRE_BODY is the sequence of statements that are loop invariant.  */
 
-gimple
+gimple *
 gimple_build_omp_for (gimple_seq body, int kind, tree clauses, size_t collapse,
 		      gimple_seq pre_body)
 {
@@ -852,11 +852,11 @@ gimple_build_omp_for (gimple_seq body, int kind, tree clauses, size_t collapse,
    CHILD_FN is the function created for the parallel threads to execute.
    DATA_ARG are the shared data argument(s).  */
 
-gimple
+gimple *
 gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn,
 			   tree data_arg)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_PARALLEL, 0);
+  gimple *p = gimple_alloc (GIMPLE_OMP_PARALLEL, 0);
   if (body)
     gimple_omp_set_body (p, body);
   gimple_omp_parallel_set_clauses (p, clauses);
@@ -876,12 +876,12 @@ gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn,
    COPY_FN is the optional function for firstprivate initialization.
    ARG_SIZE and ARG_ALIGN are size and alignment of the data block.  */
 
-gimple
+gimple *
 gimple_build_omp_task (gimple_seq body, tree clauses, tree child_fn,
 		       tree data_arg, tree copy_fn, tree arg_size,
 		       tree arg_align)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_TASK, 0);
+  gimple *p = gimple_alloc (GIMPLE_OMP_TASK, 0);
   if (body)
     gimple_omp_set_body (p, body);
   gimple_omp_task_set_clauses (p, clauses);
@@ -899,10 +899,10 @@ gimple_build_omp_task (gimple_seq body, tree clauses, tree child_fn,
 
    BODY is the sequence of statements in the section.  */
 
-gimple
+gimple *
 gimple_build_omp_section (gimple_seq body)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_SECTION, 0);
+  gimple *p = gimple_alloc (GIMPLE_OMP_SECTION, 0);
   if (body)
     gimple_omp_set_body (p, body);
 
@@ -914,10 +914,10 @@ gimple_build_omp_section (gimple_seq body)
 
    BODY is the sequence of statements to be executed by just the master.  */
 
-gimple
+gimple *
 gimple_build_omp_master (gimple_seq body)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_MASTER, 0);
+  gimple *p = gimple_alloc (GIMPLE_OMP_MASTER, 0);
   if (body)
     gimple_omp_set_body (p, body);
 
@@ -930,10 +930,10 @@ gimple_build_omp_master (gimple_seq body)
    BODY is the sequence of statements to be executed by the taskgroup
    construct.  */
 
-gimple
+gimple *
 gimple_build_omp_taskgroup (gimple_seq body)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_TASKGROUP, 0);
+  gimple *p = gimple_alloc (GIMPLE_OMP_TASKGROUP, 0);
   if (body)
     gimple_omp_set_body (p, body);
 
@@ -946,10 +946,10 @@ gimple_build_omp_taskgroup (gimple_seq body)
    CONTROL_DEF is the definition of the control variable.
    CONTROL_USE is the use of the control variable.  */
 
-gimple
+gimple *
 gimple_build_omp_continue (tree control_def, tree control_use)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_CONTINUE, 0);
+  gimple *p = gimple_alloc (GIMPLE_OMP_CONTINUE, 0);
   gimple_omp_continue_set_control_def (p, control_def);
   gimple_omp_continue_set_control_use (p, control_use);
   return p;
@@ -960,10 +960,10 @@ gimple_build_omp_continue (tree control_def, tree control_use)
    BODY is the sequence of statements inside a loop that will executed in
    sequence.  */
 
-gimple
+gimple *
 gimple_build_omp_ordered (gimple_seq body)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_ORDERED, 0);
+  gimple *p = gimple_alloc (GIMPLE_OMP_ORDERED, 0);
   if (body)
     gimple_omp_set_body (p, body);
 
@@ -974,10 +974,10 @@ gimple_build_omp_ordered (gimple_seq body)
 /* Build a GIMPLE_OMP_RETURN statement.
    WAIT_P is true if this is a non-waiting return.  */
 
-gimple
+gimple *
 gimple_build_omp_return (bool wait_p)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_RETURN, 0);
+  gimple *p = gimple_alloc (GIMPLE_OMP_RETURN, 0);
   if (wait_p)
     gimple_omp_return_set_nowait (p);
 
@@ -991,10 +991,10 @@ gimple_build_omp_return (bool wait_p)
    CLAUSES are any of the OMP sections contsruct's clauses: private,
    firstprivate, lastprivate, reduction, and nowait.  */
 
-gimple
+gimple *
 gimple_build_omp_sections (gimple_seq body, tree clauses)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_SECTIONS, 0);
+  gimple *p = gimple_alloc (GIMPLE_OMP_SECTIONS, 0);
   if (body)
     gimple_omp_set_body (p, body);
   gimple_omp_sections_set_clauses (p, clauses);
@@ -1005,7 +1005,7 @@ gimple_build_omp_sections (gimple_seq body, tree clauses)
 
 /* Build a GIMPLE_OMP_SECTIONS_SWITCH.  */
 
-gimple
+gimple *
 gimple_build_omp_sections_switch (void)
 {
   return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH, 0);
@@ -1018,10 +1018,10 @@ gimple_build_omp_sections_switch (void)
    CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
    copyprivate, nowait.  */
 
-gimple
+gimple *
 gimple_build_omp_single (gimple_seq body, tree clauses)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_SINGLE, 0);
+  gimple *p = gimple_alloc (GIMPLE_OMP_SINGLE, 0);
   if (body)
     gimple_omp_set_body (p, body);
   gimple_omp_single_set_clauses (p, clauses);
@@ -1035,10 +1035,10 @@ gimple_build_omp_single (gimple_seq body, tree clauses)
    BODY is the sequence of statements that will be executed.
    CLAUSES are any of the OMP target construct's clauses.  */
 
-gimple
+gimple *
 gimple_build_omp_target (gimple_seq body, int kind, tree clauses)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_TARGET, 0);
+  gimple *p = gimple_alloc (GIMPLE_OMP_TARGET, 0);
   if (body)
     gimple_omp_set_body (p, body);
   gimple_omp_target_set_clauses (p, clauses);
@@ -1053,10 +1053,10 @@ gimple_build_omp_target (gimple_seq body, int kind, tree clauses)
    BODY is the sequence of statements that will be executed.
    CLAUSES are any of the OMP teams construct's clauses.  */
 
-gimple
+gimple *
 gimple_build_omp_teams (gimple_seq body, tree clauses)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_TEAMS, 0);
+  gimple *p = gimple_alloc (GIMPLE_OMP_TEAMS, 0);
   if (body)
     gimple_omp_set_body (p, body);
   gimple_omp_teams_set_clauses (p, clauses);
@@ -1067,10 +1067,10 @@ gimple_build_omp_teams (gimple_seq body, tree clauses)
 
 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement.  */
 
-gimple
+gimple *
 gimple_build_omp_atomic_load (tree lhs, tree rhs)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD, 0);
+  gimple *p = gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD, 0);
   gimple_omp_atomic_load_set_lhs (p, lhs);
   gimple_omp_atomic_load_set_rhs (p, rhs);
   return p;
@@ -1080,20 +1080,20 @@ gimple_build_omp_atomic_load (tree lhs, tree rhs)
 
    VAL is the value we are storing.  */
 
-gimple
+gimple *
 gimple_build_omp_atomic_store (tree val)
 {
-  gimple p = gimple_alloc (GIMPLE_OMP_ATOMIC_STORE, 0);
+  gimple *p = gimple_alloc (GIMPLE_OMP_ATOMIC_STORE, 0);
   gimple_omp_atomic_store_set_val (p, val);
   return p;
 }
 
 /* Build a GIMPLE_TRANSACTION statement.  */
 
-gimple
+gimple *
 gimple_build_transaction (gimple_seq body, tree label)
 {
-  gimple p = gimple_alloc (GIMPLE_TRANSACTION, 0);
+  gimple *p = gimple_alloc (GIMPLE_TRANSACTION, 0);
   gimple_transaction_set_body (p, body);
   gimple_transaction_set_label (p, label);
   return p;
@@ -1102,10 +1102,10 @@ gimple_build_transaction (gimple_seq body, tree label)
 /* Build a GIMPLE_PREDICT statement.  PREDICT is one of the predictors from
    predict.def, OUTCOME is NOT_TAKEN or TAKEN.  */
 
-gimple
+gimple *
 gimple_build_predict (enum br_predictor predictor, enum prediction outcome)
 {
-  gimple p = gimple_alloc (GIMPLE_PREDICT, 0);
+  gimple *p = gimple_alloc (GIMPLE_PREDICT, 0);
   /* Ensure all the predictors fit into the lower bits of the subcode.  */
   gcc_assert ((int) END_PREDICTORS <= GF_PREDICT_TAKEN);
   gimple_predict_set_predictor (p, predictor);
@@ -1117,7 +1117,7 @@ gimple_build_predict (enum br_predictor predictor, enum prediction outcome)
 /* Complain of a gimple type mismatch and die.  */
 
 void
-gimple_check_failed (const_gimple gs, const char *file, int line,
+gimple_check_failed (const gimple *gs, const char *file, int line,
 		     const char *function, enum gimple_code code,
 		     enum tree_code subcode)
 {
@@ -1137,7 +1137,7 @@ gimple_check_failed (const_gimple gs, const char *file, int line,
    *SEQ_P is NULL, a new sequence is allocated.  */
 
 void
-gimple_seq_add_stmt (gimple_seq *seq_p, gimple gs)
+gimple_seq_add_stmt (gimple_seq *seq_p, gimple *gs)
 {
   gimple_stmt_iterator si;
   if (gs == NULL)
@@ -1154,7 +1154,7 @@ gimple_seq_add_stmt (gimple_seq *seq_p, gimple gs)
    before the def/use vectors have been constructed.  */
 
 void
-gimple_seq_add_stmt_without_update (gimple_seq *seq_p, gimple gs)
+gimple_seq_add_stmt_without_update (gimple_seq *seq_p, gimple *gs)
 {
   gimple_stmt_iterator si;
 
@@ -1182,7 +1182,7 @@ gimple_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
 /* Determine whether to assign a location to the statement GS.  */
 
 static bool
-should_carry_location_p (gimple gs)
+should_carry_location_p (gimple *gs)
 {
   /* Don't emit a line note for a label.  We particularly don't want to
      emit one for the break label, since it doesn't actually correspond
@@ -1196,7 +1196,7 @@ should_carry_location_p (gimple gs)
 /* Set the location for gimple statement GS to LOCATION.  */
 
 static void
-annotate_one_with_location (gimple gs, location_t location)
+annotate_one_with_location (gimple *gs, location_t location)
 {
   if (!gimple_has_location (gs)
       && !gimple_do_not_emit_location_p (gs)
@@ -1233,7 +1233,7 @@ annotate_all_with_location (gimple_seq stmt_p, location_t location)
 
   for (i = gsi_start (stmt_p); !gsi_end_p (i); gsi_next (&i))
     {
-      gimple gs = gsi_stmt (i);
+      gimple *gs = gsi_stmt (i);
       annotate_one_with_location (gs, location);
     }
 }
@@ -1242,7 +1242,7 @@ annotate_all_with_location (gimple_seq stmt_p, location_t location)
    statement.  */
 
 static bool
-empty_stmt_p (gimple stmt)
+empty_stmt_p (gimple *stmt)
 {
   if (gimple_code (stmt) == GIMPLE_NOP)
     return true;
@@ -1277,7 +1277,7 @@ gimple_seq_copy (gimple_seq src)
 {
   gimple_stmt_iterator gsi;
   gimple_seq new_seq = NULL;
-  gimple stmt;
+  gimple *stmt;
 
   for (gsi = gsi_start (src); !gsi_end_p (gsi); gsi_next (&gsi))
     {
@@ -1293,7 +1293,7 @@ gimple_seq_copy (gimple_seq src)
 /* Return true if calls C1 and C2 are known to go to the same function.  */
 
 bool
-gimple_call_same_target_p (const_gimple c1, const_gimple c2)
+gimple_call_same_target_p (const gimple *c1, const gimple *c2)
 {
   if (gimple_call_internal_p (c1))
     return (gimple_call_internal_p (c2)
@@ -1308,7 +1308,7 @@ gimple_call_same_target_p (const_gimple c1, const_gimple c2)
    call_expr_flags, but for gimple tuples.  */
 
 int
-gimple_call_flags (const_gimple stmt)
+gimple_call_flags (const gimple *stmt)
 {
   int flags;
   tree decl = gimple_call_fndecl (stmt);
@@ -1329,7 +1329,7 @@ gimple_call_flags (const_gimple stmt)
 /* Return the "fn spec" string for call STMT.  */
 
 static tree
-gimple_call_fnspec (const_gimple stmt)
+gimple_call_fnspec (const gimple *stmt)
 {
   tree type, attr;
 
@@ -1347,7 +1347,7 @@ gimple_call_fnspec (const_gimple stmt)
 /* Detects argument flags for argument number ARG on call STMT.  */
 
 int
-gimple_call_arg_flags (const_gimple stmt, unsigned arg)
+gimple_call_arg_flags (const gimple *stmt, unsigned arg)
 {
   tree attr = gimple_call_fnspec (stmt);
 
@@ -1381,7 +1381,7 @@ gimple_call_arg_flags (const_gimple stmt, unsigned arg)
 /* Detects return flags for the call STMT.  */
 
 int
-gimple_call_return_flags (const_gimple stmt)
+gimple_call_return_flags (const gimple *stmt)
 {
   tree attr;
 
@@ -1413,7 +1413,7 @@ gimple_call_return_flags (const_gimple stmt)
 /* Return true if GS is a copy assignment.  */
 
 bool
-gimple_assign_copy_p (gimple gs)
+gimple_assign_copy_p (gimple *gs)
 {
   return (gimple_assign_single_p (gs)
 	  && is_gimple_val (gimple_op (gs, 1)));
@@ -1423,7 +1423,7 @@ gimple_assign_copy_p (gimple gs)
 /* Return true if GS is a SSA_NAME copy assignment.  */
 
 bool
-gimple_assign_ssa_name_copy_p (gimple gs)
+gimple_assign_ssa_name_copy_p (gimple *gs)
 {
   return (gimple_assign_single_p (gs)
 	  && TREE_CODE (gimple_assign_lhs (gs)) == SSA_NAME
@@ -1446,7 +1446,7 @@ gimple_assign_ssa_name_copy_p (gimple gs)
    treatment of unary NOPs is appropriate.  */
 
 bool
-gimple_assign_unary_nop_p (gimple gs)
+gimple_assign_unary_nop_p (gimple *gs)
 {
   return (is_gimple_assign (gs)
           && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs))
@@ -1459,7 +1459,7 @@ gimple_assign_unary_nop_p (gimple gs)
 /* Set BB to be the basic block holding G.  */
 
 void
-gimple_set_bb (gimple stmt, basic_block bb)
+gimple_set_bb (gimple *stmt, basic_block bb)
 {
   stmt->bb = bb;
 
@@ -1533,13 +1533,13 @@ gimple_assign_set_rhs_with_ops_1 (gimple_stmt_iterator *gsi, enum tree_code code
 				  tree op1, tree op2, tree op3)
 {
   unsigned new_rhs_ops = get_gimple_rhs_num_ops (code);
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
 
   /* If the new CODE needs more operands, allocate a new statement.  */
   if (gimple_num_ops (stmt) < new_rhs_ops + 1)
     {
       tree lhs = gimple_assign_lhs (stmt);
-      gimple new_stmt = gimple_alloc (gimple_code (stmt), new_rhs_ops + 1);
+      gimple *new_stmt = gimple_alloc (gimple_code (stmt), new_rhs_ops + 1);
       memcpy (new_stmt, stmt, gimple_size (gimple_code (stmt)));
       gimple_init_singleton (new_stmt);
       gsi_replace (gsi, new_stmt, true);
@@ -1566,7 +1566,7 @@ gimple_assign_set_rhs_with_ops_1 (gimple_stmt_iterator *gsi, enum tree_code code
    statement other than an assignment or a call.  */
 
 tree
-gimple_get_lhs (const_gimple stmt)
+gimple_get_lhs (const gimple *stmt)
 {
   enum gimple_code code = gimple_code (stmt);
 
@@ -1583,7 +1583,7 @@ gimple_get_lhs (const_gimple stmt)
    either a GIMPLE_ASSIGN or a GIMPLE_CALL.  */
 
 void
-gimple_set_lhs (gimple stmt, tree lhs)
+gimple_set_lhs (gimple *stmt, tree lhs)
 {
   enum gimple_code code = gimple_code (stmt);
 
@@ -1601,12 +1601,12 @@ gimple_set_lhs (gimple stmt, tree lhs)
    and VUSE operand arrays are set to empty in the new copy.  The new
    copy isn't part of any sequence.  */
 
-gimple
-gimple_copy (gimple stmt)
+gimple *
+gimple_copy (gimple *stmt)
 {
   enum gimple_code code = gimple_code (stmt);
   unsigned num_ops = gimple_num_ops (stmt);
-  gimple copy = gimple_alloc (code, num_ops);
+  gimple *copy = gimple_alloc (code, num_ops);
   unsigned i;
 
   /* Shallow copy all the fields from STMT.  */
@@ -1777,7 +1777,7 @@ gimple_copy (gimple stmt)
    - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS.  */
 
 bool
-gimple_has_side_effects (const_gimple s)
+gimple_has_side_effects (const gimple *s)
 {
   if (is_gimple_debug (s))
     return false;
@@ -1813,7 +1813,7 @@ gimple_has_side_effects (const_gimple s)
    S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked.  */
 
 bool
-gimple_could_trap_p_1 (gimple s, bool include_mem, bool include_stores)
+gimple_could_trap_p_1 (gimple *s, bool include_mem, bool include_stores)
 {
   tree t, div = NULL_TREE;
   enum tree_code op;
@@ -1859,7 +1859,7 @@ gimple_could_trap_p_1 (gimple s, bool include_mem, bool include_stores)
 /* Return true if statement S can trap.  */
 
 bool
-gimple_could_trap_p (gimple s)
+gimple_could_trap_p (gimple *s)
 {
   return gimple_could_trap_p_1 (s, true, true);
 }
@@ -1867,7 +1867,7 @@ gimple_could_trap_p (gimple s)
 /* Return true if RHS of a GIMPLE_ASSIGN S can trap.  */
 
 bool
-gimple_assign_rhs_could_trap_p (gimple s)
+gimple_assign_rhs_could_trap_p (gimple *s)
 {
   gcc_assert (is_gimple_assign (s));
   return gimple_could_trap_p_1 (s, true, false);
@@ -2002,13 +2002,13 @@ canonicalize_cond_expr_cond (tree t)
 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
    the positions marked by the set ARGS_TO_SKIP.  */
 
-gimple
-gimple_call_copy_skip_args (gimple stmt, bitmap args_to_skip)
+gimple *
+gimple_call_copy_skip_args (gimple *stmt, bitmap args_to_skip)
 {
   int i;
   int nargs = gimple_call_num_args (stmt);
   auto_vec<tree> vargs (nargs);
-  gimple new_stmt;
+  gimple *new_stmt;
 
   for (i = 0; i < nargs; i++)
     if (!bitmap_bit_p (args_to_skip, i))
@@ -2327,7 +2327,7 @@ gimple_get_alias_set (tree t)
 /* Helper for gimple_ior_addresses_taken_1.  */
 
 static bool
-gimple_ior_addresses_taken_1 (gimple, tree addr, tree, void *data)
+gimple_ior_addresses_taken_1 (gimple *, tree addr, tree, void *data)
 {
   bitmap addresses_taken = (bitmap)data;
   addr = get_base_address (addr);
@@ -2345,7 +2345,7 @@ gimple_ior_addresses_taken_1 (gimple, tree addr, tree, void *data)
    were any in this stmt.  */
 
 bool
-gimple_ior_addresses_taken (bitmap addresses_taken, gimple stmt)
+gimple_ior_addresses_taken (bitmap addresses_taken, gimple *stmt)
 {
   return walk_stmt_load_store_addr_ops (stmt, addresses_taken, NULL, NULL,
 					gimple_ior_addresses_taken_1);
@@ -2374,7 +2374,7 @@ validate_type (tree type1, tree type2)
    a decl of a builtin function.  */
 
 bool
-gimple_builtin_call_types_compatible_p (const_gimple stmt, tree fndecl)
+gimple_builtin_call_types_compatible_p (const gimple *stmt, tree fndecl)
 {
   gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN);
 
@@ -2403,7 +2403,7 @@ gimple_builtin_call_types_compatible_p (const_gimple stmt, tree fndecl)
 /* Return true when STMT is builtins call.  */
 
 bool
-gimple_call_builtin_p (const_gimple stmt)
+gimple_call_builtin_p (const gimple *stmt)
 {
   tree fndecl;
   if (is_gimple_call (stmt)
@@ -2416,7 +2416,7 @@ gimple_call_builtin_p (const_gimple stmt)
 /* Return true when STMT is builtins call to CLASS.  */
 
 bool
-gimple_call_builtin_p (const_gimple stmt, enum built_in_class klass)
+gimple_call_builtin_p (const gimple *stmt, enum built_in_class klass)
 {
   tree fndecl;
   if (is_gimple_call (stmt)
@@ -2429,7 +2429,7 @@ gimple_call_builtin_p (const_gimple stmt, enum built_in_class klass)
 /* Return true when STMT is builtins call to CODE of CLASS.  */
 
 bool
-gimple_call_builtin_p (const_gimple stmt, enum built_in_function code)
+gimple_call_builtin_p (const gimple *stmt, enum built_in_function code)
 {
   tree fndecl;
   if (is_gimple_call (stmt)
@@ -2444,7 +2444,7 @@ gimple_call_builtin_p (const_gimple stmt, enum built_in_function code)
    GIMPLE_ASM.  */
 
 bool
-gimple_asm_clobbers_memory_p (const_gimple stmt)
+gimple_asm_clobbers_memory_p (const gimple *stmt)
 {
   unsigned i;
 
@@ -2485,7 +2485,7 @@ dump_decl_set (FILE *file, bitmap set)
 /* Return true when CALL is a call stmt that definitely doesn't
    free any memory or makes it unavailable otherwise.  */
 bool
-nonfreeing_call_p (gimple call)
+nonfreeing_call_p (gimple *call)
 {
   if (gimple_call_builtin_p (call, BUILT_IN_NORMAL)
       && gimple_call_flags (call) & ECF_LEAF)
@@ -2512,7 +2512,7 @@ nonfreeing_call_p (gimple call)
    This routine only makes a superficial check for a dereference.  Thus
    it must only be used if it is safe to return a false negative.  */
 static bool
-check_loadstore (gimple, tree op, tree, void *data)
+check_loadstore (gimple *, tree op, tree, void *data)
 {
   if ((TREE_CODE (op) == MEM_REF || TREE_CODE (op) == TARGET_MEM_REF)
       && operand_equal_p (TREE_OPERAND (op, 0), (tree)data, 0))
@@ -2529,7 +2529,7 @@ check_loadstore (gimple, tree op, tree, void *data)
    for function arguments and return values.  FALSE otherwise.  */
 
 bool
-infer_nonnull_range (gimple stmt, tree op, bool dereference, bool attribute)
+infer_nonnull_range (gimple *stmt, tree op, bool dereference, bool attribute)
 {
   /* We can only assume that a pointer dereference will yield
      non-NULL if -fdelete-null-pointer-checks is enabled.  */
diff --git a/gcc/gimple.h b/gcc/gimple.h
index 1635ab5..173f1b4 100644
--- a/gcc/gimple.h
+++ b/gcc/gimple.h
@@ -22,11 +22,11 @@ along with GCC; see the file COPYING3.  If not see
 #ifndef GCC_GIMPLE_H
 #define GCC_GIMPLE_H
 
-typedef gimple gimple_seq_node;
+typedef gimple *gimple_seq_node;
 
 /* For each block, the PHI nodes that need to be rewritten are stored into
    these vectors.  */
-typedef vec<gimple> gimple_vec;
+typedef vec<gimple *> gimple_vec;
 
 enum gimple_code {
 #define DEFGSCODE(SYM, STRING, STRUCT)	SYM,
@@ -41,13 +41,13 @@ extern const unsigned char gimple_rhs_class_table[];
 /* Error out if a gimple tuple is addressed incorrectly.  */
 #if defined ENABLE_GIMPLE_CHECKING
 #define gcc_gimple_checking_assert(EXPR) gcc_assert (EXPR)
-extern void gimple_check_failed (const_gimple, const char *, int,          \
+extern void gimple_check_failed (const gimple *, const char *, int,          \
                                  const char *, enum gimple_code,           \
 				 enum tree_code) ATTRIBUTE_NORETURN;
 
 #define GIMPLE_CHECK(GS, CODE)						\
   do {									\
-    const_gimple __gs = (GS);						\
+    const gimple *__gs = (GS);						\
     if (gimple_code (__gs) != (CODE))					\
       gimple_check_failed (__gs, __FILE__, __LINE__, __FUNCTION__,	\
 	  		   (CODE), ERROR_MARK);				\
@@ -197,8 +197,8 @@ struct GTY((desc ("gimple_statement_structure (&%h)"), tag ("GSS_BASE"),
      A gimple statement is hence also a double-ended list of
      statements, with the pointer itself being the first element,
      and the prev pointer being the last.  */
-  gimple next;
-  gimple GTY((skip)) prev;
+  gimple *next;
+  gimple *GTY((skip)) prev;
 };
 
 
@@ -767,7 +767,7 @@ enum gimple_statement_structure_enum {
 template <>
 template <>
 inline bool
-is_a_helper <gasm *>::test (gimple gs)
+is_a_helper <gasm *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_ASM;
 }
@@ -775,7 +775,7 @@ is_a_helper <gasm *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gbind *>::test (gimple gs)
+is_a_helper <gbind *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_BIND;
 }
@@ -783,7 +783,7 @@ is_a_helper <gbind *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gcall *>::test (gimple gs)
+is_a_helper <gcall *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_CALL;
 }
@@ -791,7 +791,7 @@ is_a_helper <gcall *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gcatch *>::test (gimple gs)
+is_a_helper <gcatch *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_CATCH;
 }
@@ -799,7 +799,7 @@ is_a_helper <gcatch *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gresx *>::test (gimple gs)
+is_a_helper <gresx *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_RESX;
 }
@@ -807,7 +807,7 @@ is_a_helper <gresx *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <geh_dispatch *>::test (gimple gs)
+is_a_helper <geh_dispatch *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_EH_DISPATCH;
 }
@@ -815,7 +815,7 @@ is_a_helper <geh_dispatch *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <geh_else *>::test (gimple gs)
+is_a_helper <geh_else *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_EH_ELSE;
 }
@@ -823,7 +823,7 @@ is_a_helper <geh_else *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <geh_filter *>::test (gimple gs)
+is_a_helper <geh_filter *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_EH_FILTER;
 }
@@ -831,7 +831,7 @@ is_a_helper <geh_filter *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <geh_mnt *>::test (gimple gs)
+is_a_helper <geh_mnt *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_EH_MUST_NOT_THROW;
 }
@@ -839,7 +839,7 @@ is_a_helper <geh_mnt *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gomp_atomic_load *>::test (gimple gs)
+is_a_helper <gomp_atomic_load *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_ATOMIC_LOAD;
 }
@@ -847,7 +847,7 @@ is_a_helper <gomp_atomic_load *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gomp_atomic_store *>::test (gimple gs)
+is_a_helper <gomp_atomic_store *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_ATOMIC_STORE;
 }
@@ -855,7 +855,7 @@ is_a_helper <gomp_atomic_store *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gomp_return *>::test (gimple gs)
+is_a_helper <gomp_return *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_RETURN;
 }
@@ -863,7 +863,7 @@ is_a_helper <gomp_return *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gomp_continue *>::test (gimple gs)
+is_a_helper <gomp_continue *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_CONTINUE;
 }
@@ -871,7 +871,7 @@ is_a_helper <gomp_continue *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gomp_critical *>::test (gimple gs)
+is_a_helper <gomp_critical *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_CRITICAL;
 }
@@ -879,7 +879,7 @@ is_a_helper <gomp_critical *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gomp_for *>::test (gimple gs)
+is_a_helper <gomp_for *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_FOR;
 }
@@ -887,7 +887,7 @@ is_a_helper <gomp_for *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gomp_taskreg *>::test (gimple gs)
+is_a_helper <gomp_taskreg *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_PARALLEL || gs->code == GIMPLE_OMP_TASK;
 }
@@ -895,7 +895,7 @@ is_a_helper <gomp_taskreg *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gomp_parallel *>::test (gimple gs)
+is_a_helper <gomp_parallel *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_PARALLEL;
 }
@@ -903,7 +903,7 @@ is_a_helper <gomp_parallel *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gomp_target *>::test (gimple gs)
+is_a_helper <gomp_target *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_TARGET;
 }
@@ -911,7 +911,7 @@ is_a_helper <gomp_target *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gomp_sections *>::test (gimple gs)
+is_a_helper <gomp_sections *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_SECTIONS;
 }
@@ -919,7 +919,7 @@ is_a_helper <gomp_sections *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gomp_single *>::test (gimple gs)
+is_a_helper <gomp_single *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_SINGLE;
 }
@@ -927,7 +927,7 @@ is_a_helper <gomp_single *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gomp_teams *>::test (gimple gs)
+is_a_helper <gomp_teams *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_TEAMS;
 }
@@ -935,7 +935,7 @@ is_a_helper <gomp_teams *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gomp_task *>::test (gimple gs)
+is_a_helper <gomp_task *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_TASK;
 }
@@ -943,7 +943,7 @@ is_a_helper <gomp_task *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gphi *>::test (gimple gs)
+is_a_helper <gphi *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_PHI;
 }
@@ -951,7 +951,7 @@ is_a_helper <gphi *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gtransaction *>::test (gimple gs)
+is_a_helper <gtransaction *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_TRANSACTION;
 }
@@ -959,7 +959,7 @@ is_a_helper <gtransaction *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gtry *>::test (gimple gs)
+is_a_helper <gtry *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_TRY;
 }
@@ -967,7 +967,7 @@ is_a_helper <gtry *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gwce *>::test (gimple gs)
+is_a_helper <gwce *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_WITH_CLEANUP_EXPR;
 }
@@ -975,7 +975,7 @@ is_a_helper <gwce *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gasm *>::test (const_gimple gs)
+is_a_helper <const gasm *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_ASM;
 }
@@ -983,7 +983,7 @@ is_a_helper <const gasm *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gbind *>::test (const_gimple gs)
+is_a_helper <const gbind *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_BIND;
 }
@@ -991,7 +991,7 @@ is_a_helper <const gbind *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gcall *>::test (const_gimple gs)
+is_a_helper <const gcall *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_CALL;
 }
@@ -999,7 +999,7 @@ is_a_helper <const gcall *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gcatch *>::test (const_gimple gs)
+is_a_helper <const gcatch *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_CATCH;
 }
@@ -1007,7 +1007,7 @@ is_a_helper <const gcatch *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gresx *>::test (const_gimple gs)
+is_a_helper <const gresx *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_RESX;
 }
@@ -1015,7 +1015,7 @@ is_a_helper <const gresx *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const geh_dispatch *>::test (const_gimple gs)
+is_a_helper <const geh_dispatch *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_EH_DISPATCH;
 }
@@ -1023,7 +1023,7 @@ is_a_helper <const geh_dispatch *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const geh_filter *>::test (const_gimple gs)
+is_a_helper <const geh_filter *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_EH_FILTER;
 }
@@ -1031,7 +1031,7 @@ is_a_helper <const geh_filter *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gomp_atomic_load *>::test (const_gimple gs)
+is_a_helper <const gomp_atomic_load *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_ATOMIC_LOAD;
 }
@@ -1039,7 +1039,7 @@ is_a_helper <const gomp_atomic_load *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gomp_atomic_store *>::test (const_gimple gs)
+is_a_helper <const gomp_atomic_store *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_ATOMIC_STORE;
 }
@@ -1047,7 +1047,7 @@ is_a_helper <const gomp_atomic_store *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gomp_return *>::test (const_gimple gs)
+is_a_helper <const gomp_return *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_RETURN;
 }
@@ -1055,7 +1055,7 @@ is_a_helper <const gomp_return *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gomp_continue *>::test (const_gimple gs)
+is_a_helper <const gomp_continue *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_CONTINUE;
 }
@@ -1063,7 +1063,7 @@ is_a_helper <const gomp_continue *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gomp_critical *>::test (const_gimple gs)
+is_a_helper <const gomp_critical *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_CRITICAL;
 }
@@ -1071,7 +1071,7 @@ is_a_helper <const gomp_critical *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gomp_for *>::test (const_gimple gs)
+is_a_helper <const gomp_for *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_FOR;
 }
@@ -1079,7 +1079,7 @@ is_a_helper <const gomp_for *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gomp_taskreg *>::test (const_gimple gs)
+is_a_helper <const gomp_taskreg *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_PARALLEL || gs->code == GIMPLE_OMP_TASK;
 }
@@ -1087,7 +1087,7 @@ is_a_helper <const gomp_taskreg *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gomp_parallel *>::test (const_gimple gs)
+is_a_helper <const gomp_parallel *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_PARALLEL;
 }
@@ -1095,7 +1095,7 @@ is_a_helper <const gomp_parallel *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gomp_target *>::test (const_gimple gs)
+is_a_helper <const gomp_target *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_TARGET;
 }
@@ -1103,7 +1103,7 @@ is_a_helper <const gomp_target *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gomp_sections *>::test (const_gimple gs)
+is_a_helper <const gomp_sections *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_SECTIONS;
 }
@@ -1111,7 +1111,7 @@ is_a_helper <const gomp_sections *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gomp_single *>::test (const_gimple gs)
+is_a_helper <const gomp_single *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_SINGLE;
 }
@@ -1119,7 +1119,7 @@ is_a_helper <const gomp_single *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gomp_teams *>::test (const_gimple gs)
+is_a_helper <const gomp_teams *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_TEAMS;
 }
@@ -1127,7 +1127,7 @@ is_a_helper <const gomp_teams *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gomp_task *>::test (const_gimple gs)
+is_a_helper <const gomp_task *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_TASK;
 }
@@ -1135,7 +1135,7 @@ is_a_helper <const gomp_task *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gphi *>::test (const_gimple gs)
+is_a_helper <const gphi *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_PHI;
 }
@@ -1143,7 +1143,7 @@ is_a_helper <const gphi *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gtransaction *>::test (const_gimple gs)
+is_a_helper <const gtransaction *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_TRANSACTION;
 }
@@ -1157,113 +1157,113 @@ extern enum gimple_statement_structure_enum const gss_for_code_[];
 
 /* This variable holds the currently expanded gimple statement for purposes
    of comminucating the profile info to the builtin expanders.  */
-extern gimple currently_expanding_gimple_stmt;
+extern gimple *currently_expanding_gimple_stmt;
 
 #define gimple_alloc(c, n) gimple_alloc_stat (c, n MEM_STAT_INFO)
-gimple gimple_alloc_stat (enum gimple_code, unsigned MEM_STAT_DECL);
-gimple gimple_build_return (tree);
-void gimple_call_reset_alias_info (gimple);
-gimple gimple_build_call_vec (tree, vec<tree> );
-gimple gimple_build_call (tree, unsigned, ...);
-gimple gimple_build_call_valist (tree, unsigned, va_list);
-gimple gimple_build_call_internal (enum internal_fn, unsigned, ...);
-gimple gimple_build_call_internal_vec (enum internal_fn, vec<tree> );
-gimple gimple_build_call_from_tree (tree);
-gimple gimple_build_assign_stat (tree, tree MEM_STAT_DECL);
+gimple *gimple_alloc_stat (enum gimple_code, unsigned MEM_STAT_DECL);
+gimple *gimple_build_return (tree);
+void gimple_call_reset_alias_info (gimple *);
+gimple *gimple_build_call_vec (tree, vec<tree> );
+gimple *gimple_build_call (tree, unsigned, ...);
+gimple *gimple_build_call_valist (tree, unsigned, va_list);
+gimple *gimple_build_call_internal (enum internal_fn, unsigned, ...);
+gimple *gimple_build_call_internal_vec (enum internal_fn, vec<tree> );
+gimple *gimple_build_call_from_tree (tree);
+gimple *gimple_build_assign_stat (tree, tree MEM_STAT_DECL);
 #define gimple_build_assign(l,r) gimple_build_assign_stat (l, r MEM_STAT_INFO)
-gimple gimple_build_assign_with_ops (enum tree_code, tree,
+gimple *gimple_build_assign_with_ops (enum tree_code, tree,
 				     tree, tree, tree CXX_MEM_STAT_INFO);
-gimple gimple_build_assign_with_ops (enum tree_code, tree,
+gimple *gimple_build_assign_with_ops (enum tree_code, tree,
 				     tree, tree CXX_MEM_STAT_INFO);
-gimple gimple_build_cond (enum tree_code, tree, tree, tree, tree);
-gimple gimple_build_cond_from_tree (tree, tree, tree);
-void gimple_cond_set_condition_from_tree (gimple, tree);
-gimple gimple_build_label (tree label);
-gimple gimple_build_goto (tree dest);
-gimple gimple_build_nop (void);
-gimple gimple_build_bind (tree, gimple_seq, tree);
-gimple gimple_build_asm_vec (const char *, vec<tree, va_gc> *,
+gimple *gimple_build_cond (enum tree_code, tree, tree, tree, tree);
+gimple *gimple_build_cond_from_tree (tree, tree, tree);
+void gimple_cond_set_condition_from_tree (gimple *, tree);
+gimple *gimple_build_label (tree label);
+gimple *gimple_build_goto (tree dest);
+gimple *gimple_build_nop (void);
+gimple *gimple_build_bind (tree, gimple_seq, tree);
+gimple *gimple_build_asm_vec (const char *, vec<tree, va_gc> *,
 			     vec<tree, va_gc> *, vec<tree, va_gc> *,
 			     vec<tree, va_gc> *);
-gimple gimple_build_catch (tree, gimple_seq);
-gimple gimple_build_eh_filter (tree, gimple_seq);
-gimple gimple_build_eh_must_not_throw (tree);
-gimple gimple_build_eh_else (gimple_seq, gimple_seq);
+gimple *gimple_build_catch (tree, gimple_seq);
+gimple *gimple_build_eh_filter (tree, gimple_seq);
+gimple *gimple_build_eh_must_not_throw (tree);
+gimple *gimple_build_eh_else (gimple_seq, gimple_seq);
 gtry *gimple_build_try (gimple_seq, gimple_seq,
 			enum gimple_try_flags);
-gimple gimple_build_wce (gimple_seq);
-gimple gimple_build_resx (int);
-gimple gimple_build_switch_nlabels (unsigned, tree, tree);
-gimple gimple_build_switch (tree, tree, vec<tree> );
-gimple gimple_build_eh_dispatch (int);
-gimple gimple_build_debug_bind_stat (tree, tree, gimple MEM_STAT_DECL);
+gimple *gimple_build_wce (gimple_seq);
+gimple *gimple_build_resx (int);
+gimple *gimple_build_switch_nlabels (unsigned, tree, tree);
+gimple *gimple_build_switch (tree, tree, vec<tree> );
+gimple *gimple_build_eh_dispatch (int);
+gimple *gimple_build_debug_bind_stat (tree, tree, gimple *MEM_STAT_DECL);
 #define gimple_build_debug_bind(var,val,stmt)			\
   gimple_build_debug_bind_stat ((var), (val), (stmt) MEM_STAT_INFO)
-gimple gimple_build_debug_source_bind_stat (tree, tree, gimple MEM_STAT_DECL);
+gimple *gimple_build_debug_source_bind_stat (tree, tree, gimple *MEM_STAT_DECL);
 #define gimple_build_debug_source_bind(var,val,stmt)			\
   gimple_build_debug_source_bind_stat ((var), (val), (stmt) MEM_STAT_INFO)
-gimple gimple_build_omp_critical (gimple_seq, tree);
-gimple gimple_build_omp_for (gimple_seq, int, tree, size_t, gimple_seq);
-gimple gimple_build_omp_parallel (gimple_seq, tree, tree, tree);
-gimple gimple_build_omp_task (gimple_seq, tree, tree, tree, tree, tree, tree);
-gimple gimple_build_omp_section (gimple_seq);
-gimple gimple_build_omp_master (gimple_seq);
-gimple gimple_build_omp_taskgroup (gimple_seq);
-gimple gimple_build_omp_continue (tree, tree);
-gimple gimple_build_omp_ordered (gimple_seq);
-gimple gimple_build_omp_return (bool);
-gimple gimple_build_omp_sections (gimple_seq, tree);
-gimple gimple_build_omp_sections_switch (void);
-gimple gimple_build_omp_single (gimple_seq, tree);
-gimple gimple_build_omp_target (gimple_seq, int, tree);
-gimple gimple_build_omp_teams (gimple_seq, tree);
-gimple gimple_build_omp_atomic_load (tree, tree);
-gimple gimple_build_omp_atomic_store (tree);
-gimple gimple_build_transaction (gimple_seq, tree);
-gimple gimple_build_predict (enum br_predictor, enum prediction);
-extern void gimple_seq_add_stmt (gimple_seq *, gimple);
-extern void gimple_seq_add_stmt_without_update (gimple_seq *, gimple);
+gimple *gimple_build_omp_critical (gimple_seq, tree);
+gimple *gimple_build_omp_for (gimple_seq, int, tree, size_t, gimple_seq);
+gimple *gimple_build_omp_parallel (gimple_seq, tree, tree, tree);
+gimple *gimple_build_omp_task (gimple_seq, tree, tree, tree, tree, tree, tree);
+gimple *gimple_build_omp_section (gimple_seq);
+gimple *gimple_build_omp_master (gimple_seq);
+gimple *gimple_build_omp_taskgroup (gimple_seq);
+gimple *gimple_build_omp_continue (tree, tree);
+gimple *gimple_build_omp_ordered (gimple_seq);
+gimple *gimple_build_omp_return (bool);
+gimple *gimple_build_omp_sections (gimple_seq, tree);
+gimple *gimple_build_omp_sections_switch (void);
+gimple *gimple_build_omp_single (gimple_seq, tree);
+gimple *gimple_build_omp_target (gimple_seq, int, tree);
+gimple *gimple_build_omp_teams (gimple_seq, tree);
+gimple *gimple_build_omp_atomic_load (tree, tree);
+gimple *gimple_build_omp_atomic_store (tree);
+gimple *gimple_build_transaction (gimple_seq, tree);
+gimple *gimple_build_predict (enum br_predictor, enum prediction);
+extern void gimple_seq_add_stmt (gimple_seq *, gimple *);
+extern void gimple_seq_add_stmt_without_update (gimple_seq *, gimple *);
 void gimple_seq_add_seq (gimple_seq *, gimple_seq);
 extern void annotate_all_with_location_after (gimple_seq, gimple_stmt_iterator,
 					      location_t);
 extern void annotate_all_with_location (gimple_seq, location_t);
 bool empty_body_p (gimple_seq);
 gimple_seq gimple_seq_copy (gimple_seq);
-bool gimple_call_same_target_p (const_gimple, const_gimple);
-int gimple_call_flags (const_gimple);
-int gimple_call_arg_flags (const_gimple, unsigned);
-int gimple_call_return_flags (const_gimple);
-bool gimple_assign_copy_p (gimple);
-bool gimple_assign_ssa_name_copy_p (gimple);
-bool gimple_assign_unary_nop_p (gimple);
-void gimple_set_bb (gimple, basic_block);
+bool gimple_call_same_target_p (const gimple *, const gimple *);
+int gimple_call_flags (const gimple *);
+int gimple_call_arg_flags (const gimple *, unsigned);
+int gimple_call_return_flags (const gimple *);
+bool gimple_assign_copy_p (gimple *);
+bool gimple_assign_ssa_name_copy_p (gimple *);
+bool gimple_assign_unary_nop_p (gimple *);
+void gimple_set_bb (gimple *, basic_block);
 void gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *, tree);
 void gimple_assign_set_rhs_with_ops_1 (gimple_stmt_iterator *, enum tree_code,
 				       tree, tree, tree);
-tree gimple_get_lhs (const_gimple);
-void gimple_set_lhs (gimple, tree);
-gimple gimple_copy (gimple);
-bool gimple_has_side_effects (const_gimple);
-bool gimple_could_trap_p_1 (gimple, bool, bool);
-bool gimple_could_trap_p (gimple);
-bool gimple_assign_rhs_could_trap_p (gimple);
+tree gimple_get_lhs (const gimple *);
+void gimple_set_lhs (gimple *, tree);
+gimple *gimple_copy (gimple *);
+bool gimple_has_side_effects (const gimple *);
+bool gimple_could_trap_p_1 (gimple *, bool, bool);
+bool gimple_could_trap_p (gimple *);
+bool gimple_assign_rhs_could_trap_p (gimple *);
 extern void dump_gimple_statistics (void);
 unsigned get_gimple_rhs_num_ops (enum tree_code);
 extern tree canonicalize_cond_expr_cond (tree);
-gimple gimple_call_copy_skip_args (gimple, bitmap);
+gimple *gimple_call_copy_skip_args (gimple *, bitmap);
 extern bool gimple_compare_field_offset (tree, tree);
 extern tree gimple_unsigned_type (tree);
 extern tree gimple_signed_type (tree);
 extern alias_set_type gimple_get_alias_set (tree);
-extern bool gimple_ior_addresses_taken (bitmap, gimple);
-extern bool gimple_builtin_call_types_compatible_p (const_gimple, tree);
-extern bool gimple_call_builtin_p (const_gimple);
-extern bool gimple_call_builtin_p (const_gimple, enum built_in_class);
-extern bool gimple_call_builtin_p (const_gimple, enum built_in_function);
-extern bool gimple_asm_clobbers_memory_p (const_gimple);
+extern bool gimple_ior_addresses_taken (bitmap, gimple *);
+extern bool gimple_builtin_call_types_compatible_p (const gimple *, tree);
+extern bool gimple_call_builtin_p (const gimple *);
+extern bool gimple_call_builtin_p (const gimple *, enum built_in_class);
+extern bool gimple_call_builtin_p (const gimple *, enum built_in_function);
+extern bool gimple_asm_clobbers_memory_p (const gimple *);
 extern void dump_decl_set (FILE *, bitmap);
-extern bool nonfreeing_call_p (gimple);
-extern bool infer_nonnull_range (gimple, tree, bool, bool);
+extern bool nonfreeing_call_p (gimple *);
+extern bool infer_nonnull_range (gimple *, tree, bool, bool);
 extern void sort_case_labels (vec<tree> );
 extern void preprocess_case_label_vec_for_gimple (vec<tree> , tree, tree *);
 extern void gimple_seq_set_location (gimple_seq , location_t);
@@ -1309,7 +1309,7 @@ gimple_seq_first (gimple_seq s)
 
 /* Return the first statement in GIMPLE sequence S.  */
 
-static inline gimple
+static inline gimple *
 gimple_seq_first_stmt (gimple_seq s)
 {
   gimple_seq_node n = gimple_seq_first (s);
@@ -1328,7 +1328,7 @@ gimple_seq_last (gimple_seq s)
 
 /* Return the last statement in GIMPLE sequence S.  */
 
-static inline gimple
+static inline gimple *
 gimple_seq_last_stmt (gimple_seq s)
 {
   gimple_seq_node n = gimple_seq_last (s);
@@ -1365,7 +1365,7 @@ gimple_seq_empty_p (gimple_seq s)
 /* Allocate a new sequence and initialize its first element with STMT.  */
 
 static inline gimple_seq
-gimple_seq_alloc_with_stmt (gimple stmt)
+gimple_seq_alloc_with_stmt (gimple *stmt)
 {
   gimple_seq seq = NULL;
   gimple_seq_add_stmt (&seq, stmt);
@@ -1400,7 +1400,7 @@ set_bb_seq (basic_block bb, gimple_seq seq)
 /* Return the code for GIMPLE statement G.  */
 
 static inline enum gimple_code
-gimple_code (const_gimple g)
+gimple_code (const gimple *g)
 {
   return g->code;
 }
@@ -1419,7 +1419,7 @@ gss_for_code (enum gimple_code code)
 /* Return which GSS code is used by GS.  */
 
 static inline enum gimple_statement_structure_enum
-gimple_statement_structure (gimple gs)
+gimple_statement_structure (gimple *gs)
 {
   return gss_for_code (gimple_code (gs));
 }
@@ -1429,7 +1429,7 @@ gimple_statement_structure (gimple gs)
    High GIMPLE statements.  */
 
 static inline bool
-gimple_has_substatements (gimple g)
+gimple_has_substatements (gimple *g)
 {
   switch (gimple_code (g))
     {
@@ -1463,7 +1463,7 @@ gimple_has_substatements (gimple g)
 /* Return the basic block holding statement G.  */
 
 static inline basic_block
-gimple_bb (const_gimple g)
+gimple_bb (const gimple *g)
 {
   return g->bb;
 }
@@ -1472,7 +1472,7 @@ gimple_bb (const_gimple g)
 /* Return the lexical scope block holding statement G.  */
 
 static inline tree
-gimple_block (const_gimple g)
+gimple_block (const gimple *g)
 {
   return LOCATION_BLOCK (g->location);
 }
@@ -1481,7 +1481,7 @@ gimple_block (const_gimple g)
 /* Set BLOCK to be the lexical scope block holding statement G.  */
 
 static inline void
-gimple_set_block (gimple g, tree block)
+gimple_set_block (gimple *g, tree block)
 {
   if (block)
     g->location =
@@ -1494,7 +1494,7 @@ gimple_set_block (gimple g, tree block)
 /* Return location information for statement G.  */
 
 static inline location_t
-gimple_location (const_gimple g)
+gimple_location (const gimple *g)
 {
   return g->location;
 }
@@ -1502,7 +1502,7 @@ gimple_location (const_gimple g)
 /* Return pointer to location information for statement G.  */
 
 static inline const location_t *
-gimple_location_ptr (const_gimple g)
+gimple_location_ptr (const gimple *g)
 {
   return &g->location;
 }
@@ -1511,7 +1511,7 @@ gimple_location_ptr (const_gimple g)
 /* Set location information for statement G.  */
 
 static inline void
-gimple_set_location (gimple g, location_t location)
+gimple_set_location (gimple *g, location_t location)
 {
   g->location = location;
 }
@@ -1520,7 +1520,7 @@ gimple_set_location (gimple g, location_t location)
 /* Return true if G contains location information.  */
 
 static inline bool
-gimple_has_location (const_gimple g)
+gimple_has_location (const gimple *g)
 {
   return LOCATION_LOCUS (gimple_location (g)) != UNKNOWN_LOCATION;
 }
@@ -1529,7 +1529,7 @@ gimple_has_location (const_gimple g)
 /* Return the file name of the location of STMT.  */
 
 static inline const char *
-gimple_filename (const_gimple stmt)
+gimple_filename (const gimple *stmt)
 {
   return LOCATION_FILE (gimple_location (stmt));
 }
@@ -1538,7 +1538,7 @@ gimple_filename (const_gimple stmt)
 /* Return the line number of the location of STMT.  */
 
 static inline int
-gimple_lineno (const_gimple stmt)
+gimple_lineno (const gimple *stmt)
 {
   return LOCATION_LINE (gimple_location (stmt));
 }
@@ -1556,7 +1556,7 @@ gimple_seq_singleton_p (gimple_seq seq)
 /* Return true if no warnings should be emitted for statement STMT.  */
 
 static inline bool
-gimple_no_warning_p (const_gimple stmt)
+gimple_no_warning_p (const gimple *stmt)
 {
   return stmt->no_warning;
 }
@@ -1564,7 +1564,7 @@ gimple_no_warning_p (const_gimple stmt)
 /* Set the no_warning flag of STMT to NO_WARNING.  */
 
 static inline void
-gimple_set_no_warning (gimple stmt, bool no_warning)
+gimple_set_no_warning (gimple *stmt, bool no_warning)
 {
   stmt->no_warning = (unsigned) no_warning;
 }
@@ -1572,7 +1572,7 @@ gimple_set_no_warning (gimple stmt, bool no_warning)
 /* Set the visited status on statement STMT to VISITED_P.  */
 
 static inline void
-gimple_set_visited (gimple stmt, bool visited_p)
+gimple_set_visited (gimple *stmt, bool visited_p)
 {
   stmt->visited = (unsigned) visited_p;
 }
@@ -1581,7 +1581,7 @@ gimple_set_visited (gimple stmt, bool visited_p)
 /* Return the visited status for statement STMT.  */
 
 static inline bool
-gimple_visited_p (gimple stmt)
+gimple_visited_p (gimple *stmt)
 {
   return stmt->visited;
 }
@@ -1590,7 +1590,7 @@ gimple_visited_p (gimple stmt)
 /* Set pass local flag PLF on statement STMT to VAL_P.  */
 
 static inline void
-gimple_set_plf (gimple stmt, enum plf_mask plf, bool val_p)
+gimple_set_plf (gimple *stmt, enum plf_mask plf, bool val_p)
 {
   if (val_p)
     stmt->plf |= (unsigned int) plf;
@@ -1602,7 +1602,7 @@ gimple_set_plf (gimple stmt, enum plf_mask plf, bool val_p)
 /* Return the value of pass local flag PLF on statement STMT.  */
 
 static inline unsigned int
-gimple_plf (gimple stmt, enum plf_mask plf)
+gimple_plf (gimple *stmt, enum plf_mask plf)
 {
   return stmt->plf & ((unsigned int) plf);
 }
@@ -1611,7 +1611,7 @@ gimple_plf (gimple stmt, enum plf_mask plf)
 /* Set the UID of statement.  */
 
 static inline void
-gimple_set_uid (gimple g, unsigned uid)
+gimple_set_uid (gimple *g, unsigned uid)
 {
   g->uid = uid;
 }
@@ -1620,7 +1620,7 @@ gimple_set_uid (gimple g, unsigned uid)
 /* Return the UID of statement.  */
 
 static inline unsigned
-gimple_uid (const_gimple g)
+gimple_uid (const gimple *g)
 {
   return g->uid;
 }
@@ -1629,7 +1629,7 @@ gimple_uid (const_gimple g)
 /* Make statement G a singleton sequence.  */
 
 static inline void
-gimple_init_singleton (gimple g)
+gimple_init_singleton (gimple *g)
 {
   g->next = NULL;
   g->prev = g;
@@ -1639,7 +1639,7 @@ gimple_init_singleton (gimple g)
 /* Return true if GIMPLE statement G has register or memory operands.  */
 
 static inline bool
-gimple_has_ops (const_gimple g)
+gimple_has_ops (const gimple *g)
 {
   return gimple_code (g) >= GIMPLE_COND && gimple_code (g) <= GIMPLE_RETURN;
 }
@@ -1647,7 +1647,7 @@ gimple_has_ops (const_gimple g)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_with_ops *>::test (const_gimple gs)
+is_a_helper <const gimple_with_ops *>::test (const gimple *gs)
 {
   return gimple_has_ops (gs);
 }
@@ -1655,7 +1655,7 @@ is_a_helper <const gimple_with_ops *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_with_ops *>::test (gimple gs)
+is_a_helper <gimple_with_ops *>::test (gimple *gs)
 {
   return gimple_has_ops (gs);
 }
@@ -1663,7 +1663,7 @@ is_a_helper <gimple_with_ops *>::test (gimple gs)
 /* Return true if GIMPLE statement G has memory operands.  */
 
 static inline bool
-gimple_has_mem_ops (const_gimple g)
+gimple_has_mem_ops (const gimple *g)
 {
   return gimple_code (g) >= GIMPLE_ASSIGN && gimple_code (g) <= GIMPLE_RETURN;
 }
@@ -1671,7 +1671,7 @@ gimple_has_mem_ops (const_gimple g)
 template <>
 template <>
 inline bool
-is_a_helper <const gimple_with_memory_ops *>::test (const_gimple gs)
+is_a_helper <const gimple_with_memory_ops *>::test (const gimple *gs)
 {
   return gimple_has_mem_ops (gs);
 }
@@ -1679,7 +1679,7 @@ is_a_helper <const gimple_with_memory_ops *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_with_memory_ops *>::test (gimple gs)
+is_a_helper <gimple_with_memory_ops *>::test (gimple *gs)
 {
   return gimple_has_mem_ops (gs);
 }
@@ -1687,7 +1687,7 @@ is_a_helper <gimple_with_memory_ops *>::test (gimple gs)
 /* Return the set of USE operands for statement G.  */
 
 static inline struct use_optype_d *
-gimple_use_ops (const_gimple g)
+gimple_use_ops (const gimple *g)
 {
   const gimple_with_ops *ops_stmt = dyn_cast <const gimple_with_ops *> (g);
   if (!ops_stmt)
@@ -1699,7 +1699,7 @@ gimple_use_ops (const_gimple g)
 /* Set USE to be the set of USE operands for statement G.  */
 
 static inline void
-gimple_set_use_ops (gimple g, struct use_optype_d *use)
+gimple_set_use_ops (gimple *g, struct use_optype_d *use)
 {
   gimple_with_ops *ops_stmt = as_a <gimple_with_ops *> (g);
   ops_stmt->use_ops = use;
@@ -1709,7 +1709,7 @@ gimple_set_use_ops (gimple g, struct use_optype_d *use)
 /* Return the single VUSE operand of the statement G.  */
 
 static inline tree
-gimple_vuse (const_gimple g)
+gimple_vuse (const gimple *g)
 {
   const gimple_with_memory_ops *mem_ops_stmt =
      dyn_cast <const gimple_with_memory_ops *> (g);
@@ -1721,7 +1721,7 @@ gimple_vuse (const_gimple g)
 /* Return the single VDEF operand of the statement G.  */
 
 static inline tree
-gimple_vdef (const_gimple g)
+gimple_vdef (const gimple *g)
 {
   const gimple_with_memory_ops *mem_ops_stmt =
      dyn_cast <const gimple_with_memory_ops *> (g);
@@ -1733,7 +1733,7 @@ gimple_vdef (const_gimple g)
 /* Return the single VUSE operand of the statement G.  */
 
 static inline tree *
-gimple_vuse_ptr (gimple g)
+gimple_vuse_ptr (gimple *g)
 {
   gimple_with_memory_ops *mem_ops_stmt =
      dyn_cast <gimple_with_memory_ops *> (g);
@@ -1745,7 +1745,7 @@ gimple_vuse_ptr (gimple g)
 /* Return the single VDEF operand of the statement G.  */
 
 static inline tree *
-gimple_vdef_ptr (gimple g)
+gimple_vdef_ptr (gimple *g)
 {
   gimple_with_memory_ops *mem_ops_stmt =
      dyn_cast <gimple_with_memory_ops *> (g);
@@ -1757,7 +1757,7 @@ gimple_vdef_ptr (gimple g)
 /* Set the single VUSE operand of the statement G.  */
 
 static inline void
-gimple_set_vuse (gimple g, tree vuse)
+gimple_set_vuse (gimple *g, tree vuse)
 {
   gimple_with_memory_ops *mem_ops_stmt =
     as_a <gimple_with_memory_ops *> (g);
@@ -1767,7 +1767,7 @@ gimple_set_vuse (gimple g, tree vuse)
 /* Set the single VDEF operand of the statement G.  */
 
 static inline void
-gimple_set_vdef (gimple g, tree vdef)
+gimple_set_vdef (gimple *g, tree vdef)
 {
   gimple_with_memory_ops *mem_ops_stmt =
     as_a <gimple_with_memory_ops *> (g);
@@ -1779,7 +1779,7 @@ gimple_set_vdef (gimple g, tree vdef)
    been set.  */
 
 static inline bool
-gimple_modified_p (const_gimple g)
+gimple_modified_p (const gimple *g)
 {
   return (gimple_has_ops (g)) ? (bool) g->modified : false;
 }
@@ -1789,7 +1789,7 @@ gimple_modified_p (const_gimple g)
    a MODIFIED field.  */
 
 static inline void
-gimple_set_modified (gimple s, bool modifiedp)
+gimple_set_modified (gimple *s, bool modifiedp)
 {
   if (gimple_has_ops (s))
     s->modified = (unsigned) modifiedp;
@@ -1803,7 +1803,7 @@ gimple_set_modified (gimple s, bool modifiedp)
    three kinds of computation that GIMPLE supports.  */
 
 static inline enum tree_code
-gimple_expr_code (const_gimple stmt)
+gimple_expr_code (const gimple *stmt)
 {
   enum gimple_code code = gimple_code (stmt);
   if (code == GIMPLE_ASSIGN || code == GIMPLE_COND)
@@ -1819,7 +1819,7 @@ gimple_expr_code (const_gimple stmt)
 /* Return true if statement STMT contains volatile operands.  */
 
 static inline bool
-gimple_has_volatile_ops (const_gimple stmt)
+gimple_has_volatile_ops (const gimple *stmt)
 {
   if (gimple_has_mem_ops (stmt))
     return stmt->has_volatile_ops;
@@ -1831,7 +1831,7 @@ gimple_has_volatile_ops (const_gimple stmt)
 /* Set the HAS_VOLATILE_OPS flag to VOLATILEP.  */
 
 static inline void
-gimple_set_has_volatile_ops (gimple stmt, bool volatilep)
+gimple_set_has_volatile_ops (gimple *stmt, bool volatilep)
 {
   if (gimple_has_mem_ops (stmt))
     stmt->has_volatile_ops = (unsigned) volatilep;
@@ -1840,7 +1840,7 @@ gimple_set_has_volatile_ops (gimple stmt, bool volatilep)
 /* Return true if STMT is in a transaction.  */
 
 static inline bool
-gimple_in_transaction (gimple stmt)
+gimple_in_transaction (gimple *stmt)
 {
   return bb_in_transaction (gimple_bb (stmt));
 }
@@ -1848,7 +1848,7 @@ gimple_in_transaction (gimple stmt)
 /* Return true if statement STMT may access memory.  */
 
 static inline bool
-gimple_references_memory_p (gimple stmt)
+gimple_references_memory_p (gimple *stmt)
 {
   return gimple_has_mem_ops (stmt) && gimple_vuse (stmt);
 }
@@ -1857,7 +1857,7 @@ gimple_references_memory_p (gimple stmt)
 /* Return the subcode for OMP statement S.  */
 
 static inline unsigned
-gimple_omp_subcode (const_gimple s)
+gimple_omp_subcode (const gimple *s)
 {
   gcc_gimple_checking_assert (gimple_code (s) >= GIMPLE_OMP_ATOMIC_LOAD
 	      && gimple_code (s) <= GIMPLE_OMP_TEAMS);
@@ -1867,7 +1867,7 @@ gimple_omp_subcode (const_gimple s)
 /* Set the subcode for OMP statement S to SUBCODE.  */
 
 static inline void
-gimple_omp_set_subcode (gimple s, unsigned int subcode)
+gimple_omp_set_subcode (gimple *s, unsigned int subcode)
 {
   /* We only have 16 bits for the subcode.  Assert that we are not
      overflowing it.  */
@@ -1878,7 +1878,7 @@ gimple_omp_set_subcode (gimple s, unsigned int subcode)
 /* Set the nowait flag on OMP_RETURN statement S.  */
 
 static inline void
-gimple_omp_return_set_nowait (gimple s)
+gimple_omp_return_set_nowait (gimple *s)
 {
   GIMPLE_CHECK (s, GIMPLE_OMP_RETURN);
   s->subcode |= GF_OMP_RETURN_NOWAIT;
@@ -1889,7 +1889,7 @@ gimple_omp_return_set_nowait (gimple s)
    flag set.  */
 
 static inline bool
-gimple_omp_return_nowait_p (const_gimple g)
+gimple_omp_return_nowait_p (const gimple *g)
 {
   GIMPLE_CHECK (g, GIMPLE_OMP_RETURN);
   return (gimple_omp_subcode (g) & GF_OMP_RETURN_NOWAIT) != 0;
@@ -1899,7 +1899,7 @@ gimple_omp_return_nowait_p (const_gimple g)
 /* Set the LHS of OMP return.  */
 
 static inline void
-gimple_omp_return_set_lhs (gimple g, tree lhs)
+gimple_omp_return_set_lhs (gimple *g, tree lhs)
 {
   gomp_return *omp_return_stmt = as_a <gomp_return *> (g);
   omp_return_stmt->val = lhs;
@@ -1909,7 +1909,7 @@ gimple_omp_return_set_lhs (gimple g, tree lhs)
 /* Get the LHS of OMP return.  */
 
 static inline tree
-gimple_omp_return_lhs (const_gimple g)
+gimple_omp_return_lhs (const gimple *g)
 {
   const gomp_return *omp_return_stmt = as_a <const gomp_return *> (g);
   return omp_return_stmt->val;
@@ -1919,7 +1919,7 @@ gimple_omp_return_lhs (const_gimple g)
 /* Return a pointer to the LHS of OMP return.  */
 
 static inline tree *
-gimple_omp_return_lhs_ptr (gimple g)
+gimple_omp_return_lhs_ptr (gimple *g)
 {
   gomp_return *omp_return_stmt = as_a <gomp_return *> (g);
   return &omp_return_stmt->val;
@@ -1930,7 +1930,7 @@ gimple_omp_return_lhs_ptr (gimple g)
    flag set.  */
 
 static inline bool
-gimple_omp_section_last_p (const_gimple g)
+gimple_omp_section_last_p (const gimple *g)
 {
   GIMPLE_CHECK (g, GIMPLE_OMP_SECTION);
   return (gimple_omp_subcode (g) & GF_OMP_SECTION_LAST) != 0;
@@ -1940,7 +1940,7 @@ gimple_omp_section_last_p (const_gimple g)
 /* Set the GF_OMP_SECTION_LAST flag on G.  */
 
 static inline void
-gimple_omp_section_set_last (gimple g)
+gimple_omp_section_set_last (gimple *g)
 {
   GIMPLE_CHECK (g, GIMPLE_OMP_SECTION);
   g->subcode |= GF_OMP_SECTION_LAST;
@@ -1951,7 +1951,7 @@ gimple_omp_section_set_last (gimple g)
    GF_OMP_PARALLEL_COMBINED flag set.  */
 
 static inline bool
-gimple_omp_parallel_combined_p (const_gimple g)
+gimple_omp_parallel_combined_p (const gimple *g)
 {
   GIMPLE_CHECK (g, GIMPLE_OMP_PARALLEL);
   return (gimple_omp_subcode (g) & GF_OMP_PARALLEL_COMBINED) != 0;
@@ -1962,7 +1962,7 @@ gimple_omp_parallel_combined_p (const_gimple g)
    value of COMBINED_P.  */
 
 static inline void
-gimple_omp_parallel_set_combined_p (gimple g, bool combined_p)
+gimple_omp_parallel_set_combined_p (gimple *g, bool combined_p)
 {
   GIMPLE_CHECK (g, GIMPLE_OMP_PARALLEL);
   if (combined_p)
@@ -1976,7 +1976,7 @@ gimple_omp_parallel_set_combined_p (gimple g, bool combined_p)
    GF_OMP_ATOMIC_NEED_VALUE flag set.  */
 
 static inline bool
-gimple_omp_atomic_need_value_p (const_gimple g)
+gimple_omp_atomic_need_value_p (const gimple *g)
 {
   if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
     GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
@@ -1987,7 +1987,7 @@ gimple_omp_atomic_need_value_p (const_gimple g)
 /* Set the GF_OMP_ATOMIC_NEED_VALUE flag on G.  */
 
 static inline void
-gimple_omp_atomic_set_need_value (gimple g)
+gimple_omp_atomic_set_need_value (gimple *g)
 {
   if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
     GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
@@ -1999,7 +1999,7 @@ gimple_omp_atomic_set_need_value (gimple g)
    GF_OMP_ATOMIC_SEQ_CST flag set.  */
 
 static inline bool
-gimple_omp_atomic_seq_cst_p (const_gimple g)
+gimple_omp_atomic_seq_cst_p (const gimple *g)
 {
   if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
     GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
@@ -2010,7 +2010,7 @@ gimple_omp_atomic_seq_cst_p (const_gimple g)
 /* Set the GF_OMP_ATOMIC_SEQ_CST flag on G.  */
 
 static inline void
-gimple_omp_atomic_set_seq_cst (gimple g)
+gimple_omp_atomic_set_seq_cst (gimple *g)
 {
   if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
     GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
@@ -2021,7 +2021,7 @@ gimple_omp_atomic_set_seq_cst (gimple g)
 /* Return the number of operands for statement GS.  */
 
 static inline unsigned
-gimple_num_ops (const_gimple gs)
+gimple_num_ops (const gimple *gs)
 {
   return gs->num_ops;
 }
@@ -2030,7 +2030,7 @@ gimple_num_ops (const_gimple gs)
 /* Set the number of operands for statement GS.  */
 
 static inline void
-gimple_set_num_ops (gimple gs, unsigned num_ops)
+gimple_set_num_ops (gimple *gs, unsigned num_ops)
 {
   gs->num_ops = num_ops;
 }
@@ -2039,7 +2039,7 @@ gimple_set_num_ops (gimple gs, unsigned num_ops)
 /* Return the array of operands for statement GS.  */
 
 static inline tree *
-gimple_ops (gimple gs)
+gimple_ops (gimple *gs)
 {
   size_t off;
 
@@ -2056,7 +2056,7 @@ gimple_ops (gimple gs)
 /* Return operand I for statement GS.  */
 
 static inline tree
-gimple_op (const_gimple gs, unsigned i)
+gimple_op (const gimple *gs, unsigned i)
 {
   if (gimple_has_ops (gs))
     {
@@ -2070,7 +2070,7 @@ gimple_op (const_gimple gs, unsigned i)
 /* Return a pointer to operand I for statement GS.  */
 
 static inline tree *
-gimple_op_ptr (const_gimple gs, unsigned i)
+gimple_op_ptr (const gimple *gs, unsigned i)
 {
   if (gimple_has_ops (gs))
     {
@@ -2084,7 +2084,7 @@ gimple_op_ptr (const_gimple gs, unsigned i)
 /* Set operand I of statement GS to OP.  */
 
 static inline void
-gimple_set_op (gimple gs, unsigned i, tree op)
+gimple_set_op (gimple *gs, unsigned i, tree op)
 {
   gcc_gimple_checking_assert (gimple_has_ops (gs) && i < gimple_num_ops (gs));
 
@@ -2098,7 +2098,7 @@ gimple_set_op (gimple gs, unsigned i, tree op)
 /* Return true if GS is a GIMPLE_ASSIGN.  */
 
 static inline bool
-is_gimple_assign (const_gimple gs)
+is_gimple_assign (const gimple *gs)
 {
   return gimple_code (gs) == GIMPLE_ASSIGN;
 }
@@ -2115,7 +2115,7 @@ get_gimple_rhs_class (enum tree_code code)
 /* Return the LHS of assignment statement GS.  */
 
 static inline tree
-gimple_assign_lhs (const_gimple gs)
+gimple_assign_lhs (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
   return gimple_op (gs, 0);
@@ -2125,7 +2125,7 @@ gimple_assign_lhs (const_gimple gs)
 /* Return a pointer to the LHS of assignment statement GS.  */
 
 static inline tree *
-gimple_assign_lhs_ptr (const_gimple gs)
+gimple_assign_lhs_ptr (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
   return gimple_op_ptr (gs, 0);
@@ -2135,7 +2135,7 @@ gimple_assign_lhs_ptr (const_gimple gs)
 /* Set LHS to be the LHS operand of assignment statement GS.  */
 
 static inline void
-gimple_assign_set_lhs (gimple gs, tree lhs)
+gimple_assign_set_lhs (gimple *gs, tree lhs)
 {
   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
   gimple_set_op (gs, 0, lhs);
@@ -2148,7 +2148,7 @@ gimple_assign_set_lhs (gimple gs, tree lhs)
 /* Return the first operand on the RHS of assignment statement GS.  */
 
 static inline tree
-gimple_assign_rhs1 (const_gimple gs)
+gimple_assign_rhs1 (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
   return gimple_op (gs, 1);
@@ -2159,7 +2159,7 @@ gimple_assign_rhs1 (const_gimple gs)
    statement GS.  */
 
 static inline tree *
-gimple_assign_rhs1_ptr (const_gimple gs)
+gimple_assign_rhs1_ptr (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
   return gimple_op_ptr (gs, 1);
@@ -2168,7 +2168,7 @@ gimple_assign_rhs1_ptr (const_gimple gs)
 /* Set RHS to be the first operand on the RHS of assignment statement GS.  */
 
 static inline void
-gimple_assign_set_rhs1 (gimple gs, tree rhs)
+gimple_assign_set_rhs1 (gimple *gs, tree rhs)
 {
   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
 
@@ -2180,7 +2180,7 @@ gimple_assign_set_rhs1 (gimple gs, tree rhs)
    If GS does not have two operands, NULL is returned instead.  */
 
 static inline tree
-gimple_assign_rhs2 (const_gimple gs)
+gimple_assign_rhs2 (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
 
@@ -2195,7 +2195,7 @@ gimple_assign_rhs2 (const_gimple gs)
    statement GS.  */
 
 static inline tree *
-gimple_assign_rhs2_ptr (const_gimple gs)
+gimple_assign_rhs2_ptr (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
   return gimple_op_ptr (gs, 2);
@@ -2205,7 +2205,7 @@ gimple_assign_rhs2_ptr (const_gimple gs)
 /* Set RHS to be the second operand on the RHS of assignment statement GS.  */
 
 static inline void
-gimple_assign_set_rhs2 (gimple gs, tree rhs)
+gimple_assign_set_rhs2 (gimple *gs, tree rhs)
 {
   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
 
@@ -2216,7 +2216,7 @@ gimple_assign_set_rhs2 (gimple gs, tree rhs)
    If GS does not have two operands, NULL is returned instead.  */
 
 static inline tree
-gimple_assign_rhs3 (const_gimple gs)
+gimple_assign_rhs3 (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
 
@@ -2230,7 +2230,7 @@ gimple_assign_rhs3 (const_gimple gs)
    statement GS.  */
 
 static inline tree *
-gimple_assign_rhs3_ptr (const_gimple gs)
+gimple_assign_rhs3_ptr (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
   return gimple_op_ptr (gs, 3);
@@ -2240,7 +2240,7 @@ gimple_assign_rhs3_ptr (const_gimple gs)
 /* Set RHS to be the third operand on the RHS of assignment statement GS.  */
 
 static inline void
-gimple_assign_set_rhs3 (gimple gs, tree rhs)
+gimple_assign_set_rhs3 (gimple *gs, tree rhs)
 {
   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
 
@@ -2260,7 +2260,7 @@ gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
 /* Returns true if GS is a nontemporal move.  */
 
 static inline bool
-gimple_assign_nontemporal_move_p (const_gimple gs)
+gimple_assign_nontemporal_move_p (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
   return gs->nontemporal_move;
@@ -2269,7 +2269,7 @@ gimple_assign_nontemporal_move_p (const_gimple gs)
 /* Sets nontemporal move flag of GS to NONTEMPORAL.  */
 
 static inline void
-gimple_assign_set_nontemporal_move (gimple gs, bool nontemporal)
+gimple_assign_set_nontemporal_move (gimple *gs, bool nontemporal)
 {
   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
   gs->nontemporal_move = nontemporal;
@@ -2281,7 +2281,7 @@ gimple_assign_set_nontemporal_move (gimple gs, bool nontemporal)
    tree code of the object.  */
 
 static inline enum tree_code
-gimple_assign_rhs_code (const_gimple gs)
+gimple_assign_rhs_code (const gimple *gs)
 {
   enum tree_code code;
   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
@@ -2301,7 +2301,7 @@ gimple_assign_rhs_code (const_gimple gs)
    assignment S.  */
 
 static inline void
-gimple_assign_set_rhs_code (gimple s, enum tree_code code)
+gimple_assign_set_rhs_code (gimple *s, enum tree_code code)
 {
   GIMPLE_CHECK (s, GIMPLE_ASSIGN);
   s->subcode = code;
@@ -2313,7 +2313,7 @@ gimple_assign_set_rhs_code (gimple s, enum tree_code code)
    This will never return GIMPLE_INVALID_RHS.  */
 
 static inline enum gimple_rhs_class
-gimple_assign_rhs_class (const_gimple gs)
+gimple_assign_rhs_class (const gimple *gs)
 {
   return get_gimple_rhs_class (gimple_assign_rhs_code (gs));
 }
@@ -2325,7 +2325,7 @@ gimple_assign_rhs_class (const_gimple gs)
    and do not have the semantics of a copy, such as COND_EXPR.  */
 
 static inline bool
-gimple_assign_single_p (const_gimple gs)
+gimple_assign_single_p (const gimple *gs)
 {
   return (is_gimple_assign (gs)
           && gimple_assign_rhs_class (gs) == GIMPLE_SINGLE_RHS);
@@ -2334,7 +2334,7 @@ gimple_assign_single_p (const_gimple gs)
 /* Return true if GS performs a store to its lhs.  */
 
 static inline bool
-gimple_store_p (const_gimple gs)
+gimple_store_p (const gimple *gs)
 {
   tree lhs = gimple_get_lhs (gs);
   return lhs && !is_gimple_reg (lhs);
@@ -2343,7 +2343,7 @@ gimple_store_p (const_gimple gs)
 /* Return true if GS is an assignment that loads from its rhs1.  */
 
 static inline bool
-gimple_assign_load_p (const_gimple gs)
+gimple_assign_load_p (const gimple *gs)
 {
   tree rhs;
   if (!gimple_assign_single_p (gs))
@@ -2360,7 +2360,7 @@ gimple_assign_load_p (const_gimple gs)
 /* Return true if S is a type-cast assignment.  */
 
 static inline bool
-gimple_assign_cast_p (const_gimple s)
+gimple_assign_cast_p (const gimple *s)
 {
   if (is_gimple_assign (s))
     {
@@ -2376,7 +2376,7 @@ gimple_assign_cast_p (const_gimple s)
 /* Return true if S is a clobber statement.  */
 
 static inline bool
-gimple_clobber_p (const_gimple s)
+gimple_clobber_p (const gimple *s)
 {
   return gimple_assign_single_p (s)
          && TREE_CLOBBER_P (gimple_assign_rhs1 (s));
@@ -2385,7 +2385,7 @@ gimple_clobber_p (const_gimple s)
 /* Return true if GS is a GIMPLE_CALL.  */
 
 static inline bool
-is_gimple_call (const_gimple gs)
+is_gimple_call (const gimple *gs)
 {
   return gimple_code (gs) == GIMPLE_CALL;
 }
@@ -2393,7 +2393,7 @@ is_gimple_call (const_gimple gs)
 /* Return the LHS of call statement GS.  */
 
 static inline tree
-gimple_call_lhs (const_gimple gs)
+gimple_call_lhs (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_CALL);
   return gimple_op (gs, 0);
@@ -2403,7 +2403,7 @@ gimple_call_lhs (const_gimple gs)
 /* Return a pointer to the LHS of call statement GS.  */
 
 static inline tree *
-gimple_call_lhs_ptr (const_gimple gs)
+gimple_call_lhs_ptr (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_CALL);
   return gimple_op_ptr (gs, 0);
@@ -2413,7 +2413,7 @@ gimple_call_lhs_ptr (const_gimple gs)
 /* Set LHS to be the LHS operand of call statement GS.  */
 
 static inline void
-gimple_call_set_lhs (gimple gs, tree lhs)
+gimple_call_set_lhs (gimple *gs, tree lhs)
 {
   GIMPLE_CHECK (gs, GIMPLE_CALL);
   gimple_set_op (gs, 0, lhs);
@@ -2426,7 +2426,7 @@ gimple_call_set_lhs (gimple gs, tree lhs)
    by internal_fn.  */
 
 static inline bool
-gimple_call_internal_p (const_gimple gs)
+gimple_call_internal_p (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_CALL);
   return (gs->subcode & GF_CALL_INTERNAL) != 0;
@@ -2436,7 +2436,7 @@ gimple_call_internal_p (const_gimple gs)
 /* Return the target of internal call GS.  */
 
 static inline enum internal_fn
-gimple_call_internal_fn (const_gimple gs)
+gimple_call_internal_fn (const gimple *gs)
 {
   gcc_gimple_checking_assert (gimple_call_internal_p (gs));
   return static_cast <const gcall *> (gs)->u.internal_fn;
@@ -2446,7 +2446,7 @@ gimple_call_internal_fn (const_gimple gs)
 /* Return the function type of the function called by GS.  */
 
 static inline tree
-gimple_call_fntype (const_gimple gs)
+gimple_call_fntype (const gimple *gs)
 {
   const gcall *call_stmt =
     as_a <const gcall *> (gs);
@@ -2458,7 +2458,7 @@ gimple_call_fntype (const_gimple gs)
 /* Set the type of the function called by GS to FNTYPE.  */
 
 static inline void
-gimple_call_set_fntype (gimple gs, tree fntype)
+gimple_call_set_fntype (gimple *gs, tree fntype)
 {
   gcall *call_stmt = as_a <gcall *> (gs);
   gcc_gimple_checking_assert (!gimple_call_internal_p (gs));
@@ -2470,7 +2470,7 @@ gimple_call_set_fntype (gimple gs, tree fntype)
    statement GS.  */
 
 static inline tree
-gimple_call_fn (const_gimple gs)
+gimple_call_fn (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_CALL);
   return gimple_op (gs, 1);
@@ -2480,7 +2480,7 @@ gimple_call_fn (const_gimple gs)
    statement GS.  */
 
 static inline tree *
-gimple_call_fn_ptr (const_gimple gs)
+gimple_call_fn_ptr (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_CALL);
   return gimple_op_ptr (gs, 1);
@@ -2490,7 +2490,7 @@ gimple_call_fn_ptr (const_gimple gs)
 /* Set FN to be the function called by call statement GS.  */
 
 static inline void
-gimple_call_set_fn (gimple gs, tree fn)
+gimple_call_set_fn (gimple *gs, tree fn)
 {
   GIMPLE_CHECK (gs, GIMPLE_CALL);
   gcc_gimple_checking_assert (!gimple_call_internal_p (gs));
@@ -2501,7 +2501,7 @@ gimple_call_set_fn (gimple gs, tree fn)
 /* Set FNDECL to be the function called by call statement GS.  */
 
 static inline void
-gimple_call_set_fndecl (gimple gs, tree decl)
+gimple_call_set_fndecl (gimple *gs, tree decl)
 {
   GIMPLE_CHECK (gs, GIMPLE_CALL);
   gcc_gimple_checking_assert (!gimple_call_internal_p (gs));
@@ -2512,7 +2512,7 @@ gimple_call_set_fndecl (gimple gs, tree decl)
 /* Set internal function FN to be the function called by call statement GS.  */
 
 static inline void
-gimple_call_set_internal_fn (gimple gs, enum internal_fn fn)
+gimple_call_set_internal_fn (gimple *gs, enum internal_fn fn)
 {
   gcall *call_stmt = as_a <gcall *> (gs);
   gcc_gimple_checking_assert (gimple_call_internal_p (gs));
@@ -2525,7 +2525,7 @@ gimple_call_set_internal_fn (gimple gs, enum internal_fn fn)
    get_callee_fndecl in tree land.  */
 
 static inline tree
-gimple_call_fndecl (const_gimple gs)
+gimple_call_fndecl (const gimple *gs)
 {
   return gimple_call_addr_fndecl (gimple_call_fn (gs));
 }
@@ -2534,7 +2534,7 @@ gimple_call_fndecl (const_gimple gs)
 /* Return the type returned by call statement GS.  */
 
 static inline tree
-gimple_call_return_type (const_gimple gs)
+gimple_call_return_type (const gimple *gs)
 {
   tree type = gimple_call_fntype (gs);
 
@@ -2550,7 +2550,7 @@ gimple_call_return_type (const_gimple gs)
 /* Return the static chain for call statement GS.  */
 
 static inline tree
-gimple_call_chain (const_gimple gs)
+gimple_call_chain (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_CALL);
   return gimple_op (gs, 2);
@@ -2560,7 +2560,7 @@ gimple_call_chain (const_gimple gs)
 /* Return a pointer to the static chain for call statement GS.  */
 
 static inline tree *
-gimple_call_chain_ptr (const_gimple gs)
+gimple_call_chain_ptr (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_CALL);
   return gimple_op_ptr (gs, 2);
@@ -2569,7 +2569,7 @@ gimple_call_chain_ptr (const_gimple gs)
 /* Set CHAIN to be the static chain for call statement GS.  */
 
 static inline void
-gimple_call_set_chain (gimple gs, tree chain)
+gimple_call_set_chain (gimple *gs, tree chain)
 {
   GIMPLE_CHECK (gs, GIMPLE_CALL);
 
@@ -2580,7 +2580,7 @@ gimple_call_set_chain (gimple gs, tree chain)
 /* Return the number of arguments used by call statement GS.  */
 
 static inline unsigned
-gimple_call_num_args (const_gimple gs)
+gimple_call_num_args (const gimple *gs)
 {
   unsigned num_ops;
   GIMPLE_CHECK (gs, GIMPLE_CALL);
@@ -2592,7 +2592,7 @@ gimple_call_num_args (const_gimple gs)
 /* Return the argument at position INDEX for call statement GS.  */
 
 static inline tree
-gimple_call_arg (const_gimple gs, unsigned index)
+gimple_call_arg (const gimple *gs, unsigned index)
 {
   GIMPLE_CHECK (gs, GIMPLE_CALL);
   return gimple_op (gs, index + 3);
@@ -2603,7 +2603,7 @@ gimple_call_arg (const_gimple gs, unsigned index)
    statement GS.  */
 
 static inline tree *
-gimple_call_arg_ptr (const_gimple gs, unsigned index)
+gimple_call_arg_ptr (const gimple *gs, unsigned index)
 {
   GIMPLE_CHECK (gs, GIMPLE_CALL);
   return gimple_op_ptr (gs, index + 3);
@@ -2613,7 +2613,7 @@ gimple_call_arg_ptr (const_gimple gs, unsigned index)
 /* Set ARG to be the argument at position INDEX for call statement GS.  */
 
 static inline void
-gimple_call_set_arg (gimple gs, unsigned index, tree arg)
+gimple_call_set_arg (gimple *gs, unsigned index, tree arg)
 {
   GIMPLE_CHECK (gs, GIMPLE_CALL);
   gimple_set_op (gs, index + 3, arg);
@@ -2625,7 +2625,7 @@ gimple_call_set_arg (gimple gs, unsigned index, tree arg)
    candidate for tail call optimization.  */
 
 static inline void
-gimple_call_set_tail (gimple s, bool tail_p)
+gimple_call_set_tail (gimple *s, bool tail_p)
 {
   GIMPLE_CHECK (s, GIMPLE_CALL);
   if (tail_p)
@@ -2638,7 +2638,7 @@ gimple_call_set_tail (gimple s, bool tail_p)
 /* Return true if GIMPLE_CALL S is marked as a tail call.  */
 
 static inline bool
-gimple_call_tail_p (gimple s)
+gimple_call_tail_p (gimple *s)
 {
   GIMPLE_CHECK (s, GIMPLE_CALL);
   return (s->subcode & GF_CALL_TAILCALL) != 0;
@@ -2650,7 +2650,7 @@ gimple_call_tail_p (gimple s)
    expansion as the return slot for calls that return in memory.  */
 
 static inline void
-gimple_call_set_return_slot_opt (gimple s, bool return_slot_opt_p)
+gimple_call_set_return_slot_opt (gimple *s, bool return_slot_opt_p)
 {
   GIMPLE_CHECK (s, GIMPLE_CALL);
   if (return_slot_opt_p)
@@ -2663,7 +2663,7 @@ gimple_call_set_return_slot_opt (gimple s, bool return_slot_opt_p)
 /* Return true if S is marked for return slot optimization.  */
 
 static inline bool
-gimple_call_return_slot_opt_p (gimple s)
+gimple_call_return_slot_opt_p (gimple *s)
 {
   GIMPLE_CHECK (s, GIMPLE_CALL);
   return (s->subcode & GF_CALL_RETURN_SLOT_OPT) != 0;
@@ -2674,7 +2674,7 @@ gimple_call_return_slot_opt_p (gimple s)
    thunk to the thunked-to function.  */
 
 static inline void
-gimple_call_set_from_thunk (gimple s, bool from_thunk_p)
+gimple_call_set_from_thunk (gimple *s, bool from_thunk_p)
 {
   GIMPLE_CHECK (s, GIMPLE_CALL);
   if (from_thunk_p)
@@ -2687,7 +2687,7 @@ gimple_call_set_from_thunk (gimple s, bool from_thunk_p)
 /* Return true if GIMPLE_CALL S is a jump from a thunk.  */
 
 static inline bool
-gimple_call_from_thunk_p (gimple s)
+gimple_call_from_thunk_p (gimple *s)
 {
   GIMPLE_CHECK (s, GIMPLE_CALL);
   return (s->subcode & GF_CALL_FROM_THUNK) != 0;
@@ -2698,7 +2698,7 @@ gimple_call_from_thunk_p (gimple s)
    argument pack in its argument list.  */
 
 static inline void
-gimple_call_set_va_arg_pack (gimple s, bool pass_arg_pack_p)
+gimple_call_set_va_arg_pack (gimple *s, bool pass_arg_pack_p)
 {
   GIMPLE_CHECK (s, GIMPLE_CALL);
   if (pass_arg_pack_p)
@@ -2712,7 +2712,7 @@ gimple_call_set_va_arg_pack (gimple s, bool pass_arg_pack_p)
    argument pack in its argument list.  */
 
 static inline bool
-gimple_call_va_arg_pack_p (gimple s)
+gimple_call_va_arg_pack_p (gimple *s)
 {
   GIMPLE_CHECK (s, GIMPLE_CALL);
   return (s->subcode & GF_CALL_VA_ARG_PACK) != 0;
@@ -2722,7 +2722,7 @@ gimple_call_va_arg_pack_p (gimple s)
 /* Return true if S is a noreturn call.  */
 
 static inline bool
-gimple_call_noreturn_p (gimple s)
+gimple_call_noreturn_p (gimple *s)
 {
   GIMPLE_CHECK (s, GIMPLE_CALL);
   return (gimple_call_flags (s) & ECF_NORETURN) != 0;
@@ -2733,7 +2733,7 @@ gimple_call_noreturn_p (gimple s)
    even if the called function can throw in other cases.  */
 
 static inline void
-gimple_call_set_nothrow (gimple s, bool nothrow_p)
+gimple_call_set_nothrow (gimple *s, bool nothrow_p)
 {
   GIMPLE_CHECK (s, GIMPLE_CALL);
   if (nothrow_p)
@@ -2745,7 +2745,7 @@ gimple_call_set_nothrow (gimple s, bool nothrow_p)
 /* Return true if S is a nothrow call.  */
 
 static inline bool
-gimple_call_nothrow_p (gimple s)
+gimple_call_nothrow_p (gimple *s)
 {
   GIMPLE_CHECK (s, GIMPLE_CALL);
   return (gimple_call_flags (s) & ECF_NOTHROW) != 0;
@@ -2757,7 +2757,7 @@ gimple_call_nothrow_p (gimple s)
    stack growth even when they occur in loops.  */
 
 static inline void
-gimple_call_set_alloca_for_var (gimple s, bool for_var)
+gimple_call_set_alloca_for_var (gimple *s, bool for_var)
 {
   GIMPLE_CHECK (s, GIMPLE_CALL);
   if (for_var)
@@ -2769,7 +2769,7 @@ gimple_call_set_alloca_for_var (gimple s, bool for_var)
 /* Return true of S is a call to builtin_alloca emitted for VLA objects.  */
 
 static inline bool
-gimple_call_alloca_for_var_p (gimple s)
+gimple_call_alloca_for_var_p (gimple *s)
 {
   GIMPLE_CHECK (s, GIMPLE_CALL);
   return (s->subcode & GF_CALL_ALLOCA_FOR_VAR) != 0;
@@ -2778,7 +2778,7 @@ gimple_call_alloca_for_var_p (gimple s)
 /* Copy all the GF_CALL_* flags from ORIG_CALL to DEST_CALL.  */
 
 static inline void
-gimple_call_copy_flags (gimple dest_call, gimple orig_call)
+gimple_call_copy_flags (gimple *dest_call, gimple *orig_call)
 {
   GIMPLE_CHECK (dest_call, GIMPLE_CALL);
   GIMPLE_CHECK (orig_call, GIMPLE_CALL);
@@ -2790,7 +2790,7 @@ gimple_call_copy_flags (gimple dest_call, gimple orig_call)
    variables of the call CALL.  */
 
 static inline struct pt_solution *
-gimple_call_use_set (gimple call)
+gimple_call_use_set (gimple *call)
 {
   gcall *call_stmt = as_a <gcall *> (call);
   return &call_stmt->call_used;
@@ -2801,7 +2801,7 @@ gimple_call_use_set (gimple call)
    variables of the call CALL.  */
 
 static inline struct pt_solution *
-gimple_call_clobber_set (gimple call)
+gimple_call_clobber_set (gimple *call)
 {
   gcall *call_stmt = as_a <gcall *> (call);
   return &call_stmt->call_clobbered;
@@ -2812,7 +2812,7 @@ gimple_call_clobber_set (gimple call)
    non-NULL lhs.  */
 
 static inline bool
-gimple_has_lhs (gimple stmt)
+gimple_has_lhs (gimple *stmt)
 {
   return (is_gimple_assign (stmt)
 	  || (is_gimple_call (stmt)
@@ -2823,7 +2823,7 @@ gimple_has_lhs (gimple stmt)
 /* Return the code of the predicate computed by conditional statement GS.  */
 
 static inline enum tree_code
-gimple_cond_code (const_gimple gs)
+gimple_cond_code (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_COND);
   return (enum tree_code) gs->subcode;
@@ -2833,7 +2833,7 @@ gimple_cond_code (const_gimple gs)
 /* Set CODE to be the predicate code for the conditional statement GS.  */
 
 static inline void
-gimple_cond_set_code (gimple gs, enum tree_code code)
+gimple_cond_set_code (gimple *gs, enum tree_code code)
 {
   GIMPLE_CHECK (gs, GIMPLE_COND);
   gs->subcode = code;
@@ -2843,7 +2843,7 @@ gimple_cond_set_code (gimple gs, enum tree_code code)
 /* Return the LHS of the predicate computed by conditional statement GS.  */
 
 static inline tree
-gimple_cond_lhs (const_gimple gs)
+gimple_cond_lhs (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_COND);
   return gimple_op (gs, 0);
@@ -2853,7 +2853,7 @@ gimple_cond_lhs (const_gimple gs)
    statement GS.  */
 
 static inline tree *
-gimple_cond_lhs_ptr (const_gimple gs)
+gimple_cond_lhs_ptr (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_COND);
   return gimple_op_ptr (gs, 0);
@@ -2863,7 +2863,7 @@ gimple_cond_lhs_ptr (const_gimple gs)
    conditional statement GS.  */
 
 static inline void
-gimple_cond_set_lhs (gimple gs, tree lhs)
+gimple_cond_set_lhs (gimple *gs, tree lhs)
 {
   GIMPLE_CHECK (gs, GIMPLE_COND);
   gimple_set_op (gs, 0, lhs);
@@ -2873,7 +2873,7 @@ gimple_cond_set_lhs (gimple gs, tree lhs)
 /* Return the RHS operand of the predicate computed by conditional GS.  */
 
 static inline tree
-gimple_cond_rhs (const_gimple gs)
+gimple_cond_rhs (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_COND);
   return gimple_op (gs, 1);
@@ -2883,7 +2883,7 @@ gimple_cond_rhs (const_gimple gs)
    conditional GS.  */
 
 static inline tree *
-gimple_cond_rhs_ptr (const_gimple gs)
+gimple_cond_rhs_ptr (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_COND);
   return gimple_op_ptr (gs, 1);
@@ -2894,7 +2894,7 @@ gimple_cond_rhs_ptr (const_gimple gs)
    conditional statement GS.  */
 
 static inline void
-gimple_cond_set_rhs (gimple gs, tree rhs)
+gimple_cond_set_rhs (gimple *gs, tree rhs)
 {
   GIMPLE_CHECK (gs, GIMPLE_COND);
   gimple_set_op (gs, 1, rhs);
@@ -2905,7 +2905,7 @@ gimple_cond_set_rhs (gimple gs, tree rhs)
    predicate evaluates to true.  */
 
 static inline tree
-gimple_cond_true_label (const_gimple gs)
+gimple_cond_true_label (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_COND);
   return gimple_op (gs, 2);
@@ -2916,7 +2916,7 @@ gimple_cond_true_label (const_gimple gs)
    predicate evaluates to true.  */
 
 static inline void
-gimple_cond_set_true_label (gimple gs, tree label)
+gimple_cond_set_true_label (gimple *gs, tree label)
 {
   GIMPLE_CHECK (gs, GIMPLE_COND);
   gimple_set_op (gs, 2, label);
@@ -2927,7 +2927,7 @@ gimple_cond_set_true_label (gimple gs, tree label)
    predicate evaluates to false.  */
 
 static inline void
-gimple_cond_set_false_label (gimple gs, tree label)
+gimple_cond_set_false_label (gimple *gs, tree label)
 {
   GIMPLE_CHECK (gs, GIMPLE_COND);
   gimple_set_op (gs, 3, label);
@@ -2938,7 +2938,7 @@ gimple_cond_set_false_label (gimple gs, tree label)
    predicate evaluates to false.  */
 
 static inline tree
-gimple_cond_false_label (const_gimple gs)
+gimple_cond_false_label (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_COND);
   return gimple_op (gs, 3);
@@ -2948,7 +2948,7 @@ gimple_cond_false_label (const_gimple gs)
 /* Set the conditional COND_STMT to be of the form 'if (1 == 0)'.  */
 
 static inline void
-gimple_cond_make_false (gimple gs)
+gimple_cond_make_false (gimple *gs)
 {
   gimple_cond_set_lhs (gs, boolean_true_node);
   gimple_cond_set_rhs (gs, boolean_false_node);
@@ -2959,7 +2959,7 @@ gimple_cond_make_false (gimple gs)
 /* Set the conditional COND_STMT to be of the form 'if (1 == 1)'.  */
 
 static inline void
-gimple_cond_make_true (gimple gs)
+gimple_cond_make_true (gimple *gs)
 {
   gimple_cond_set_lhs (gs, boolean_true_node);
   gimple_cond_set_rhs (gs, boolean_true_node);
@@ -2970,7 +2970,7 @@ gimple_cond_make_true (gimple gs)
   'if (0 == 0)', 'if (1 != 0)' or 'if (0 != 1)' */
 
 static inline bool
-gimple_cond_true_p (const_gimple gs)
+gimple_cond_true_p (const gimple *gs)
 {
   tree lhs = gimple_cond_lhs (gs);
   tree rhs = gimple_cond_rhs (gs);
@@ -2995,7 +2995,7 @@ gimple_cond_true_p (const_gimple gs)
    'if (0 != 0)', 'if (1 == 0)' or 'if (0 == 1)' */
 
 static inline bool
-gimple_cond_false_p (const_gimple gs)
+gimple_cond_false_p (const gimple *gs)
 {
   tree lhs = gimple_cond_lhs (gs);
   tree rhs = gimple_cond_rhs (gs);
@@ -3019,7 +3019,7 @@ gimple_cond_false_p (const_gimple gs)
 /* Set the code, LHS and RHS of GIMPLE_COND STMT from CODE, LHS and RHS.  */
 
 static inline void
-gimple_cond_set_condition (gimple stmt, enum tree_code code, tree lhs, tree rhs)
+gimple_cond_set_condition (gimple *stmt, enum tree_code code, tree lhs, tree rhs)
 {
   gimple_cond_set_code (stmt, code);
   gimple_cond_set_lhs (stmt, lhs);
@@ -3029,7 +3029,7 @@ gimple_cond_set_condition (gimple stmt, enum tree_code code, tree lhs, tree rhs)
 /* Return the LABEL_DECL node used by GIMPLE_LABEL statement GS.  */
 
 static inline tree
-gimple_label_label (const_gimple gs)
+gimple_label_label (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_LABEL);
   return gimple_op (gs, 0);
@@ -3040,7 +3040,7 @@ gimple_label_label (const_gimple gs)
    GS.  */
 
 static inline void
-gimple_label_set_label (gimple gs, tree label)
+gimple_label_set_label (gimple *gs, tree label)
 {
   GIMPLE_CHECK (gs, GIMPLE_LABEL);
   gimple_set_op (gs, 0, label);
@@ -3050,7 +3050,7 @@ gimple_label_set_label (gimple gs, tree label)
 /* Return the destination of the unconditional jump GS.  */
 
 static inline tree
-gimple_goto_dest (const_gimple gs)
+gimple_goto_dest (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_GOTO);
   return gimple_op (gs, 0);
@@ -3060,7 +3060,7 @@ gimple_goto_dest (const_gimple gs)
 /* Set DEST to be the destination of the unconditonal jump GS.  */
 
 static inline void
-gimple_goto_set_dest (gimple gs, tree dest)
+gimple_goto_set_dest (gimple *gs, tree dest)
 {
   GIMPLE_CHECK (gs, GIMPLE_GOTO);
   gimple_set_op (gs, 0, dest);
@@ -3070,7 +3070,7 @@ gimple_goto_set_dest (gimple gs, tree dest)
 /* Return the variables declared in the GIMPLE_BIND statement GS.  */
 
 static inline tree
-gimple_bind_vars (const_gimple gs)
+gimple_bind_vars (const gimple *gs)
 {
   const gbind *bind_stmt = as_a <const gbind *> (gs);
   return bind_stmt->vars;
@@ -3081,7 +3081,7 @@ gimple_bind_vars (const_gimple gs)
    statement GS.  */
 
 static inline void
-gimple_bind_set_vars (gimple gs, tree vars)
+gimple_bind_set_vars (gimple *gs, tree vars)
 {
   gbind *bind_stmt = as_a <gbind *> (gs);
   bind_stmt->vars = vars;
@@ -3092,7 +3092,7 @@ gimple_bind_set_vars (gimple gs, tree vars)
    statement GS.  */
 
 static inline void
-gimple_bind_append_vars (gimple gs, tree vars)
+gimple_bind_append_vars (gimple *gs, tree vars)
 {
   gbind *bind_stmt = as_a <gbind *> (gs);
   bind_stmt->vars = chainon (bind_stmt->vars, vars);
@@ -3100,7 +3100,7 @@ gimple_bind_append_vars (gimple gs, tree vars)
 
 
 static inline gimple_seq *
-gimple_bind_body_ptr (gimple gs)
+gimple_bind_body_ptr (gimple *gs)
 {
   gbind *bind_stmt = as_a <gbind *> (gs);
   return &bind_stmt->body;
@@ -3109,7 +3109,7 @@ gimple_bind_body_ptr (gimple gs)
 /* Return the GIMPLE sequence contained in the GIMPLE_BIND statement GS.  */
 
 static inline gimple_seq
-gimple_bind_body (gimple gs)
+gimple_bind_body (gimple *gs)
 {
   return *gimple_bind_body_ptr (gs);
 }
@@ -3119,7 +3119,7 @@ gimple_bind_body (gimple gs)
    statement GS.  */
 
 static inline void
-gimple_bind_set_body (gimple gs, gimple_seq seq)
+gimple_bind_set_body (gimple *gs, gimple_seq seq)
 {
   gbind *bind_stmt = as_a <gbind *> (gs);
   bind_stmt->body = seq;
@@ -3129,7 +3129,7 @@ gimple_bind_set_body (gimple gs, gimple_seq seq)
 /* Append a statement to the end of a GIMPLE_BIND's body.  */
 
 static inline void
-gimple_bind_add_stmt (gimple gs, gimple stmt)
+gimple_bind_add_stmt (gimple *gs, gimple *stmt)
 {
   gbind *bind_stmt = as_a <gbind *> (gs);
   gimple_seq_add_stmt (&bind_stmt->body, stmt);
@@ -3139,7 +3139,7 @@ gimple_bind_add_stmt (gimple gs, gimple stmt)
 /* Append a sequence of statements to the end of a GIMPLE_BIND's body.  */
 
 static inline void
-gimple_bind_add_seq (gimple gs, gimple_seq seq)
+gimple_bind_add_seq (gimple *gs, gimple_seq seq)
 {
   gbind *bind_stmt = as_a <gbind *> (gs);
   gimple_seq_add_seq (&bind_stmt->body, seq);
@@ -3150,7 +3150,7 @@ gimple_bind_add_seq (gimple gs, gimple_seq seq)
    GS.  This is analogous to the BIND_EXPR_BLOCK field in trees.  */
 
 static inline tree
-gimple_bind_block (const_gimple gs)
+gimple_bind_block (const gimple *gs)
 {
   const gbind *bind_stmt = as_a <const gbind *> (gs);
   return bind_stmt->block;
@@ -3161,7 +3161,7 @@ gimple_bind_block (const_gimple gs)
    statement GS.  */
 
 static inline void
-gimple_bind_set_block (gimple gs, tree block)
+gimple_bind_set_block (gimple *gs, tree block)
 {
   gbind *bind_stmt = as_a <gbind *> (gs);
   gcc_gimple_checking_assert (block == NULL_TREE
@@ -3173,7 +3173,7 @@ gimple_bind_set_block (gimple gs, tree block)
 /* Return the number of input operands for GIMPLE_ASM GS.  */
 
 static inline unsigned
-gimple_asm_ninputs (const_gimple gs)
+gimple_asm_ninputs (const gimple *gs)
 {
   const gasm *asm_stmt = as_a <const gasm *> (gs);
   return asm_stmt->ni;
@@ -3183,7 +3183,7 @@ gimple_asm_ninputs (const_gimple gs)
 /* Return the number of output operands for GIMPLE_ASM GS.  */
 
 static inline unsigned
-gimple_asm_noutputs (const_gimple gs)
+gimple_asm_noutputs (const gimple *gs)
 {
   const gasm *asm_stmt = as_a <const gasm *> (gs);
   return asm_stmt->no;
@@ -3193,7 +3193,7 @@ gimple_asm_noutputs (const_gimple gs)
 /* Return the number of clobber operands for GIMPLE_ASM GS.  */
 
 static inline unsigned
-gimple_asm_nclobbers (const_gimple gs)
+gimple_asm_nclobbers (const gimple *gs)
 {
   const gasm *asm_stmt = as_a <const gasm *> (gs);
   return asm_stmt->nc;
@@ -3202,7 +3202,7 @@ gimple_asm_nclobbers (const_gimple gs)
 /* Return the number of label operands for GIMPLE_ASM GS.  */
 
 static inline unsigned
-gimple_asm_nlabels (const_gimple gs)
+gimple_asm_nlabels (const gimple *gs)
 {
   const gasm *asm_stmt = as_a <const gasm *> (gs);
   return asm_stmt->nl;
@@ -3211,7 +3211,7 @@ gimple_asm_nlabels (const_gimple gs)
 /* Return input operand INDEX of GIMPLE_ASM GS.  */
 
 static inline tree
-gimple_asm_input_op (const_gimple gs, unsigned index)
+gimple_asm_input_op (const gimple *gs, unsigned index)
 {
   const gasm *asm_stmt = as_a <const gasm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->ni);
@@ -3221,7 +3221,7 @@ gimple_asm_input_op (const_gimple gs, unsigned index)
 /* Return a pointer to input operand INDEX of GIMPLE_ASM GS.  */
 
 static inline tree *
-gimple_asm_input_op_ptr (const_gimple gs, unsigned index)
+gimple_asm_input_op_ptr (const gimple *gs, unsigned index)
 {
   const gasm *asm_stmt = as_a <const gasm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->ni);
@@ -3232,7 +3232,7 @@ gimple_asm_input_op_ptr (const_gimple gs, unsigned index)
 /* Set IN_OP to be input operand INDEX in GIMPLE_ASM GS.  */
 
 static inline void
-gimple_asm_set_input_op (gimple gs, unsigned index, tree in_op)
+gimple_asm_set_input_op (gimple *gs, unsigned index, tree in_op)
 {
   gasm *asm_stmt = as_a <gasm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->ni
@@ -3244,7 +3244,7 @@ gimple_asm_set_input_op (gimple gs, unsigned index, tree in_op)
 /* Return output operand INDEX of GIMPLE_ASM GS.  */
 
 static inline tree
-gimple_asm_output_op (const_gimple gs, unsigned index)
+gimple_asm_output_op (const gimple *gs, unsigned index)
 {
   const gasm *asm_stmt = as_a <const gasm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->no);
@@ -3254,7 +3254,7 @@ gimple_asm_output_op (const_gimple gs, unsigned index)
 /* Return a pointer to output operand INDEX of GIMPLE_ASM GS.  */
 
 static inline tree *
-gimple_asm_output_op_ptr (const_gimple gs, unsigned index)
+gimple_asm_output_op_ptr (const gimple *gs, unsigned index)
 {
   const gasm *asm_stmt = as_a <const gasm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->no);
@@ -3265,7 +3265,7 @@ gimple_asm_output_op_ptr (const_gimple gs, unsigned index)
 /* Set OUT_OP to be output operand INDEX in GIMPLE_ASM GS.  */
 
 static inline void
-gimple_asm_set_output_op (gimple gs, unsigned index, tree out_op)
+gimple_asm_set_output_op (gimple *gs, unsigned index, tree out_op)
 {
   gasm *asm_stmt = as_a <gasm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->no
@@ -3277,7 +3277,7 @@ gimple_asm_set_output_op (gimple gs, unsigned index, tree out_op)
 /* Return clobber operand INDEX of GIMPLE_ASM GS.  */
 
 static inline tree
-gimple_asm_clobber_op (const_gimple gs, unsigned index)
+gimple_asm_clobber_op (const gimple *gs, unsigned index)
 {
   const gasm *asm_stmt = as_a <const gasm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->nc);
@@ -3288,7 +3288,7 @@ gimple_asm_clobber_op (const_gimple gs, unsigned index)
 /* Set CLOBBER_OP to be clobber operand INDEX in GIMPLE_ASM GS.  */
 
 static inline void
-gimple_asm_set_clobber_op (gimple gs, unsigned index, tree clobber_op)
+gimple_asm_set_clobber_op (gimple *gs, unsigned index, tree clobber_op)
 {
   gasm *asm_stmt = as_a <gasm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->nc
@@ -3299,7 +3299,7 @@ gimple_asm_set_clobber_op (gimple gs, unsigned index, tree clobber_op)
 /* Return label operand INDEX of GIMPLE_ASM GS.  */
 
 static inline tree
-gimple_asm_label_op (const_gimple gs, unsigned index)
+gimple_asm_label_op (const gimple *gs, unsigned index)
 {
   const gasm *asm_stmt = as_a <const gasm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->nl);
@@ -3309,7 +3309,7 @@ gimple_asm_label_op (const_gimple gs, unsigned index)
 /* Set LABEL_OP to be label operand INDEX in GIMPLE_ASM GS.  */
 
 static inline void
-gimple_asm_set_label_op (gimple gs, unsigned index, tree label_op)
+gimple_asm_set_label_op (gimple *gs, unsigned index, tree label_op)
 {
   gasm *asm_stmt = as_a <gasm *> (gs);
   gcc_gimple_checking_assert (index < asm_stmt->nl
@@ -3321,7 +3321,7 @@ gimple_asm_set_label_op (gimple gs, unsigned index, tree label_op)
    GIMPLE_ASM GS.  */
 
 static inline const char *
-gimple_asm_string (const_gimple gs)
+gimple_asm_string (const gimple *gs)
 {
   const gasm *asm_stmt = as_a <const gasm *> (gs);
   return asm_stmt->string;
@@ -3331,7 +3331,7 @@ gimple_asm_string (const_gimple gs)
 /* Return true if GS is an asm statement marked volatile.  */
 
 static inline bool
-gimple_asm_volatile_p (const_gimple gs)
+gimple_asm_volatile_p (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_ASM);
   return (gs->subcode & GF_ASM_VOLATILE) != 0;
@@ -3341,7 +3341,7 @@ gimple_asm_volatile_p (const_gimple gs)
 /* If VOLATLE_P is true, mark asm statement GS as volatile.  */
 
 static inline void
-gimple_asm_set_volatile (gimple gs, bool volatile_p)
+gimple_asm_set_volatile (gimple *gs, bool volatile_p)
 {
   GIMPLE_CHECK (gs, GIMPLE_ASM);
   if (volatile_p)
@@ -3354,7 +3354,7 @@ gimple_asm_set_volatile (gimple gs, bool volatile_p)
 /* If INPUT_P is true, mark asm GS as an ASM_INPUT.  */
 
 static inline void
-gimple_asm_set_input (gimple gs, bool input_p)
+gimple_asm_set_input (gimple *gs, bool input_p)
 {
   GIMPLE_CHECK (gs, GIMPLE_ASM);
   if (input_p)
@@ -3367,7 +3367,7 @@ gimple_asm_set_input (gimple gs, bool input_p)
 /* Return true if asm GS is an ASM_INPUT.  */
 
 static inline bool
-gimple_asm_input_p (const_gimple gs)
+gimple_asm_input_p (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_ASM);
   return (gs->subcode & GF_ASM_INPUT) != 0;
@@ -3377,7 +3377,7 @@ gimple_asm_input_p (const_gimple gs)
 /* Return the types handled by GIMPLE_CATCH statement GS.  */
 
 static inline tree
-gimple_catch_types (const_gimple gs)
+gimple_catch_types (const gimple *gs)
 {
   const gcatch *catch_stmt = as_a <const gcatch *> (gs);
   return catch_stmt->types;
@@ -3387,7 +3387,7 @@ gimple_catch_types (const_gimple gs)
 /* Return a pointer to the types handled by GIMPLE_CATCH statement GS.  */
 
 static inline tree *
-gimple_catch_types_ptr (gimple gs)
+gimple_catch_types_ptr (gimple *gs)
 {
   gcatch *catch_stmt = as_a <gcatch *> (gs);
   return &catch_stmt->types;
@@ -3398,7 +3398,7 @@ gimple_catch_types_ptr (gimple gs)
    the handler of GIMPLE_CATCH statement GS.  */
 
 static inline gimple_seq *
-gimple_catch_handler_ptr (gimple gs)
+gimple_catch_handler_ptr (gimple *gs)
 {
   gcatch *catch_stmt = as_a <gcatch *> (gs);
   return &catch_stmt->handler;
@@ -3409,7 +3409,7 @@ gimple_catch_handler_ptr (gimple gs)
    GIMPLE_CATCH statement GS.  */
 
 static inline gimple_seq
-gimple_catch_handler (gimple gs)
+gimple_catch_handler (gimple *gs)
 {
   return *gimple_catch_handler_ptr (gs);
 }
@@ -3418,7 +3418,7 @@ gimple_catch_handler (gimple gs)
 /* Set T to be the set of types handled by GIMPLE_CATCH GS.  */
 
 static inline void
-gimple_catch_set_types (gimple gs, tree t)
+gimple_catch_set_types (gimple *gs, tree t)
 {
   gcatch *catch_stmt = as_a <gcatch *> (gs);
   catch_stmt->types = t;
@@ -3428,7 +3428,7 @@ gimple_catch_set_types (gimple gs, tree t)
 /* Set HANDLER to be the body of GIMPLE_CATCH GS.  */
 
 static inline void
-gimple_catch_set_handler (gimple gs, gimple_seq handler)
+gimple_catch_set_handler (gimple *gs, gimple_seq handler)
 {
   gcatch *catch_stmt = as_a <gcatch *> (gs);
   catch_stmt->handler = handler;
@@ -3438,7 +3438,7 @@ gimple_catch_set_handler (gimple gs, gimple_seq handler)
 /* Return the types handled by GIMPLE_EH_FILTER statement GS.  */
 
 static inline tree
-gimple_eh_filter_types (const_gimple gs)
+gimple_eh_filter_types (const gimple *gs)
 {
   const geh_filter *eh_filter_stmt = as_a <const geh_filter *> (gs);
   return eh_filter_stmt->types;
@@ -3449,7 +3449,7 @@ gimple_eh_filter_types (const_gimple gs)
    GS.  */
 
 static inline tree *
-gimple_eh_filter_types_ptr (gimple gs)
+gimple_eh_filter_types_ptr (gimple *gs)
 {
   geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
   return &eh_filter_stmt->types;
@@ -3460,7 +3460,7 @@ gimple_eh_filter_types_ptr (gimple gs)
    GIMPLE_EH_FILTER statement fails.  */
 
 static inline gimple_seq *
-gimple_eh_filter_failure_ptr (gimple gs)
+gimple_eh_filter_failure_ptr (gimple *gs)
 {
   geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
   return &eh_filter_stmt->failure;
@@ -3471,7 +3471,7 @@ gimple_eh_filter_failure_ptr (gimple gs)
    statement fails.  */
 
 static inline gimple_seq
-gimple_eh_filter_failure (gimple gs)
+gimple_eh_filter_failure (gimple *gs)
 {
   return *gimple_eh_filter_failure_ptr (gs);
 }
@@ -3480,7 +3480,7 @@ gimple_eh_filter_failure (gimple gs)
 /* Set TYPES to be the set of types handled by GIMPLE_EH_FILTER GS.  */
 
 static inline void
-gimple_eh_filter_set_types (gimple gs, tree types)
+gimple_eh_filter_set_types (gimple *gs, tree types)
 {
   geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
   eh_filter_stmt->types = types;
@@ -3491,7 +3491,7 @@ gimple_eh_filter_set_types (gimple gs, tree types)
    for GIMPLE_EH_FILTER GS.  */
 
 static inline void
-gimple_eh_filter_set_failure (gimple gs, gimple_seq failure)
+gimple_eh_filter_set_failure (gimple *gs, gimple_seq failure)
 {
   geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
   eh_filter_stmt->failure = failure;
@@ -3500,7 +3500,7 @@ gimple_eh_filter_set_failure (gimple gs, gimple_seq failure)
 /* Get the function decl to be called by the MUST_NOT_THROW region.  */
 
 static inline tree
-gimple_eh_must_not_throw_fndecl (gimple gs)
+gimple_eh_must_not_throw_fndecl (gimple *gs)
 {
   geh_mnt *eh_mnt_stmt = as_a <geh_mnt *> (gs);
   return eh_mnt_stmt->fndecl;
@@ -3509,7 +3509,7 @@ gimple_eh_must_not_throw_fndecl (gimple gs)
 /* Set the function decl to be called by GS to DECL.  */
 
 static inline void
-gimple_eh_must_not_throw_set_fndecl (gimple gs, tree decl)
+gimple_eh_must_not_throw_set_fndecl (gimple *gs, tree decl)
 {
   geh_mnt *eh_mnt_stmt = as_a <geh_mnt *> (gs);
   eh_mnt_stmt->fndecl = decl;
@@ -3518,40 +3518,40 @@ gimple_eh_must_not_throw_set_fndecl (gimple gs, tree decl)
 /* GIMPLE_EH_ELSE accessors.  */
 
 static inline gimple_seq *
-gimple_eh_else_n_body_ptr (gimple gs)
+gimple_eh_else_n_body_ptr (gimple *gs)
 {
   geh_else *eh_else_stmt = as_a <geh_else *> (gs);
   return &eh_else_stmt->n_body;
 }
 
 static inline gimple_seq
-gimple_eh_else_n_body (gimple gs)
+gimple_eh_else_n_body (gimple *gs)
 {
   return *gimple_eh_else_n_body_ptr (gs);
 }
 
 static inline gimple_seq *
-gimple_eh_else_e_body_ptr (gimple gs)
+gimple_eh_else_e_body_ptr (gimple *gs)
 {
   geh_else *eh_else_stmt = as_a <geh_else *> (gs);
   return &eh_else_stmt->e_body;
 }
 
 static inline gimple_seq
-gimple_eh_else_e_body (gimple gs)
+gimple_eh_else_e_body (gimple *gs)
 {
   return *gimple_eh_else_e_body_ptr (gs);
 }
 
 static inline void
-gimple_eh_else_set_n_body (gimple gs, gimple_seq seq)
+gimple_eh_else_set_n_body (gimple *gs, gimple_seq seq)
 {
   geh_else *eh_else_stmt = as_a <geh_else *> (gs);
   eh_else_stmt->n_body = seq;
 }
 
 static inline void
-gimple_eh_else_set_e_body (gimple gs, gimple_seq seq)
+gimple_eh_else_set_e_body (gimple *gs, gimple_seq seq)
 {
   geh_else *eh_else_stmt = as_a <geh_else *> (gs);
   eh_else_stmt->e_body = seq;
@@ -3563,7 +3563,7 @@ gimple_eh_else_set_e_body (gimple gs, gimple_seq seq)
    either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY.  */
 
 static inline enum gimple_try_flags
-gimple_try_kind (const_gimple gs)
+gimple_try_kind (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_TRY);
   return (enum gimple_try_flags) (gs->subcode & GIMPLE_TRY_KIND);
@@ -3573,7 +3573,7 @@ gimple_try_kind (const_gimple gs)
 /* Set the kind of try block represented by GIMPLE_TRY GS.  */
 
 static inline void
-gimple_try_set_kind (gimple gs, enum gimple_try_flags kind)
+gimple_try_set_kind (gimple *gs, enum gimple_try_flags kind)
 {
   GIMPLE_CHECK (gs, GIMPLE_TRY);
   gcc_gimple_checking_assert (kind == GIMPLE_TRY_CATCH
@@ -3586,7 +3586,7 @@ gimple_try_set_kind (gimple gs, enum gimple_try_flags kind)
 /* Return the GIMPLE_TRY_CATCH_IS_CLEANUP flag.  */
 
 static inline bool
-gimple_try_catch_is_cleanup (const_gimple gs)
+gimple_try_catch_is_cleanup (const gimple *gs)
 {
   gcc_gimple_checking_assert (gimple_try_kind (gs) == GIMPLE_TRY_CATCH);
   return (gs->subcode & GIMPLE_TRY_CATCH_IS_CLEANUP) != 0;
@@ -3597,7 +3597,7 @@ gimple_try_catch_is_cleanup (const_gimple gs)
    body for GIMPLE_TRY GS.  */
 
 static inline gimple_seq *
-gimple_try_eval_ptr (gimple gs)
+gimple_try_eval_ptr (gimple *gs)
 {
   gtry *try_stmt = as_a <gtry *> (gs);
   return &try_stmt->eval;
@@ -3607,7 +3607,7 @@ gimple_try_eval_ptr (gimple gs)
 /* Return the sequence of statements used as the body for GIMPLE_TRY GS.  */
 
 static inline gimple_seq
-gimple_try_eval (gimple gs)
+gimple_try_eval (gimple *gs)
 {
   return *gimple_try_eval_ptr (gs);
 }
@@ -3617,7 +3617,7 @@ gimple_try_eval (gimple gs)
    GIMPLE_TRY GS.  */
 
 static inline gimple_seq *
-gimple_try_cleanup_ptr (gimple gs)
+gimple_try_cleanup_ptr (gimple *gs)
 {
   gtry *try_stmt = as_a <gtry *> (gs);
   return &try_stmt->cleanup;
@@ -3628,7 +3628,7 @@ gimple_try_cleanup_ptr (gimple gs)
    GIMPLE_TRY GS.  */
 
 static inline gimple_seq
-gimple_try_cleanup (gimple gs)
+gimple_try_cleanup (gimple *gs)
 {
   return *gimple_try_cleanup_ptr (gs);
 }
@@ -3637,7 +3637,7 @@ gimple_try_cleanup (gimple gs)
 /* Set the GIMPLE_TRY_CATCH_IS_CLEANUP flag.  */
 
 static inline void
-gimple_try_set_catch_is_cleanup (gimple g, bool catch_is_cleanup)
+gimple_try_set_catch_is_cleanup (gimple *g, bool catch_is_cleanup)
 {
   gcc_gimple_checking_assert (gimple_try_kind (g) == GIMPLE_TRY_CATCH);
   if (catch_is_cleanup)
@@ -3651,7 +3651,7 @@ gimple_try_set_catch_is_cleanup (gimple g, bool catch_is_cleanup)
    GIMPLE_TRY GS.  */
 
 static inline void
-gimple_try_set_eval (gimple gs, gimple_seq eval)
+gimple_try_set_eval (gimple *gs, gimple_seq eval)
 {
   gtry *try_stmt = as_a <gtry *> (gs);
   try_stmt->eval = eval;
@@ -3662,7 +3662,7 @@ gimple_try_set_eval (gimple gs, gimple_seq eval)
    body for GIMPLE_TRY GS.  */
 
 static inline void
-gimple_try_set_cleanup (gimple gs, gimple_seq cleanup)
+gimple_try_set_cleanup (gimple *gs, gimple_seq cleanup)
 {
   gtry *try_stmt = as_a <gtry *> (gs);
   try_stmt->cleanup = cleanup;
@@ -3672,7 +3672,7 @@ gimple_try_set_cleanup (gimple gs, gimple_seq cleanup)
 /* Return a pointer to the cleanup sequence for cleanup statement GS.  */
 
 static inline gimple_seq *
-gimple_wce_cleanup_ptr (gimple gs)
+gimple_wce_cleanup_ptr (gimple *gs)
 {
   gwce *wce_stmt = as_a <gwce *> (gs);
   return &wce_stmt->cleanup;
@@ -3682,7 +3682,7 @@ gimple_wce_cleanup_ptr (gimple gs)
 /* Return the cleanup sequence for cleanup statement GS.  */
 
 static inline gimple_seq
-gimple_wce_cleanup (gimple gs)
+gimple_wce_cleanup (gimple *gs)
 {
   return *gimple_wce_cleanup_ptr (gs);
 }
@@ -3691,7 +3691,7 @@ gimple_wce_cleanup (gimple gs)
 /* Set CLEANUP to be the cleanup sequence for GS.  */
 
 static inline void
-gimple_wce_set_cleanup (gimple gs, gimple_seq cleanup)
+gimple_wce_set_cleanup (gimple *gs, gimple_seq cleanup)
 {
   gwce *wce_stmt = as_a <gwce *> (gs);
   wce_stmt->cleanup = cleanup;
@@ -3701,7 +3701,7 @@ gimple_wce_set_cleanup (gimple gs, gimple_seq cleanup)
 /* Return the CLEANUP_EH_ONLY flag for a WCE tuple.  */
 
 static inline bool
-gimple_wce_cleanup_eh_only (const_gimple gs)
+gimple_wce_cleanup_eh_only (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
   return gs->subcode != 0;
@@ -3711,7 +3711,7 @@ gimple_wce_cleanup_eh_only (const_gimple gs)
 /* Set the CLEANUP_EH_ONLY flag for a WCE tuple.  */
 
 static inline void
-gimple_wce_set_cleanup_eh_only (gimple gs, bool eh_only_p)
+gimple_wce_set_cleanup_eh_only (gimple *gs, bool eh_only_p)
 {
   GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
   gs->subcode = (unsigned int) eh_only_p;
@@ -3721,7 +3721,7 @@ gimple_wce_set_cleanup_eh_only (gimple gs, bool eh_only_p)
 /* Return the maximum number of arguments supported by GIMPLE_PHI GS.  */
 
 static inline unsigned
-gimple_phi_capacity (const_gimple gs)
+gimple_phi_capacity (const gimple *gs)
 {
   const gphi *phi_stmt = as_a <const gphi *> (gs);
   return phi_stmt->capacity;
@@ -3733,7 +3733,7 @@ gimple_phi_capacity (const_gimple gs)
    GS.  */
 
 static inline unsigned
-gimple_phi_num_args (const_gimple gs)
+gimple_phi_num_args (const gimple *gs)
 {
   const gphi *phi_stmt = as_a <const gphi *> (gs);
   return phi_stmt->nargs;
@@ -3743,7 +3743,7 @@ gimple_phi_num_args (const_gimple gs)
 /* Return the SSA name created by GIMPLE_PHI GS.  */
 
 static inline tree
-gimple_phi_result (const_gimple gs)
+gimple_phi_result (const gimple *gs)
 {
   const gphi *phi_stmt = as_a <const gphi *> (gs);
   return phi_stmt->result;
@@ -3752,7 +3752,7 @@ gimple_phi_result (const_gimple gs)
 /* Return a pointer to the SSA name created by GIMPLE_PHI GS.  */
 
 static inline tree *
-gimple_phi_result_ptr (gimple gs)
+gimple_phi_result_ptr (gimple *gs)
 {
   gphi *phi_stmt = as_a <gphi *> (gs);
   return &phi_stmt->result;
@@ -3761,7 +3761,7 @@ gimple_phi_result_ptr (gimple gs)
 /* Set RESULT to be the SSA name created by GIMPLE_PHI GS.  */
 
 static inline void
-gimple_phi_set_result (gimple gs, tree result)
+gimple_phi_set_result (gimple *gs, tree result)
 {
   gphi *phi_stmt = as_a <gphi *> (gs);
   phi_stmt->result = result;
@@ -3774,7 +3774,7 @@ gimple_phi_set_result (gimple gs, tree result)
    GIMPLE_PHI GS.  */
 
 static inline struct phi_arg_d *
-gimple_phi_arg (gimple gs, unsigned index)
+gimple_phi_arg (gimple *gs, unsigned index)
 {
   gphi *phi_stmt = as_a <gphi *> (gs);
   gcc_gimple_checking_assert (index <= phi_stmt->capacity);
@@ -3785,7 +3785,7 @@ gimple_phi_arg (gimple gs, unsigned index)
    for GIMPLE_PHI GS.  */
 
 static inline void
-gimple_phi_set_arg (gimple gs, unsigned index, struct phi_arg_d * phiarg)
+gimple_phi_set_arg (gimple *gs, unsigned index, struct phi_arg_d * phiarg)
 {
   gphi *phi_stmt = as_a <gphi *> (gs);
   gcc_gimple_checking_assert (index <= phi_stmt->nargs);
@@ -3814,7 +3814,7 @@ phi_nodes_ptr (basic_block bb)
 /* Return the tree operand for argument I of PHI node GS.  */
 
 static inline tree
-gimple_phi_arg_def (gimple gs, size_t index)
+gimple_phi_arg_def (gimple *gs, size_t index)
 {
   return gimple_phi_arg (gs, index)->def;
 }
@@ -3823,7 +3823,7 @@ gimple_phi_arg_def (gimple gs, size_t index)
 /* Return a pointer to the tree operand for argument I of PHI node GS.  */
 
 static inline tree *
-gimple_phi_arg_def_ptr (gimple gs, size_t index)
+gimple_phi_arg_def_ptr (gimple *gs, size_t index)
 {
   return &gimple_phi_arg (gs, index)->def;
 }
@@ -3831,7 +3831,7 @@ gimple_phi_arg_def_ptr (gimple gs, size_t index)
 /* Return the edge associated with argument I of phi node GS.  */
 
 static inline edge
-gimple_phi_arg_edge (gimple gs, size_t i)
+gimple_phi_arg_edge (gimple *gs, size_t i)
 {
   return EDGE_PRED (gimple_bb (gs), i);
 }
@@ -3839,7 +3839,7 @@ gimple_phi_arg_edge (gimple gs, size_t i)
 /* Return the source location of gimple argument I of phi node GS.  */
 
 static inline source_location
-gimple_phi_arg_location (gimple gs, size_t i)
+gimple_phi_arg_location (gimple *gs, size_t i)
 {
   return gimple_phi_arg (gs, i)->locus;
 }
@@ -3847,7 +3847,7 @@ gimple_phi_arg_location (gimple gs, size_t i)
 /* Return the source location of the argument on edge E of phi node GS.  */
 
 static inline source_location
-gimple_phi_arg_location_from_edge (gimple gs, edge e)
+gimple_phi_arg_location_from_edge (gimple *gs, edge e)
 {
   return gimple_phi_arg (gs, e->dest_idx)->locus;
 }
@@ -3855,7 +3855,7 @@ gimple_phi_arg_location_from_edge (gimple gs, edge e)
 /* Set the source location of gimple argument I of phi node GS to LOC.  */
 
 static inline void
-gimple_phi_arg_set_location (gimple gs, size_t i, source_location loc)
+gimple_phi_arg_set_location (gimple *gs, size_t i, source_location loc)
 {
   gimple_phi_arg (gs, i)->locus = loc;
 }
@@ -3863,7 +3863,7 @@ gimple_phi_arg_set_location (gimple gs, size_t i, source_location loc)
 /* Return TRUE if argument I of phi node GS has a location record.  */
 
 static inline bool
-gimple_phi_arg_has_location (gimple gs, size_t i)
+gimple_phi_arg_has_location (gimple *gs, size_t i)
 {
   return gimple_phi_arg_location (gs, i) != UNKNOWN_LOCATION;
 }
@@ -3872,7 +3872,7 @@ gimple_phi_arg_has_location (gimple gs, size_t i)
 /* Return the region number for GIMPLE_RESX GS.  */
 
 static inline int
-gimple_resx_region (const_gimple gs)
+gimple_resx_region (const gimple *gs)
 {
   const gresx *resx_stmt = as_a <const gresx *> (gs);
   return resx_stmt->region;
@@ -3881,7 +3881,7 @@ gimple_resx_region (const_gimple gs)
 /* Set REGION to be the region number for GIMPLE_RESX GS.  */
 
 static inline void
-gimple_resx_set_region (gimple gs, int region)
+gimple_resx_set_region (gimple *gs, int region)
 {
   gresx *resx_stmt = as_a <gresx *> (gs);
   resx_stmt->region = region;
@@ -3890,7 +3890,7 @@ gimple_resx_set_region (gimple gs, int region)
 /* Return the region number for GIMPLE_EH_DISPATCH GS.  */
 
 static inline int
-gimple_eh_dispatch_region (const_gimple gs)
+gimple_eh_dispatch_region (const gimple *gs)
 {
   const geh_dispatch *eh_dispatch_stmt = as_a <const geh_dispatch *> (gs);
   return eh_dispatch_stmt->region;
@@ -3899,7 +3899,7 @@ gimple_eh_dispatch_region (const_gimple gs)
 /* Set REGION to be the region number for GIMPLE_EH_DISPATCH GS.  */
 
 static inline void
-gimple_eh_dispatch_set_region (gimple gs, int region)
+gimple_eh_dispatch_set_region (gimple *gs, int region)
 {
   geh_dispatch *eh_dispatch_stmt = as_a <geh_dispatch *> (gs);
   eh_dispatch_stmt->region = region;
@@ -3908,7 +3908,7 @@ gimple_eh_dispatch_set_region (gimple gs, int region)
 /* Return the number of labels associated with the switch statement GS.  */
 
 static inline unsigned
-gimple_switch_num_labels (const_gimple gs)
+gimple_switch_num_labels (const gimple *gs)
 {
   unsigned num_ops;
   GIMPLE_CHECK (gs, GIMPLE_SWITCH);
@@ -3921,7 +3921,7 @@ gimple_switch_num_labels (const_gimple gs)
 /* Set NLABELS to be the number of labels for the switch statement GS.  */
 
 static inline void
-gimple_switch_set_num_labels (gimple g, unsigned nlabels)
+gimple_switch_set_num_labels (gimple *g, unsigned nlabels)
 {
   GIMPLE_CHECK (g, GIMPLE_SWITCH);
   gimple_set_num_ops (g, nlabels + 1);
@@ -3931,7 +3931,7 @@ gimple_switch_set_num_labels (gimple g, unsigned nlabels)
 /* Return the index variable used by the switch statement GS.  */
 
 static inline tree
-gimple_switch_index (const_gimple gs)
+gimple_switch_index (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_SWITCH);
   return gimple_op (gs, 0);
@@ -3941,7 +3941,7 @@ gimple_switch_index (const_gimple gs)
 /* Return a pointer to the index variable for the switch statement GS.  */
 
 static inline tree *
-gimple_switch_index_ptr (const_gimple gs)
+gimple_switch_index_ptr (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_SWITCH);
   return gimple_op_ptr (gs, 0);
@@ -3951,7 +3951,7 @@ gimple_switch_index_ptr (const_gimple gs)
 /* Set INDEX to be the index variable for switch statement GS.  */
 
 static inline void
-gimple_switch_set_index (gimple gs, tree index)
+gimple_switch_set_index (gimple *gs, tree index)
 {
   GIMPLE_CHECK (gs, GIMPLE_SWITCH);
   gcc_gimple_checking_assert (SSA_VAR_P (index) || CONSTANT_CLASS_P (index));
@@ -3963,7 +3963,7 @@ gimple_switch_set_index (gimple gs, tree index)
    labels in a switch statement.  */
 
 static inline tree
-gimple_switch_label (const_gimple gs, unsigned index)
+gimple_switch_label (const gimple *gs, unsigned index)
 {
   GIMPLE_CHECK (gs, GIMPLE_SWITCH);
   gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1);
@@ -3973,7 +3973,7 @@ gimple_switch_label (const_gimple gs, unsigned index)
 /* Set the label number INDEX to LABEL.  0 is always the default label.  */
 
 static inline void
-gimple_switch_set_label (gimple gs, unsigned index, tree label)
+gimple_switch_set_label (gimple *gs, unsigned index, tree label)
 {
   GIMPLE_CHECK (gs, GIMPLE_SWITCH);
   gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1
@@ -3985,7 +3985,7 @@ gimple_switch_set_label (gimple gs, unsigned index, tree label)
 /* Return the default label for a switch statement.  */
 
 static inline tree
-gimple_switch_default_label (const_gimple gs)
+gimple_switch_default_label (const gimple *gs)
 {
   tree label = gimple_switch_label (gs, 0);
   gcc_checking_assert (!CASE_LOW (label) && !CASE_HIGH (label));
@@ -3995,7 +3995,7 @@ gimple_switch_default_label (const_gimple gs)
 /* Set the default label for a switch statement.  */
 
 static inline void
-gimple_switch_set_default_label (gimple gs, tree label)
+gimple_switch_set_default_label (gimple *gs, tree label)
 {
   gcc_checking_assert (!CASE_LOW (label) && !CASE_HIGH (label));
   gimple_switch_set_label (gs, 0, label);
@@ -4004,7 +4004,7 @@ gimple_switch_set_default_label (gimple gs, tree label)
 /* Return true if GS is a GIMPLE_DEBUG statement.  */
 
 static inline bool
-is_gimple_debug (const_gimple gs)
+is_gimple_debug (const gimple *gs)
 {
   return gimple_code (gs) == GIMPLE_DEBUG;
 }
@@ -4012,7 +4012,7 @@ is_gimple_debug (const_gimple gs)
 /* Return true if S is a GIMPLE_DEBUG BIND statement.  */
 
 static inline bool
-gimple_debug_bind_p (const_gimple s)
+gimple_debug_bind_p (const gimple *s)
 {
   if (is_gimple_debug (s))
     return s->subcode == GIMPLE_DEBUG_BIND;
@@ -4023,7 +4023,7 @@ gimple_debug_bind_p (const_gimple s)
 /* Return the variable bound in a GIMPLE_DEBUG bind statement.  */
 
 static inline tree
-gimple_debug_bind_get_var (gimple dbg)
+gimple_debug_bind_get_var (gimple *dbg)
 {
   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
   gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
@@ -4034,7 +4034,7 @@ gimple_debug_bind_get_var (gimple dbg)
    statement.  */
 
 static inline tree
-gimple_debug_bind_get_value (gimple dbg)
+gimple_debug_bind_get_value (gimple *dbg)
 {
   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
   gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
@@ -4045,7 +4045,7 @@ gimple_debug_bind_get_value (gimple dbg)
    GIMPLE_DEBUG bind statement.  */
 
 static inline tree *
-gimple_debug_bind_get_value_ptr (gimple dbg)
+gimple_debug_bind_get_value_ptr (gimple *dbg)
 {
   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
   gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
@@ -4055,7 +4055,7 @@ gimple_debug_bind_get_value_ptr (gimple dbg)
 /* Set the variable bound in a GIMPLE_DEBUG bind statement.  */
 
 static inline void
-gimple_debug_bind_set_var (gimple dbg, tree var)
+gimple_debug_bind_set_var (gimple *dbg, tree var)
 {
   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
   gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
@@ -4066,7 +4066,7 @@ gimple_debug_bind_set_var (gimple dbg, tree var)
    statement.  */
 
 static inline void
-gimple_debug_bind_set_value (gimple dbg, tree value)
+gimple_debug_bind_set_value (gimple *dbg, tree value)
 {
   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
   gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
@@ -4081,7 +4081,7 @@ gimple_debug_bind_set_value (gimple dbg, tree value)
    statement.  */
 
 static inline void
-gimple_debug_bind_reset_value (gimple dbg)
+gimple_debug_bind_reset_value (gimple *dbg)
 {
   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
   gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
@@ -4092,7 +4092,7 @@ gimple_debug_bind_reset_value (gimple dbg)
    value.  */
 
 static inline bool
-gimple_debug_bind_has_value_p (gimple dbg)
+gimple_debug_bind_has_value_p (gimple *dbg)
 {
   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
   gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
@@ -4104,7 +4104,7 @@ gimple_debug_bind_has_value_p (gimple dbg)
 /* Return true if S is a GIMPLE_DEBUG SOURCE BIND statement.  */
 
 static inline bool
-gimple_debug_source_bind_p (const_gimple s)
+gimple_debug_source_bind_p (const gimple *s)
 {
   if (is_gimple_debug (s))
     return s->subcode == GIMPLE_DEBUG_SOURCE_BIND;
@@ -4115,7 +4115,7 @@ gimple_debug_source_bind_p (const_gimple s)
 /* Return the variable bound in a GIMPLE_DEBUG source bind statement.  */
 
 static inline tree
-gimple_debug_source_bind_get_var (gimple dbg)
+gimple_debug_source_bind_get_var (gimple *dbg)
 {
   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
   gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
@@ -4126,7 +4126,7 @@ gimple_debug_source_bind_get_var (gimple dbg)
    statement.  */
 
 static inline tree
-gimple_debug_source_bind_get_value (gimple dbg)
+gimple_debug_source_bind_get_value (gimple *dbg)
 {
   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
   gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
@@ -4137,7 +4137,7 @@ gimple_debug_source_bind_get_value (gimple dbg)
    GIMPLE_DEBUG source bind statement.  */
 
 static inline tree *
-gimple_debug_source_bind_get_value_ptr (gimple dbg)
+gimple_debug_source_bind_get_value_ptr (gimple *dbg)
 {
   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
   gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
@@ -4147,7 +4147,7 @@ gimple_debug_source_bind_get_value_ptr (gimple dbg)
 /* Set the variable bound in a GIMPLE_DEBUG source bind statement.  */
 
 static inline void
-gimple_debug_source_bind_set_var (gimple dbg, tree var)
+gimple_debug_source_bind_set_var (gimple *dbg, tree var)
 {
   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
   gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
@@ -4158,7 +4158,7 @@ gimple_debug_source_bind_set_var (gimple dbg, tree var)
    statement.  */
 
 static inline void
-gimple_debug_source_bind_set_value (gimple dbg, tree value)
+gimple_debug_source_bind_set_value (gimple *dbg, tree value)
 {
   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
   gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
@@ -4168,7 +4168,7 @@ gimple_debug_source_bind_set_value (gimple dbg, tree value)
 /* Return the line number for EXPR, or return -1 if we have no line
    number information for it.  */
 static inline int
-get_lineno (const_gimple stmt)
+get_lineno (const gimple *stmt)
 {
   location_t loc;
 
@@ -4185,7 +4185,7 @@ get_lineno (const_gimple stmt)
 /* Return a pointer to the body for the OMP statement GS.  */
 
 static inline gimple_seq *
-gimple_omp_body_ptr (gimple gs)
+gimple_omp_body_ptr (gimple *gs)
 {
   return &static_cast <gomp *> (gs)->body;
 }
@@ -4193,7 +4193,7 @@ gimple_omp_body_ptr (gimple gs)
 /* Return the body for the OMP statement GS.  */
 
 static inline gimple_seq
-gimple_omp_body (gimple gs)
+gimple_omp_body (gimple *gs)
 {
   return *gimple_omp_body_ptr (gs);
 }
@@ -4201,7 +4201,7 @@ gimple_omp_body (gimple gs)
 /* Set BODY to be the body for the OMP statement GS.  */
 
 static inline void
-gimple_omp_set_body (gimple gs, gimple_seq body)
+gimple_omp_set_body (gimple *gs, gimple_seq body)
 {
   static_cast <gomp *> (gs)->body = body;
 }
@@ -4210,7 +4210,7 @@ gimple_omp_set_body (gimple gs, gimple_seq body)
 /* Return the name associated with OMP_CRITICAL statement GS.  */
 
 static inline tree
-gimple_omp_critical_name (const_gimple gs)
+gimple_omp_critical_name (const gimple *gs)
 {
   const gomp_critical *omp_critical_stmt = as_a <const gomp_critical *> (gs);
   return omp_critical_stmt->name;
@@ -4220,7 +4220,7 @@ gimple_omp_critical_name (const_gimple gs)
 /* Return a pointer to the name associated with OMP critical statement GS.  */
 
 static inline tree *
-gimple_omp_critical_name_ptr (gimple gs)
+gimple_omp_critical_name_ptr (gimple *gs)
 {
   gomp_critical *omp_critical_stmt = as_a <gomp_critical *> (gs);
   return &omp_critical_stmt->name;
@@ -4230,7 +4230,7 @@ gimple_omp_critical_name_ptr (gimple gs)
 /* Set NAME to be the name associated with OMP critical statement GS.  */
 
 static inline void
-gimple_omp_critical_set_name (gimple gs, tree name)
+gimple_omp_critical_set_name (gimple *gs, tree name)
 {
   gomp_critical *omp_critical_stmt = as_a <gomp_critical *> (gs);
   omp_critical_stmt->name = name;
@@ -4240,7 +4240,7 @@ gimple_omp_critical_set_name (gimple gs, tree name)
 /* Return the kind of OMP for statemement.  */
 
 static inline int
-gimple_omp_for_kind (const_gimple g)
+gimple_omp_for_kind (const gimple *g)
 {
   GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
   return (gimple_omp_subcode (g) & GF_OMP_FOR_KIND_MASK);
@@ -4250,7 +4250,7 @@ gimple_omp_for_kind (const_gimple g)
 /* Set the OMP for kind.  */
 
 static inline void
-gimple_omp_for_set_kind (gimple g, int kind)
+gimple_omp_for_set_kind (gimple *g, int kind)
 {
   GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
   g->subcode = (g->subcode & ~GF_OMP_FOR_KIND_MASK)
@@ -4262,7 +4262,7 @@ gimple_omp_for_set_kind (gimple g, int kind)
    GF_OMP_FOR_COMBINED flag set.  */
 
 static inline bool
-gimple_omp_for_combined_p (const_gimple g)
+gimple_omp_for_combined_p (const gimple *g)
 {
   GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
   return (gimple_omp_subcode (g) & GF_OMP_FOR_COMBINED) != 0;
@@ -4273,7 +4273,7 @@ gimple_omp_for_combined_p (const_gimple g)
    value of COMBINED_P.  */
 
 static inline void
-gimple_omp_for_set_combined_p (gimple g, bool combined_p)
+gimple_omp_for_set_combined_p (gimple *g, bool combined_p)
 {
   GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
   if (combined_p)
@@ -4287,7 +4287,7 @@ gimple_omp_for_set_combined_p (gimple g, bool combined_p)
    GF_OMP_FOR_COMBINED_INTO flag set.  */
 
 static inline bool
-gimple_omp_for_combined_into_p (const_gimple g)
+gimple_omp_for_combined_into_p (const gimple *g)
 {
   GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
   return (gimple_omp_subcode (g) & GF_OMP_FOR_COMBINED_INTO) != 0;
@@ -4298,7 +4298,7 @@ gimple_omp_for_combined_into_p (const_gimple g)
    value of COMBINED_P.  */
 
 static inline void
-gimple_omp_for_set_combined_into_p (gimple g, bool combined_p)
+gimple_omp_for_set_combined_into_p (gimple *g, bool combined_p)
 {
   GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
   if (combined_p)
@@ -4311,7 +4311,7 @@ gimple_omp_for_set_combined_into_p (gimple g, bool combined_p)
 /* Return the clauses associated with OMP_FOR GS.  */
 
 static inline tree
-gimple_omp_for_clauses (const_gimple gs)
+gimple_omp_for_clauses (const gimple *gs)
 {
   const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
   return omp_for_stmt->clauses;
@@ -4321,7 +4321,7 @@ gimple_omp_for_clauses (const_gimple gs)
 /* Return a pointer to the OMP_FOR GS.  */
 
 static inline tree *
-gimple_omp_for_clauses_ptr (gimple gs)
+gimple_omp_for_clauses_ptr (gimple *gs)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   return &omp_for_stmt->clauses;
@@ -4331,7 +4331,7 @@ gimple_omp_for_clauses_ptr (gimple gs)
 /* Set CLAUSES to be the list of clauses associated with OMP_FOR GS.  */
 
 static inline void
-gimple_omp_for_set_clauses (gimple gs, tree clauses)
+gimple_omp_for_set_clauses (gimple *gs, tree clauses)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   omp_for_stmt->clauses = clauses;
@@ -4341,7 +4341,7 @@ gimple_omp_for_set_clauses (gimple gs, tree clauses)
 /* Get the collapse count of OMP_FOR GS.  */
 
 static inline size_t
-gimple_omp_for_collapse (gimple gs)
+gimple_omp_for_collapse (gimple *gs)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   return omp_for_stmt->collapse;
@@ -4351,7 +4351,7 @@ gimple_omp_for_collapse (gimple gs)
 /* Return the index variable for OMP_FOR GS.  */
 
 static inline tree
-gimple_omp_for_index (const_gimple gs, size_t i)
+gimple_omp_for_index (const gimple *gs, size_t i)
 {
   const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4362,7 +4362,7 @@ gimple_omp_for_index (const_gimple gs, size_t i)
 /* Return a pointer to the index variable for OMP_FOR GS.  */
 
 static inline tree *
-gimple_omp_for_index_ptr (gimple gs, size_t i)
+gimple_omp_for_index_ptr (gimple *gs, size_t i)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4373,7 +4373,7 @@ gimple_omp_for_index_ptr (gimple gs, size_t i)
 /* Set INDEX to be the index variable for OMP_FOR GS.  */
 
 static inline void
-gimple_omp_for_set_index (gimple gs, size_t i, tree index)
+gimple_omp_for_set_index (gimple *gs, size_t i, tree index)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4384,7 +4384,7 @@ gimple_omp_for_set_index (gimple gs, size_t i, tree index)
 /* Return the initial value for OMP_FOR GS.  */
 
 static inline tree
-gimple_omp_for_initial (const_gimple gs, size_t i)
+gimple_omp_for_initial (const gimple *gs, size_t i)
 {
   const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4395,7 +4395,7 @@ gimple_omp_for_initial (const_gimple gs, size_t i)
 /* Return a pointer to the initial value for OMP_FOR GS.  */
 
 static inline tree *
-gimple_omp_for_initial_ptr (gimple gs, size_t i)
+gimple_omp_for_initial_ptr (gimple *gs, size_t i)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4406,7 +4406,7 @@ gimple_omp_for_initial_ptr (gimple gs, size_t i)
 /* Set INITIAL to be the initial value for OMP_FOR GS.  */
 
 static inline void
-gimple_omp_for_set_initial (gimple gs, size_t i, tree initial)
+gimple_omp_for_set_initial (gimple *gs, size_t i, tree initial)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4417,7 +4417,7 @@ gimple_omp_for_set_initial (gimple gs, size_t i, tree initial)
 /* Return the final value for OMP_FOR GS.  */
 
 static inline tree
-gimple_omp_for_final (const_gimple gs, size_t i)
+gimple_omp_for_final (const gimple *gs, size_t i)
 {
   const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4428,7 +4428,7 @@ gimple_omp_for_final (const_gimple gs, size_t i)
 /* Return a pointer to the final value for OMP_FOR GS.  */
 
 static inline tree *
-gimple_omp_for_final_ptr (gimple gs, size_t i)
+gimple_omp_for_final_ptr (gimple *gs, size_t i)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4439,7 +4439,7 @@ gimple_omp_for_final_ptr (gimple gs, size_t i)
 /* Set FINAL to be the final value for OMP_FOR GS.  */
 
 static inline void
-gimple_omp_for_set_final (gimple gs, size_t i, tree final)
+gimple_omp_for_set_final (gimple *gs, size_t i, tree final)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4450,7 +4450,7 @@ gimple_omp_for_set_final (gimple gs, size_t i, tree final)
 /* Return the increment value for OMP_FOR GS.  */
 
 static inline tree
-gimple_omp_for_incr (const_gimple gs, size_t i)
+gimple_omp_for_incr (const gimple *gs, size_t i)
 {
   const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4461,7 +4461,7 @@ gimple_omp_for_incr (const_gimple gs, size_t i)
 /* Return a pointer to the increment value for OMP_FOR GS.  */
 
 static inline tree *
-gimple_omp_for_incr_ptr (gimple gs, size_t i)
+gimple_omp_for_incr_ptr (gimple *gs, size_t i)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4472,7 +4472,7 @@ gimple_omp_for_incr_ptr (gimple gs, size_t i)
 /* Set INCR to be the increment value for OMP_FOR GS.  */
 
 static inline void
-gimple_omp_for_set_incr (gimple gs, size_t i, tree incr)
+gimple_omp_for_set_incr (gimple *gs, size_t i, tree incr)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4484,7 +4484,7 @@ gimple_omp_for_set_incr (gimple gs, size_t i, tree incr)
    statement GS starts.  */
 
 static inline gimple_seq *
-gimple_omp_for_pre_body_ptr (gimple gs)
+gimple_omp_for_pre_body_ptr (gimple *gs)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   return &omp_for_stmt->pre_body;
@@ -4495,7 +4495,7 @@ gimple_omp_for_pre_body_ptr (gimple gs)
    statement GS starts.  */
 
 static inline gimple_seq
-gimple_omp_for_pre_body (gimple gs)
+gimple_omp_for_pre_body (gimple *gs)
 {
   return *gimple_omp_for_pre_body_ptr (gs);
 }
@@ -4505,7 +4505,7 @@ gimple_omp_for_pre_body (gimple gs)
    OMP_FOR statement GS starts.  */
 
 static inline void
-gimple_omp_for_set_pre_body (gimple gs, gimple_seq pre_body)
+gimple_omp_for_set_pre_body (gimple *gs, gimple_seq pre_body)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   omp_for_stmt->pre_body = pre_body;
@@ -4515,7 +4515,7 @@ gimple_omp_for_set_pre_body (gimple gs, gimple_seq pre_body)
 /* Return the clauses associated with OMP_PARALLEL GS.  */
 
 static inline tree
-gimple_omp_parallel_clauses (const_gimple gs)
+gimple_omp_parallel_clauses (const gimple *gs)
 {
   const gomp_parallel *omp_parallel_stmt =
     as_a <const gomp_parallel *> (gs);
@@ -4526,7 +4526,7 @@ gimple_omp_parallel_clauses (const_gimple gs)
 /* Return a pointer to the clauses associated with OMP_PARALLEL GS.  */
 
 static inline tree *
-gimple_omp_parallel_clauses_ptr (gimple gs)
+gimple_omp_parallel_clauses_ptr (gimple *gs)
 {
   gomp_parallel *omp_parallel_stmt = as_a <gomp_parallel *> (gs);
   return &omp_parallel_stmt->clauses;
@@ -4537,7 +4537,7 @@ gimple_omp_parallel_clauses_ptr (gimple gs)
    GS.  */
 
 static inline void
-gimple_omp_parallel_set_clauses (gimple gs, tree clauses)
+gimple_omp_parallel_set_clauses (gimple *gs, tree clauses)
 {
   gomp_parallel *omp_parallel_stmt = as_a <gomp_parallel *> (gs);
   omp_parallel_stmt->clauses = clauses;
@@ -4547,7 +4547,7 @@ gimple_omp_parallel_set_clauses (gimple gs, tree clauses)
 /* Return the child function used to hold the body of OMP_PARALLEL GS.  */
 
 static inline tree
-gimple_omp_parallel_child_fn (const_gimple gs)
+gimple_omp_parallel_child_fn (const gimple *gs)
 {
   const gomp_parallel *omp_parallel_stmt =
     as_a <const gomp_parallel *> (gs);
@@ -4558,7 +4558,7 @@ gimple_omp_parallel_child_fn (const_gimple gs)
    OMP_PARALLEL GS.  */
 
 static inline tree *
-gimple_omp_parallel_child_fn_ptr (gimple gs)
+gimple_omp_parallel_child_fn_ptr (gimple *gs)
 {
   gomp_parallel *omp_parallel_stmt = as_a <gomp_parallel *> (gs);
   return &omp_parallel_stmt->child_fn;
@@ -4568,7 +4568,7 @@ gimple_omp_parallel_child_fn_ptr (gimple gs)
 /* Set CHILD_FN to be the child function for OMP_PARALLEL GS.  */
 
 static inline void
-gimple_omp_parallel_set_child_fn (gimple gs, tree child_fn)
+gimple_omp_parallel_set_child_fn (gimple *gs, tree child_fn)
 {
   gomp_parallel *omp_parallel_stmt =as_a <gomp_parallel *> (gs);
   omp_parallel_stmt->child_fn = child_fn;
@@ -4579,7 +4579,7 @@ gimple_omp_parallel_set_child_fn (gimple gs, tree child_fn)
    from the parent to the children threads in OMP_PARALLEL GS.  */
 
 static inline tree
-gimple_omp_parallel_data_arg (const_gimple gs)
+gimple_omp_parallel_data_arg (const gimple *gs)
 {
   const gomp_parallel *omp_parallel_stmt =
     as_a <const gomp_parallel *> (gs);
@@ -4590,7 +4590,7 @@ gimple_omp_parallel_data_arg (const_gimple gs)
 /* Return a pointer to the data argument for OMP_PARALLEL GS.  */
 
 static inline tree *
-gimple_omp_parallel_data_arg_ptr (gimple gs)
+gimple_omp_parallel_data_arg_ptr (gimple *gs)
 {
   gomp_parallel *omp_parallel_stmt = as_a <gomp_parallel *> (gs);
   return &omp_parallel_stmt->data_arg;
@@ -4600,7 +4600,7 @@ gimple_omp_parallel_data_arg_ptr (gimple gs)
 /* Set DATA_ARG to be the data argument for OMP_PARALLEL GS.  */
 
 static inline void
-gimple_omp_parallel_set_data_arg (gimple gs, tree data_arg)
+gimple_omp_parallel_set_data_arg (gimple *gs, tree data_arg)
 {
   gomp_parallel *omp_parallel_stmt = as_a <gomp_parallel *> (gs);
   omp_parallel_stmt->data_arg = data_arg;
@@ -4610,7 +4610,7 @@ gimple_omp_parallel_set_data_arg (gimple gs, tree data_arg)
 /* Return the clauses associated with OMP_TASK GS.  */
 
 static inline tree
-gimple_omp_task_clauses (const_gimple gs)
+gimple_omp_task_clauses (const gimple *gs)
 {
   const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
   return omp_task_stmt->clauses;
@@ -4620,7 +4620,7 @@ gimple_omp_task_clauses (const_gimple gs)
 /* Return a pointer to the clauses associated with OMP_TASK GS.  */
 
 static inline tree *
-gimple_omp_task_clauses_ptr (gimple gs)
+gimple_omp_task_clauses_ptr (gimple *gs)
 {
   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   return &omp_task_stmt->clauses;
@@ -4631,7 +4631,7 @@ gimple_omp_task_clauses_ptr (gimple gs)
    GS.  */
 
 static inline void
-gimple_omp_task_set_clauses (gimple gs, tree clauses)
+gimple_omp_task_set_clauses (gimple *gs, tree clauses)
 {
   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   omp_task_stmt->clauses = clauses;
@@ -4641,7 +4641,7 @@ gimple_omp_task_set_clauses (gimple gs, tree clauses)
 /* Return the child function used to hold the body of OMP_TASK GS.  */
 
 static inline tree
-gimple_omp_task_child_fn (const_gimple gs)
+gimple_omp_task_child_fn (const gimple *gs)
 {
   const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
   return omp_task_stmt->child_fn;
@@ -4651,7 +4651,7 @@ gimple_omp_task_child_fn (const_gimple gs)
    OMP_TASK GS.  */
 
 static inline tree *
-gimple_omp_task_child_fn_ptr (gimple gs)
+gimple_omp_task_child_fn_ptr (gimple *gs)
 {
   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   return &omp_task_stmt->child_fn;
@@ -4661,7 +4661,7 @@ gimple_omp_task_child_fn_ptr (gimple gs)
 /* Set CHILD_FN to be the child function for OMP_TASK GS.  */
 
 static inline void
-gimple_omp_task_set_child_fn (gimple gs, tree child_fn)
+gimple_omp_task_set_child_fn (gimple *gs, tree child_fn)
 {
   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   omp_task_stmt->child_fn = child_fn;
@@ -4672,7 +4672,7 @@ gimple_omp_task_set_child_fn (gimple gs, tree child_fn)
    from the parent to the children threads in OMP_TASK GS.  */
 
 static inline tree
-gimple_omp_task_data_arg (const_gimple gs)
+gimple_omp_task_data_arg (const gimple *gs)
 {
   const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
   return omp_task_stmt->data_arg;
@@ -4682,7 +4682,7 @@ gimple_omp_task_data_arg (const_gimple gs)
 /* Return a pointer to the data argument for OMP_TASK GS.  */
 
 static inline tree *
-gimple_omp_task_data_arg_ptr (gimple gs)
+gimple_omp_task_data_arg_ptr (gimple *gs)
 {
   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   return &omp_task_stmt->data_arg;
@@ -4692,7 +4692,7 @@ gimple_omp_task_data_arg_ptr (gimple gs)
 /* Set DATA_ARG to be the data argument for OMP_TASK GS.  */
 
 static inline void
-gimple_omp_task_set_data_arg (gimple gs, tree data_arg)
+gimple_omp_task_set_data_arg (gimple *gs, tree data_arg)
 {
   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   omp_task_stmt->data_arg = data_arg;
@@ -4702,7 +4702,7 @@ gimple_omp_task_set_data_arg (gimple gs, tree data_arg)
 /* Return the clauses associated with OMP_TASK GS.  */
 
 static inline tree
-gimple_omp_taskreg_clauses (const_gimple gs)
+gimple_omp_taskreg_clauses (const gimple *gs)
 {
   const gomp_taskreg *omp_taskreg_stmt = as_a <const gomp_taskreg *> (gs);
   return omp_taskreg_stmt->clauses;
@@ -4712,7 +4712,7 @@ gimple_omp_taskreg_clauses (const_gimple gs)
 /* Return a pointer to the clauses associated with OMP_TASK GS.  */
 
 static inline tree *
-gimple_omp_taskreg_clauses_ptr (gimple gs)
+gimple_omp_taskreg_clauses_ptr (gimple *gs)
 {
   gomp_taskreg *omp_taskreg_stmt = as_a <gomp_taskreg *> (gs);
   return &omp_taskreg_stmt->clauses;
@@ -4723,7 +4723,7 @@ gimple_omp_taskreg_clauses_ptr (gimple gs)
    GS.  */
 
 static inline void
-gimple_omp_taskreg_set_clauses (gimple gs, tree clauses)
+gimple_omp_taskreg_set_clauses (gimple *gs, tree clauses)
 {
   gomp_taskreg *omp_taskreg_stmt = as_a <gomp_taskreg *> (gs);
   omp_taskreg_stmt->clauses = clauses;
@@ -4733,7 +4733,7 @@ gimple_omp_taskreg_set_clauses (gimple gs, tree clauses)
 /* Return the child function used to hold the body of OMP_TASK GS.  */
 
 static inline tree
-gimple_omp_taskreg_child_fn (const_gimple gs)
+gimple_omp_taskreg_child_fn (const gimple *gs)
 {
   const gomp_taskreg *omp_taskreg_stmt = as_a <const gomp_taskreg *> (gs);
   return omp_taskreg_stmt->child_fn;
@@ -4743,7 +4743,7 @@ gimple_omp_taskreg_child_fn (const_gimple gs)
    OMP_TASK GS.  */
 
 static inline tree *
-gimple_omp_taskreg_child_fn_ptr (gimple gs)
+gimple_omp_taskreg_child_fn_ptr (gimple *gs)
 {
   gomp_taskreg *omp_taskreg_stmt = as_a <gomp_taskreg *> (gs);
   return &omp_taskreg_stmt->child_fn;
@@ -4753,7 +4753,7 @@ gimple_omp_taskreg_child_fn_ptr (gimple gs)
 /* Set CHILD_FN to be the child function for OMP_TASK GS.  */
 
 static inline void
-gimple_omp_taskreg_set_child_fn (gimple gs, tree child_fn)
+gimple_omp_taskreg_set_child_fn (gimple *gs, tree child_fn)
 {
   gomp_taskreg *omp_taskreg_stmt = as_a <gomp_taskreg *> (gs);
   omp_taskreg_stmt->child_fn = child_fn;
@@ -4764,7 +4764,7 @@ gimple_omp_taskreg_set_child_fn (gimple gs, tree child_fn)
    from the parent to the children threads in OMP_TASK GS.  */
 
 static inline tree
-gimple_omp_taskreg_data_arg (const_gimple gs)
+gimple_omp_taskreg_data_arg (const gimple *gs)
 {
   const gomp_taskreg *omp_taskreg_stmt = as_a <const gomp_taskreg *> (gs);
   return omp_taskreg_stmt->data_arg;
@@ -4774,7 +4774,7 @@ gimple_omp_taskreg_data_arg (const_gimple gs)
 /* Return a pointer to the data argument for OMP_TASK GS.  */
 
 static inline tree *
-gimple_omp_taskreg_data_arg_ptr (gimple gs)
+gimple_omp_taskreg_data_arg_ptr (gimple *gs)
 {
   gomp_taskreg *omp_taskreg_stmt = as_a <gomp_taskreg *> (gs);
   return &omp_taskreg_stmt->data_arg;
@@ -4784,7 +4784,7 @@ gimple_omp_taskreg_data_arg_ptr (gimple gs)
 /* Set DATA_ARG to be the data argument for OMP_TASK GS.  */
 
 static inline void
-gimple_omp_taskreg_set_data_arg (gimple gs, tree data_arg)
+gimple_omp_taskreg_set_data_arg (gimple *gs, tree data_arg)
 {
   gomp_taskreg *omp_taskreg_stmt = as_a <gomp_taskreg *> (gs);
   omp_taskreg_stmt->data_arg = data_arg;
@@ -4794,7 +4794,7 @@ gimple_omp_taskreg_set_data_arg (gimple gs, tree data_arg)
 /* Return the copy function used to hold the body of OMP_TASK GS.  */
 
 static inline tree
-gimple_omp_task_copy_fn (const_gimple gs)
+gimple_omp_task_copy_fn (const gimple *gs)
 {
   const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
   return omp_task_stmt->copy_fn;
@@ -4804,7 +4804,7 @@ gimple_omp_task_copy_fn (const_gimple gs)
    OMP_TASK GS.  */
 
 static inline tree *
-gimple_omp_task_copy_fn_ptr (gimple gs)
+gimple_omp_task_copy_fn_ptr (gimple *gs)
 {
   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   return &omp_task_stmt->copy_fn;
@@ -4814,7 +4814,7 @@ gimple_omp_task_copy_fn_ptr (gimple gs)
 /* Set CHILD_FN to be the copy function for OMP_TASK GS.  */
 
 static inline void
-gimple_omp_task_set_copy_fn (gimple gs, tree copy_fn)
+gimple_omp_task_set_copy_fn (gimple *gs, tree copy_fn)
 {
   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   omp_task_stmt->copy_fn = copy_fn;
@@ -4824,7 +4824,7 @@ gimple_omp_task_set_copy_fn (gimple gs, tree copy_fn)
 /* Return size of the data block in bytes in OMP_TASK GS.  */
 
 static inline tree
-gimple_omp_task_arg_size (const_gimple gs)
+gimple_omp_task_arg_size (const gimple *gs)
 {
   const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
   return omp_task_stmt->arg_size;
@@ -4834,7 +4834,7 @@ gimple_omp_task_arg_size (const_gimple gs)
 /* Return a pointer to the data block size for OMP_TASK GS.  */
 
 static inline tree *
-gimple_omp_task_arg_size_ptr (gimple gs)
+gimple_omp_task_arg_size_ptr (gimple *gs)
 {
   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   return &omp_task_stmt->arg_size;
@@ -4844,7 +4844,7 @@ gimple_omp_task_arg_size_ptr (gimple gs)
 /* Set ARG_SIZE to be the data block size for OMP_TASK GS.  */
 
 static inline void
-gimple_omp_task_set_arg_size (gimple gs, tree arg_size)
+gimple_omp_task_set_arg_size (gimple *gs, tree arg_size)
 {
   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   omp_task_stmt->arg_size = arg_size;
@@ -4854,7 +4854,7 @@ gimple_omp_task_set_arg_size (gimple gs, tree arg_size)
 /* Return align of the data block in bytes in OMP_TASK GS.  */
 
 static inline tree
-gimple_omp_task_arg_align (const_gimple gs)
+gimple_omp_task_arg_align (const gimple *gs)
 {
   const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
   return omp_task_stmt->arg_align;
@@ -4864,7 +4864,7 @@ gimple_omp_task_arg_align (const_gimple gs)
 /* Return a pointer to the data block align for OMP_TASK GS.  */
 
 static inline tree *
-gimple_omp_task_arg_align_ptr (gimple gs)
+gimple_omp_task_arg_align_ptr (gimple *gs)
 {
   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   return &omp_task_stmt->arg_align;
@@ -4874,7 +4874,7 @@ gimple_omp_task_arg_align_ptr (gimple gs)
 /* Set ARG_SIZE to be the data block align for OMP_TASK GS.  */
 
 static inline void
-gimple_omp_task_set_arg_align (gimple gs, tree arg_align)
+gimple_omp_task_set_arg_align (gimple *gs, tree arg_align)
 {
   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   omp_task_stmt->arg_align = arg_align;
@@ -4884,7 +4884,7 @@ gimple_omp_task_set_arg_align (gimple gs, tree arg_align)
 /* Return the clauses associated with OMP_SINGLE GS.  */
 
 static inline tree
-gimple_omp_single_clauses (const_gimple gs)
+gimple_omp_single_clauses (const gimple *gs)
 {
   const gomp_single *omp_single_stmt = as_a <const gomp_single *> (gs);
   return omp_single_stmt->clauses;
@@ -4894,7 +4894,7 @@ gimple_omp_single_clauses (const_gimple gs)
 /* Return a pointer to the clauses associated with OMP_SINGLE GS.  */
 
 static inline tree *
-gimple_omp_single_clauses_ptr (gimple gs)
+gimple_omp_single_clauses_ptr (gimple *gs)
 {
   gomp_single *omp_single_stmt = as_a <gomp_single *> (gs);
   return &omp_single_stmt->clauses;
@@ -4904,7 +4904,7 @@ gimple_omp_single_clauses_ptr (gimple gs)
 /* Set CLAUSES to be the clauses associated with OMP_SINGLE GS.  */
 
 static inline void
-gimple_omp_single_set_clauses (gimple gs, tree clauses)
+gimple_omp_single_set_clauses (gimple *gs, tree clauses)
 {
   gomp_single *omp_single_stmt = as_a <gomp_single *> (gs);
   omp_single_stmt->clauses = clauses;
@@ -4914,7 +4914,7 @@ gimple_omp_single_set_clauses (gimple gs, tree clauses)
 /* Return the clauses associated with OMP_TARGET GS.  */
 
 static inline tree
-gimple_omp_target_clauses (const_gimple gs)
+gimple_omp_target_clauses (const gimple *gs)
 {
   const gomp_target *omp_target_stmt = as_a <const gomp_target *> (gs);
   return omp_target_stmt->clauses;
@@ -4924,7 +4924,7 @@ gimple_omp_target_clauses (const_gimple gs)
 /* Return a pointer to the clauses associated with OMP_TARGET GS.  */
 
 static inline tree *
-gimple_omp_target_clauses_ptr (gimple gs)
+gimple_omp_target_clauses_ptr (gimple *gs)
 {
   gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
   return &omp_target_stmt->clauses;
@@ -4934,7 +4934,7 @@ gimple_omp_target_clauses_ptr (gimple gs)
 /* Set CLAUSES to be the clauses associated with OMP_TARGET GS.  */
 
 static inline void
-gimple_omp_target_set_clauses (gimple gs, tree clauses)
+gimple_omp_target_set_clauses (gimple *gs, tree clauses)
 {
   gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
   omp_target_stmt->clauses = clauses;
@@ -4944,7 +4944,7 @@ gimple_omp_target_set_clauses (gimple gs, tree clauses)
 /* Return the kind of OMP target statemement.  */
 
 static inline int
-gimple_omp_target_kind (const_gimple g)
+gimple_omp_target_kind (const gimple *g)
 {
   GIMPLE_CHECK (g, GIMPLE_OMP_TARGET);
   return (gimple_omp_subcode (g) & GF_OMP_TARGET_KIND_MASK);
@@ -4954,7 +4954,7 @@ gimple_omp_target_kind (const_gimple g)
 /* Set the OMP target kind.  */
 
 static inline void
-gimple_omp_target_set_kind (gimple g, int kind)
+gimple_omp_target_set_kind (gimple *g, int kind)
 {
   GIMPLE_CHECK (g, GIMPLE_OMP_TARGET);
   g->subcode = (g->subcode & ~GF_OMP_TARGET_KIND_MASK)
@@ -4965,7 +4965,7 @@ gimple_omp_target_set_kind (gimple g, int kind)
 /* Return the child function used to hold the body of OMP_TARGET GS.  */
 
 static inline tree
-gimple_omp_target_child_fn (const_gimple gs)
+gimple_omp_target_child_fn (const gimple *gs)
 {
   const gomp_target *omp_target_stmt = as_a <const gomp_target *> (gs);
   return omp_target_stmt->child_fn;
@@ -4975,7 +4975,7 @@ gimple_omp_target_child_fn (const_gimple gs)
    OMP_TARGET GS.  */
 
 static inline tree *
-gimple_omp_target_child_fn_ptr (gimple gs)
+gimple_omp_target_child_fn_ptr (gimple *gs)
 {
   gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
   return &omp_target_stmt->child_fn;
@@ -4985,7 +4985,7 @@ gimple_omp_target_child_fn_ptr (gimple gs)
 /* Set CHILD_FN to be the child function for OMP_TARGET GS.  */
 
 static inline void
-gimple_omp_target_set_child_fn (gimple gs, tree child_fn)
+gimple_omp_target_set_child_fn (gimple *gs, tree child_fn)
 {
   gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
   omp_target_stmt->child_fn = child_fn;
@@ -4996,7 +4996,7 @@ gimple_omp_target_set_child_fn (gimple gs, tree child_fn)
    from the parent to the children threads in OMP_TARGET GS.  */
 
 static inline tree
-gimple_omp_target_data_arg (const_gimple gs)
+gimple_omp_target_data_arg (const gimple *gs)
 {
   const gomp_target *omp_target_stmt = as_a <const gomp_target *> (gs);
   return omp_target_stmt->data_arg;
@@ -5006,7 +5006,7 @@ gimple_omp_target_data_arg (const_gimple gs)
 /* Return a pointer to the data argument for OMP_TARGET GS.  */
 
 static inline tree *
-gimple_omp_target_data_arg_ptr (gimple gs)
+gimple_omp_target_data_arg_ptr (gimple *gs)
 {
   gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
   return &omp_target_stmt->data_arg;
@@ -5016,7 +5016,7 @@ gimple_omp_target_data_arg_ptr (gimple gs)
 /* Set DATA_ARG to be the data argument for OMP_TARGET GS.  */
 
 static inline void
-gimple_omp_target_set_data_arg (gimple gs, tree data_arg)
+gimple_omp_target_set_data_arg (gimple *gs, tree data_arg)
 {
   gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
   omp_target_stmt->data_arg = data_arg;
@@ -5026,7 +5026,7 @@ gimple_omp_target_set_data_arg (gimple gs, tree data_arg)
 /* Return the clauses associated with OMP_TEAMS GS.  */
 
 static inline tree
-gimple_omp_teams_clauses (const_gimple gs)
+gimple_omp_teams_clauses (const gimple *gs)
 {
   const gomp_teams *omp_teams_stmt = as_a <const gomp_teams *> (gs);
   return omp_teams_stmt->clauses;
@@ -5036,7 +5036,7 @@ gimple_omp_teams_clauses (const_gimple gs)
 /* Return a pointer to the clauses associated with OMP_TEAMS GS.  */
 
 static inline tree *
-gimple_omp_teams_clauses_ptr (gimple gs)
+gimple_omp_teams_clauses_ptr (gimple *gs)
 {
   gomp_teams *omp_teams_stmt = as_a <gomp_teams *> (gs);
   return &omp_teams_stmt->clauses;
@@ -5046,7 +5046,7 @@ gimple_omp_teams_clauses_ptr (gimple gs)
 /* Set CLAUSES to be the clauses associated with OMP_TEAMS GS.  */
 
 static inline void
-gimple_omp_teams_set_clauses (gimple gs, tree clauses)
+gimple_omp_teams_set_clauses (gimple *gs, tree clauses)
 {
   gomp_teams *omp_teams_stmt = as_a <gomp_teams *> (gs);
   omp_teams_stmt->clauses = clauses;
@@ -5056,7 +5056,7 @@ gimple_omp_teams_set_clauses (gimple gs, tree clauses)
 /* Return the clauses associated with OMP_SECTIONS GS.  */
 
 static inline tree
-gimple_omp_sections_clauses (const_gimple gs)
+gimple_omp_sections_clauses (const gimple *gs)
 {
   const gomp_sections *omp_sections_stmt =
     as_a <const gomp_sections *> (gs);
@@ -5067,7 +5067,7 @@ gimple_omp_sections_clauses (const_gimple gs)
 /* Return a pointer to the clauses associated with OMP_SECTIONS GS.  */
 
 static inline tree *
-gimple_omp_sections_clauses_ptr (gimple gs)
+gimple_omp_sections_clauses_ptr (gimple *gs)
 {
   gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
   return &omp_sections_stmt->clauses;
@@ -5078,7 +5078,7 @@ gimple_omp_sections_clauses_ptr (gimple gs)
    GS.  */
 
 static inline void
-gimple_omp_sections_set_clauses (gimple gs, tree clauses)
+gimple_omp_sections_set_clauses (gimple *gs, tree clauses)
 {
   gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
   omp_sections_stmt->clauses = clauses;
@@ -5089,7 +5089,7 @@ gimple_omp_sections_set_clauses (gimple gs, tree clauses)
    in GS.  */
 
 static inline tree
-gimple_omp_sections_control (const_gimple gs)
+gimple_omp_sections_control (const gimple *gs)
 {
   const gomp_sections *omp_sections_stmt =
     as_a <const gomp_sections *> (gs);
@@ -5101,7 +5101,7 @@ gimple_omp_sections_control (const_gimple gs)
    GS.  */
 
 static inline tree *
-gimple_omp_sections_control_ptr (gimple gs)
+gimple_omp_sections_control_ptr (gimple *gs)
 {
   gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
   return &omp_sections_stmt->control;
@@ -5112,7 +5112,7 @@ gimple_omp_sections_control_ptr (gimple gs)
    GIMPLE_OMP_SECTIONS in GS.  */
 
 static inline void
-gimple_omp_sections_set_control (gimple gs, tree control)
+gimple_omp_sections_set_control (gimple *gs, tree control)
 {
   gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
   omp_sections_stmt->control = control;
@@ -5122,7 +5122,7 @@ gimple_omp_sections_set_control (gimple gs, tree control)
 /* Set COND to be the condition code for OMP_FOR GS.  */
 
 static inline void
-gimple_omp_for_set_cond (gimple gs, size_t i, enum tree_code cond)
+gimple_omp_for_set_cond (gimple *gs, size_t i, enum tree_code cond)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (TREE_CODE_CLASS (cond) == tcc_comparison
@@ -5134,7 +5134,7 @@ gimple_omp_for_set_cond (gimple gs, size_t i, enum tree_code cond)
 /* Return the condition code associated with OMP_FOR GS.  */
 
 static inline enum tree_code
-gimple_omp_for_cond (const_gimple gs, size_t i)
+gimple_omp_for_cond (const gimple *gs, size_t i)
 {
   const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -5145,7 +5145,7 @@ gimple_omp_for_cond (const_gimple gs, size_t i)
 /* Set the value being stored in an atomic store.  */
 
 static inline void
-gimple_omp_atomic_store_set_val (gimple g, tree val)
+gimple_omp_atomic_store_set_val (gimple *g, tree val)
 {
   gomp_atomic_store *omp_atomic_store_stmt = as_a <gomp_atomic_store *> (g);
   omp_atomic_store_stmt->val = val;
@@ -5155,7 +5155,7 @@ gimple_omp_atomic_store_set_val (gimple g, tree val)
 /* Return the value being stored in an atomic store.  */
 
 static inline tree
-gimple_omp_atomic_store_val (const_gimple g)
+gimple_omp_atomic_store_val (const gimple *g)
 {
   const gomp_atomic_store *omp_atomic_store_stmt =
     as_a <const gomp_atomic_store *> (g);
@@ -5166,7 +5166,7 @@ gimple_omp_atomic_store_val (const_gimple g)
 /* Return a pointer to the value being stored in an atomic store.  */
 
 static inline tree *
-gimple_omp_atomic_store_val_ptr (gimple g)
+gimple_omp_atomic_store_val_ptr (gimple *g)
 {
   gomp_atomic_store *omp_atomic_store_stmt = as_a <gomp_atomic_store *> (g);
   return &omp_atomic_store_stmt->val;
@@ -5176,7 +5176,7 @@ gimple_omp_atomic_store_val_ptr (gimple g)
 /* Set the LHS of an atomic load.  */
 
 static inline void
-gimple_omp_atomic_load_set_lhs (gimple g, tree lhs)
+gimple_omp_atomic_load_set_lhs (gimple *g, tree lhs)
 {
   gomp_atomic_load *omp_atomic_load_stmt = as_a <gomp_atomic_load *> (g);
   omp_atomic_load_stmt->lhs = lhs;
@@ -5186,7 +5186,7 @@ gimple_omp_atomic_load_set_lhs (gimple g, tree lhs)
 /* Get the LHS of an atomic load.  */
 
 static inline tree
-gimple_omp_atomic_load_lhs (const_gimple g)
+gimple_omp_atomic_load_lhs (const gimple *g)
 {
   const gomp_atomic_load *omp_atomic_load_stmt =
     as_a <const gomp_atomic_load *> (g);
@@ -5197,7 +5197,7 @@ gimple_omp_atomic_load_lhs (const_gimple g)
 /* Return a pointer to the LHS of an atomic load.  */
 
 static inline tree *
-gimple_omp_atomic_load_lhs_ptr (gimple g)
+gimple_omp_atomic_load_lhs_ptr (gimple *g)
 {
   gomp_atomic_load *omp_atomic_load_stmt = as_a <gomp_atomic_load *> (g);
   return &omp_atomic_load_stmt->lhs;
@@ -5207,7 +5207,7 @@ gimple_omp_atomic_load_lhs_ptr (gimple g)
 /* Set the RHS of an atomic load.  */
 
 static inline void
-gimple_omp_atomic_load_set_rhs (gimple g, tree rhs)
+gimple_omp_atomic_load_set_rhs (gimple *g, tree rhs)
 {
   gomp_atomic_load *omp_atomic_load_stmt = as_a <gomp_atomic_load *> (g);
   omp_atomic_load_stmt->rhs = rhs;
@@ -5217,7 +5217,7 @@ gimple_omp_atomic_load_set_rhs (gimple g, tree rhs)
 /* Get the RHS of an atomic load.  */
 
 static inline tree
-gimple_omp_atomic_load_rhs (const_gimple g)
+gimple_omp_atomic_load_rhs (const gimple *g)
 {
   const gomp_atomic_load *omp_atomic_load_stmt = as_a <const gomp_atomic_load *> (g);
   return omp_atomic_load_stmt->rhs;
@@ -5227,7 +5227,7 @@ gimple_omp_atomic_load_rhs (const_gimple g)
 /* Return a pointer to the RHS of an atomic load.  */
 
 static inline tree *
-gimple_omp_atomic_load_rhs_ptr (gimple g)
+gimple_omp_atomic_load_rhs_ptr (gimple *g)
 {
   gomp_atomic_load *omp_atomic_load_stmt = as_a <gomp_atomic_load *> (g);
   return &omp_atomic_load_stmt->rhs;
@@ -5237,7 +5237,7 @@ gimple_omp_atomic_load_rhs_ptr (gimple g)
 /* Get the definition of the control variable in a GIMPLE_OMP_CONTINUE.  */
 
 static inline tree
-gimple_omp_continue_control_def (const_gimple g)
+gimple_omp_continue_control_def (const gimple *g)
 {
   const gomp_continue *omp_continue_stmt = as_a <const gomp_continue *> (g);
   return omp_continue_stmt->control_def;
@@ -5246,7 +5246,7 @@ gimple_omp_continue_control_def (const_gimple g)
 /* The same as above, but return the address.  */
 
 static inline tree *
-gimple_omp_continue_control_def_ptr (gimple g)
+gimple_omp_continue_control_def_ptr (gimple *g)
 {
   gomp_continue *omp_continue_stmt = as_a <gomp_continue *> (g);
   return &omp_continue_stmt->control_def;
@@ -5255,7 +5255,7 @@ gimple_omp_continue_control_def_ptr (gimple g)
 /* Set the definition of the control variable in a GIMPLE_OMP_CONTINUE.  */
 
 static inline void
-gimple_omp_continue_set_control_def (gimple g, tree def)
+gimple_omp_continue_set_control_def (gimple *g, tree def)
 {
   gomp_continue *omp_continue_stmt = as_a <gomp_continue *> (g);
   omp_continue_stmt->control_def = def;
@@ -5265,7 +5265,7 @@ gimple_omp_continue_set_control_def (gimple g, tree def)
 /* Get the use of the control variable in a GIMPLE_OMP_CONTINUE.  */
 
 static inline tree
-gimple_omp_continue_control_use (const_gimple g)
+gimple_omp_continue_control_use (const gimple *g)
 {
   const gomp_continue *omp_continue_stmt = as_a <const gomp_continue *> (g);
   return omp_continue_stmt->control_use;
@@ -5275,7 +5275,7 @@ gimple_omp_continue_control_use (const_gimple g)
 /* The same as above, but return the address.  */
 
 static inline tree *
-gimple_omp_continue_control_use_ptr (gimple g)
+gimple_omp_continue_control_use_ptr (gimple *g)
 {
   gomp_continue *omp_continue_stmt = as_a <gomp_continue *> (g);
   return &omp_continue_stmt->control_use;
@@ -5285,7 +5285,7 @@ gimple_omp_continue_control_use_ptr (gimple g)
 /* Set the use of the control variable in a GIMPLE_OMP_CONTINUE.  */
 
 static inline void
-gimple_omp_continue_set_control_use (gimple g, tree use)
+gimple_omp_continue_set_control_use (gimple *g, tree use)
 {
   gomp_continue *omp_continue_stmt = as_a <gomp_continue *> (g);
   omp_continue_stmt->control_use = use;
@@ -5294,7 +5294,7 @@ gimple_omp_continue_set_control_use (gimple g, tree use)
 /* Return a pointer to the body for the GIMPLE_TRANSACTION statement GS.  */
 
 static inline gimple_seq *
-gimple_transaction_body_ptr (gimple gs)
+gimple_transaction_body_ptr (gimple *gs)
 {
   gtransaction *transaction_stmt = as_a <gtransaction *> (gs);
   return &transaction_stmt->body;
@@ -5303,7 +5303,7 @@ gimple_transaction_body_ptr (gimple gs)
 /* Return the body for the GIMPLE_TRANSACTION statement GS.  */
 
 static inline gimple_seq
-gimple_transaction_body (gimple gs)
+gimple_transaction_body (gimple *gs)
 {
   return *gimple_transaction_body_ptr (gs);
 }
@@ -5311,14 +5311,14 @@ gimple_transaction_body (gimple gs)
 /* Return the label associated with a GIMPLE_TRANSACTION.  */
 
 static inline tree
-gimple_transaction_label (const_gimple gs)
+gimple_transaction_label (const gimple *gs)
 {
   const gtransaction *transaction_stmt = as_a <const gtransaction *> (gs);
   return transaction_stmt->label;
 }
 
 static inline tree *
-gimple_transaction_label_ptr (gimple gs)
+gimple_transaction_label_ptr (gimple *gs)
 {
   gtransaction *transaction_stmt = as_a <gtransaction *> (gs);
   return &transaction_stmt->label;
@@ -5327,7 +5327,7 @@ gimple_transaction_label_ptr (gimple gs)
 /* Return the subcode associated with a GIMPLE_TRANSACTION.  */
 
 static inline unsigned int
-gimple_transaction_subcode (const_gimple gs)
+gimple_transaction_subcode (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_TRANSACTION);
   return gs->subcode;
@@ -5336,7 +5336,7 @@ gimple_transaction_subcode (const_gimple gs)
 /* Set BODY to be the body for the GIMPLE_TRANSACTION statement GS.  */
 
 static inline void
-gimple_transaction_set_body (gimple gs, gimple_seq body)
+gimple_transaction_set_body (gimple *gs, gimple_seq body)
 {
   gtransaction *transaction_stmt = as_a <gtransaction *> (gs);
   transaction_stmt->body = body;
@@ -5345,7 +5345,7 @@ gimple_transaction_set_body (gimple gs, gimple_seq body)
 /* Set the label associated with a GIMPLE_TRANSACTION.  */
 
 static inline void
-gimple_transaction_set_label (gimple gs, tree label)
+gimple_transaction_set_label (gimple *gs, tree label)
 {
   gtransaction *transaction_stmt = as_a <gtransaction *> (gs);
   transaction_stmt->label = label;
@@ -5354,7 +5354,7 @@ gimple_transaction_set_label (gimple gs, tree label)
 /* Set the subcode associated with a GIMPLE_TRANSACTION.  */
 
 static inline void
-gimple_transaction_set_subcode (gimple gs, unsigned int subcode)
+gimple_transaction_set_subcode (gimple *gs, unsigned int subcode)
 {
   GIMPLE_CHECK (gs, GIMPLE_TRANSACTION);
   gs->subcode = subcode;
@@ -5364,7 +5364,7 @@ gimple_transaction_set_subcode (gimple gs, unsigned int subcode)
 /* Return a pointer to the return value for GIMPLE_RETURN GS.  */
 
 static inline tree *
-gimple_return_retval_ptr (const_gimple gs)
+gimple_return_retval_ptr (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_RETURN);
   return gimple_op_ptr (gs, 0);
@@ -5373,7 +5373,7 @@ gimple_return_retval_ptr (const_gimple gs)
 /* Return the return value for GIMPLE_RETURN GS.  */
 
 static inline tree
-gimple_return_retval (const_gimple gs)
+gimple_return_retval (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_RETURN);
   return gimple_op (gs, 0);
@@ -5383,7 +5383,7 @@ gimple_return_retval (const_gimple gs)
 /* Set RETVAL to be the return value for GIMPLE_RETURN GS.  */
 
 static inline void
-gimple_return_set_retval (gimple gs, tree retval)
+gimple_return_set_retval (gimple *gs, tree retval)
 {
   GIMPLE_CHECK (gs, GIMPLE_RETURN);
   gimple_set_op (gs, 0, retval);
@@ -5412,7 +5412,7 @@ gimple_return_set_retval (gimple gs, tree retval)
     case GIMPLE_OMP_CONTINUE
 
 static inline bool
-is_gimple_omp (const_gimple stmt)
+is_gimple_omp (const gimple *stmt)
 {
   switch (gimple_code (stmt))
     {
@@ -5427,7 +5427,7 @@ is_gimple_omp (const_gimple stmt)
 /* Returns TRUE if statement G is a GIMPLE_NOP.  */
 
 static inline bool
-gimple_nop_p (const_gimple g)
+gimple_nop_p (const gimple *g)
 {
   return gimple_code (g) == GIMPLE_NOP;
 }
@@ -5436,7 +5436,7 @@ gimple_nop_p (const_gimple g)
 /* Return true if GS is a GIMPLE_RESX.  */
 
 static inline bool
-is_gimple_resx (const_gimple gs)
+is_gimple_resx (const gimple *gs)
 {
   return gimple_code (gs) == GIMPLE_RESX;
 }
@@ -5444,7 +5444,7 @@ is_gimple_resx (const_gimple gs)
 /* Return the predictor of GIMPLE_PREDICT statement GS.  */
 
 static inline enum br_predictor
-gimple_predict_predictor (gimple gs)
+gimple_predict_predictor (gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_PREDICT);
   return (enum br_predictor) (gs->subcode & ~GF_PREDICT_TAKEN);
@@ -5454,7 +5454,7 @@ gimple_predict_predictor (gimple gs)
 /* Set the predictor of GIMPLE_PREDICT statement GS to PREDICT.  */
 
 static inline void
-gimple_predict_set_predictor (gimple gs, enum br_predictor predictor)
+gimple_predict_set_predictor (gimple *gs, enum br_predictor predictor)
 {
   GIMPLE_CHECK (gs, GIMPLE_PREDICT);
   gs->subcode = (gs->subcode & GF_PREDICT_TAKEN)
@@ -5465,7 +5465,7 @@ gimple_predict_set_predictor (gimple gs, enum br_predictor predictor)
 /* Return the outcome of GIMPLE_PREDICT statement GS.  */
 
 static inline enum prediction
-gimple_predict_outcome (gimple gs)
+gimple_predict_outcome (gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_PREDICT);
   return (gs->subcode & GF_PREDICT_TAKEN) ? TAKEN : NOT_TAKEN;
@@ -5475,7 +5475,7 @@ gimple_predict_outcome (gimple gs)
 /* Set the outcome of GIMPLE_PREDICT statement GS to OUTCOME.  */
 
 static inline void
-gimple_predict_set_outcome (gimple gs, enum prediction outcome)
+gimple_predict_set_outcome (gimple *gs, enum prediction outcome)
 {
   GIMPLE_CHECK (gs, GIMPLE_PREDICT);
   if (outcome == TAKEN)
@@ -5489,7 +5489,7 @@ gimple_predict_set_outcome (gimple gs, enum prediction outcome)
    void_type_node if the statement computes nothing.  */
 
 static inline tree
-gimple_expr_type (const_gimple stmt)
+gimple_expr_type (const gimple *stmt)
 {
   enum gimple_code code = gimple_code (stmt);
 
@@ -5563,7 +5563,7 @@ gimple_alloc_kind (enum gimple_code code)
    by annotate_all_with_location.  */
 
 static inline bool
-gimple_do_not_emit_location_p (gimple g)
+gimple_do_not_emit_location_p (gimple *g)
 {
   return gimple_plf (g, GF_PLF_1);
 }
@@ -5572,7 +5572,7 @@ gimple_do_not_emit_location_p (gimple g)
    annotate_one_with_location.  */
 
 static inline void
-gimple_set_do_not_emit_location (gimple g)
+gimple_set_do_not_emit_location (gimple *g)
 {
   /* The PLF flags are initialized to 0 when a new tuple is created,
      so no need to initialize it anywhere.  */
diff --git a/gcc/gimplify-me.c b/gcc/gimplify-me.c
index 05e986a..0357331 100644
--- a/gcc/gimplify-me.c
+++ b/gcc/gimplify-me.c
@@ -156,12 +156,12 @@ force_gimple_operand_gsi (gimple_stmt_iterator *gsi, tree expr,
    GIMPLE statements are inserted before *GSI_P.  */
 
 void
-gimple_regimplify_operands (gimple stmt, gimple_stmt_iterator *gsi_p)
+gimple_regimplify_operands (gimple *stmt, gimple_stmt_iterator *gsi_p)
 {
   size_t i, num_ops;
   tree lhs;
   gimple_seq pre = NULL;
-  gimple post_stmt = NULL;
+  gimple *post_stmt = NULL;
 
   push_gimplify_context (gimple_in_ssa_p (cfun));
 
diff --git a/gcc/gimplify-me.h b/gcc/gimplify-me.h
index 841831d..90d52bc 100644
--- a/gcc/gimplify-me.h
+++ b/gcc/gimplify-me.h
@@ -32,6 +32,6 @@ extern tree force_gimple_operand_gsi_1 (gimple_stmt_iterator *, tree,
 					bool, enum gsi_iterator_update);
 extern tree force_gimple_operand_gsi (gimple_stmt_iterator *, tree, bool, tree,
 				      bool, enum gsi_iterator_update);
-extern void gimple_regimplify_operands (gimple, gimple_stmt_iterator *);
+extern void gimple_regimplify_operands (gimple *, gimple_stmt_iterator *);
 
 #endif /* GCC_GIMPLIFY_ME_H */
diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index cf4ac84..f3e555f 100644
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -112,7 +112,7 @@ struct gimplify_ctx
 {
   struct gimplify_ctx *prev_context;
 
-  vec<gimple> bind_expr_stack;
+  vec<gimple *> bind_expr_stack;
   tree temps;
   gimple_seq conditional_cleanups;
   tree exit_label;
@@ -150,7 +150,7 @@ static enum gimplify_status gimplify_compound_expr (tree *, gimple_seq *, bool);
    only.  */
 
 static inline void
-gimplify_seq_add_stmt (gimple_seq *seq_p, gimple gs)
+gimplify_seq_add_stmt (gimple_seq *seq_p, gimple *gs)
 {
   gimple_seq_add_stmt_without_update (seq_p, gs);
 }
@@ -239,7 +239,7 @@ push_gimplify_context (bool in_ssa, bool rhs_cond_ok)
    BODY is not a sequence, but the first tuple in a sequence.  */
 
 void
-pop_gimplify_context (gimple body)
+pop_gimplify_context (gimple *body)
 {
   struct gimplify_ctx *c = gimplify_ctxp;
 
@@ -262,7 +262,7 @@ pop_gimplify_context (gimple body)
 /* Push a GIMPLE_BIND tuple onto the stack of bindings.  */
 
 static void
-gimple_push_bind_expr (gimple gimple_bind)
+gimple_push_bind_expr (gimple *gimple_bind)
 {
   gimplify_ctxp->bind_expr_stack.reserve (8);
   gimplify_ctxp->bind_expr_stack.safe_push (gimple_bind);
@@ -278,7 +278,7 @@ gimple_pop_bind_expr (void)
 
 /* Return the first element of the stack of bindings.  */
 
-gimple
+gimple *
 gimple_current_bind_expr (void)
 {
   return gimplify_ctxp->bind_expr_stack.last ();
@@ -286,7 +286,7 @@ gimple_current_bind_expr (void)
 
 /* Return the stack of bindings created during gimplification.  */
 
-vec<gimple> 
+vec<gimple *> 
 gimple_bind_expr_stack (void)
 {
   return gimplify_ctxp->bind_expr_stack;
@@ -388,7 +388,7 @@ gimplify_and_add (tree t, gimple_seq *seq_p)
    tuple in the sequence of generated tuples for this statement.
    Return NULL if gimplifying T produced no tuples.  */
 
-static gimple
+static gimple *
 gimplify_and_return_first (tree t, gimple_seq *seq_p)
 {
   gimple_stmt_iterator last = gsi_last (*seq_p);
@@ -564,7 +564,7 @@ get_initialized_tmp_var (tree val, gimple_seq *pre_p, gimple_seq *post_p)
    generate debug info for them; otherwise don't.  */
 
 void
-declare_vars (tree vars, gimple scope, bool debug_info)
+declare_vars (tree vars, gimple *scope, bool debug_info)
 {
   tree last = vars;
   if (last)
@@ -1022,7 +1022,7 @@ voidify_wrapper_expr (tree wrapper, tree temp)
    a temporary through which they communicate.  */
 
 static void
-build_stack_save_restore (gimple *save, gimple *restore)
+build_stack_save_restore (gimple **save, gimple **restore)
 {
   tree tmp_var;
 
@@ -1043,9 +1043,9 @@ gimplify_bind_expr (tree *expr_p, gimple_seq *pre_p)
   tree bind_expr = *expr_p;
   bool old_save_stack = gimplify_ctxp->save_stack;
   tree t;
-  gimple gimple_bind;
+  gimple *gimple_bind;
   gimple_seq body, cleanup;
-  gimple stack_save;
+  gimple *stack_save;
 
   tree temp = voidify_wrapper_expr (bind_expr, NULL);
 
@@ -1102,7 +1102,7 @@ gimplify_bind_expr (tree *expr_p, gimple_seq *pre_p)
   stack_save = NULL;
   if (gimplify_ctxp->save_stack)
     {
-      gimple stack_restore;
+      gimple *stack_restore;
 
       /* Save stack on entry and restore it on exit.  Add a try_finally
 	 block to achieve this.  */
@@ -1134,7 +1134,7 @@ gimplify_bind_expr (tree *expr_p, gimple_seq *pre_p)
 
   if (cleanup)
     {
-      gimple gs;
+      gimple *gs;
       gimple_seq new_body;
 
       new_body = NULL;
@@ -1172,7 +1172,7 @@ gimplify_bind_expr (tree *expr_p, gimple_seq *pre_p)
 static enum gimplify_status
 gimplify_return_expr (tree stmt, gimple_seq *pre_p)
 {
-  gimple ret;
+  gimple *ret;
   tree ret_expr = TREE_OPERAND (stmt, 0);
   tree result_decl, result;
 
@@ -1192,7 +1192,7 @@ gimplify_return_expr (tree stmt, gimple_seq *pre_p)
       || TREE_CODE (ret_expr) == RESULT_DECL
       || ret_expr == error_mark_node)
     {
-      gimple ret = gimple_build_return (ret_expr);
+      gimple *ret = gimple_build_return (ret_expr);
       gimple_set_no_warning (ret, TREE_NO_WARNING (stmt));
       gimplify_seq_add_stmt (pre_p, ret);
       return GS_ALL_DONE;
@@ -1465,7 +1465,7 @@ gimplify_switch_expr (tree *expr_p, gimple_seq *pre_p)
       vec<tree> labels;
       vec<tree> saved_labels;
       tree default_case = NULL_TREE;
-      gimple gimple_switch;
+      gimple *gimple_switch;
 
       /* If someone can be bothered to fill in the labels, they can
 	 be bothered to null out the body too.  */
@@ -1485,7 +1485,7 @@ gimplify_switch_expr (tree *expr_p, gimple_seq *pre_p)
 
       if (!default_case)
 	{
-	  gimple new_default;
+	  gimple *new_default;
 
 	  default_case
 	    = build_case_label (NULL_TREE, NULL_TREE,
@@ -1512,7 +1512,7 @@ static enum gimplify_status
 gimplify_case_label_expr (tree *expr_p, gimple_seq *pre_p)
 {
   struct gimplify_ctx *ctxp;
-  gimple gimple_label;
+  gimple *gimple_label;
 
   /* Invalid OpenMP programs can play Duff's Device type games with
      #pragma omp parallel.  At least in the C front end, we don't
@@ -2233,7 +2233,7 @@ gimplify_call_expr (tree *expr_p, gimple_seq *pre_p, bool want_value)
   tree fndecl, parms, p, fnptrtype;
   enum gimplify_status ret;
   int i, nargs;
-  gimple call;
+  gimple *call;
   bool builtin_va_start_p = false;
   location_t loc = EXPR_LOCATION (*expr_p);
 
@@ -2920,7 +2920,7 @@ gimplify_cond_expr (tree *expr_p, gimple_seq *pre_p, fallback_t fallback)
   enum gimplify_status ret;
   tree label_true, label_false, label_cont;
   bool have_then_clause_p, have_else_clause_p;
-  gimple gimple_cond;
+  gimple *gimple_cond;
   enum tree_code pred_code;
   gimple_seq seq = NULL;
 
@@ -3094,7 +3094,7 @@ gimplify_cond_expr (tree *expr_p, gimple_seq *pre_p, fallback_t fallback)
 	      && TREE_OPERAND (expr, 2) != NULL_TREE
 	      && gimple_seq_may_fallthru (seq))
 	    {
-	      gimple g;
+	      gimple *g;
 	      label_cont = create_artificial_label (UNKNOWN_LOCATION);
 
 	      g = gimple_build_goto (label_cont);
@@ -3164,7 +3164,7 @@ gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value,
     				gimple_seq *seq_p)
 {
   tree t, to, to_ptr, from, from_ptr;
-  gimple gs;
+  gimple *gs;
   location_t loc = EXPR_LOCATION (*expr_p);
 
   to = TREE_OPERAND (*expr_p, 0);
@@ -3211,7 +3211,7 @@ gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value,
     				gimple_seq *seq_p)
 {
   tree t, from, to, to_ptr;
-  gimple gs;
+  gimple *gs;
   location_t loc = EXPR_LOCATION (*expr_p);
 
   /* Assert our assumptions, to abort instead of producing wrong code
@@ -4024,7 +4024,7 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
 	{
 	  tree lhs = TREE_OPERAND (*expr_p, 0);
 	  tree rhs = TREE_OPERAND (*expr_p, 1);
-	  gimple init = gimple_build_assign (lhs, rhs);
+	  gimple *init = gimple_build_assign (lhs, rhs);
 	  gimplify_seq_add_stmt (pre_p, init);
 	  *expr_p = NULL;
 	}
@@ -4451,7 +4451,7 @@ gimplify_modify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
   tree *from_p = &TREE_OPERAND (*expr_p, 1);
   tree *to_p = &TREE_OPERAND (*expr_p, 0);
   enum gimplify_status ret = GS_UNHANDLED;
-  gimple assign;
+  gimple *assign;
   location_t loc = EXPR_LOCATION (*expr_p);
   gimple_stmt_iterator gsi;
 
@@ -4883,7 +4883,7 @@ gimplify_asm_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
   const char *constraint;
   bool allows_mem, allows_reg, is_inout;
   enum gimplify_status ret, tret;
-  gimple stmt;
+  gimple *stmt;
   vec<tree, va_gc> *inputs;
   vec<tree, va_gc> *outputs;
   vec<tree, va_gc> *clobbers;
@@ -5156,7 +5156,7 @@ gimplify_cleanup_point_expr (tree *expr_p, gimple_seq *pre_p)
 
   for (iter = gsi_start (body_sequence); !gsi_end_p (iter); )
     {
-      gimple wce = gsi_stmt (iter);
+      gimple *wce = gsi_stmt (iter);
 
       if (gimple_code (wce) == GIMPLE_WITH_CLEANUP_EXPR)
 	{
@@ -5214,7 +5214,7 @@ gimplify_cleanup_point_expr (tree *expr_p, gimple_seq *pre_p)
 static void
 gimple_push_cleanup (tree var, tree cleanup, bool eh_only, gimple_seq *pre_p)
 {
-  gimple wce;
+  gimple *wce;
   gimple_seq cleanup_stmts = NULL;
 
   /* Errors can result in improperly nested cleanups.  Which results in
@@ -5245,8 +5245,8 @@ gimple_push_cleanup (tree var, tree cleanup, bool eh_only, gimple_seq *pre_p)
 	   val
       */
       tree flag = create_tmp_var (boolean_type_node, "cleanup");
-      gimple ffalse = gimple_build_assign (flag, boolean_false_node);
-      gimple ftrue = gimple_build_assign (flag, boolean_true_node);
+      gimple *ffalse = gimple_build_assign (flag, boolean_false_node);
+      gimple *ftrue = gimple_build_assign (flag, boolean_true_node);
 
       cleanup = build3 (COND_EXPR, void_type_node, flag, cleanup, NULL);
       gimplify_stmt (&cleanup, &cleanup_stmts);
@@ -6525,7 +6525,7 @@ static void
 gimplify_omp_parallel (tree *expr_p, gimple_seq *pre_p)
 {
   tree expr = *expr_p;
-  gimple g;
+  gimple *g;
   gimple_seq body = NULL;
 
   gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr), pre_p,
@@ -6561,7 +6561,7 @@ static void
 gimplify_omp_task (tree *expr_p, gimple_seq *pre_p)
 {
   tree expr = *expr_p;
-  gimple g;
+  gimple *g;
   gimple_seq body = NULL;
 
   gimplify_scan_omp_clauses (&OMP_TASK_CLAUSES (expr), pre_p,
@@ -6622,7 +6622,7 @@ gimplify_omp_for (tree *expr_p, gimple_seq *pre_p)
   tree for_stmt, orig_for_stmt, decl, var, t;
   enum gimplify_status ret = GS_ALL_DONE;
   enum gimplify_status tret;
-  gimple gfor;
+  gimple *gfor;
   gimple_seq for_body, for_pre_body;
   int i;
   bool simd;
@@ -6978,7 +6978,7 @@ static void
 gimplify_omp_workshare (tree *expr_p, gimple_seq *pre_p)
 {
   tree expr = *expr_p;
-  gimple stmt;
+  gimple *stmt;
   gimple_seq body = NULL;
   enum omp_region_type ort = ORT_WORKSHARE;
 
@@ -7003,7 +7003,7 @@ gimplify_omp_workshare (tree *expr_p, gimple_seq *pre_p)
   if (ort == ORT_TARGET || ort == ORT_TARGET_DATA)
     {
       push_gimplify_context ();
-      gimple g = gimplify_and_return_first (OMP_BODY (expr), &body);
+      gimple *g = gimplify_and_return_first (OMP_BODY (expr), &body);
       if (gimple_code (g) == GIMPLE_BIND)
 	pop_gimplify_context (g);
       else
@@ -7056,7 +7056,7 @@ static void
 gimplify_omp_target_update (tree *expr_p, gimple_seq *pre_p)
 {
   tree expr = *expr_p;
-  gimple stmt;
+  gimple *stmt;
 
   gimplify_scan_omp_clauses (&OMP_TARGET_UPDATE_CLAUSES (expr), pre_p,
 			     ORT_WORKSHARE);
@@ -7184,7 +7184,7 @@ gimplify_omp_atomic (tree *expr_p, gimple_seq *pre_p)
 	     ? NULL : TREE_OPERAND (*expr_p, 1);
   tree type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr)));
   tree tmp_load;
-  gimple loadstmt, storestmt;
+  gimple *loadstmt, *storestmt;
 
   tmp_load = create_tmp_reg (type, NULL);
   if (rhs && goa_stabilize_expr (&rhs, pre_p, addr, tmp_load) < 0)
@@ -7235,7 +7235,7 @@ static enum gimplify_status
 gimplify_transaction (tree *expr_p, gimple_seq *pre_p)
 {
   tree expr = *expr_p, temp, tbody = TRANSACTION_EXPR_BODY (expr);
-  gimple g;
+  gimple *g;
   gimple_seq body = NULL;
   int subcode = 0;
 
@@ -7604,7 +7604,7 @@ gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
 	      }
 	    tree tmp = create_tmp_var (type, NULL);
 	    gimplify_arg (&cond, pre_p, EXPR_LOCATION (*expr_p));
-	    gimple call
+	    gimple *call
 	      = gimple_build_call_internal (IFN_ANNOTATE, 2, cond, kind);
 	    gimple_call_set_lhs (call, tmp);
 	    gimplify_seq_add_stmt (pre_p, call);
@@ -7867,7 +7867,7 @@ gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
 	case TRY_CATCH_EXPR:
 	  {
 	    gimple_seq eval, cleanup;
-	    gimple try_;
+	    gimple *try_;
 
 	    /* Calls to destructors are generated automatically in FINALLY/CATCH
 	       block. They should have location as UNKNOWN_LOCATION. However,
@@ -7914,7 +7914,7 @@ gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
 
 	case CATCH_EXPR:
 	  {
-	    gimple c;
+	    gimple *c;
 	    gimple_seq handler = NULL;
 	    gimplify_and_add (CATCH_BODY (*expr_p), &handler);
 	    c = gimple_build_catch (CATCH_TYPES (*expr_p), handler);
@@ -7925,7 +7925,7 @@ gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
 
 	case EH_FILTER_EXPR:
 	  {
-	    gimple ehf;
+	    gimple *ehf;
 	    gimple_seq failure = NULL;
 
 	    gimplify_and_add (EH_FILTER_FAILURE (*expr_p), &failure);
@@ -8026,7 +8026,7 @@ gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
 	case OMP_CRITICAL:
 	  {
 	    gimple_seq body = NULL;
-	    gimple g;
+	    gimple *g;
 
 	    gimplify_and_add (OMP_BODY (*expr_p), &body);
 	    switch (TREE_CODE (*expr_p))
@@ -8605,12 +8605,12 @@ gimplify_one_sizepos (tree *expr_p, gimple_seq *stmt_p)
    containing the sequence of corresponding GIMPLE statements.  If DO_PARMS
    is true, also gimplify the parameters.  */
 
-gimple
+gimple *
 gimplify_body (tree fndecl, bool do_parms)
 {
   location_t saved_location = input_location;
   gimple_seq parm_stmts, seq;
-  gimple outer_bind;
+  gimple *outer_bind;
   struct cgraph_node *cgn;
 
   timevar_push (TV_TREE_GIMPLIFY);
@@ -8775,7 +8775,7 @@ gimplify_function_tree (tree fndecl)
 {
   tree parm, ret;
   gimple_seq seq;
-  gimple bind;
+  gimple *bind;
 
   gcc_assert (!gimple_body (fndecl));
 
@@ -8819,11 +8819,11 @@ gimplify_function_tree (tree fndecl)
       && !flag_instrument_functions_exclude_p (fndecl))
     {
       tree x;
-      gimple new_bind;
-      gimple tf;
+      gimple *new_bind;
+      gimple *tf;
       gimple_seq cleanup = NULL, body = NULL;
       tree tmp_var;
-      gimple call;
+      gimple *call;
 
       x = builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS);
       call = gimple_build_call (x, 1, integer_zero_node);
@@ -8977,7 +8977,7 @@ gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
 
    This function returns the newly created GIMPLE_ASSIGN tuple.  */
 
-gimple
+gimple *
 gimplify_assign (tree dst, tree src, gimple_seq *seq_p)
 {
   tree t = build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
diff --git a/gcc/gimplify.h b/gcc/gimplify.h
index 47e7213..fb2db31 100644
--- a/gcc/gimplify.h
+++ b/gcc/gimplify.h
@@ -52,13 +52,13 @@ enum gimplify_status {
 extern void free_gimplify_stack (void);
 extern void push_gimplify_context (bool in_ssa = false,
 				   bool rhs_cond_ok = false);
-extern void pop_gimplify_context (gimple);
-extern gimple gimple_current_bind_expr (void);
-extern vec<gimple> gimple_bind_expr_stack (void);
+extern void pop_gimplify_context (gimple *);
+extern gimple *gimple_current_bind_expr (void);
+extern vec<gimple *> gimple_bind_expr_stack (void);
 extern void gimplify_and_add (tree, gimple_seq *);
 extern tree get_formal_tmp_var (tree, gimple_seq *);
 extern tree get_initialized_tmp_var (tree, gimple_seq *, gimple_seq *);
-extern void declare_vars (tree, gimple, bool);
+extern void declare_vars (tree, gimple *, bool);
 extern void gimple_add_tmp_var (tree);
 extern void gimple_add_tmp_var_fn (struct function *, tree);
 extern tree unshare_expr (tree);
@@ -76,11 +76,11 @@ extern enum gimplify_status gimplify_expr (tree *, gimple_seq *, gimple_seq *,
 
 extern void gimplify_type_sizes (tree, gimple_seq *);
 extern void gimplify_one_sizepos (tree *, gimple_seq *);
-extern gimple gimplify_body (tree, bool);
+extern gimple *gimplify_body (tree, bool);
 extern void gimplify_function_tree (tree);
 extern enum gimplify_status gimplify_va_arg_expr (tree *, gimple_seq *,
 						  gimple_seq *);
-gimple gimplify_assign (tree, tree, gimple_seq *);
+gimple *gimplify_assign (tree, tree, gimple_seq *);
 
 /* Return true if gimplify_one_sizepos doesn't need to gimplify
    expr (when in TYPE_SIZE{,_UNIT} and similar type/decl size/bitsize
diff --git a/gcc/graphite-poly.c b/gcc/graphite-poly.c
index 4ca62f9..33dbaca 100644
--- a/gcc/graphite-poly.c
+++ b/gcc/graphite-poly.c
@@ -523,8 +523,8 @@ static void
 dump_gbb_cases (FILE *file, gimple_bb_p gbb)
 {
   int i;
-  gimple stmt;
-  vec<gimple> cases;
+  gimple *stmt;
+  vec<gimple *> cases;
 
   if (!gbb)
     return;
@@ -550,8 +550,8 @@ static void
 dump_gbb_conditions (FILE *file, gimple_bb_p gbb)
 {
   int i;
-  gimple stmt;
-  vec<gimple> conditions;
+  gimple *stmt;
+  vec<gimple *> conditions;
 
   if (!gbb)
     return;
diff --git a/gcc/graphite-scop-detection.c b/gcc/graphite-scop-detection.c
index 5d1c96e..b0101e3 100644
--- a/gcc/graphite-scop-detection.c
+++ b/gcc/graphite-scop-detection.c
@@ -286,7 +286,7 @@ graphite_can_represent_expr (basic_block scop_entry, loop_p loop,
 
 static bool
 stmt_has_simple_data_refs_p (loop_p outermost_loop ATTRIBUTE_UNUSED,
-			     gimple stmt)
+			     gimple *stmt)
 {
   data_reference_p dr;
   unsigned i;
@@ -326,7 +326,7 @@ stmt_has_simple_data_refs_p (loop_p outermost_loop ATTRIBUTE_UNUSED,
 
 static bool
 stmt_simple_for_scop_p (basic_block scop_entry, loop_p outermost_loop,
-			gimple stmt, basic_block bb)
+			gimple *stmt, basic_block bb)
 {
   loop_p loop = bb->loop_father;
 
@@ -397,7 +397,7 @@ stmt_simple_for_scop_p (basic_block scop_entry, loop_p outermost_loop,
    scop should end before this statement.  The evaluation is limited using
    OUTERMOST_LOOP as outermost loop that may change.  */
 
-static gimple
+static gimple *
 harmful_stmt_in_bb (basic_block scop_entry, loop_p outer_loop, basic_block bb)
 {
   gimple_stmt_iterator gsi;
@@ -459,7 +459,7 @@ scopdet_basic_block_info (basic_block bb, loop_p outermost_loop,
 {
   loop_p loop = bb->loop_father;
   struct scopdet_info result;
-  gimple stmt;
+  gimple *stmt;
 
   /* XXX: ENTRY_BLOCK_PTR could be optimized in later steps.  */
   basic_block entry_block = ENTRY_BLOCK_PTR_FOR_FN (cfun);
@@ -1244,7 +1244,7 @@ limit_scops (vec<scop_p> *scops)
    argument.  */
 
 static inline bool
-same_close_phi_node (gimple p1, gimple p2)
+same_close_phi_node (gimple *p1, gimple *p2)
 {
   return operand_equal_p (gimple_phi_arg_def (p1, 0),
 			  gimple_phi_arg_def (p2, 0), 0);
@@ -1254,9 +1254,9 @@ same_close_phi_node (gimple p1, gimple p2)
    of PHI.  */
 
 static void
-remove_duplicate_close_phi (gimple phi, gimple_stmt_iterator *gsi)
+remove_duplicate_close_phi (gimple *phi, gimple_stmt_iterator *gsi)
 {
-  gimple use_stmt;
+  gimple *use_stmt;
   use_operand_p use_p;
   imm_use_iterator imm_iter;
   tree res = gimple_phi_result (phi);
@@ -1292,7 +1292,7 @@ make_close_phi_nodes_unique (basic_block bb)
   for (psi = gsi_start_phis (bb); !gsi_end_p (psi); gsi_next (&psi))
     {
       gimple_stmt_iterator gsi = psi;
-      gimple phi = gsi_stmt (psi);
+      gimple *phi = gsi_stmt (psi);
 
       /* At this point, PHI should be a close phi in normal form.  */
       gcc_assert (gimple_phi_num_args (phi) == 1);
@@ -1334,7 +1334,7 @@ canonicalize_loop_closed_ssa (loop_p loop)
 
       for (psi = gsi_start_phis (bb); !gsi_end_p (psi); gsi_next (&psi))
 	{
-	  gimple phi = gsi_stmt (psi);
+	  gimple *phi = gsi_stmt (psi);
 	  unsigned i;
 
 	  for (i = 0; i < gimple_phi_num_args (phi); i++)
@@ -1342,7 +1342,7 @@ canonicalize_loop_closed_ssa (loop_p loop)
 	      {
 		tree res, arg = gimple_phi_arg_def (phi, i);
 		use_operand_p use_p;
-		gimple close_phi;
+		gimple *close_phi;
 
 		if (TREE_CODE (arg) != SSA_NAME)
 		  continue;
diff --git a/gcc/graphite-sese-to-poly.c b/gcc/graphite-sese-to-poly.c
index 0bc4433..439a069 100644
--- a/gcc/graphite-sese-to-poly.c
+++ b/gcc/graphite-sese-to-poly.c
@@ -80,7 +80,7 @@ tree_int_to_gmp (tree t, mpz_t res)
    loop.  */
 
 static size_t
-phi_arg_in_outermost_loop (gimple phi)
+phi_arg_in_outermost_loop (gimple *phi)
 {
   loop_p loop = gimple_bb (phi)->loop_father;
   size_t i, res = 0;
@@ -101,11 +101,11 @@ phi_arg_in_outermost_loop (gimple phi)
 static void
 remove_simple_copy_phi (gimple_stmt_iterator *psi)
 {
-  gimple phi = gsi_stmt (*psi);
+  gimple *phi = gsi_stmt (*psi);
   tree res = gimple_phi_result (phi);
   size_t entry = phi_arg_in_outermost_loop (phi);
   tree init = gimple_phi_arg_def (phi, entry);
-  gimple stmt = gimple_build_assign (res, init);
+  gimple *stmt = gimple_build_assign (res, init);
   edge e = gimple_phi_arg_edge (phi, entry);
 
   remove_phi_node (psi, false);
@@ -118,14 +118,14 @@ remove_simple_copy_phi (gimple_stmt_iterator *psi)
 static void
 remove_invariant_phi (sese region, gimple_stmt_iterator *psi)
 {
-  gimple phi = gsi_stmt (*psi);
+  gimple *phi = gsi_stmt (*psi);
   loop_p loop = loop_containing_stmt (phi);
   tree res = gimple_phi_result (phi);
   tree scev = scalar_evolution_in_region (region, loop, res);
   size_t entry = phi_arg_in_outermost_loop (phi);
   edge e = gimple_phi_arg_edge (phi, entry);
   tree var;
-  gimple stmt;
+  gimple *stmt;
   gimple_seq stmts = NULL;
 
   if (tree_contains_chrecs (scev, NULL))
@@ -144,7 +144,7 @@ remove_invariant_phi (sese region, gimple_stmt_iterator *psi)
 /* Returns true when the phi node at PSI is of the form "a = phi (a, x)".  */
 
 static inline bool
-simple_copy_phi_p (gimple phi)
+simple_copy_phi_p (gimple *phi)
 {
   tree res;
 
@@ -164,7 +164,7 @@ static bool
 reduction_phi_p (sese region, gimple_stmt_iterator *psi)
 {
   loop_p loop;
-  gimple phi = gsi_stmt (*psi);
+  gimple *phi = gsi_stmt (*psi);
   tree res = gimple_phi_result (phi);
 
   loop = loop_containing_stmt (phi);
@@ -314,7 +314,7 @@ try_generate_gimple_bb (scop_p scop, basic_block bb)
 
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       loop_p loop;
 
       if (is_gimple_debug (stmt))
@@ -914,7 +914,7 @@ find_params_in_bb (sese region, gimple_bb_p gbb)
   int i;
   unsigned j;
   data_reference_p dr;
-  gimple stmt;
+  gimple *stmt;
   loop_p loop = GBB_BB (gbb)->loop_father;
 
   /* Find parameters in the access functions of data references.  */
@@ -1118,7 +1118,7 @@ create_pw_aff_from_tree (poly_bb_p pbb, tree t)
    inequalities.  */
 
 static void
-add_condition_to_pbb (poly_bb_p pbb, gimple stmt, enum tree_code code)
+add_condition_to_pbb (poly_bb_p pbb, gimple *stmt, enum tree_code code)
 {
   isl_pw_aff *lhs = create_pw_aff_from_tree (pbb, gimple_cond_lhs (stmt));
   isl_pw_aff *rhs = create_pw_aff_from_tree (pbb, gimple_cond_rhs (stmt));
@@ -1167,7 +1167,7 @@ static void
 add_conditions_to_domain (poly_bb_p pbb)
 {
   unsigned int i;
-  gimple stmt;
+  gimple *stmt;
   gimple_bb_p gbb = PBB_BLACK_BOX (pbb);
 
   if (GBB_CONDITIONS (gbb).is_empty ())
@@ -1214,14 +1214,14 @@ add_conditions_to_constraints (scop_p scop)
    edge between BB and its predecessor is not a loop exit edge, and
    the last statement of the single predecessor is a COND_EXPR.  */
 
-static gimple
+static gimple *
 single_pred_cond_non_loop_exit (basic_block bb)
 {
   if (single_pred_p (bb))
     {
       edge e = single_pred_edge (bb);
       basic_block pred = e->src;
-      gimple stmt;
+      gimple *stmt;
 
       if (loop_depth (pred->loop_father) > loop_depth (bb->loop_father))
 	return NULL;
@@ -1244,7 +1244,7 @@ public:
   virtual void after_dom_children (basic_block);
 
 private:
-  auto_vec<gimple, 3> m_conditions, m_cases;
+  auto_vec<gimple *, 3> m_conditions, m_cases;
   sese m_region;
 };
 
@@ -1260,7 +1260,7 @@ void
 sese_dom_walker::before_dom_children (basic_block bb)
 {
   gimple_bb_p gbb;
-  gimple stmt;
+  gimple *stmt;
 
   if (!bb_in_sese_p (bb, m_region))
     return;
@@ -1931,7 +1931,7 @@ build_scop_drs (scop_p scop)
 /* Return a gsi at the position of the phi node STMT.  */
 
 static gimple_stmt_iterator
-gsi_for_phi_node (gimple stmt)
+gsi_for_phi_node (gimple *stmt)
 {
   gimple_stmt_iterator psi;
   basic_block bb = gimple_bb (stmt);
@@ -1948,11 +1948,11 @@ gsi_for_phi_node (gimple stmt)
    GBB_DATA_REFS vector of BB.  */
 
 static void
-analyze_drs_in_stmts (scop_p scop, basic_block bb, vec<gimple> stmts)
+analyze_drs_in_stmts (scop_p scop, basic_block bb, vec<gimple *> stmts)
 {
   loop_p nest;
   gimple_bb_p gbb;
-  gimple stmt;
+  gimple *stmt;
   int i;
   sese region = SCOP_REGION (scop);
 
@@ -1983,11 +1983,11 @@ analyze_drs_in_stmts (scop_p scop, basic_block bb, vec<gimple> stmts)
    on STMTS.  */
 
 static void
-insert_stmts (scop_p scop, gimple stmt, gimple_seq stmts,
+insert_stmts (scop_p scop, gimple *stmt, gimple_seq stmts,
 	      gimple_stmt_iterator insert_gsi)
 {
   gimple_stmt_iterator gsi;
-  auto_vec<gimple, 3> x;
+  auto_vec<gimple *, 3> x;
 
   gimple_seq_add_stmt (&stmts, stmt);
   for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi))
@@ -2000,13 +2000,13 @@ insert_stmts (scop_p scop, gimple stmt, gimple_seq stmts,
 /* Insert the assignment "RES := EXPR" just after AFTER_STMT.  */
 
 static void
-insert_out_of_ssa_copy (scop_p scop, tree res, tree expr, gimple after_stmt)
+insert_out_of_ssa_copy (scop_p scop, tree res, tree expr, gimple *after_stmt)
 {
   gimple_seq stmts;
   gimple_stmt_iterator gsi;
   tree var = force_gimple_operand (expr, &stmts, true, NULL_TREE);
-  gimple stmt = gimple_build_assign (unshare_expr (res), var);
-  auto_vec<gimple, 3> x;
+  gimple *stmt = gimple_build_assign (unshare_expr (res), var);
+  auto_vec<gimple *, 3> x;
 
   gimple_seq_add_stmt (&stmts, stmt);
   for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi))
@@ -2059,9 +2059,9 @@ insert_out_of_ssa_copy_on_edge (scop_p scop, edge e, tree res, tree expr)
   gimple_stmt_iterator gsi;
   gimple_seq stmts = NULL;
   tree var = force_gimple_operand (expr, &stmts, true, NULL_TREE);
-  gimple stmt = gimple_build_assign (unshare_expr (res), var);
+  gimple *stmt = gimple_build_assign (unshare_expr (res), var);
   basic_block bb;
-  auto_vec<gimple, 3> x;
+  auto_vec<gimple *, 3> x;
 
   gimple_seq_add_stmt (&stmts, stmt);
   for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi))
@@ -2097,7 +2097,7 @@ create_zero_dim_array (tree var, const char *base_name)
 /* Returns true when PHI is a loop close phi node.  */
 
 static bool
-scalar_close_phi_node_p (gimple phi)
+scalar_close_phi_node_p (gimple *phi)
 {
   if (gimple_code (phi) != GIMPLE_PHI
       || virtual_operand_p (gimple_phi_result (phi)))
@@ -2116,7 +2116,7 @@ static void
 propagate_expr_outside_region (tree def, tree expr, sese region)
 {
   imm_use_iterator imm_iter;
-  gimple use_stmt;
+  gimple *use_stmt;
   gimple_seq stmts;
   bool replaced_once = false;
 
@@ -2154,12 +2154,12 @@ static void
 rewrite_close_phi_out_of_ssa (scop_p scop, gimple_stmt_iterator *psi)
 {
   sese region = SCOP_REGION (scop);
-  gimple phi = gsi_stmt (*psi);
+  gimple *phi = gsi_stmt (*psi);
   tree res = gimple_phi_result (phi);
   basic_block bb = gimple_bb (phi);
   gimple_stmt_iterator gsi = gsi_after_labels (bb);
   tree arg = gimple_phi_arg_def (phi, 0);
-  gimple stmt;
+  gimple *stmt;
 
   /* Note that loop close phi nodes should have a single argument
      because we translated the representation into a canonical form
@@ -2235,11 +2235,11 @@ static void
 rewrite_phi_out_of_ssa (scop_p scop, gimple_stmt_iterator *psi)
 {
   size_t i;
-  gimple phi = gsi_stmt (*psi);
+  gimple *phi = gsi_stmt (*psi);
   basic_block bb = gimple_bb (phi);
   tree res = gimple_phi_result (phi);
   tree zero_dim_array = create_zero_dim_array (res, "phi_out_of_ssa");
-  gimple stmt;
+  gimple *stmt;
 
   for (i = 0; i < gimple_phi_num_args (phi); i++)
     {
@@ -2269,9 +2269,9 @@ static void
 rewrite_degenerate_phi (gimple_stmt_iterator *psi)
 {
   tree rhs;
-  gimple stmt;
+  gimple *stmt;
   gimple_stmt_iterator gsi;
-  gimple phi = gsi_stmt (*psi);
+  gimple *phi = gsi_stmt (*psi);
   tree res = gimple_phi_result (phi);
   basic_block bb;
 
@@ -2299,7 +2299,7 @@ rewrite_reductions_out_of_ssa (scop_p scop)
     if (bb_in_sese_p (bb, region))
       for (psi = gsi_start_phis (bb); !gsi_end_p (psi);)
 	{
-	  gimple phi = gsi_stmt (psi);
+	  gimple *phi = gsi_stmt (psi);
 
 	  if (virtual_operand_p (gimple_phi_result (phi)))
 	    {
@@ -2329,9 +2329,9 @@ rewrite_reductions_out_of_ssa (scop_p scop)
 
 static void
 rewrite_cross_bb_scalar_dependence (scop_p scop, tree zero_dim_array,
-				    tree def, gimple use_stmt)
+				    tree def, gimple *use_stmt)
 {
-  gimple name_stmt;
+  gimple *name_stmt;
   tree name;
   ssa_op_iter iter;
   use_operand_p use_p;
@@ -2356,14 +2356,14 @@ rewrite_cross_bb_scalar_dependence (scop_p scop, tree zero_dim_array,
    SCOP.  */
 
 static void
-handle_scalar_deps_crossing_scop_limits (scop_p scop, tree def, gimple stmt)
+handle_scalar_deps_crossing_scop_limits (scop_p scop, tree def, gimple *stmt)
 {
   tree var = create_tmp_reg (TREE_TYPE (def), NULL);
   tree new_name = make_ssa_name (var, stmt);
   bool needs_copy = false;
   use_operand_p use_p;
   imm_use_iterator imm_iter;
-  gimple use_stmt;
+  gimple *use_stmt;
   sese region = SCOP_REGION (scop);
 
   FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, def)
@@ -2384,7 +2384,7 @@ handle_scalar_deps_crossing_scop_limits (scop_p scop, tree def, gimple stmt)
      arrays everywhere else.  */
   if (needs_copy)
     {
-      gimple assign = gimple_build_assign (new_name, def);
+      gimple *assign = gimple_build_assign (new_name, def);
       gimple_stmt_iterator psi = gsi_after_labels (SESE_EXIT (region)->dest);
 
       update_stmt (assign);
@@ -2400,12 +2400,12 @@ static bool
 rewrite_cross_bb_scalar_deps (scop_p scop, gimple_stmt_iterator *gsi)
 {
   sese region = SCOP_REGION (scop);
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   imm_use_iterator imm_iter;
   tree def;
   basic_block def_bb;
   tree zero_dim_array = NULL_TREE;
-  gimple use_stmt;
+  gimple *use_stmt;
   bool res = false;
 
   switch (gimple_code (stmt))
@@ -2540,7 +2540,7 @@ nb_data_writes_in_bb (basic_block bb)
    polyhedral form.  */
 
 static edge
-split_pbb (scop_p scop, poly_bb_p pbb, basic_block bb, gimple stmt)
+split_pbb (scop_p scop, poly_bb_p pbb, basic_block bb, gimple *stmt)
 {
   edge e1 = split_block (bb, stmt);
   new_pbb_from_pbb (scop, pbb, e1->dest);
@@ -2551,7 +2551,7 @@ split_pbb (scop_p scop, poly_bb_p pbb, basic_block bb, gimple stmt)
    statements for which we want to ignore data dependences.  */
 
 static basic_block
-split_reduction_stmt (scop_p scop, gimple stmt)
+split_reduction_stmt (scop_p scop, gimple *stmt)
 {
   basic_block bb = gimple_bb (stmt);
   poly_bb_p pbb = pbb_from_bb (bb);
@@ -2600,7 +2600,7 @@ split_reduction_stmt (scop_p scop, gimple stmt)
 /* Return true when stmt is a reduction operation.  */
 
 static inline bool
-is_reduction_operation_p (gimple stmt)
+is_reduction_operation_p (gimple *stmt)
 {
   enum tree_code code;
 
@@ -2615,7 +2615,7 @@ is_reduction_operation_p (gimple stmt)
 /* Returns true when PHI contains an argument ARG.  */
 
 static bool
-phi_contains_arg (gimple phi, tree arg)
+phi_contains_arg (gimple *phi, tree arg)
 {
   size_t i;
 
@@ -2628,10 +2628,10 @@ phi_contains_arg (gimple phi, tree arg)
 
 /* Return a loop phi node that corresponds to a reduction containing LHS.  */
 
-static gimple
+static gimple *
 follow_ssa_with_commutative_ops (tree arg, tree lhs)
 {
-  gimple stmt;
+  gimple *stmt;
 
   if (TREE_CODE (arg) != SSA_NAME)
     return NULL;
@@ -2657,7 +2657,7 @@ follow_ssa_with_commutative_ops (tree arg, tree lhs)
 
   if (is_reduction_operation_p (stmt))
     {
-      gimple res = follow_ssa_with_commutative_ops (gimple_assign_rhs1 (stmt), lhs);
+      gimple *res = follow_ssa_with_commutative_ops (gimple_assign_rhs1 (stmt), lhs);
 
       return res ? res :
 	follow_ssa_with_commutative_ops (gimple_assign_rhs2 (stmt), lhs);
@@ -2669,12 +2669,12 @@ follow_ssa_with_commutative_ops (tree arg, tree lhs)
 /* Detect commutative and associative scalar reductions starting at
    the STMT.  Return the phi node of the reduction cycle, or NULL.  */
 
-static gimple
-detect_commutative_reduction_arg (tree lhs, gimple stmt, tree arg,
-				  vec<gimple> *in,
-				  vec<gimple> *out)
+static gimple *
+detect_commutative_reduction_arg (tree lhs, gimple *stmt, tree arg,
+				  vec<gimple *> *in,
+				  vec<gimple *> *out)
 {
-  gimple phi = follow_ssa_with_commutative_ops (arg, lhs);
+  gimple *phi = follow_ssa_with_commutative_ops (arg, lhs);
 
   if (!phi)
     return NULL;
@@ -2687,9 +2687,9 @@ detect_commutative_reduction_arg (tree lhs, gimple stmt, tree arg,
 /* Detect commutative and associative scalar reductions starting at
    STMT.  Return the phi node of the reduction cycle, or NULL.  */
 
-static gimple
-detect_commutative_reduction_assign (gimple stmt, vec<gimple> *in,
-				     vec<gimple> *out)
+static gimple *
+detect_commutative_reduction_assign (gimple *stmt, vec<gimple *> *in,
+				     vec<gimple *> *out)
 {
   tree lhs = gimple_assign_lhs (stmt);
 
@@ -2700,7 +2700,7 @@ detect_commutative_reduction_assign (gimple stmt, vec<gimple> *in,
 
   if (is_reduction_operation_p (stmt))
     {
-      gimple res = detect_commutative_reduction_arg (lhs, stmt,
+      gimple *res = detect_commutative_reduction_arg (lhs, stmt,
 						     gimple_assign_rhs1 (stmt),
 						     in, out);
       return res ? res
@@ -2714,10 +2714,10 @@ detect_commutative_reduction_assign (gimple stmt, vec<gimple> *in,
 
 /* Return a loop phi node that corresponds to a reduction containing LHS.  */
 
-static gimple
+static gimple *
 follow_inital_value_to_phi (tree arg, tree lhs)
 {
-  gimple stmt;
+  gimple *stmt;
 
   if (!arg || TREE_CODE (arg) != SSA_NAME)
     return NULL;
@@ -2736,7 +2736,7 @@ follow_inital_value_to_phi (tree arg, tree lhs)
    from outside the loop.  */
 
 static edge
-edge_initial_value_for_loop_phi (gimple phi)
+edge_initial_value_for_loop_phi (gimple *phi)
 {
   size_t i;
 
@@ -2756,7 +2756,7 @@ edge_initial_value_for_loop_phi (gimple phi)
    from outside the loop.  */
 
 static tree
-initial_value_for_loop_phi (gimple phi)
+initial_value_for_loop_phi (gimple *phi)
 {
   size_t i;
 
@@ -2776,7 +2776,7 @@ initial_value_for_loop_phi (gimple phi)
    LOOP_PHI.  */
 
 static bool
-used_outside_reduction (tree def, gimple loop_phi)
+used_outside_reduction (tree def, gimple *loop_phi)
 {
   use_operand_p use_p;
   imm_use_iterator imm_iter;
@@ -2785,7 +2785,7 @@ used_outside_reduction (tree def, gimple loop_phi)
   /* In LOOP, DEF should be used only in LOOP_PHI.  */
   FOR_EACH_IMM_USE_FAST (use_p, imm_iter, def)
     {
-      gimple stmt = USE_STMT (use_p);
+      gimple *stmt = USE_STMT (use_p);
 
       if (stmt != loop_phi
 	  && !is_gimple_debug (stmt)
@@ -2800,13 +2800,13 @@ used_outside_reduction (tree def, gimple loop_phi)
    the SCOP starting at the loop closed phi node STMT.  Return the phi
    node of the reduction cycle, or NULL.  */
 
-static gimple
-detect_commutative_reduction (scop_p scop, gimple stmt, vec<gimple> *in,
-			      vec<gimple> *out)
+static gimple *
+detect_commutative_reduction (scop_p scop, gimple *stmt, vec<gimple *> *in,
+			      vec<gimple *> *out)
 {
   if (scalar_close_phi_node_p (stmt))
     {
-      gimple def, loop_phi, phi, close_phi = stmt;
+      gimple *def, *loop_phi, *phi, *close_phi = stmt;
       tree init, lhs, arg = gimple_phi_arg_def (close_phi, 0);
 
       if (TREE_CODE (arg) != SSA_NAME)
@@ -2846,10 +2846,10 @@ detect_commutative_reduction (scop_p scop, gimple stmt, vec<gimple> *in,
 
 static void
 translate_scalar_reduction_to_array_for_stmt (scop_p scop, tree red,
-					      gimple stmt, gimple loop_phi)
+					      gimple *stmt, gimple *loop_phi)
 {
   tree res = gimple_phi_result (loop_phi);
-  gimple assign = gimple_build_assign (res, unshare_expr (red));
+  gimple *assign = gimple_build_assign (res, unshare_expr (red));
   gimple_stmt_iterator gsi;
 
   insert_stmts (scop, assign, NULL, gsi_after_labels (gimple_bb (loop_phi)));
@@ -2864,15 +2864,15 @@ translate_scalar_reduction_to_array_for_stmt (scop_p scop, tree red,
    the PHI_RESULT.  */
 
 static void
-remove_phi (gimple phi)
+remove_phi (gimple *phi)
 {
   imm_use_iterator imm_iter;
   tree def;
   use_operand_p use_p;
   gimple_stmt_iterator gsi;
-  auto_vec<gimple, 3> update;
+  auto_vec<gimple *, 3> update;
   unsigned int i;
-  gimple stmt;
+  gimple *stmt;
 
   def = PHI_RESULT (phi);
   FOR_EACH_IMM_USE_FAST (use_p, imm_iter, def)
@@ -2902,7 +2902,7 @@ dr_indices_valid_in_loop (tree ref ATTRIBUTE_UNUSED, tree *index, void *data)
 {
   loop_p loop;
   basic_block header, def_bb;
-  gimple stmt;
+  gimple *stmt;
 
   if (TREE_CODE (*index) != SSA_NAME)
     return true;
@@ -2927,11 +2927,11 @@ dr_indices_valid_in_loop (tree ref ATTRIBUTE_UNUSED, tree *index, void *data)
    NULL_TREE.  */
 
 static tree
-close_phi_written_to_memory (gimple close_phi)
+close_phi_written_to_memory (gimple *close_phi)
 {
   imm_use_iterator imm_iter;
   use_operand_p use_p;
-  gimple stmt;
+  gimple *stmt;
   tree res, def = gimple_phi_result (close_phi);
 
   FOR_EACH_IMM_USE_FAST (use_p, imm_iter, def)
@@ -2979,20 +2979,20 @@ close_phi_written_to_memory (gimple close_phi)
 
 static void
 translate_scalar_reduction_to_array (scop_p scop,
-				     vec<gimple> in,
-				     vec<gimple> out)
+				     vec<gimple *> in,
+				     vec<gimple *> out)
 {
-  gimple loop_phi;
+  gimple *loop_phi;
   unsigned int i = out.length () - 1;
   tree red = close_phi_written_to_memory (out[i]);
 
   FOR_EACH_VEC_ELT (in, i, loop_phi)
     {
-      gimple close_phi = out[i];
+      gimple *close_phi = out[i];
 
       if (i == 0)
 	{
-	  gimple stmt = loop_phi;
+	  gimple *stmt = loop_phi;
 	  basic_block bb = split_reduction_stmt (scop, stmt);
 	  poly_bb_p pbb = pbb_from_bb (bb);
 	  PBB_IS_REDUCTION (pbb) = true;
@@ -3025,11 +3025,11 @@ translate_scalar_reduction_to_array (scop_p scop,
 
 static bool
 rewrite_commutative_reductions_out_of_ssa_close_phi (scop_p scop,
-						     gimple close_phi)
+						     gimple *close_phi)
 {
   bool res;
-  auto_vec<gimple, 10> in;
-  auto_vec<gimple, 10> out;
+  auto_vec<gimple *, 10> in;
+  auto_vec<gimple *, 10> out;
 
   detect_commutative_reduction (scop, close_phi, &in, &out);
   res = in.length () > 1;
@@ -3107,7 +3107,7 @@ scop_ivs_can_be_represented (scop_p scop)
       for (psi = gsi_start_phis (loop->header);
 	   !gsi_end_p (psi); gsi_next (&psi))
 	{
-	  gimple phi = gsi_stmt (psi);
+	  gimple *phi = gsi_stmt (psi);
 	  tree res = PHI_RESULT (phi);
 	  tree type = TREE_TYPE (res);
 
diff --git a/gcc/internal-fn.c b/gcc/internal-fn.c
index 68b2b66..ef935ff 100644
--- a/gcc/internal-fn.c
+++ b/gcc/internal-fn.c
@@ -76,7 +76,7 @@ get_multi_vector_move (tree array_type, convert_optab optab)
 /* Expand LOAD_LANES call STMT.  */
 
 static void
-expand_LOAD_LANES (gimple stmt)
+expand_LOAD_LANES (gimple *stmt)
 {
   struct expand_operand ops[2];
   tree type, lhs, rhs;
@@ -100,7 +100,7 @@ expand_LOAD_LANES (gimple stmt)
 /* Expand STORE_LANES call STMT.  */
 
 static void
-expand_STORE_LANES (gimple stmt)
+expand_STORE_LANES (gimple *stmt)
 {
   struct expand_operand ops[2];
   tree type, lhs, rhs;
@@ -122,7 +122,7 @@ expand_STORE_LANES (gimple stmt)
 }
 
 static void
-expand_ANNOTATE (gimple stmt ATTRIBUTE_UNUSED)
+expand_ANNOTATE (gimple *stmt ATTRIBUTE_UNUSED)
 {
   gcc_unreachable ();
 }
@@ -130,7 +130,7 @@ expand_ANNOTATE (gimple stmt ATTRIBUTE_UNUSED)
 /* This should get expanded in adjust_simduid_builtins.  */
 
 static void
-expand_GOMP_SIMD_LANE (gimple stmt ATTRIBUTE_UNUSED)
+expand_GOMP_SIMD_LANE (gimple *stmt ATTRIBUTE_UNUSED)
 {
   gcc_unreachable ();
 }
@@ -138,7 +138,7 @@ expand_GOMP_SIMD_LANE (gimple stmt ATTRIBUTE_UNUSED)
 /* This should get expanded in adjust_simduid_builtins.  */
 
 static void
-expand_GOMP_SIMD_VF (gimple stmt ATTRIBUTE_UNUSED)
+expand_GOMP_SIMD_VF (gimple *stmt ATTRIBUTE_UNUSED)
 {
   gcc_unreachable ();
 }
@@ -146,7 +146,7 @@ expand_GOMP_SIMD_VF (gimple stmt ATTRIBUTE_UNUSED)
 /* This should get expanded in adjust_simduid_builtins.  */
 
 static void
-expand_GOMP_SIMD_LAST_LANE (gimple stmt ATTRIBUTE_UNUSED)
+expand_GOMP_SIMD_LAST_LANE (gimple *stmt ATTRIBUTE_UNUSED)
 {
   gcc_unreachable ();
 }
@@ -154,7 +154,7 @@ expand_GOMP_SIMD_LAST_LANE (gimple stmt ATTRIBUTE_UNUSED)
 /* This should get expanded in the sanopt pass.  */
 
 static void
-expand_UBSAN_NULL (gimple stmt ATTRIBUTE_UNUSED)
+expand_UBSAN_NULL (gimple *stmt ATTRIBUTE_UNUSED)
 {
   gcc_unreachable ();
 }
@@ -163,7 +163,7 @@ expand_UBSAN_NULL (gimple stmt ATTRIBUTE_UNUSED)
    CODE says whether the operation is +, or -.  */
 
 void
-ubsan_expand_si_overflow_addsub_check (tree_code code, gimple stmt)
+ubsan_expand_si_overflow_addsub_check (tree_code code, gimple *stmt)
 {
   rtx res, op0, op1;
   tree lhs, fn, arg0, arg1;
@@ -311,7 +311,7 @@ ubsan_expand_si_overflow_addsub_check (tree_code code, gimple stmt)
 /* Add negate overflow checking to the statement STMT.  */
 
 void
-ubsan_expand_si_overflow_neg_check (gimple stmt)
+ubsan_expand_si_overflow_neg_check (gimple *stmt)
 {
   rtx res, op1;
   tree lhs, fn, arg1;
@@ -387,7 +387,7 @@ ubsan_expand_si_overflow_neg_check (gimple stmt)
 /* Add mul overflow checking to the statement STMT.  */
 
 void
-ubsan_expand_si_overflow_mul_check (gimple stmt)
+ubsan_expand_si_overflow_mul_check (gimple *stmt)
 {
   rtx res, op0, op1;
   tree lhs, fn, arg0, arg1;
@@ -780,7 +780,7 @@ ubsan_expand_si_overflow_mul_check (gimple stmt)
 /* Expand UBSAN_CHECK_ADD call STMT.  */
 
 static void
-expand_UBSAN_CHECK_ADD (gimple stmt)
+expand_UBSAN_CHECK_ADD (gimple *stmt)
 {
   ubsan_expand_si_overflow_addsub_check (PLUS_EXPR, stmt);
 }
@@ -788,7 +788,7 @@ expand_UBSAN_CHECK_ADD (gimple stmt)
 /* Expand UBSAN_CHECK_SUB call STMT.  */
 
 static void
-expand_UBSAN_CHECK_SUB (gimple stmt)
+expand_UBSAN_CHECK_SUB (gimple *stmt)
 {
   if (integer_zerop (gimple_call_arg (stmt, 0)))
     ubsan_expand_si_overflow_neg_check (stmt);
@@ -799,7 +799,7 @@ expand_UBSAN_CHECK_SUB (gimple stmt)
 /* Expand UBSAN_CHECK_MUL call STMT.  */
 
 static void
-expand_UBSAN_CHECK_MUL (gimple stmt)
+expand_UBSAN_CHECK_MUL (gimple *stmt)
 {
   ubsan_expand_si_overflow_mul_check (stmt);
 }
@@ -807,13 +807,13 @@ expand_UBSAN_CHECK_MUL (gimple stmt)
 /* This should get folded in tree-vectorizer.c.  */
 
 static void
-expand_LOOP_VECTORIZED (gimple stmt ATTRIBUTE_UNUSED)
+expand_LOOP_VECTORIZED (gimple *stmt ATTRIBUTE_UNUSED)
 {
   gcc_unreachable ();
 }
 
 static void
-expand_MASK_LOAD (gimple stmt)
+expand_MASK_LOAD (gimple *stmt)
 {
   struct expand_operand ops[3];
   tree type, lhs, rhs, maskt;
@@ -838,7 +838,7 @@ expand_MASK_LOAD (gimple stmt)
 }
 
 static void
-expand_MASK_STORE (gimple stmt)
+expand_MASK_STORE (gimple *stmt)
 {
   struct expand_operand ops[3];
   tree type, lhs, rhs, maskt;
@@ -861,12 +861,12 @@ expand_MASK_STORE (gimple stmt)
 }
 
 static void
-expand_ABNORMAL_DISPATCHER (gimple)
+expand_ABNORMAL_DISPATCHER (gimple *)
 {
 }
 
 static void
-expand_BUILTIN_EXPECT (gimple stmt)
+expand_BUILTIN_EXPECT (gimple *stmt)
 {
   /* When guessing was done, the hints should be already stripped away.  */
   gcc_assert (!flag_guess_branch_prob || optimize == 0 || seen_error ());
@@ -888,7 +888,7 @@ expand_BUILTIN_EXPECT (gimple stmt)
        expand_<NAME> (gimple stmt)
 
    where STMT is the statement that performs the call. */
-static void (*const internal_fn_expanders[]) (gimple) = {
+static void (*const internal_fn_expanders[]) (gimple *) = {
 #define DEF_INTERNAL_FN(CODE, FLAGS) expand_##CODE,
 #include "internal-fn.def"
 #undef DEF_INTERNAL_FN
@@ -898,7 +898,7 @@ static void (*const internal_fn_expanders[]) (gimple) = {
 /* Expand STMT, which is a call to internal function FN.  */
 
 void
-expand_internal_call (gimple stmt)
+expand_internal_call (gimple *stmt)
 {
   internal_fn_expanders[(int) gimple_call_internal_fn (stmt)] (stmt);
 }
diff --git a/gcc/internal-fn.h b/gcc/internal-fn.h
index 9c3215f..7e66088 100644
--- a/gcc/internal-fn.h
+++ b/gcc/internal-fn.h
@@ -48,6 +48,6 @@ internal_fn_flags (enum internal_fn fn)
   return internal_fn_flags_array[(int) fn];
 }
 
-extern void expand_internal_call (gimple);
+extern void expand_internal_call (gimple *);
 
 #endif
diff --git a/gcc/ipa-inline-analysis.c b/gcc/ipa-inline-analysis.c
index 2bb3759..db9fbf7 100644
--- a/gcc/ipa-inline-analysis.c
+++ b/gcc/ipa-inline-analysis.c
@@ -1493,7 +1493,7 @@ mark_modified (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef ATTRIBUTE_UNUSED,
    parameter.  */
 
 static tree
-unmodified_parm_1 (gimple stmt, tree op)
+unmodified_parm_1 (gimple *stmt, tree op)
 {
   /* SSA_NAME referring to parm default def?  */
   if (TREE_CODE (op) == SSA_NAME
@@ -1519,7 +1519,7 @@ unmodified_parm_1 (gimple stmt, tree op)
    parameter.  Also traverse chains of SSA register assignments.  */
 
 static tree
-unmodified_parm (gimple stmt, tree op)
+unmodified_parm (gimple *stmt, tree op)
 {
   tree res = unmodified_parm_1 (stmt, op);
   if (res)
@@ -1542,7 +1542,7 @@ unmodified_parm (gimple stmt, tree op)
 
 static bool
 unmodified_parm_or_parm_agg_item (struct ipa_node_params *info,
-				  gimple stmt, tree op, int *index_p,
+				  gimple *stmt, tree op, int *index_p,
 				  struct agg_position_info *aggpos)
 {
   tree res = unmodified_parm_1 (stmt, op);
@@ -1583,7 +1583,7 @@ unmodified_parm_or_parm_agg_item (struct ipa_node_params *info,
    penalty wrappers.  */
 
 static int
-eliminated_by_inlining_prob (gimple stmt)
+eliminated_by_inlining_prob (gimple *stmt)
 {
   enum gimple_code code = gimple_code (stmt);
   enum tree_code rhs_code;
@@ -1716,14 +1716,14 @@ set_cond_stmt_execution_predicate (struct ipa_node_params *info,
 				   struct inline_summary *summary,
 				   basic_block bb)
 {
-  gimple last;
+  gimple *last;
   tree op;
   int index;
   struct agg_position_info aggpos;
   enum tree_code code, inverted_code;
   edge e;
   edge_iterator ei;
-  gimple set_stmt;
+  gimple *set_stmt;
   tree op2;
 
   last = last_stmt (bb);
@@ -1801,7 +1801,7 @@ set_switch_stmt_execution_predicate (struct ipa_node_params *info,
 				     struct inline_summary *summary,
 				     basic_block bb)
 {
-  gimple last;
+  gimple *last;
   tree op;
   int index;
   struct agg_position_info aggpos;
@@ -2002,7 +2002,7 @@ will_be_nonconstant_expr_predicate (struct ipa_node_params *info,
 static struct predicate
 will_be_nonconstant_predicate (struct ipa_node_params *info,
 			       struct inline_summary *summary,
-			       gimple stmt,
+			       gimple *stmt,
 			       vec<predicate_t> nonconstant_names)
 {
   struct predicate p = true_predicate ();
@@ -2089,7 +2089,7 @@ will_be_nonconstant_predicate (struct ipa_node_params *info,
 struct record_modified_bb_info
 {
   bitmap bb_set;
-  gimple stmt;
+  gimple *stmt;
 };
 
 /* Callback of walk_aliased_vdefs.  Records basic blocks where the value may be
@@ -2117,7 +2117,7 @@ record_modified (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef, void *data)
    ought to be REG_BR_PROB_BASE / estimated_iters.  */
 
 static int
-param_change_prob (gimple stmt, int i)
+param_change_prob (gimple *stmt, int i)
 {
   tree op = gimple_call_arg (stmt, i);
   basic_block bb = gimple_bb (stmt);
@@ -2210,7 +2210,7 @@ phi_result_unknown_predicate (struct ipa_node_params *info,
   edge e;
   edge_iterator ei;
   basic_block first_bb = NULL;
-  gimple stmt;
+  gimple *stmt;
 
   if (single_pred_p (bb))
     {
@@ -2262,7 +2262,7 @@ phi_result_unknown_predicate (struct ipa_node_params *info,
    NONCONSTANT_NAMES, if possible.  */
 
 static void
-predicate_for_phi_result (struct inline_summary *summary, gimple phi,
+predicate_for_phi_result (struct inline_summary *summary, gimple *phi,
 			  struct predicate *p,
 			  vec<predicate_t> nonconstant_names)
 {
@@ -2325,14 +2325,14 @@ array_index_predicate (struct inline_summary *info,
    an impact on the earlier inlining.
    Here find this pattern and fix it up later.  */
 
-static gimple
+static gimple *
 find_foldable_builtin_expect (basic_block bb)
 {
   gimple_stmt_iterator bsi;
 
   for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
     {
-      gimple stmt = gsi_stmt (bsi);
+      gimple *stmt = gsi_stmt (bsi);
       if (gimple_call_builtin_p (stmt, BUILT_IN_EXPECT)
 	  || (is_gimple_call (stmt)
 	      && gimple_call_internal_p (stmt)
@@ -2341,7 +2341,7 @@ find_foldable_builtin_expect (basic_block bb)
           tree var = gimple_call_lhs (stmt);
           tree arg = gimple_call_arg (stmt, 0);
           use_operand_p use_p;
-          gimple use_stmt;
+          gimple *use_stmt;
           bool match = false;
           bool done = false;
 
@@ -2351,7 +2351,7 @@ find_foldable_builtin_expect (basic_block bb)
 
           while (TREE_CODE (arg) == SSA_NAME)
             {
-              gimple stmt_tmp = SSA_NAME_DEF_STMT (arg);
+              gimple *stmt_tmp = SSA_NAME_DEF_STMT (arg);
               if (!is_gimple_assign (stmt_tmp))
                 break;
               switch (gimple_assign_rhs_code (stmt_tmp))
@@ -2413,7 +2413,7 @@ clobber_only_eh_bb_p (basic_block bb, bool need_eh = true)
 
   for (; !gsi_end_p (gsi); gsi_prev (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       if (is_gimple_debug (stmt))
 	continue;
       if (gimple_clobber_p (stmt))
@@ -2455,7 +2455,7 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early)
   int nblocks, n;
   int *order;
   predicate array_index = true_predicate ();
-  gimple fix_builtin_expect_stmt;
+  gimple *fix_builtin_expect_stmt;
 
   info->conds = NULL;
   info->entry = NULL;
@@ -2548,7 +2548,7 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early)
 
       for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
 	{
-	  gimple stmt = gsi_stmt (bsi);
+	  gimple *stmt = gsi_stmt (bsi);
 	  int this_size = estimate_num_insns (stmt, &eni_size_weights);
 	  int this_time = estimate_num_insns (stmt, &eni_time_weights);
 	  int prob;
@@ -2744,7 +2744,7 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early)
 	      for (gsi = gsi_start_bb (body[i]); !gsi_end_p (gsi);
 		   gsi_next (&gsi))
 		{
-		  gimple stmt = gsi_stmt (gsi);
+		  gimple *stmt = gsi_stmt (gsi);
 		  affine_iv iv;
 		  ssa_op_iter iter;
 		  tree use;
diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c
index 65e6533..34775fd 100644
--- a/gcc/ipa-inline.c
+++ b/gcc/ipa-inline.c
@@ -1731,9 +1731,9 @@ inline_small_functions (void)
 		   " Estimated badness is %i, frequency %.2f.\n",
 		   edge->caller->name (), edge->caller->order,
 		   flag_wpa ? "unknown"
-		   : gimple_filename ((const_gimple) edge->call_stmt),
+		   : gimple_filename ((const gimple *) edge->call_stmt),
 		   flag_wpa ? -1
-		   : gimple_lineno ((const_gimple) edge->call_stmt),
+		   : gimple_lineno ((const gimple *) edge->call_stmt),
 		   badness,
 		   edge->frequency / (double)CGRAPH_FREQ_BASE);
 	  if (edge->count)
diff --git a/gcc/ipa-profile.c b/gcc/ipa-profile.c
index 71bd61b..7e37e82 100644
--- a/gcc/ipa-profile.c
+++ b/gcc/ipa-profile.c
@@ -193,7 +193,7 @@ ipa_profile_generate_summary (void)
 	int size = 0;
         for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	  {
-	    gimple stmt = gsi_stmt (gsi);
+	    gimple *stmt = gsi_stmt (gsi);
 	    if (gimple_code (stmt) == GIMPLE_CALL
 		&& !gimple_call_fndecl (stmt))
 	      {
diff --git a/gcc/ipa-prop.c b/gcc/ipa-prop.c
index da6ffe8..412ffb7 100644
--- a/gcc/ipa-prop.c
+++ b/gcc/ipa-prop.c
@@ -569,7 +569,7 @@ struct type_change_info
   */
 
 static bool
-stmt_may_be_vtbl_ptr_store (gimple stmt)
+stmt_may_be_vtbl_ptr_store (gimple *stmt)
 {
   if (is_gimple_call (stmt))
     return false;
@@ -600,7 +600,7 @@ stmt_may_be_vtbl_ptr_store (gimple stmt)
    identified, return the type.  Otherwise return NULL_TREE.  */
 
 static tree
-extr_type_from_vtbl_ptr_store (gimple stmt, struct type_change_info *tci)
+extr_type_from_vtbl_ptr_store (gimple *stmt, struct type_change_info *tci)
 {
   HOST_WIDE_INT offset, size, max_size;
   tree lhs, rhs, base, binfo;
@@ -651,7 +651,7 @@ extr_type_from_vtbl_ptr_store (gimple stmt, struct type_change_info *tci)
 static bool
 check_stmt_for_type_change (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef, void *data)
 {
-  gimple stmt = SSA_NAME_DEF_STMT (vdef);
+  gimple *stmt = SSA_NAME_DEF_STMT (vdef);
   struct type_change_info *tci = (struct type_change_info *) data;
 
   if (stmt_may_be_vtbl_ptr_store (stmt))
@@ -679,7 +679,7 @@ check_stmt_for_type_change (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef, void *data)
    returned by get_ref_base_and_extent, as is the offset.  */
 
 static bool
-detect_type_change (tree arg, tree base, tree comp_type, gimple call,
+detect_type_change (tree arg, tree base, tree comp_type, gimple *call,
 		    struct ipa_jump_func *jfunc, HOST_WIDE_INT offset)
 {
   struct type_change_info tci;
@@ -744,7 +744,7 @@ detect_type_change (tree arg, tree base, tree comp_type, gimple call,
 
 static bool
 detect_type_change_ssa (tree arg, tree comp_type,
-			gimple call, struct ipa_jump_func *jfunc)
+			gimple *call, struct ipa_jump_func *jfunc)
 {
   gcc_checking_assert (TREE_CODE (arg) == SSA_NAME);
   if (!flag_devirtualize
@@ -776,7 +776,7 @@ mark_modified (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef ATTRIBUTE_UNUSED,
 
 static bool
 parm_preserved_before_stmt_p (struct param_analysis_info *parm_ainfo,
-			       gimple stmt, tree parm_load)
+			       gimple *stmt, tree parm_load)
 {
   bool modified = false;
   bitmap *visited_stmts;
@@ -807,7 +807,7 @@ parm_preserved_before_stmt_p (struct param_analysis_info *parm_ainfo,
 static int
 load_from_unmodified_param (vec<ipa_param_descriptor> descriptors,
 			    struct param_analysis_info *parms_ainfo,
-			    gimple stmt)
+			    gimple *stmt)
 {
   int index;
   tree op1;
@@ -835,7 +835,7 @@ load_from_unmodified_param (vec<ipa_param_descriptor> descriptors,
 
 static bool
 parm_ref_data_preserved_p (struct param_analysis_info *parm_ainfo,
-			      gimple stmt, tree ref)
+			      gimple *stmt, tree ref)
 {
   bool modified = false;
   ao_ref refd;
@@ -859,7 +859,7 @@ parm_ref_data_preserved_p (struct param_analysis_info *parm_ainfo,
 
 static bool
 parm_ref_data_pass_through_p (struct param_analysis_info *parm_ainfo,
-			       gimple call, tree parm)
+			       gimple *call, tree parm)
 {
   bool modified = false;
   ao_ref refd;
@@ -894,7 +894,7 @@ parm_ref_data_pass_through_p (struct param_analysis_info *parm_ainfo,
 
 static bool
 ipa_load_from_parm_agg_1 (vec<ipa_param_descriptor> descriptors,
-			  struct param_analysis_info *parms_ainfo, gimple stmt,
+			  struct param_analysis_info *parms_ainfo, gimple *stmt,
 			  tree op, int *index_p, HOST_WIDE_INT *offset_p,
 			  HOST_WIDE_INT *size_p, bool *by_ref_p)
 {
@@ -948,7 +948,7 @@ ipa_load_from_parm_agg_1 (vec<ipa_param_descriptor> descriptors,
 	 gdp = &p;
       */
 
-      gimple def = SSA_NAME_DEF_STMT (TREE_OPERAND (base, 0));
+      gimple *def = SSA_NAME_DEF_STMT (TREE_OPERAND (base, 0));
       index = load_from_unmodified_param (descriptors, parms_ainfo, def);
     }
 
@@ -969,7 +969,7 @@ ipa_load_from_parm_agg_1 (vec<ipa_param_descriptor> descriptors,
    pointer, for users outside of this file.  */
 
 bool
-ipa_load_from_parm_agg (struct ipa_node_params *info, gimple stmt,
+ipa_load_from_parm_agg (struct ipa_node_params *info, gimple *stmt,
 			tree op, int *index_p, HOST_WIDE_INT *offset_p,
 			bool *by_ref_p)
 {
@@ -1034,7 +1034,7 @@ static void
 compute_complex_assign_jump_func (struct ipa_node_params *info,
 				  struct param_analysis_info *parms_ainfo,
 				  struct ipa_jump_func *jfunc,
-				  gimple call, gimple stmt, tree name,
+				  gimple *call, gimple *stmt, tree name,
 				  tree param_type)
 {
   HOST_WIDE_INT offset, size, max_size;
@@ -1132,7 +1132,7 @@ compute_complex_assign_jump_func (struct ipa_node_params *info,
    RHS stripped off the ADDR_EXPR is stored into *OBJ_P.  */
 
 static tree
-get_ancestor_addr_info (gimple assign, tree *obj_p, HOST_WIDE_INT *offset)
+get_ancestor_addr_info (gimple *assign, tree *obj_p, HOST_WIDE_INT *offset)
 {
   HOST_WIDE_INT size, max_size;
   tree expr, parm, obj;
@@ -1190,10 +1190,10 @@ static void
 compute_complex_ancestor_jump_func (struct ipa_node_params *info,
 				    struct param_analysis_info *parms_ainfo,
 				    struct ipa_jump_func *jfunc,
-				    gimple call, gimple phi, tree param_type)
+				    gimple *call, gimple *phi, tree param_type)
 {
   HOST_WIDE_INT offset;
-  gimple assign, cond;
+  gimple *assign, *cond;
   basic_block phi_bb, assign_bb, cond_bb;
   tree tmp, parm, expr, obj;
   int index, i;
@@ -1259,7 +1259,7 @@ compute_complex_ancestor_jump_func (struct ipa_node_params *info,
 
 static void
 compute_known_type_jump_func (tree op, struct ipa_jump_func *jfunc,
-			      gimple call, tree expected_type)
+			      gimple *call, tree expected_type)
 {
   HOST_WIDE_INT offset, size, max_size;
   tree base;
@@ -1334,7 +1334,7 @@ get_ssa_def_if_simple_copy (tree rhs)
 {
   while (TREE_CODE (rhs) == SSA_NAME && !SSA_NAME_IS_DEFAULT_DEF (rhs))
     {
-      gimple def_stmt = SSA_NAME_DEF_STMT (rhs);
+      gimple *def_stmt = SSA_NAME_DEF_STMT (rhs);
 
       if (gimple_assign_single_p (def_stmt))
 	rhs = gimple_assign_rhs1 (def_stmt);
@@ -1363,7 +1363,7 @@ struct ipa_known_agg_contents_list
    JFUNC is the jump function into which the constants are subsequently stored.  */
 
 static void
-determine_known_aggregate_parts (gimple call, tree arg, tree arg_type,
+determine_known_aggregate_parts (gimple *call, tree arg, tree arg_type,
 				 struct ipa_jump_func *jfunc)
 {
   struct ipa_known_agg_contents_list *list = NULL;
@@ -1444,7 +1444,7 @@ determine_known_aggregate_parts (gimple call, tree arg, tree arg_type,
   for (; !gsi_end_p (gsi); gsi_prev (&gsi))
     {
       struct ipa_known_agg_contents_list *n, **p;
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       HOST_WIDE_INT lhs_offset, lhs_size, lhs_max_size;
       tree lhs, rhs, lhs_base;
       bool partial_overlap;
@@ -1599,7 +1599,7 @@ ipa_compute_jump_functions_for_edge (struct param_analysis_info *parms_ainfo,
 {
   struct ipa_node_params *info = IPA_NODE_REF (cs->caller);
   struct ipa_edge_args *args = IPA_EDGE_REF (cs);
-  gimple call = cs->call_stmt;
+  gimple *call = cs->call_stmt;
   int n, arg_num = gimple_call_num_args (call);
 
   if (arg_num == 0 || args->jump_functions)
@@ -1656,7 +1656,7 @@ ipa_compute_jump_functions_for_edge (struct param_analysis_info *parms_ainfo,
 	    }
 	  else
 	    {
-	      gimple stmt = SSA_NAME_DEF_STMT (arg);
+	      gimple *stmt = SSA_NAME_DEF_STMT (arg);
 	      if (is_gimple_assign (stmt))
 		compute_complex_assign_jump_func (info, parms_ainfo, jfunc,
 						  call, stmt, arg, param_type);
@@ -1722,7 +1722,7 @@ ipa_compute_jump_functions (struct cgraph_node *node,
    field rather than the pfn.  */
 
 static tree
-ipa_get_stmt_member_ptr_load_param (gimple stmt, bool use_delta,
+ipa_get_stmt_member_ptr_load_param (gimple *stmt, bool use_delta,
 				    HOST_WIDE_INT *offset_p)
 {
   tree rhs, rec, ref_field, ref_offset, fld, ptr_field, delta_field;
@@ -1784,7 +1784,7 @@ ipa_is_ssa_with_stmt_def (tree t)
    indirect call graph edge.  */
 
 static struct cgraph_edge *
-ipa_note_param_call (struct cgraph_node *node, int param_index, gimple stmt)
+ipa_note_param_call (struct cgraph_node *node, int param_index, gimple *stmt)
 {
   struct cgraph_edge *cs;
 
@@ -1858,13 +1858,13 @@ static void
 ipa_analyze_indirect_call_uses (struct cgraph_node *node,
 				struct ipa_node_params *info,
 				struct param_analysis_info *parms_ainfo,
-				gimple call, tree target)
+				gimple *call, tree target)
 {
-  gimple def;
+  gimple *def;
   tree n1, n2;
-  gimple d1, d2;
+  gimple *d1, *d2;
   tree rec, rec2, cond;
-  gimple branch;
+  gimple *branch;
   int index;
   basic_block bb, virt_bb, join;
   HOST_WIDE_INT offset;
@@ -2001,7 +2001,7 @@ ipa_analyze_indirect_call_uses (struct cgraph_node *node,
 
 static void
 ipa_analyze_virtual_call_uses (struct cgraph_node *node,
-			       struct ipa_node_params *info, gimple call,
+			       struct ipa_node_params *info, gimple *call,
 			       tree target)
 {
   struct cgraph_edge *cs;
@@ -2031,7 +2031,7 @@ ipa_analyze_virtual_call_uses (struct cgraph_node *node,
     }
   else
     {
-      gimple stmt = SSA_NAME_DEF_STMT (obj);
+      gimple *stmt = SSA_NAME_DEF_STMT (obj);
       tree expr;
 
       expr = get_ancestor_addr_info (stmt, &obj, &anc_offset);
@@ -2060,7 +2060,7 @@ ipa_analyze_virtual_call_uses (struct cgraph_node *node,
 static void
 ipa_analyze_call_uses (struct cgraph_node *node,
 		       struct ipa_node_params *info,
-		       struct param_analysis_info *parms_ainfo, gimple call)
+		       struct param_analysis_info *parms_ainfo, gimple *call)
 {
   tree target = gimple_call_fn (call);
   struct cgraph_edge *cs;
@@ -2089,7 +2089,7 @@ ipa_analyze_call_uses (struct cgraph_node *node,
 
 static void
 ipa_analyze_stmt_uses (struct cgraph_node *node, struct ipa_node_params *info,
-		       struct param_analysis_info *parms_ainfo, gimple stmt)
+		       struct param_analysis_info *parms_ainfo, gimple *stmt)
 {
   if (is_gimple_call (stmt))
     ipa_analyze_call_uses (node, info, parms_ainfo, stmt);
@@ -2100,7 +2100,7 @@ ipa_analyze_stmt_uses (struct cgraph_node *node, struct ipa_node_params *info,
    passed in DATA.  */
 
 static bool
-visit_ref_for_mod_analysis (gimple, tree op, tree, void *data)
+visit_ref_for_mod_analysis (gimple *, tree op, tree, void *data)
 {
   struct ipa_node_params *info = (struct ipa_node_params *) data;
 
@@ -2188,7 +2188,7 @@ ipa_analyze_params_uses (struct cgraph_node *node,
     {
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 
 	  if (is_gimple_debug (stmt))
 	    continue;
@@ -2256,7 +2256,7 @@ ipa_analyze_node (struct cgraph_node *node)
    target function declaration, otherwise return NULL.  */
 
 tree
-ipa_intraprocedural_devirtualization (gimple call)
+ipa_intraprocedural_devirtualization (gimple *call)
 {
   tree binfo, token, fndecl;
   struct ipa_jump_func jfunc;
@@ -3659,13 +3659,13 @@ ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec adjustments)
    contain the corresponding call graph edge.  */
 
 void
-ipa_modify_call_arguments (struct cgraph_edge *cs, gimple stmt,
+ipa_modify_call_arguments (struct cgraph_edge *cs, gimple *stmt,
 			   ipa_parm_adjustment_vec adjustments)
 {
   struct cgraph_node *current_node = cgraph_get_node (current_function_decl);
   vec<tree> vargs;
   vec<tree, va_gc> **debug_args = NULL;
-  gimple new_stmt;
+  gimple *new_stmt;
   gimple_stmt_iterator gsi, prev_gsi;
   tree callee_decl;
   int i, len;
@@ -3801,7 +3801,7 @@ ipa_modify_call_arguments (struct cgraph_edge *cs, gimple stmt,
 	         a load into a temporary.  */
 	      if (is_gimple_reg_type (TREE_TYPE (expr)))
 		{
-		  gimple tem = gimple_build_assign (NULL_TREE, expr);
+		  gimple *tem = gimple_build_assign (NULL_TREE, expr);
 		  if (gimple_in_ssa_p (cfun))
 		    {
 		      gimple_set_vuse (tem, gimple_vuse (stmt));
@@ -3826,7 +3826,7 @@ ipa_modify_call_arguments (struct cgraph_edge *cs, gimple stmt,
 	{
 	  unsigned int ix;
 	  tree ddecl = NULL_TREE, origin = DECL_ORIGIN (adj->base), arg;
-	  gimple def_temp;
+	  gimple *def_temp;
 
 	  arg = gimple_call_arg (stmt, adj->base_index);
 	  if (!useless_type_conversion_p (TREE_TYPE (origin), TREE_TYPE (arg)))
@@ -4858,7 +4858,7 @@ ipcp_transform_function (struct cgraph_node *node)
     for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
       {
 	struct ipa_agg_replacement_value *v;
-	gimple stmt = gsi_stmt (gsi);
+	gimple *stmt = gsi_stmt (gsi);
 	tree rhs, val, t;
 	HOST_WIDE_INT offset, size;
 	int index;
diff --git a/gcc/ipa-prop.h b/gcc/ipa-prop.h
index 8fdd92c..392a503 100644
--- a/gcc/ipa-prop.h
+++ b/gcc/ipa-prop.h
@@ -584,7 +584,7 @@ tree ipa_get_indirect_edge_target (struct cgraph_edge *ie,
 				   vec<ipa_agg_jump_function_p> );
 struct cgraph_edge *ipa_make_edge_direct_to_target (struct cgraph_edge *, tree);
 tree ipa_binfo_from_known_type_jfunc (struct ipa_jump_func *);
-tree ipa_intraprocedural_devirtualization (gimple);
+tree ipa_intraprocedural_devirtualization (gimple *);
 
 /* Functions related to both.  */
 void ipa_analyze_node (struct cgraph_node *);
@@ -592,7 +592,7 @@ void ipa_analyze_node (struct cgraph_node *);
 /* Aggregate jump function related functions.  */
 tree ipa_find_agg_cst_for_param (struct ipa_agg_jump_function *, HOST_WIDE_INT,
 				 bool);
-bool ipa_load_from_parm_agg (struct ipa_node_params *, gimple, tree, int *,
+bool ipa_load_from_parm_agg (struct ipa_node_params *, gimple *, tree, int *,
 			     HOST_WIDE_INT *, bool *);
 
 /* Debugging interface.  */
@@ -687,7 +687,7 @@ typedef vec<ipa_parm_adjustment> ipa_parm_adjustment_vec;
 vec<tree> ipa_get_vector_of_formal_parms (tree fndecl);
 vec<tree> ipa_get_vector_of_formal_parm_types (tree fntype);
 void ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec);
-void ipa_modify_call_arguments (struct cgraph_edge *, gimple,
+void ipa_modify_call_arguments (struct cgraph_edge *, gimple *,
 				ipa_parm_adjustment_vec);
 ipa_parm_adjustment_vec ipa_combine_adjustments (ipa_parm_adjustment_vec,
 						 ipa_parm_adjustment_vec);
diff --git a/gcc/ipa-pure-const.c b/gcc/ipa-pure-const.c
index 0ebfe5d..c49355f 100644
--- a/gcc/ipa-pure-const.c
+++ b/gcc/ipa-pure-const.c
@@ -464,7 +464,7 @@ special_builtin_state (enum pure_const_state_e *state, bool *looping,
    the entire call expression.  */
 
 static void
-check_call (funct_state local, gimple call, bool ipa)
+check_call (funct_state local, gimple *call, bool ipa)
 {
   int flags = gimple_call_flags (call);
   tree callee_t = gimple_call_fndecl (call);
@@ -589,7 +589,7 @@ check_call (funct_state local, gimple call, bool ipa)
 /* Wrapper around check_decl for loads in local more.  */
 
 static bool
-check_load (gimple, tree op, tree, void *data)
+check_load (gimple *, tree op, tree, void *data)
 {
   if (DECL_P (op))
     check_decl ((funct_state)data, op, false, false);
@@ -601,7 +601,7 @@ check_load (gimple, tree op, tree, void *data)
 /* Wrapper around check_decl for stores in local more.  */
 
 static bool
-check_store (gimple, tree op, tree, void *data)
+check_store (gimple *, tree op, tree, void *data)
 {
   if (DECL_P (op))
     check_decl ((funct_state)data, op, true, false);
@@ -613,7 +613,7 @@ check_store (gimple, tree op, tree, void *data)
 /* Wrapper around check_decl for loads in ipa mode.  */
 
 static bool
-check_ipa_load (gimple, tree op, tree, void *data)
+check_ipa_load (gimple *, tree op, tree, void *data)
 {
   if (DECL_P (op))
     check_decl ((funct_state)data, op, false, true);
@@ -625,7 +625,7 @@ check_ipa_load (gimple, tree op, tree, void *data)
 /* Wrapper around check_decl for stores in ipa mode.  */
 
 static bool
-check_ipa_store (gimple, tree op, tree, void *data)
+check_ipa_store (gimple *, tree op, tree, void *data)
 {
   if (DECL_P (op))
     check_decl ((funct_state)data, op, true, true);
@@ -639,7 +639,7 @@ check_ipa_store (gimple, tree op, tree, void *data)
 static void
 check_stmt (gimple_stmt_iterator *gsip, funct_state local, bool ipa)
 {
-  gimple stmt = gsi_stmt (*gsip);
+  gimple *stmt = gsi_stmt (*gsip);
 
   if (is_gimple_debug (stmt))
     return;
diff --git a/gcc/ipa-ref.c b/gcc/ipa-ref.c
index df84c9c..dd69073 100644
--- a/gcc/ipa-ref.c
+++ b/gcc/ipa-ref.c
@@ -36,7 +36,7 @@ static const char *ipa_ref_use_name[] = {"read","write","addr","alias"};
 struct ipa_ref *
 ipa_record_reference (symtab_node *referring_node,
 		      symtab_node *referred_node,
-		      enum ipa_ref_use use_type, gimple stmt)
+		      enum ipa_ref_use use_type, gimple *stmt)
 {
   struct ipa_ref *ref, *ref2;
   struct ipa_ref_list *list, *list2;
@@ -77,7 +77,7 @@ ipa_record_reference (symtab_node *referring_node,
 
 struct ipa_ref *
 ipa_maybe_record_reference (symtab_node *referring_node, tree val,
-			    enum ipa_ref_use use_type, gimple stmt)
+			    enum ipa_ref_use use_type, gimple *stmt)
 {
   STRIP_NOPS (val);
   if (TREE_CODE (val) != ADDR_EXPR)
@@ -187,7 +187,7 @@ ipa_dump_referring (FILE * file, struct ipa_ref_list *list)
 struct ipa_ref *
 ipa_clone_ref (struct ipa_ref *ref,
 	       symtab_node *dest_node,
-	       gimple stmt)
+	       gimple *stmt)
 {
   bool speculative = ref->speculative;
   unsigned int stmt_uid = ref->lto_stmt_uid;
@@ -269,7 +269,7 @@ ipa_ref_has_aliases_p (struct ipa_ref_list *ref_list)
 
 struct ipa_ref *
 ipa_find_reference (symtab_node *referring_node, symtab_node *referred_node,
-		    gimple stmt, unsigned int lto_stmt_uid)
+		    gimple *stmt, unsigned int lto_stmt_uid)
 {
   struct ipa_ref *r = NULL;
   int i;
@@ -288,7 +288,7 @@ ipa_find_reference (symtab_node *referring_node, symtab_node *referred_node,
    STMT.  */
 
 void
-ipa_remove_stmt_references (symtab_node *referring_node, gimple stmt)
+ipa_remove_stmt_references (symtab_node *referring_node, gimple *stmt)
 {
   struct ipa_ref *r = NULL;
   int i = 0;
diff --git a/gcc/ipa-ref.h b/gcc/ipa-ref.h
index 4ce5f8d..c024012 100644
--- a/gcc/ipa-ref.h
+++ b/gcc/ipa-ref.h
@@ -37,7 +37,7 @@ struct GTY(()) ipa_ref
 {
   symtab_node *referring;
   symtab_node *referred;
-  gimple stmt;
+  gimple *stmt;
   unsigned int lto_stmt_uid;
   unsigned int referred_index;
   ENUM_BITFIELD (ipa_ref_use) use:2;
@@ -60,9 +60,9 @@ struct GTY(()) ipa_ref_list
 
 struct ipa_ref * ipa_record_reference (symtab_node *,
 				       symtab_node *,
-				       enum ipa_ref_use, gimple);
+				       enum ipa_ref_use, gimple *);
 struct ipa_ref * ipa_maybe_record_reference (symtab_node *, tree,
-					     enum ipa_ref_use, gimple);
+					     enum ipa_ref_use, gimple *);
 
 void ipa_remove_reference (struct ipa_ref *);
 void ipa_remove_all_references (struct ipa_ref_list *);
@@ -71,9 +71,9 @@ void ipa_dump_references (FILE *, struct ipa_ref_list *);
 void ipa_dump_referring (FILE *, struct ipa_ref_list *);
 void ipa_clone_references (symtab_node *, struct ipa_ref_list *);
 void ipa_clone_referring (symtab_node *, struct ipa_ref_list *);
-struct ipa_ref * ipa_clone_ref (struct ipa_ref *, symtab_node *, gimple);
+struct ipa_ref * ipa_clone_ref (struct ipa_ref *, symtab_node *, gimple *);
 bool ipa_ref_cannot_lead_to_return (struct ipa_ref *);
 bool ipa_ref_has_aliases_p (struct ipa_ref_list *);
-struct ipa_ref * ipa_find_reference (symtab_node *, symtab_node *, gimple, unsigned int);
-void ipa_remove_stmt_references (symtab_node *, gimple);
+struct ipa_ref * ipa_find_reference (symtab_node *, symtab_node *, gimple *, unsigned int);
+void ipa_remove_stmt_references (symtab_node *, gimple *);
 void ipa_clear_stmts_in_references (symtab_node *);
diff --git a/gcc/ipa-split.c b/gcc/ipa-split.c
index bd1c086..72c3a25 100644
--- a/gcc/ipa-split.c
+++ b/gcc/ipa-split.c
@@ -156,7 +156,7 @@ static tree find_retval (basic_block return_bb);
    variable, check it if it is present in bitmap passed via DATA.  */
 
 static bool
-test_nonssa_use (gimple, tree t, tree, void *data)
+test_nonssa_use (gimple *, tree t, tree, void *data)
 {
   t = get_base_address (t);
 
@@ -237,7 +237,7 @@ verify_non_ssa_vars (struct split_point *current, bitmap non_ssa_vars,
 	  }
       for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
 	{
-	  gimple stmt = gsi_stmt (bsi);
+	  gimple *stmt = gsi_stmt (bsi);
 	  if (is_gimple_debug (stmt))
 	    continue;
 	  if (walk_stmt_load_store_addr_ops
@@ -272,7 +272,7 @@ verify_non_ssa_vars (struct split_point *current, bitmap non_ssa_vars,
 	  for (bsi = gsi_start_phis (return_bb); !gsi_end_p (bsi);
 	       gsi_next (&bsi))
 	    {
-	      gimple stmt = gsi_stmt (bsi);
+	      gimple *stmt = gsi_stmt (bsi);
 	      tree op = gimple_phi_arg_def (stmt, e->dest_idx);
 
 	      if (virtual_operand_p (gimple_phi_result (stmt)))
@@ -302,7 +302,7 @@ done:
    to optimize away an unused function call.  */
 
 static void
-check_forbidden_calls (gimple stmt)
+check_forbidden_calls (gimple *stmt)
 {
   imm_use_iterator use_iter;
   use_operand_p use_p;
@@ -324,7 +324,7 @@ check_forbidden_calls (gimple stmt)
       basic_block use_bb, forbidden_bb;
       enum tree_code code;
       edge true_edge, false_edge;
-      gimple use_stmt = USE_STMT (use_p);
+      gimple *use_stmt = USE_STMT (use_p);
 
       if (gimple_code (use_stmt) != GIMPLE_COND)
 	continue;
@@ -440,7 +440,7 @@ consider_split (struct split_point *current, bitmap non_ssa_vars,
      incoming from header are the same.  */
   for (bsi = gsi_start_phis (current->entry_bb); !gsi_end_p (bsi); gsi_next (&bsi))
     {
-      gimple stmt = gsi_stmt (bsi);
+      gimple *stmt = gsi_stmt (bsi);
       tree val = NULL;
 
       if (virtual_operand_p (gimple_phi_result (stmt)))
@@ -667,7 +667,7 @@ find_return_bb (void)
   e = single_pred_edge (EXIT_BLOCK_PTR_FOR_FN (cfun));
   for (bsi = gsi_last_bb (e->src); !gsi_end_p (bsi); gsi_prev (&bsi))
     {
-      gimple stmt = gsi_stmt (bsi);
+      gimple *stmt = gsi_stmt (bsi);
       if (gimple_code (stmt) == GIMPLE_LABEL
 	  || is_gimple_debug (stmt)
 	  || gimple_clobber_p (stmt))
@@ -714,7 +714,7 @@ find_retval (basic_block return_bb)
    Return true when access to T prevents splitting the function.  */
 
 static bool
-mark_nonssa_use (gimple, tree t, tree, void *data)
+mark_nonssa_use (gimple *, tree t, tree, void *data)
 {
   t = get_base_address (t);
 
@@ -773,7 +773,7 @@ visit_bb (basic_block bb, basic_block return_bb,
 
   for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
     {
-      gimple stmt = gsi_stmt (bsi);
+      gimple *stmt = gsi_stmt (bsi);
       tree op;
       ssa_op_iter iter;
       tree decl;
@@ -842,7 +842,7 @@ visit_bb (basic_block bb, basic_block return_bb,
     }
   for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
     {
-      gimple stmt = gsi_stmt (bsi);
+      gimple *stmt = gsi_stmt (bsi);
       unsigned int i;
 
       if (virtual_operand_p (gimple_phi_result (stmt)))
@@ -866,7 +866,7 @@ visit_bb (basic_block bb, basic_block return_bb,
       {
 	for (bsi = gsi_start_phis (return_bb); !gsi_end_p (bsi); gsi_next (&bsi))
 	  {
-	    gimple stmt = gsi_stmt (bsi);
+	    gimple *stmt = gsi_stmt (bsi);
 	    tree op = gimple_phi_arg_def (stmt, e->dest_idx);
 
 	    if (virtual_operand_p (gimple_phi_result (stmt)))
@@ -1091,12 +1091,12 @@ split_function (struct split_point *split_point)
   basic_block return_bb = find_return_bb ();
   basic_block call_bb;
   gimple_stmt_iterator gsi;
-  gimple call;
+  gimple *call;
   edge e;
   edge_iterator ei;
   tree retval = NULL, real_retval = NULL;
   bool split_part_return_p = false;
-  gimple last_stmt = NULL;
+  gimple *last_stmt = NULL;
   unsigned int i;
   tree arg, ddef;
   vec<tree, va_gc> **debug_args = NULL;
@@ -1196,7 +1196,7 @@ split_function (struct split_point *split_point)
       bool phi_p = false;
       for (gsi = gsi_start_phis (return_bb); !gsi_end_p (gsi);)
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  if (!virtual_operand_p (gimple_phi_result (stmt)))
 	    {
 	      gsi_next (&gsi);
@@ -1217,7 +1217,7 @@ split_function (struct split_point *split_point)
       if (!phi_p)
 	for (gsi = gsi_start_bb (return_bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	  {
-	    gimple stmt = gsi_stmt (gsi);
+	    gimple *stmt = gsi_stmt (gsi);
 	    if (gimple_vuse (stmt))
 	      {
 		gimple_set_vuse (stmt, NULL_TREE);
@@ -1298,7 +1298,7 @@ split_function (struct split_point *split_point)
 	  && is_gimple_reg (parm))
 	{
 	  tree ddecl;
-	  gimple def_temp;
+	  gimple *def_temp;
 
 	  /* This needs to be done even without MAY_HAVE_DEBUG_STMTS,
 	     otherwise if it didn't exist before, we'd end up with
@@ -1332,7 +1332,7 @@ split_function (struct split_point *split_point)
       unsigned int i;
       tree var, vexpr;
       gimple_stmt_iterator cgsi;
-      gimple def_temp;
+      gimple *def_temp;
 
       push_cfun (DECL_STRUCT_FUNCTION (node->decl));
       var = BLOCK_VARS (DECL_INITIAL (node->decl));
@@ -1445,7 +1445,7 @@ split_function (struct split_point *split_point)
 		  gsi_insert_after (&gsi, call, GSI_NEW_STMT);
 		  if (!useless_type_conversion_p (TREE_TYPE (retval), restype))
 		    {
-		      gimple cpy;
+		      gimple *cpy;
 		      tree tem = create_tmp_reg (restype, NULL);
 		      tem = make_ssa_name (tem, call);
 		      cpy = gimple_build_assign_with_ops (NOP_EXPR, retval,
@@ -1465,7 +1465,7 @@ split_function (struct split_point *split_point)
 	 */
       else
 	{
-	  gimple ret;
+	  gimple *ret;
 	  if (split_point->split_part_set_retval
 	      && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
 	    {
@@ -1613,7 +1613,7 @@ execute_split_functions (void)
       for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
 	{
 	  int this_time, this_size;
-	  gimple stmt = gsi_stmt (bsi);
+	  gimple *stmt = gsi_stmt (bsi);
 
 	  this_size = estimate_num_insns (stmt, &eni_size_weights);
 	  this_time = estimate_num_insns (stmt, &eni_time_weights) * freq;
diff --git a/gcc/java/java-gimplify.c b/gcc/java/java-gimplify.c
index 6c7a1b6..b65cdac 100644
--- a/gcc/java/java-gimplify.c
+++ b/gcc/java/java-gimplify.c
@@ -128,7 +128,7 @@ java_gimplify_block (tree java_block)
 {
   tree decls = BLOCK_VARS (java_block);
   tree body = BLOCK_EXPR_BODY (java_block);
-  gimple outer = gimple_current_bind_expr ();
+  gimple *outer = gimple_current_bind_expr ();
   tree block;
 
   /* Don't bother with empty blocks.  */
diff --git a/gcc/lto-streamer-in.c b/gcc/lto-streamer-in.c
index d0c8662..2b8baad 100644
--- a/gcc/lto-streamer-in.c
+++ b/gcc/lto-streamer-in.c
@@ -781,7 +781,7 @@ input_ssa_names (struct lto_input_block *ib, struct data_in *data_in,
    so they point to STMTS.  */
 
 static void
-fixup_call_stmt_edges_1 (struct cgraph_node *node, gimple *stmts,
+fixup_call_stmt_edges_1 (struct cgraph_node *node, gimple **stmts,
 			 struct function *fn)
 {
   struct cgraph_edge *cedge;
@@ -821,7 +821,7 @@ fixup_call_stmt_edges_1 (struct cgraph_node *node, gimple *stmts,
 /* Fixup call_stmt pointers in NODE and all clones.  */
 
 static void
-fixup_call_stmt_edges (struct cgraph_node *orig, gimple *stmts)
+fixup_call_stmt_edges (struct cgraph_node *orig, gimple **stmts)
 {
   struct cgraph_node *node;
   struct function *fn;
@@ -913,7 +913,7 @@ input_function (tree fn_decl, struct data_in *data_in,
 {
   struct function *fn;
   enum LTO_tags tag;
-  gimple *stmts;
+  gimple **stmts;
   basic_block bb;
   struct cgraph_node *node;
 
@@ -970,29 +970,29 @@ input_function (tree fn_decl, struct data_in *data_in,
       gimple_stmt_iterator gsi;
       for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
 	}
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
 	}
     }
-  stmts = (gimple *) xcalloc (gimple_stmt_max_uid (fn), sizeof (gimple));
+  stmts = (gimple **) xcalloc (gimple_stmt_max_uid (fn), sizeof (gimple *));
   FOR_ALL_BB_FN (bb, cfun)
     {
       gimple_stmt_iterator bsi = gsi_start_phis (bb);
       while (!gsi_end_p (bsi))
 	{
-	  gimple stmt = gsi_stmt (bsi);
+	  gimple *stmt = gsi_stmt (bsi);
 	  gsi_next (&bsi);
 	  stmts[gimple_uid (stmt)] = stmt;
 	}
       bsi = gsi_start_bb (bb);
       while (!gsi_end_p (bsi))
 	{
-	  gimple stmt = gsi_stmt (bsi);
+	  gimple *stmt = gsi_stmt (bsi);
 	  /* If we're recompiling LTO objects with debug stmts but
 	     we're not supposed to have debug stmts, remove them now.
 	     We can't remove them earlier because this would cause uid
diff --git a/gcc/lto-streamer-out.c b/gcc/lto-streamer-out.c
index 6f2bf9c..30e95e9 100644
--- a/gcc/lto-streamer-out.c
+++ b/gcc/lto-streamer-out.c
@@ -1875,7 +1875,7 @@ output_function (struct cgraph_node *node)
 	  gimple_stmt_iterator gsi;
 	  for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	    {
-	      gimple stmt = gsi_stmt (gsi);
+	      gimple *stmt = gsi_stmt (gsi);
 
 	      /* Virtual PHIs are not going to be streamed.  */
 	      if (!virtual_operand_p (gimple_phi_result (stmt)))
@@ -1883,7 +1883,7 @@ output_function (struct cgraph_node *node)
 	    }
 	  for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	    {
-	      gimple stmt = gsi_stmt (gsi);
+	      gimple *stmt = gsi_stmt (gsi);
 	      gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
 	    }
 	}
@@ -1894,7 +1894,7 @@ output_function (struct cgraph_node *node)
 	  gimple_stmt_iterator gsi;
 	  for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	    {
-	      gimple stmt = gsi_stmt (gsi);
+	      gimple *stmt = gsi_stmt (gsi);
 	      if (virtual_operand_p (gimple_phi_result (stmt)))
 	        gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
 	    }
diff --git a/gcc/omp-low.c b/gcc/omp-low.c
index ddd2bd5..708fe48 100644
--- a/gcc/omp-low.c
+++ b/gcc/omp-low.c
@@ -136,7 +136,7 @@ typedef struct omp_context
 
   /* The tree of contexts corresponding to the encountered constructs.  */
   struct omp_context *outer;
-  gimple stmt;
+  gimple *stmt;
 
   /* Map variables to fields in a structure that allows communication
      between sending and receiving threads.  */
@@ -190,7 +190,7 @@ struct omp_for_data
 {
   struct omp_for_data_loop loop;
   tree chunk_size;
-  gimple for_stmt;
+  gimple *for_stmt;
   tree pre, iter_type;
   int collapse;
   bool have_nowait, have_ordered;
@@ -289,7 +289,7 @@ is_combined_parallel (struct omp_region *region)
    them into *FD.  */
 
 static void
-extract_omp_for_data (gimple for_stmt, struct omp_for_data *fd,
+extract_omp_for_data (gimple *for_stmt, struct omp_for_data *fd,
 		      struct omp_for_data_loop *loops)
 {
   tree t, var, *collapse_iter, *collapse_count;
@@ -625,7 +625,7 @@ static bool
 workshare_safe_to_combine_p (basic_block ws_entry_bb)
 {
   struct omp_for_data fd;
-  gimple ws_stmt = last_stmt (ws_entry_bb);
+  gimple *ws_stmt = last_stmt (ws_entry_bb);
 
   if (gimple_code (ws_stmt) == GIMPLE_OMP_SECTIONS)
     return true;
@@ -659,7 +659,7 @@ workshare_safe_to_combine_p (basic_block ws_entry_bb)
    expanded.  */
 
 static vec<tree, va_gc> *
-get_ws_args_for (gimple par_stmt, gimple ws_stmt)
+get_ws_args_for (gimple *par_stmt, gimple *ws_stmt)
 {
   tree t;
   location_t loc = gimple_location (ws_stmt);
@@ -755,8 +755,8 @@ determine_parallel_type (struct omp_region *region)
 	  || (last_and_only_stmt (ws_entry_bb)
 	      && last_and_only_stmt (par_exit_bb))))
     {
-      gimple par_stmt = last_stmt (par_entry_bb);
-      gimple ws_stmt = last_stmt (ws_entry_bb);
+      gimple *par_stmt = last_stmt (par_entry_bb);
+      gimple *ws_stmt = last_stmt (ws_entry_bb);
 
       if (region->inner->type == GIMPLE_OMP_FOR)
 	{
@@ -1329,7 +1329,7 @@ free_omp_regions (void)
 /* Create a new context, with OUTER_CTX being the surrounding context.  */
 
 static omp_context *
-new_omp_context (gimple stmt, omp_context *outer_ctx)
+new_omp_context (gimple *stmt, omp_context *outer_ctx)
 {
   omp_context *ctx = XCNEW (omp_context);
 
@@ -1368,12 +1368,12 @@ static gimple_seq maybe_catch_exception (gimple_seq);
 /* Finalize task copyfn.  */
 
 static void
-finalize_task_copyfn (gimple task_stmt)
+finalize_task_copyfn (gimple *task_stmt)
 {
   struct function *child_cfun;
   tree child_fn;
   gimple_seq seq = NULL, new_seq;
-  gimple bind;
+  gimple *bind;
 
   child_fn = gimple_omp_task_copy_fn (task_stmt);
   if (child_fn == NULL_TREE)
@@ -1935,7 +1935,7 @@ find_combined_for (gimple_stmt_iterator *gsi_p,
 		   bool *handled_ops_p,
 		   struct walk_stmt_info *wi)
 {
-  gimple stmt = gsi_stmt (*gsi_p);
+  gimple *stmt = gsi_stmt (*gsi_p);
 
   *handled_ops_p = true;
   switch (gimple_code (stmt))
@@ -1963,7 +1963,7 @@ scan_omp_parallel (gimple_stmt_iterator *gsi, omp_context *outer_ctx)
 {
   omp_context *ctx;
   tree name;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
 
   /* Ignore parallel directives with empty bodies, unless there
      are copyin clauses.  */
@@ -1978,14 +1978,14 @@ scan_omp_parallel (gimple_stmt_iterator *gsi, omp_context *outer_ctx)
 
   if (gimple_omp_parallel_combined_p (stmt))
     {
-      gimple for_stmt;
+      gimple *for_stmt;
       struct walk_stmt_info wi;
 
       memset (&wi, 0, sizeof (wi));
       wi.val_only = true;
       walk_gimple_seq (gimple_omp_body (stmt),
 		       find_combined_for, NULL, &wi);
-      for_stmt = (gimple) wi.info;
+      for_stmt = (gimple *) wi.info;
       if (for_stmt)
 	{
 	  struct omp_for_data fd;
@@ -2044,7 +2044,7 @@ scan_omp_task (gimple_stmt_iterator *gsi, omp_context *outer_ctx)
 {
   omp_context *ctx;
   tree name, t;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   location_t loc = gimple_location (stmt);
 
   /* Ignore task directives with empty bodies.  */
@@ -2127,7 +2127,7 @@ scan_omp_task (gimple_stmt_iterator *gsi, omp_context *outer_ctx)
 /* Scan an OpenMP loop directive.  */
 
 static void
-scan_omp_for (gimple stmt, omp_context *outer_ctx)
+scan_omp_for (gimple *stmt, omp_context *outer_ctx)
 {
   omp_context *ctx;
   size_t i;
@@ -2150,7 +2150,7 @@ scan_omp_for (gimple stmt, omp_context *outer_ctx)
 /* Scan an OpenMP sections directive.  */
 
 static void
-scan_omp_sections (gimple stmt, omp_context *outer_ctx)
+scan_omp_sections (gimple *stmt, omp_context *outer_ctx)
 {
   omp_context *ctx;
 
@@ -2162,7 +2162,7 @@ scan_omp_sections (gimple stmt, omp_context *outer_ctx)
 /* Scan an OpenMP single directive.  */
 
 static void
-scan_omp_single (gimple stmt, omp_context *outer_ctx)
+scan_omp_single (gimple *stmt, omp_context *outer_ctx)
 {
   omp_context *ctx;
   tree name;
@@ -2187,7 +2187,7 @@ scan_omp_single (gimple stmt, omp_context *outer_ctx)
 /* Scan an OpenMP target{, data, update} directive.  */
 
 static void
-scan_omp_target (gimple stmt, omp_context *outer_ctx)
+scan_omp_target (gimple *stmt, omp_context *outer_ctx)
 {
   omp_context *ctx;
   tree name;
@@ -2235,7 +2235,7 @@ scan_omp_target (gimple stmt, omp_context *outer_ctx)
 /* Scan an OpenMP teams directive.  */
 
 static void
-scan_omp_teams (gimple stmt, omp_context *outer_ctx)
+scan_omp_teams (gimple *stmt, omp_context *outer_ctx)
 {
   omp_context *ctx = new_omp_context (stmt, outer_ctx);
   scan_sharing_clauses (gimple_omp_teams_clauses (stmt), ctx);
@@ -2244,7 +2244,7 @@ scan_omp_teams (gimple stmt, omp_context *outer_ctx)
 
 /* Check OpenMP nesting restrictions.  */
 static bool
-check_omp_nesting_restrictions (gimple stmt, omp_context *ctx)
+check_omp_nesting_restrictions (gimple *stmt, omp_context *ctx)
 {
   if (ctx != NULL)
     {
@@ -2580,7 +2580,7 @@ static tree
 scan_omp_1_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
 		 struct walk_stmt_info *wi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   omp_context *ctx = (omp_context *) wi->info;
 
   if (gimple_has_location (stmt))
@@ -2714,12 +2714,12 @@ scan_omp (gimple_seq *body_p, omp_context *ctx)
 
 /* Build a call to GOMP_barrier.  */
 
-static gimple
+static gimple *
 build_omp_barrier (tree lhs)
 {
   tree fndecl = builtin_decl_explicit (lhs ? BUILT_IN_GOMP_BARRIER_CANCEL
 					   : BUILT_IN_GOMP_BARRIER);
-  gimple g = gimple_build_call (fndecl, 0);
+  gimple *g = gimple_build_call (fndecl, 0);
   if (lhs)
     gimple_call_set_lhs (g, lhs);
   return g;
@@ -2728,7 +2728,7 @@ build_omp_barrier (tree lhs)
 /* If a context was created for STMT when it was scanned, return it.  */
 
 static omp_context *
-maybe_lookup_ctx (gimple stmt)
+maybe_lookup_ctx (gimple *stmt)
 {
   splay_tree_node n;
   n = splay_tree_lookup (all_contexts, (splay_tree_key) stmt);
@@ -3149,7 +3149,7 @@ lower_rec_input_clauses (tree clauses, gimple_seq *ilist, gimple_seq *dlist,
 
 	      if (c_kind != OMP_CLAUSE_FIRSTPRIVATE || !is_task_ctx (ctx))
 		{
-		  gimple stmt;
+		  gimple *stmt;
 		  tree tmp, atmp;
 
 		  ptr = DECL_VALUE_EXPR (new_var);
@@ -3401,7 +3401,7 @@ lower_rec_input_clauses (tree clauses, gimple_seq *ilist, gimple_seq *dlist,
 			  gimplify_and_add (x, ilist);
 			  gimple_stmt_iterator gsi
 			    = gsi_start_1 (gimple_omp_body_ptr (ctx->stmt));
-			  gimple g
+			  gimple *g
 			    = gimple_build_assign (unshare_expr (lvar), iv);
 			  gsi_insert_before_without_update (&gsi, g,
 							    GSI_SAME_STMT);
@@ -3455,7 +3455,7 @@ lower_rec_input_clauses (tree clauses, gimple_seq *ilist, gimple_seq *dlist,
 	      if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c))
 		{
 		  tree placeholder = OMP_CLAUSE_REDUCTION_PLACEHOLDER (c);
-		  gimple tseq;
+		  gimple *tseq;
 		  x = build_outer_var_ref (var, ctx);
 
 		  if (is_reference (var)
@@ -3612,7 +3612,7 @@ lower_rec_input_clauses (tree clauses, gimple_seq *ilist, gimple_seq *dlist,
       /* Don't want uninit warnings on simduid, it is always uninitialized,
 	 but we use it not for the value, but for the DECL_UID only.  */
       TREE_NO_WARNING (uid) = 1;
-      gimple g
+      gimple *g
 	= gimple_build_call_internal (IFN_GOMP_SIMD_LANE, 1, uid);
       gimple_call_set_lhs (g, lane);
       gimple_stmt_iterator gsi = gsi_start_1 (gimple_omp_body_ptr (ctx->stmt));
@@ -3739,7 +3739,7 @@ lower_lastprivate_clauses (tree clauses, tree predicate, gimple_seq *stmt_list,
 
   if (predicate)
     {
-      gimple stmt;
+      gimple *stmt;
       tree label_true, arm1, arm2;
 
       label = create_artificial_label (UNKNOWN_LOCATION);
@@ -3786,7 +3786,7 @@ lower_lastprivate_clauses (tree clauses, tree predicate, gimple_seq *stmt_list,
 		  if (lastlane == NULL)
 		    {
 		      lastlane = create_tmp_var (unsigned_type_node, NULL);
-		      gimple g
+		      gimple *g
 			= gimple_build_call_internal (IFN_GOMP_SIMD_LAST_LANE,
 						      2, simduid,
 						      TREE_OPERAND (val, 1));
@@ -3852,7 +3852,7 @@ static void
 lower_reduction_clauses (tree clauses, gimple_seq *stmt_seqp, omp_context *ctx)
 {
   gimple_seq sub_seq = NULL;
-  gimple stmt;
+  gimple *stmt;
   tree x, c;
   int count = 0;
 
@@ -4142,7 +4142,7 @@ lower_send_shared_vars (gimple_seq *ilist, gimple_seq *olist, omp_context *ctx)
 /* A convenience function to build an empty GIMPLE_COND with just the
    condition.  */
 
-static gimple
+static gimple *
 gimple_build_cond_empty (tree cond)
 {
   enum tree_code pred_code;
@@ -4162,11 +4162,11 @@ gimple_build_cond_empty (tree cond)
 
 static void
 expand_parallel_call (struct omp_region *region, basic_block bb,
-		      gimple entry_stmt, vec<tree, va_gc> *ws_args)
+		      gimple *entry_stmt, vec<tree, va_gc> *ws_args)
 {
   tree t, t1, t2, val, cond, c, clauses, flags;
   gimple_stmt_iterator gsi;
-  gimple stmt;
+  gimple *stmt;
   enum built_in_function start_ix;
   int start_ix2;
   location_t clause_loc;
@@ -4290,7 +4290,7 @@ expand_parallel_call (struct omp_region *region, basic_block bb,
 
 	  if (gimple_in_ssa_p (cfun))
 	    {
-	      gimple phi = create_phi_node (tmp_join, bb);
+	      gimple *phi = create_phi_node (tmp_join, bb);
 	      add_phi_arg (phi, tmp_then, e_then, UNKNOWN_LOCATION);
 	      add_phi_arg (phi, tmp_else, e_else, UNKNOWN_LOCATION);
 	    }
@@ -4331,7 +4331,7 @@ expand_parallel_call (struct omp_region *region, basic_block bb,
    generate the task operation.  BB is the block where to insert the code.  */
 
 static void
-expand_task_call (basic_block bb, gimple entry_stmt)
+expand_task_call (basic_block bb, gimple *entry_stmt)
 {
   tree t, t1, t2, t3, flags, cond, c, c2, clauses, depend;
   gimple_stmt_iterator gsi;
@@ -4396,7 +4396,7 @@ expand_task_call (basic_block bb, gimple entry_stmt)
 static gimple_seq
 maybe_catch_exception (gimple_seq body)
 {
-  gimple g;
+  gimple *g;
   tree decl;
 
   if (!flag_exceptions)
@@ -4445,7 +4445,7 @@ remove_exit_barrier (struct omp_region *region)
   basic_block exit_bb;
   edge_iterator ei;
   edge e;
-  gimple stmt;
+  gimple *stmt;
   int any_addressable_vars = -1;
 
   exit_bb = region->exit;
@@ -4485,7 +4485,7 @@ remove_exit_barrier (struct omp_region *region)
 	     of such a variable.  */
 	  if (any_addressable_vars < 0)
 	    {
-	      gimple parallel_stmt = last_stmt (region->entry);
+	      gimple *parallel_stmt = last_stmt (region->entry);
 	      tree child_fun = gimple_omp_parallel_child_fn (parallel_stmt);
 	      tree local_decls, block, decl;
 	      unsigned ix;
@@ -4548,7 +4548,7 @@ remove_exit_barriers (struct omp_region *region)
    scheduling point.  */
 
 static void
-optimize_omp_library_calls (gimple entry_stmt)
+optimize_omp_library_calls (gimple *entry_stmt)
 {
   basic_block bb;
   gimple_stmt_iterator gsi;
@@ -4563,7 +4563,7 @@ optimize_omp_library_calls (gimple entry_stmt)
   FOR_EACH_BB_FN (bb, cfun)
     for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
       {
-	gimple call = gsi_stmt (gsi);
+	gimple *call = gsi_stmt (gsi);
 	tree decl;
 
 	if (is_gimple_call (call)
@@ -4631,7 +4631,7 @@ expand_omp_build_assign (gimple_stmt_iterator *gsi_p, tree to, tree from)
   bool simple_p = DECL_P (to) && TREE_ADDRESSABLE (to);
   from = force_gimple_operand_gsi (gsi_p, from, simple_p, NULL_TREE,
 				   true, GSI_SAME_STMT);
-  gimple stmt = gimple_build_assign (to, from);
+  gimple *stmt = gimple_build_assign (to, from);
   gsi_insert_before (gsi_p, stmt, GSI_SAME_STMT);
   if (walk_tree (&from, expand_omp_regimplify_p, NULL, NULL)
       || walk_tree (&to, expand_omp_regimplify_p, NULL, NULL))
@@ -4650,7 +4650,7 @@ expand_omp_taskreg (struct omp_region *region)
   struct function *child_cfun;
   tree child_fn, block, t;
   gimple_stmt_iterator gsi;
-  gimple entry_stmt, stmt;
+  gimple *entry_stmt, *stmt;
   edge e;
   vec<tree, va_gc> *ws_args;
 
@@ -4711,11 +4711,11 @@ expand_omp_taskreg (struct omp_region *region)
 	  basic_block entry_succ_bb = single_succ (entry_bb);
 	  gimple_stmt_iterator gsi;
 	  tree arg, narg;
-	  gimple parcopy_stmt = NULL;
+	  gimple *parcopy_stmt = NULL;
 
 	  for (gsi = gsi_start_bb (entry_succ_bb); ; gsi_next (&gsi))
 	    {
-	      gimple stmt;
+	      gimple *stmt;
 
 	      gcc_assert (!gsi_end_p (gsi));
 	      stmt = gsi_stmt (gsi);
@@ -4944,7 +4944,7 @@ expand_omp_for_init_counts (struct omp_for_data *fd, gimple_stmt_iterator *gsi,
 			    basic_block &l2_dom_bb)
 {
   tree t, type = TREE_TYPE (fd->loop.v);
-  gimple stmt;
+  gimple *stmt;
   edge e, ne;
   int i;
 
@@ -5083,7 +5083,7 @@ expand_omp_for_init_counts (struct omp_for_data *fd, gimple_stmt_iterator *gsi,
 
 static void
 expand_omp_for_init_vars (struct omp_for_data *fd, gimple_stmt_iterator *gsi,
-			  tree *counts, gimple inner_stmt, tree startvar)
+			  tree *counts, gimple *inner_stmt, tree startvar)
 {
   int i;
   if (gimple_omp_for_combined_p (fd->for_stmt))
@@ -5112,7 +5112,7 @@ expand_omp_for_init_vars (struct omp_for_data *fd, gimple_stmt_iterator *gsi,
 	      tree t = fold_convert (TREE_TYPE (tem), counts[i]);
 	      t = force_gimple_operand_gsi (gsi, t, false, NULL_TREE,
 					    false, GSI_CONTINUE_LINKING);
-	      gimple stmt = gimple_build_assign (tem, t);
+	      gimple *stmt = gimple_build_assign (tem, t);
 	      gsi_insert_after (gsi, stmt, GSI_CONTINUE_LINKING);
 	    }
 	}
@@ -5121,7 +5121,7 @@ expand_omp_for_init_vars (struct omp_for_data *fd, gimple_stmt_iterator *gsi,
 
   tree type = TREE_TYPE (fd->loop.v);
   tree tem = create_tmp_reg (type, ".tem");
-  gimple stmt = gimple_build_assign (tem, startvar);
+  gimple *stmt = gimple_build_assign (tem, startvar);
   gsi_insert_after (gsi, stmt, GSI_CONTINUE_LINKING);
 
   for (i = fd->collapse - 1; i >= 0; i--)
@@ -5182,7 +5182,7 @@ extract_omp_for_update_vars (struct omp_for_data *fd, basic_block cont_bb,
   gimple_stmt_iterator gsi;
   edge e;
   tree t;
-  gimple stmt;
+  gimple *stmt;
 
   last_bb = cont_bb;
   for (i = fd->collapse - 1; i >= 0; i--)
@@ -5345,14 +5345,14 @@ expand_omp_for_generic (struct omp_region *region,
 			struct omp_for_data *fd,
 			enum built_in_function start_fn,
 			enum built_in_function next_fn,
-			gimple inner_stmt)
+			gimple *inner_stmt)
 {
   tree type, istart0, iend0, iend;
   tree t, vmain, vback, bias = NULL_TREE;
   basic_block entry_bb, cont_bb, exit_bb, l0_bb, l1_bb, collapse_bb;
   basic_block l2_bb = NULL, l3_bb = NULL;
   gimple_stmt_iterator gsi;
-  gimple stmt;
+  gimple *stmt;
   bool in_combined_parallel = is_combined_parallel (region);
   bool broken_loop = region->cont == NULL;
   edge e, ne;
@@ -5671,7 +5671,7 @@ expand_omp_for_generic (struct omp_region *region,
       phis = phi_nodes (l3_bb);
       for (gsi = gsi_start (phis); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple phi = gsi_stmt (gsi);
+	  gimple *phi = gsi_stmt (gsi);
 	  SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi, ne),
 		   PHI_ARG_DEF_FROM_EDGE (phi, e));
 	}
@@ -5770,7 +5770,7 @@ expand_omp_for_generic (struct omp_region *region,
 static void
 expand_omp_for_static_nochunk (struct omp_region *region,
 			       struct omp_for_data *fd,
-			       gimple inner_stmt)
+			       gimple *inner_stmt)
 {
   tree n, q, s0, e0, e, t, tt, nthreads, threadid;
   tree type, itype, vmain, vback;
@@ -5778,7 +5778,7 @@ expand_omp_for_static_nochunk (struct omp_region *region,
   basic_block body_bb, cont_bb, collapse_bb = NULL;
   basic_block fin_bb;
   gimple_stmt_iterator gsi;
-  gimple stmt;
+  gimple *stmt;
   edge ep;
   enum built_in_function get_num_threads = BUILT_IN_OMP_GET_NUM_THREADS;
   enum built_in_function get_thread_num = BUILT_IN_OMP_GET_THREAD_NUM;
@@ -5865,7 +5865,7 @@ expand_omp_for_static_nochunk (struct omp_region *region,
 	  for (gsi = gsi_start_phis (fin_bb);
 	       !gsi_end_p (gsi); gsi_next (&gsi))
 	    {
-	      gimple phi = gsi_stmt (gsi);
+	      gimple *phi = gsi_stmt (gsi);
 	      add_phi_arg (phi, gimple_phi_arg_def (phi, dest_idx),
 			   ep, UNKNOWN_LOCATION);
 	    }
@@ -6147,7 +6147,7 @@ expand_omp_for_static_nochunk (struct omp_region *region,
 
 static void
 expand_omp_for_static_chunk (struct omp_region *region,
-			     struct omp_for_data *fd, gimple inner_stmt)
+			     struct omp_for_data *fd, gimple *inner_stmt)
 {
   tree n, s0, e0, e, t;
   tree trip_var, trip_init, trip_main, trip_back, nthreads, threadid;
@@ -6155,7 +6155,7 @@ expand_omp_for_static_chunk (struct omp_region *region,
   basic_block entry_bb, exit_bb, body_bb, seq_start_bb, iter_part_bb;
   basic_block trip_update_bb = NULL, cont_bb, collapse_bb = NULL, fin_bb;
   gimple_stmt_iterator si;
-  gimple stmt;
+  gimple *stmt;
   edge se;
   enum built_in_function get_num_threads = BUILT_IN_OMP_GET_NUM_THREADS;
   enum built_in_function get_thread_num = BUILT_IN_OMP_GET_THREAD_NUM;
@@ -6246,7 +6246,7 @@ expand_omp_for_static_chunk (struct omp_region *region,
 	  for (si = gsi_start_phis (fin_bb);
 	       !gsi_end_p (si); gsi_next (&si))
 	    {
-	      gimple phi = gsi_stmt (si);
+	      gimple *phi = gsi_stmt (si);
 	      add_phi_arg (phi, gimple_phi_arg_def (phi, dest_idx),
 			   se, UNKNOWN_LOCATION);
 	    }
@@ -6485,7 +6485,7 @@ expand_omp_for_static_chunk (struct omp_region *region,
   if (gimple_in_ssa_p (cfun))
     {
       gimple_stmt_iterator psi;
-      gimple phi;
+      gimple *phi;
       edge re, ene;
       edge_var_map_vector *head;
       edge_var_map *vm;
@@ -6505,7 +6505,7 @@ expand_omp_for_static_chunk (struct omp_region *region,
       for (i = 0; !gsi_end_p (psi) && head->iterate (i, &vm);
 	   gsi_next (&psi), ++i)
 	{
-	  gimple nphi;
+	  gimple *nphi;
 	  source_location locus;
 
 	  phi = gsi_stmt (psi);
@@ -6638,7 +6638,7 @@ expand_omp_simd (struct omp_region *region, struct omp_for_data *fd)
   tree type, t;
   basic_block entry_bb, cont_bb, exit_bb, l0_bb, l1_bb, l2_bb, l2_dom_bb;
   gimple_stmt_iterator gsi;
-  gimple stmt;
+  gimple *stmt;
   bool broken_loop = region->cont == NULL;
   edge e, ne;
   tree *counts = NULL;
@@ -6883,7 +6883,7 @@ expand_omp_simd (struct omp_region *region, struct omp_for_data *fd)
 /* Expand the OpenMP loop defined by REGION.  */
 
 static void
-expand_omp_for (struct omp_region *region, gimple inner_stmt)
+expand_omp_for (struct omp_region *region, gimple *inner_stmt)
 {
   struct omp_for_data fd;
   struct omp_for_data_loop *loops;
@@ -6985,7 +6985,7 @@ expand_omp_sections (struct omp_region *region)
   unsigned len;
   basic_block entry_bb, l0_bb, l1_bb, l2_bb, default_bb;
   gimple_stmt_iterator si, switch_si;
-  gimple sections_stmt, stmt, cont;
+  gimple *sections_stmt, *stmt, *cont;
   edge_iterator ei;
   edge e;
   struct omp_region *inner;
@@ -7241,7 +7241,7 @@ expand_omp_atomic_load (basic_block load_bb, tree addr,
   gimple_stmt_iterator gsi;
   basic_block store_bb;
   location_t loc;
-  gimple stmt;
+  gimple *stmt;
   tree decl, call, type, itype;
 
   gsi = gsi_last_bb (load_bb);
@@ -7295,7 +7295,7 @@ expand_omp_atomic_store (basic_block load_bb, tree addr,
   gimple_stmt_iterator gsi;
   basic_block store_bb = single_succ (load_bb);
   location_t loc;
-  gimple stmt;
+  gimple *stmt;
   tree decl, call, type, itype;
   enum machine_mode imode;
   bool exchange;
@@ -7376,7 +7376,7 @@ expand_omp_atomic_fetch_op (basic_block load_bb,
   tree lhs, rhs;
   basic_block store_bb = single_succ (load_bb);
   gimple_stmt_iterator gsi;
-  gimple stmt;
+  gimple *stmt;
   location_t loc;
   enum tree_code code;
   bool need_old, need_new;
@@ -7522,7 +7522,7 @@ expand_omp_atomic_pipeline (basic_block load_bb, basic_block store_bb,
   tree type, itype, cmpxchg, iaddr;
   gimple_stmt_iterator si;
   basic_block loop_header = single_succ (load_bb);
-  gimple phi, stmt;
+  gimple *phi, *stmt;
   edge e;
   enum built_in_function fncode;
 
@@ -7605,7 +7605,7 @@ expand_omp_atomic_pipeline (basic_block load_bb, basic_block store_bb,
       gsi2 = gsi_start_bb (loop_header);
       if (gimple_in_ssa_p (cfun))
 	{
-	  gimple stmt;
+	  gimple *stmt;
 	  x = force_gimple_operand_gsi (&gsi2, x, true, NULL_TREE,
 					true, GSI_SAME_STMT);
 	  stmt = gimple_build_assign (loaded_val, x);
@@ -7718,7 +7718,7 @@ expand_omp_atomic_mutex (basic_block load_bb, basic_block store_bb,
 			 tree addr, tree loaded_val, tree stored_val)
 {
   gimple_stmt_iterator si;
-  gimple stmt;
+  gimple *stmt;
   tree t;
 
   si = gsi_last_bb (load_bb);
@@ -7760,7 +7760,7 @@ static void
 expand_omp_atomic (struct omp_region *region)
 {
   basic_block load_bb = region->entry, store_bb = region->exit;
-  gimple load = last_stmt (load_bb), store = last_stmt (store_bb);
+  gimple *load = last_stmt (load_bb), *store = last_stmt (store_bb);
   tree loaded_val = gimple_omp_atomic_load_lhs (load);
   tree addr = gimple_omp_atomic_load_rhs (load);
   tree stored_val = gimple_omp_atomic_store_val (store);
@@ -7824,7 +7824,7 @@ expand_omp_target (struct omp_region *region)
   struct function *child_cfun = NULL;
   tree child_fn = NULL_TREE, block, t;
   gimple_stmt_iterator gsi;
-  gimple entry_stmt, stmt;
+  gimple *entry_stmt, *stmt;
   edge e;
 
   entry_stmt = last_stmt (region->entry);
@@ -7861,7 +7861,7 @@ expand_omp_target (struct omp_region *region)
 	  basic_block entry_succ_bb = single_succ (entry_bb);
 	  gimple_stmt_iterator gsi;
 	  tree arg;
-	  gimple tgtcopy_stmt = NULL;
+	  gimple *tgtcopy_stmt = NULL;
 	  tree sender
 	    = TREE_VEC_ELT (gimple_omp_target_data_arg (entry_stmt), 0);
 
@@ -8098,7 +8098,7 @@ expand_omp_target (struct omp_region *region)
       t4 = build_fold_addr_expr (TREE_VEC_ELT (t, 2));
     }
 
-  gimple g;
+  gimple *g;
   /* FIXME: This will be address of
      extern char __OPENMP_TARGET__[] __attribute__((visibility ("hidden")))
      symbol, as soon as the linker plugin is able to create it for us.  */
@@ -8142,7 +8142,7 @@ expand_omp (struct omp_region *region)
   while (region)
     {
       location_t saved_location;
-      gimple inner_stmt = NULL;
+      gimple *inner_stmt = NULL;
 
       /* First, determine whether this is a combined parallel+workshare
        	 region.  */
@@ -8220,7 +8220,7 @@ build_omp_regions_1 (basic_block bb, struct omp_region *parent,
 		     bool single_tree)
 {
   gimple_stmt_iterator gsi;
-  gimple stmt;
+  gimple *stmt;
   basic_block son;
 
   gsi = gsi_last_bb (bb);
@@ -8408,7 +8408,7 @@ make_pass_expand_omp (gcc::context *ctxt)
 static void
 maybe_add_implicit_barrier_cancel (omp_context *ctx, gimple_seq *body)
 {
-  gimple omp_return = gimple_seq_last_stmt (*body);
+  gimple *omp_return = gimple_seq_last_stmt (*body);
   gcc_assert (gimple_code (omp_return) == GIMPLE_OMP_RETURN);
   if (gimple_omp_return_nowait_p (omp_return))
     return;
@@ -8421,7 +8421,7 @@ maybe_add_implicit_barrier_cancel (omp_context *ctx, gimple_seq *body)
       tree lhs = create_tmp_var (c_bool_type, NULL);
       gimple_omp_return_set_lhs (omp_return, lhs);
       tree fallthru_label = create_artificial_label (UNKNOWN_LOCATION);
-      gimple g = gimple_build_cond (NE_EXPR, lhs,
+      gimple *g = gimple_build_cond (NE_EXPR, lhs,
 				    fold_convert (c_bool_type,
 						  boolean_false_node),
 				    ctx->outer->cancel_label, fallthru_label);
@@ -8438,7 +8438,7 @@ lower_omp_sections (gimple_stmt_iterator *gsi_p, omp_context *ctx)
 {
   tree block, control;
   gimple_stmt_iterator tgsi;
-  gimple stmt, new_stmt, bind, t;
+  gimple *stmt, *new_stmt, *bind, *t;
   gimple_seq ilist, dlist, olist, new_body;
 
   stmt = gsi_stmt (*gsi_p);
@@ -8456,7 +8456,7 @@ lower_omp_sections (gimple_stmt_iterator *gsi_p, omp_context *ctx)
   for (; !gsi_end_p (tgsi); gsi_next (&tgsi))
     {
       omp_context *sctx;
-      gimple sec_start;
+      gimple *sec_start;
 
       sec_start = gsi_stmt (tgsi);
       sctx = maybe_lookup_ctx (sec_start);
@@ -8536,12 +8536,12 @@ lower_omp_sections (gimple_stmt_iterator *gsi_p, omp_context *ctx)
   to a synchronization analysis pass.  */
 
 static void
-lower_omp_single_simple (gimple single_stmt, gimple_seq *pre_p)
+lower_omp_single_simple (gimple *single_stmt, gimple_seq *pre_p)
 {
   location_t loc = gimple_location (single_stmt);
   tree tlabel = create_artificial_label (loc);
   tree flabel = create_artificial_label (loc);
-  gimple call, cond;
+  gimple *call, *cond;
   tree lhs, decl;
 
   decl = builtin_decl_explicit (BUILT_IN_GOMP_SINGLE_START);
@@ -8591,7 +8591,7 @@ lower_omp_single_simple (gimple single_stmt, gimple_seq *pre_p)
   to a synchronization analysis pass.  */
 
 static void
-lower_omp_single_copy (gimple single_stmt, gimple_seq *pre_p, omp_context *ctx)
+lower_omp_single_copy (gimple *single_stmt, gimple_seq *pre_p, omp_context *ctx)
 {
   tree ptr_type, t, l0, l1, l2, bfn_decl;
   gimple_seq copyin_seq;
@@ -8647,7 +8647,7 @@ static void
 lower_omp_single (gimple_stmt_iterator *gsi_p, omp_context *ctx)
 {
   tree block;
-  gimple t, bind, single_stmt = gsi_stmt (*gsi_p);
+  gimple *t, *bind, *single_stmt = gsi_stmt (*gsi_p);
   gimple_seq bind_body, bind_body_tail = NULL, dlist;
 
   push_gimplify_context ();
@@ -8705,7 +8705,7 @@ static void
 lower_omp_master (gimple_stmt_iterator *gsi_p, omp_context *ctx)
 {
   tree block, lab = NULL, x, bfn_decl;
-  gimple stmt = gsi_stmt (*gsi_p), bind;
+  gimple *stmt = gsi_stmt (*gsi_p), *bind;
   location_t loc = gimple_location (stmt);
   gimple_seq tseq;
 
@@ -8745,7 +8745,7 @@ lower_omp_master (gimple_stmt_iterator *gsi_p, omp_context *ctx)
 static void
 lower_omp_taskgroup (gimple_stmt_iterator *gsi_p, omp_context *ctx)
 {
-  gimple stmt = gsi_stmt (*gsi_p), bind, x;
+  gimple *stmt = gsi_stmt (*gsi_p), *bind, *x;
   tree block = make_node (BLOCK);
 
   bind = gimple_build_bind (NULL, NULL, block);
@@ -8773,7 +8773,7 @@ static void
 lower_omp_ordered (gimple_stmt_iterator *gsi_p, omp_context *ctx)
 {
   tree block;
-  gimple stmt = gsi_stmt (*gsi_p), bind, x;
+  gimple *stmt = gsi_stmt (*gsi_p), *bind, *x;
 
   push_gimplify_context ();
 
@@ -8816,7 +8816,7 @@ lower_omp_critical (gimple_stmt_iterator *gsi_p, omp_context *ctx)
 {
   tree block;
   tree name, lock, unlock;
-  gimple stmt = gsi_stmt (*gsi_p), bind;
+  gimple *stmt = gsi_stmt (*gsi_p), *bind;
   location_t loc = gimple_location (stmt);
   gimple_seq tbody;
 
@@ -8958,7 +8958,7 @@ lower_omp_for (gimple_stmt_iterator *gsi_p, omp_context *ctx)
 {
   tree *rhs_p, block;
   struct omp_for_data fd, *fdp = NULL;
-  gimple stmt = gsi_stmt (*gsi_p), new_stmt;
+  gimple *stmt = gsi_stmt (*gsi_p), *new_stmt;
   gimple_seq omp_for_body, body, dlist;
   size_t i;
 
@@ -8979,7 +8979,7 @@ lower_omp_for (gimple_stmt_iterator *gsi_p, omp_context *ctx)
   if (!gimple_seq_empty_p (omp_for_body)
       && gimple_code (gimple_seq_first_stmt (omp_for_body)) == GIMPLE_BIND)
     {
-      gimple inner_bind = gimple_seq_first_stmt (omp_for_body);
+      gimple *inner_bind = gimple_seq_first_stmt (omp_for_body);
       tree vars = gimple_bind_vars (inner_bind);
       gimple_bind_append_vars (new_stmt, vars);
       /* bind_vars/BLOCK_VARS are being moved to new_stmt/block, don't
@@ -9104,7 +9104,7 @@ check_combined_parallel (gimple_stmt_iterator *gsi_p,
     			 struct walk_stmt_info *wi)
 {
   int *info = (int *) wi->info;
-  gimple stmt = gsi_stmt (*gsi_p);
+  gimple *stmt = gsi_stmt (*gsi_p);
 
   *handled_ops_p = true;
   switch (gimple_code (stmt))
@@ -9175,7 +9175,7 @@ task_copyfn_remap_type (struct omp_taskcopy_context *tcctx, tree orig_type)
 /* Create task copyfn.  */
 
 static void
-create_task_copyfn (gimple task_stmt, omp_context *ctx)
+create_task_copyfn (gimple *task_stmt, omp_context *ctx)
 {
   struct function *child_cfun;
   tree child_fn, t, c, src, dst, f, sf, arg, sarg, decl;
@@ -9403,10 +9403,10 @@ create_task_copyfn (gimple task_stmt, omp_context *ctx)
 }
 
 static void
-lower_depend_clauses (gimple stmt, gimple_seq *iseq, gimple_seq *oseq)
+lower_depend_clauses (gimple *stmt, gimple_seq *iseq, gimple_seq *oseq)
 {
   tree c, clauses;
-  gimple g;
+  gimple *g;
   size_t n_in = 0, n_out = 0, idx = 2, i;
 
   clauses = find_omp_clause (gimple_omp_task_clauses (stmt),
@@ -9472,8 +9472,8 @@ lower_omp_taskreg (gimple_stmt_iterator *gsi_p, omp_context *ctx)
 {
   tree clauses;
   tree child_fn, t;
-  gimple stmt = gsi_stmt (*gsi_p);
-  gimple par_bind, bind, dep_bind = NULL;
+  gimple *stmt = gsi_stmt (*gsi_p);
+  gimple *par_bind, *bind, *dep_bind = NULL;
   gimple_seq par_body, olist, ilist, par_olist, par_rlist, par_ilist, new_body;
   location_t loc = gimple_location (stmt);
 
@@ -9594,8 +9594,8 @@ lower_omp_target (gimple_stmt_iterator *gsi_p, omp_context *ctx)
 {
   tree clauses;
   tree child_fn, t, c;
-  gimple stmt = gsi_stmt (*gsi_p);
-  gimple tgt_bind = NULL, bind;
+  gimple *stmt = gsi_stmt (*gsi_p);
+  gimple *tgt_bind = NULL, *bind;
   gimple_seq tgt_body = NULL, olist, ilist, new_body;
   location_t loc = gimple_location (stmt);
   int kind = gimple_omp_target_kind (stmt);
@@ -9903,11 +9903,11 @@ lower_omp_target (gimple_stmt_iterator *gsi_p, omp_context *ctx)
 static void
 lower_omp_teams (gimple_stmt_iterator *gsi_p, omp_context *ctx)
 {
-  gimple teams_stmt = gsi_stmt (*gsi_p);
+  gimple *teams_stmt = gsi_stmt (*gsi_p);
   push_gimplify_context ();
 
   tree block = make_node (BLOCK);
-  gimple bind = gimple_build_bind (NULL, NULL, block);
+  gimple *bind = gimple_build_bind (NULL, NULL, block);
   gsi_replace (gsi_p, bind, true);
   gimple_seq bind_body = NULL;
   gimple_seq dlist = NULL;
@@ -9943,7 +9943,7 @@ lower_omp_teams (gimple_stmt_iterator *gsi_p, omp_context *ctx)
 
   location_t loc = gimple_location (teams_stmt);
   tree decl = builtin_decl_explicit (BUILT_IN_GOMP_TEAMS);
-  gimple call = gimple_build_call (decl, 2, num_teams, thread_limit);
+  gimple *call = gimple_build_call (decl, 2, num_teams, thread_limit);
   gimple_set_location (call, loc);
   gimple_seq_add_stmt (&bind_body, call);
 
@@ -9994,7 +9994,7 @@ lower_omp_regimplify_p (tree *tp, int *walk_subtrees,
 static void
 lower_omp_1 (gimple_stmt_iterator *gsi_p, omp_context *ctx)
 {
-  gimple stmt = gsi_stmt (*gsi_p);
+  gimple *stmt = gsi_stmt (*gsi_p);
   struct walk_stmt_info wi;
 
   if (gimple_has_location (stmt))
@@ -10140,7 +10140,7 @@ lower_omp_1 (gimple_stmt_iterator *gsi_p, omp_context *ctx)
 	    gimple_call_set_lhs (stmt, lhs);
 	    tree fallthru_label;
 	    fallthru_label = create_artificial_label (UNKNOWN_LOCATION);
-	    gimple g;
+	    gimple *g;
 	    g = gimple_build_label (fallthru_label);
 	    gsi_insert_after (gsi_p, g, GSI_SAME_STMT);
 	    g = gimple_build_cond (NE_EXPR, lhs,
@@ -10274,7 +10274,7 @@ static splay_tree all_labels;
 
 static bool
 diagnose_sb_0 (gimple_stmt_iterator *gsi_p,
-    	       gimple branch_ctx, gimple label_ctx)
+    	       gimple *branch_ctx, gimple *label_ctx)
 {
   if (label_ctx == branch_ctx)
     return false;
@@ -10356,9 +10356,9 @@ static tree
 diagnose_sb_1 (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
     	       struct walk_stmt_info *wi)
 {
-  gimple context = (gimple) wi->info;
-  gimple inner_context;
-  gimple stmt = gsi_stmt (*gsi_p);
+  gimple *context = (gimple *) wi->info;
+  gimple *inner_context;
+  gimple *stmt = gsi_stmt (*gsi_p);
 
   *handled_ops_p = true;
 
@@ -10414,9 +10414,9 @@ static tree
 diagnose_sb_2 (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
     	       struct walk_stmt_info *wi)
 {
-  gimple context = (gimple) wi->info;
+  gimple *context = (gimple *) wi->info;
   splay_tree_node n;
-  gimple stmt = gsi_stmt (*gsi_p);
+  gimple *stmt = gsi_stmt (*gsi_p);
 
   *handled_ops_p = true;
 
@@ -10458,7 +10458,7 @@ diagnose_sb_2 (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
 	      n = splay_tree_lookup (all_labels,
 				     (splay_tree_key) lab);
 	      diagnose_sb_0 (gsi_p, context,
-			     n ? (gimple) n->value : NULL);
+			     n ? (gimple *) n->value : NULL);
 	    }
 	  lab = gimple_cond_false_label (stmt);
 	  if (lab)
@@ -10466,7 +10466,7 @@ diagnose_sb_2 (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
 	      n = splay_tree_lookup (all_labels,
 				     (splay_tree_key) lab);
 	      diagnose_sb_0 (gsi_p, context,
-			     n ? (gimple) n->value : NULL);
+			     n ? (gimple *) n->value : NULL);
 	    }
 	}
       break;
@@ -10478,7 +10478,7 @@ diagnose_sb_2 (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
 	  break;
 
 	n = splay_tree_lookup (all_labels, (splay_tree_key) lab);
-	diagnose_sb_0 (gsi_p, context, n ? (gimple) n->value : NULL);
+	diagnose_sb_0 (gsi_p, context, n ? (gimple *) n->value : NULL);
       }
       break;
 
@@ -10489,7 +10489,7 @@ diagnose_sb_2 (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
 	  {
 	    tree lab = CASE_LABEL (gimple_switch_label (stmt, i));
 	    n = splay_tree_lookup (all_labels, (splay_tree_key) lab);
-	    if (n && diagnose_sb_0 (gsi_p, context, (gimple) n->value))
+	    if (n && diagnose_sb_0 (gsi_p, context, (gimple *) n->value))
 	      break;
 	  }
       }
@@ -10512,7 +10512,7 @@ bool
 make_gimple_omp_edges (basic_block bb, struct omp_region **region,
 		       int *region_idx)
 {
-  gimple last = last_stmt (bb);
+  gimple *last = last_stmt (bb);
   enum gimple_code code = gimple_code (last);
   struct omp_region *cur_region = *region;
   bool fallthru = false;
@@ -11302,7 +11302,7 @@ simd_clone_init_simd_arrays (struct cgraph_node *node,
 
 struct modify_stmt_info {
   ipa_parm_adjustment_vec adjustments;
-  gimple stmt;
+  gimple *stmt;
   /* True if the parent statement was modified by
      ipa_simd_modify_stmt_ops.  */
   bool modified;
@@ -11356,7 +11356,7 @@ ipa_simd_modify_stmt_ops (tree *tp, int *walk_subtrees, void *data)
   if (tp != orig_tp)
     {
       repl = build_fold_addr_expr (repl);
-      gimple stmt
+      gimple *stmt
 	= gimple_build_assign (make_ssa_name (TREE_TYPE (repl), NULL), repl);
       repl = gimple_assign_lhs (stmt);
       gimple_stmt_iterator gsi = gsi_for_stmt (info->stmt);
@@ -11444,7 +11444,7 @@ ipa_simd_modify_function_body (struct cgraph_node *node,
 		    set_ssa_default_def (cfun, adjustments[j].base, NULL_TREE);
 		    SET_SSA_NAME_VAR_OR_IDENTIFIER (name, base_var);
 		    SSA_NAME_IS_DEFAULT_DEF (name) = 0;
-		    gimple stmt = gimple_build_assign (name, new_decl);
+		    gimple *stmt = gimple_build_assign (name, new_decl);
 		    gsi_insert_before (&gsi, stmt, GSI_SAME_STMT);
 		  }
 		else
@@ -11463,7 +11463,7 @@ ipa_simd_modify_function_body (struct cgraph_node *node,
       gsi = gsi_start_bb (bb);
       while (!gsi_end_p (gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  info.stmt = stmt;
 	  struct walk_stmt_info wi;
 
@@ -11552,7 +11552,7 @@ simd_clone_adjust (struct cgraph_node *node)
   edge e = make_edge (incr_bb, EXIT_BLOCK_PTR_FOR_FN (cfun), 0);
   e->probability = REG_BR_PROB_BASE;
   gsi = gsi_last_bb (incr_bb);
-  gimple g = gimple_build_assign_with_ops (PLUS_EXPR, iter2, iter1,
+  gimple *g = gimple_build_assign_with_ops (PLUS_EXPR, iter2, iter1,
 					   build_int_cst (unsigned_type_node,
 							  1));
   gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING);
@@ -11616,7 +11616,7 @@ simd_clone_adjust (struct cgraph_node *node)
      make_edge (incr_bb, latch_bb, EDGE_TRUE_VALUE);  */
   FALLTHRU_EDGE (incr_bb)->flags = EDGE_TRUE_VALUE;
 
-  gimple phi = create_phi_node (iter1, body_bb);
+  gimple *phi = create_phi_node (iter1, body_bb);
   edge preheader_edge = find_edge (entry_bb, body_bb);
   edge latch_edge = single_succ_edge (latch_bb);
   add_phi_arg (phi, build_zero_cst (unsigned_type_node), preheader_edge,
@@ -11659,7 +11659,7 @@ simd_clone_adjust (struct cgraph_node *node)
 	    tree fn = builtin_decl_explicit (BUILT_IN_ASSUME_ALIGNED);
 	    gimple_seq seq = NULL;
 	    bool need_cvt = false;
-	    gimple call
+	    gimple *call
 	      = gimple_build_call (fn, 2, def, size_int (alignment));
 	    g = call;
 	    if (!useless_type_conversion_p (TREE_TYPE (orig_arg),
@@ -11687,7 +11687,7 @@ simd_clone_adjust (struct cgraph_node *node)
 
 	    imm_use_iterator iter;
 	    use_operand_p use_p;
-	    gimple use_stmt;
+	    gimple *use_stmt;
 	    tree repl = gimple_get_lhs (g);
 	    FOR_EACH_IMM_USE_STMT (use_stmt, iter, def)
 	      if (is_gimple_debug (use_stmt) || use_stmt == call)
@@ -11723,7 +11723,7 @@ simd_clone_adjust (struct cgraph_node *node)
 
 	    imm_use_iterator iter;
 	    use_operand_p use_p;
-	    gimple use_stmt;
+	    gimple *use_stmt;
 	    FOR_EACH_IMM_USE_STMT (use_stmt, iter, def)
 	      if (use_stmt == phi)
 		continue;
diff --git a/gcc/passes.c b/gcc/passes.c
index 223b693..e003cd5 100644
--- a/gcc/passes.c
+++ b/gcc/passes.c
@@ -2595,7 +2595,7 @@ execute_ipa_pass_list (opt_pass *pass)
 
 static void
 execute_ipa_stmt_fixups (opt_pass *pass,
-			 struct cgraph_node *node, gimple *stmts)
+			 struct cgraph_node *node, gimple **stmts)
 {
   while (pass)
     {
@@ -2629,7 +2629,7 @@ execute_ipa_stmt_fixups (opt_pass *pass,
 /* Execute stmt fixup hooks of all IPA passes for NODE and STMTS.  */
 
 void
-execute_all_ipa_stmt_fixups (struct cgraph_node *node, gimple *stmts)
+execute_all_ipa_stmt_fixups (struct cgraph_node *node, gimple **stmts)
 {
   pass_manager *passes = g->get_passes ();
   execute_ipa_stmt_fixups (passes->all_regular_ipa_passes, node, stmts);
diff --git a/gcc/predict.c b/gcc/predict.c
index 165cc4e..9ebb7d2 100644
--- a/gcc/predict.c
+++ b/gcc/predict.c
@@ -1107,7 +1107,7 @@ get_base_value (tree t)
    Otherwise return false and set LOOP_INVAIANT to NULL.  */
 
 static bool
-is_comparison_with_loop_invariant_p (gimple stmt, struct loop *loop,
+is_comparison_with_loop_invariant_p (gimple *stmt, struct loop *loop,
 				     tree *loop_invariant,
 				     enum tree_code *compare_code,
 				     tree *loop_step,
@@ -1194,7 +1194,7 @@ is_comparison_with_loop_invariant_p (gimple stmt, struct loop *loop,
 static bool
 expr_coherent_p (tree t1, tree t2)
 {
-  gimple stmt;
+  gimple *stmt;
   tree ssa_name_1 = NULL;
   tree ssa_name_2 = NULL;
 
@@ -1257,7 +1257,7 @@ predict_iv_comparison (struct loop *loop, basic_block bb,
 		       enum tree_code loop_bound_code,
 		       int loop_bound_step)
 {
-  gimple stmt;
+  gimple *stmt;
   tree compare_var, compare_base;
   enum tree_code compare_code;
   tree compare_step_var;
@@ -1445,9 +1445,9 @@ predict_extra_loop_exits (edge exit_edge)
 {
   unsigned i;
   bool check_value_one;
-  gimple phi_stmt;
+  gimple *phi_stmt;
   tree cmp_rhs, cmp_lhs;
-  gimple cmp_stmt = last_stmt (exit_edge->src);
+  gimple *cmp_stmt = last_stmt (exit_edge->src);
 
   if (!cmp_stmt || gimple_code (cmp_stmt) != GIMPLE_COND)
     return;
@@ -1513,7 +1513,7 @@ predict_loops (void)
       tree loop_bound_step = NULL;
       tree loop_bound_var = NULL;
       tree loop_iv_base = NULL;
-      gimple stmt = NULL;
+      gimple *stmt = NULL;
 
       exits = get_loop_exit_edges (loop);
       n_exits = exits.length ();
@@ -1780,7 +1780,7 @@ static tree
 expr_expected_value_1 (tree type, tree op0, enum tree_code code,
 		       tree op1, bitmap visited, enum br_predictor *predictor)
 {
-  gimple def;
+  gimple *def;
 
   if (predictor)
     *predictor = PRED_UNCONDITIONAL;
@@ -1974,7 +1974,7 @@ expr_expected_value (tree expr, bitmap visited,
 static void
 tree_predict_by_opcode (basic_block bb)
 {
-  gimple stmt = last_stmt (bb);
+  gimple *stmt = last_stmt (bb);
   edge then_edge;
   tree op0, op1;
   tree type;
@@ -2142,10 +2142,10 @@ return_prediction (tree val, enum prediction *prediction)
 static void
 apply_return_prediction (void)
 {
-  gimple return_stmt = NULL;
+  gimple *return_stmt = NULL;
   tree return_val;
   edge e;
-  gimple phi;
+  gimple *phi;
   int phi_num_args, i;
   enum br_predictor pred;
   enum prediction direction;
@@ -2214,7 +2214,7 @@ tree_bb_level_predictions (void)
 
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  tree decl;
 
 	  if (is_gimple_call (stmt))
@@ -2262,7 +2262,7 @@ tree_estimate_probability_bb (basic_block bb)
 {
   edge e;
   edge_iterator ei;
-  gimple last;
+  gimple *last;
 
   FOR_EACH_EDGE (e, ei, bb->succs)
     {
@@ -2272,7 +2272,7 @@ tree_estimate_probability_bb (basic_block bb)
 	  gimple_stmt_iterator gi;
 	  for (gi = gsi_start_bb (e->dest); !gsi_end_p (gi); gsi_next (&gi))
 	    {
-	      gimple stmt = gsi_stmt (gi);
+	      gimple *stmt = gsi_stmt (gi);
 	      tree decl;
 
 	      if (gimple_code (stmt) != GIMPLE_LABEL)
@@ -2344,7 +2344,7 @@ tree_estimate_probability_bb (basic_block bb)
 	  for (bi = gsi_start_bb (e->dest); !gsi_end_p (bi);
 	       gsi_next (&bi))
 	    {
-	      gimple stmt = gsi_stmt (bi);
+	      gimple *stmt = gsi_stmt (bi);
 	      if (is_gimple_call (stmt)
 		  /* Constant and pure calls are hardly used to signalize
 		     something exceptional.  */
@@ -3148,7 +3148,7 @@ unsigned int
 pass_strip_predict_hints::execute (function *fun)
 {
   basic_block bb;
-  gimple ass_stmt;
+  gimple *ass_stmt;
   tree var;
 
   FOR_EACH_BB_FN (bb, fun)
@@ -3156,7 +3156,7 @@ pass_strip_predict_hints::execute (function *fun)
       gimple_stmt_iterator bi;
       for (bi = gsi_start_bb (bb); !gsi_end_p (bi);)
 	{
-	  gimple stmt = gsi_stmt (bi);
+	  gimple *stmt = gsi_stmt (bi);
 
 	  if (gimple_code (stmt) == GIMPLE_PREDICT)
 	    {
diff --git a/gcc/profile.c b/gcc/profile.c
index 83cbc07..46121d1 100644
--- a/gcc/profile.c
+++ b/gcc/profile.c
@@ -896,7 +896,7 @@ compute_value_histograms (histogram_values values, unsigned cfg_checksum,
   for (i = 0; i < values.length (); i++)
     {
       histogram_value hist = values[i];
-      gimple stmt = hist->hvalue.stmt;
+      gimple *stmt = hist->hvalue.stmt;
 
       t = (int) hist->type;
 
@@ -1037,7 +1037,7 @@ branch_prob (void)
       FOR_EACH_EDGE (e, ei, bb->succs)
 	{
 	  gimple_stmt_iterator gsi;
-	  gimple last = NULL;
+	  gimple *last = NULL;
 
 	  /* It may happen that there are compiler generated statements
 	     without a locus at all.  Go through the basic block from the
@@ -1103,7 +1103,7 @@ branch_prob (void)
 	  if (have_exit_edge || need_exit_edge)
 	    {
 	      gimple_stmt_iterator gsi;
-	      gimple first;
+	      gimple *first;
 
 	      gsi = gsi_start_nondebug_after_labels_bb (bb);
 	      gcc_checking_assert (!gsi_end_p (gsi));
@@ -1266,7 +1266,7 @@ branch_prob (void)
 
 	  for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	    {
-	      gimple stmt = gsi_stmt (gsi);
+	      gimple *stmt = gsi_stmt (gsi);
 	      if (gimple_has_location (stmt))
 		output_location (gimple_filename (stmt), gimple_lineno (stmt),
 				 &offset, bb);
diff --git a/gcc/sese.c b/gcc/sese.c
index 342c5e8..ae98c35 100644
--- a/gcc/sese.c
+++ b/gcc/sese.c
@@ -227,7 +227,7 @@ sese_build_liveouts_bb (sese region, bitmap liveouts, basic_block bb)
 
   for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
     {
-      gimple stmt = gsi_stmt (bsi);
+      gimple *stmt = gsi_stmt (bsi);
 
       if (is_gimple_debug (stmt))
 	continue;
@@ -279,7 +279,7 @@ sese_reset_debug_liveouts_bb (sese region, bitmap liveouts, basic_block bb)
 
   for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
     {
-      gimple stmt = gsi_stmt (bsi);
+      gimple *stmt = gsi_stmt (bsi);
 
       if (!is_gimple_debug (stmt))
 	continue;
@@ -346,7 +346,7 @@ free_sese (sese region)
 static void
 sese_add_exit_phis_edge (basic_block exit, tree use, edge false_e, edge true_e)
 {
-  gimple phi = create_phi_node (NULL_TREE, exit);
+  gimple *phi = create_phi_node (NULL_TREE, exit);
   create_new_def_for (use, phi, gimple_phi_result_ptr (phi));
   add_phi_arg (phi, use, false_e, UNKNOWN_LOCATION);
   add_phi_arg (phi, use, true_e, UNKNOWN_LOCATION);
@@ -461,7 +461,7 @@ set_rename (rename_map_type rename_map, tree old_name, tree expr)
    is set when the code generation cannot continue.  */
 
 static bool
-rename_uses (gimple copy, rename_map_type rename_map,
+rename_uses (gimple *copy, rename_map_type rename_map,
 	     gimple_stmt_iterator *gsi_tgt,
 	     sese region, loop_p loop, vec<tree> iv_map,
 	     bool *gloog_error)
@@ -580,8 +580,8 @@ graphite_copy_stmts_from_block (basic_block bb, basic_block new_bb,
     {
       def_operand_p def_p;
       ssa_op_iter op_iter;
-      gimple stmt = gsi_stmt (gsi);
-      gimple copy;
+      gimple *stmt = gsi_stmt (gsi);
+      gimple *copy;
       tree lhs;
 
       /* Do not copy labels or conditions.  */
@@ -781,9 +781,9 @@ set_ifsese_condition (ifsese if_region, tree condition)
   sese region = if_region->region;
   edge entry = region->entry;
   basic_block bb = entry->dest;
-  gimple last = last_stmt (bb);
+  gimple *last = last_stmt (bb);
   gimple_stmt_iterator gsi = gsi_last_bb (bb);
-  gimple cond_stmt;
+  gimple *cond_stmt;
 
   gcc_assert (gimple_code (last) == GIMPLE_COND);
 
@@ -802,7 +802,7 @@ set_ifsese_condition (ifsese if_region, tree condition)
 tree
 scalar_evolution_in_region (sese region, loop_p loop, tree t)
 {
-  gimple def;
+  gimple *def;
   struct loop *def_loop;
   basic_block before = block_before_sese (region);
 
diff --git a/gcc/sese.h b/gcc/sese.h
index af919f8..c7da73a 100644
--- a/gcc/sese.h
+++ b/gcc/sese.h
@@ -114,7 +114,7 @@ bb_in_sese_p (basic_block bb, sese region)
 /* Returns true when STMT is defined in REGION.  */
 
 static inline bool
-stmt_in_sese_p (gimple stmt, sese region)
+stmt_in_sese_p (gimple *stmt, sese region)
 {
   basic_block bb = gimple_bb (stmt);
   return bb && bb_in_sese_p (bb, region);
@@ -125,7 +125,7 @@ stmt_in_sese_p (gimple stmt, sese region)
 static inline bool
 defined_in_sese_p (tree name, sese region)
 {
-  gimple stmt = SSA_NAME_DEF_STMT (name);
+  gimple *stmt = SSA_NAME_DEF_STMT (name);
   return stmt_in_sese_p (stmt, region);
 }
 
@@ -309,8 +309,8 @@ typedef struct gimple_bb
      corresponding element in CONDITION_CASES is not NULL_TREE.  For a
      SWITCH_EXPR the corresponding element in CONDITION_CASES is a
      CASE_LABEL_EXPR.  */
-  vec<gimple> conditions;
-  vec<gimple> condition_cases;
+  vec<gimple *> conditions;
+  vec<gimple *> condition_cases;
   vec<data_reference_p> data_refs;
 } *gimple_bb_p;
 
diff --git a/gcc/ssa-iterators.h b/gcc/ssa-iterators.h
index 2c75e4a..0c60fd0 100644
--- a/gcc/ssa-iterators.h
+++ b/gcc/ssa-iterators.h
@@ -116,7 +116,7 @@ struct imm_use_iterator
 
 extern bool has_zero_uses_1 (const ssa_use_operand_t *head);
 extern bool single_imm_use_1 (const ssa_use_operand_t *head,
-			      use_operand_p *use_p, gimple *stmt);
+			      use_operand_p *use_p, gimple **stmt);
 
 
 enum ssa_op_iter_type {
@@ -139,7 +139,7 @@ struct ssa_op_iter
   unsigned i;
   unsigned numops;
   use_optype_p uses;
-  gimple stmt;
+  gimple *stmt;
 };
 
 /* NOTE: Keep these in sync with doc/tree-ssa.texi.  */
@@ -288,7 +288,7 @@ set_ssa_use_from_ptr (use_operand_p use, tree val)
 /* Link ssa_imm_use node LINKNODE into the chain for DEF, with use occurring
    in STMT.  */
 static inline void
-link_imm_use_stmt (ssa_use_operand_t *linknode, tree def, gimple stmt)
+link_imm_use_stmt (ssa_use_operand_t *linknode, tree def, gimple *stmt)
 {
   if (stmt)
     link_imm_use (linknode, def);
@@ -318,7 +318,7 @@ relink_imm_use (ssa_use_operand_t *node, ssa_use_operand_t *old)
    in STMT.  */
 static inline void
 relink_imm_use_stmt (ssa_use_operand_t *linknode, ssa_use_operand_t *old,
-		     gimple stmt)
+		     gimple *stmt)
 {
   if (stmt)
     relink_imm_use (linknode, old);
@@ -414,7 +414,7 @@ has_single_use (const_tree var)
 /* If VAR has only a single immediate nondebug use, return true, and
    set USE_P and STMT to the use pointer and stmt of occurrence.  */
 static inline bool
-single_imm_use (const_tree var, use_operand_p *use_p, gimple *stmt)
+single_imm_use (const_tree var, use_operand_p *use_p, gimple **stmt)
 {
   const ssa_use_operand_t *const ptr = &(SSA_NAME_IMM_USE_NODE (var));
 
@@ -592,7 +592,7 @@ clear_and_done_ssa_iter (ssa_op_iter *ptr)
 
 /* Initialize the iterator PTR to the virtual defs in STMT.  */
 static inline void
-op_iter_init (ssa_op_iter *ptr, gimple stmt, int flags)
+op_iter_init (ssa_op_iter *ptr, gimple *stmt, int flags)
 {
   /* PHI nodes require a different iterator initialization path.  We
      do not support iterating over virtual defs or uses without
@@ -633,7 +633,7 @@ op_iter_init (ssa_op_iter *ptr, gimple stmt, int flags)
 /* Initialize iterator PTR to the use operands in STMT based on FLAGS. Return
    the first use.  */
 static inline use_operand_p
-op_iter_init_use (ssa_op_iter *ptr, gimple stmt, int flags)
+op_iter_init_use (ssa_op_iter *ptr, gimple *stmt, int flags)
 {
   gcc_checking_assert ((flags & SSA_OP_ALL_DEFS) == 0
 		       && (flags & SSA_OP_USE));
@@ -645,7 +645,7 @@ op_iter_init_use (ssa_op_iter *ptr, gimple stmt, int flags)
 /* Initialize iterator PTR to the def operands in STMT based on FLAGS. Return
    the first def.  */
 static inline def_operand_p
-op_iter_init_def (ssa_op_iter *ptr, gimple stmt, int flags)
+op_iter_init_def (ssa_op_iter *ptr, gimple *stmt, int flags)
 {
   gcc_checking_assert ((flags & SSA_OP_ALL_USES) == 0
 		       && (flags & SSA_OP_DEF));
@@ -657,7 +657,7 @@ op_iter_init_def (ssa_op_iter *ptr, gimple stmt, int flags)
 /* Initialize iterator PTR to the operands in STMT based on FLAGS. Return
    the first operand as a tree.  */
 static inline tree
-op_iter_init_tree (ssa_op_iter *ptr, gimple stmt, int flags)
+op_iter_init_tree (ssa_op_iter *ptr, gimple *stmt, int flags)
 {
   op_iter_init (ptr, stmt, flags);
   ptr->iter_type = ssa_op_iter_tree;
@@ -668,7 +668,7 @@ op_iter_init_tree (ssa_op_iter *ptr, gimple stmt, int flags)
 /* If there is a single operand in STMT matching FLAGS, return it.  Otherwise
    return NULL.  */
 static inline tree
-single_ssa_tree_operand (gimple stmt, int flags)
+single_ssa_tree_operand (gimple *stmt, int flags)
 {
   tree var;
   ssa_op_iter iter;
@@ -686,7 +686,7 @@ single_ssa_tree_operand (gimple stmt, int flags)
 /* If there is a single operand in STMT matching FLAGS, return it.  Otherwise
    return NULL.  */
 static inline use_operand_p
-single_ssa_use_operand (gimple stmt, int flags)
+single_ssa_use_operand (gimple *stmt, int flags)
 {
   use_operand_p var;
   ssa_op_iter iter;
@@ -705,7 +705,7 @@ single_ssa_use_operand (gimple stmt, int flags)
 /* If there is a single operand in STMT matching FLAGS, return it.  Otherwise
    return NULL.  */
 static inline def_operand_p
-single_ssa_def_operand (gimple stmt, int flags)
+single_ssa_def_operand (gimple *stmt, int flags)
 {
   def_operand_p var;
   ssa_op_iter iter;
@@ -723,7 +723,7 @@ single_ssa_def_operand (gimple stmt, int flags)
 /* Return true if there are zero operands in STMT matching the type
    given in FLAGS.  */
 static inline bool
-zero_ssa_operands (gimple stmt, int flags)
+zero_ssa_operands (gimple *stmt, int flags)
 {
   ssa_op_iter iter;
 
@@ -734,7 +734,7 @@ zero_ssa_operands (gimple stmt, int flags)
 
 /* Return the number of operands matching FLAGS in STMT.  */
 static inline int
-num_ssa_operands (gimple stmt, int flags)
+num_ssa_operands (gimple *stmt, int flags)
 {
   ssa_op_iter iter;
   tree t;
@@ -749,7 +749,7 @@ num_ssa_operands (gimple stmt, int flags)
 /* If there is a single DEF in the PHI node which matches FLAG, return it.
    Otherwise return NULL_DEF_OPERAND_P.  */
 static inline tree
-single_phi_def (gimple stmt, int flags)
+single_phi_def (gimple *stmt, int flags)
 {
   tree def = PHI_RESULT (stmt);
   if ((flags & SSA_OP_DEF) && is_gimple_reg (def))
@@ -762,7 +762,7 @@ single_phi_def (gimple stmt, int flags)
 /* Initialize the iterator PTR for uses matching FLAGS in PHI.  FLAGS should
    be either SSA_OP_USES or SSA_OP_VIRTUAL_USES.  */
 static inline use_operand_p
-op_iter_init_phiuse (ssa_op_iter *ptr, gimple phi, int flags)
+op_iter_init_phiuse (ssa_op_iter *ptr, gimple *phi, int flags)
 {
   tree phi_def = gimple_phi_result (phi);
   int comp;
@@ -792,7 +792,7 @@ op_iter_init_phiuse (ssa_op_iter *ptr, gimple phi, int flags)
 /* Start an iterator for a PHI definition.  */
 
 static inline def_operand_p
-op_iter_init_phidef (ssa_op_iter *ptr, gimple phi, int flags)
+op_iter_init_phidef (ssa_op_iter *ptr, gimple *phi, int flags)
 {
   tree phi_def = PHI_RESULT (phi);
   int comp;
@@ -873,7 +873,7 @@ link_use_stmts_after (use_operand_p head, imm_use_iterator *imm)
 {
   use_operand_p use_p;
   use_operand_p last_p = head;
-  gimple head_stmt = USE_STMT (head);
+  gimple *head_stmt = USE_STMT (head);
   tree use = USE_FROM_PTR (head);
   ssa_op_iter op_iter;
   int flag;
@@ -908,7 +908,7 @@ link_use_stmts_after (use_operand_p head, imm_use_iterator *imm)
 }
 
 /* Initialize IMM to traverse over uses of VAR.  Return the first statement.  */
-static inline gimple
+static inline gimple *
 first_imm_use_stmt (imm_use_iterator *imm, tree var)
 {
   imm->end_p = &(SSA_NAME_IMM_USE_NODE (var));
@@ -933,7 +933,7 @@ first_imm_use_stmt (imm_use_iterator *imm, tree var)
 
 /* Bump IMM to the next stmt which has a use of var.  */
 
-static inline gimple
+static inline gimple *
 next_imm_use_stmt (imm_use_iterator *imm)
 {
   imm->imm_use = imm->iter_node.next;
@@ -983,7 +983,7 @@ next_imm_use_on_stmt (imm_use_iterator *imm)
 
 /* Delink all immediate_use information for STMT.  */
 static inline void
-delink_stmt_imm_use (gimple stmt)
+delink_stmt_imm_use (gimple *stmt)
 {
    ssa_op_iter iter;
    use_operand_p use_p;
diff --git a/gcc/stmt.c b/gcc/stmt.c
index 163d495..23da44a 100644
--- a/gcc/stmt.c
+++ b/gcc/stmt.c
@@ -1130,7 +1130,7 @@ reset_out_edges_aux (basic_block bb)
    STMT. Record this information in the aux field of the edge.  */
 
 static inline void
-compute_cases_per_edge (gimple stmt)
+compute_cases_per_edge (gimple *stmt)
 {
   basic_block bb = gimple_bb (stmt);
   reset_out_edges_aux (bb);
@@ -1152,7 +1152,7 @@ compute_cases_per_edge (gimple stmt)
    Generate the code to test it and jump to the right place.  */
 
 void
-expand_case (gimple stmt)
+expand_case (gimple *stmt)
 {
   tree minval = NULL_TREE, maxval = NULL_TREE, range = NULL_TREE;
   rtx default_label = NULL_RTX;
diff --git a/gcc/tracer.c b/gcc/tracer.c
index 16c6949..c1017d0 100644
--- a/gcc/tracer.c
+++ b/gcc/tracer.c
@@ -93,7 +93,7 @@ bb_seen_p (basic_block bb)
 static bool
 ignore_bb_p (const_basic_block bb)
 {
-  gimple g;
+  gimple *g;
 
   if (bb->index < NUM_FIXED_BLOCKS)
     return true;
@@ -115,7 +115,7 @@ static int
 count_insns (basic_block bb)
 {
   gimple_stmt_iterator gsi;
-  gimple stmt;
+  gimple *stmt;
   int n = 0;
 
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
diff --git a/gcc/trans-mem.c b/gcc/trans-mem.c
index c0e44c7..9128e7c 100644
--- a/gcc/trans-mem.c
+++ b/gcc/trans-mem.c
@@ -267,7 +267,7 @@ is_tm_safe (const_tree x)
 /* Return true if CALL is const, or tm_pure.  */
 
 static bool
-is_tm_pure_call (gimple call)
+is_tm_pure_call (gimple *call)
 {
   tree fn = gimple_call_fn (call);
 
@@ -335,7 +335,7 @@ is_tm_ending_fndecl (tree fndecl)
    transaction.  */
 
 bool
-is_tm_ending (gimple stmt)
+is_tm_ending (gimple *stmt)
 {
   tree fndecl;
 
@@ -350,7 +350,7 @@ is_tm_ending (gimple stmt)
 /* Return true if STMT is a TM load.  */
 
 static bool
-is_tm_load (gimple stmt)
+is_tm_load (gimple *stmt)
 {
   tree fndecl;
 
@@ -366,7 +366,7 @@ is_tm_load (gimple stmt)
    after-write, after-read, etc optimized variants.  */
 
 static bool
-is_tm_simple_load (gimple stmt)
+is_tm_simple_load (gimple *stmt)
 {
   tree fndecl;
 
@@ -394,7 +394,7 @@ is_tm_simple_load (gimple stmt)
 /* Return true if STMT is a TM store.  */
 
 static bool
-is_tm_store (gimple stmt)
+is_tm_store (gimple *stmt)
 {
   tree fndecl;
 
@@ -410,7 +410,7 @@ is_tm_store (gimple stmt)
    after-write, after-read, etc optimized variants.  */
 
 static bool
-is_tm_simple_store (gimple stmt)
+is_tm_simple_store (gimple *stmt)
 {
   tree fndecl;
 
@@ -576,7 +576,7 @@ struct diagnose_tm
   unsigned int block_flags : 8;
   unsigned int func_flags : 8;
   unsigned int saw_volatile : 1;
-  gimple stmt;
+  gimple *stmt;
 };
 
 /* Return true if T is a volatile variable of some kind.  */
@@ -620,7 +620,7 @@ static tree
 diagnose_tm_1 (gimple_stmt_iterator *gsi, bool *handled_ops_p,
 		    struct walk_stmt_info *wi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   struct diagnose_tm *d = (struct diagnose_tm *) wi->info;
 
   /* Save stmt for use in leaf analysis.  */
@@ -1082,7 +1082,7 @@ transaction_invariant_address_p (const_tree mem, basic_block region_entry_block)
    If known, ENTRY_BLOCK is the entry block for the region, otherwise
    NULL.  */
 static void
-tm_log_add (basic_block entry_block, tree addr, gimple stmt)
+tm_log_add (basic_block entry_block, tree addr, gimple *stmt)
 {
   tm_log_entry **slot;
   struct tm_log_entry l, *lp;
@@ -1127,7 +1127,7 @@ tm_log_add (basic_block entry_block, tree addr, gimple stmt)
   else
     {
       size_t i;
-      gimple oldstmt;
+      gimple *oldstmt;
 
       lp = *slot;
 
@@ -1171,12 +1171,12 @@ gimplify_addr (gimple_stmt_iterator *gsi, tree x)
    ADDR is the address to save.
    STMT is the statement before which to place it.  */
 static void
-tm_log_emit_stmt (tree addr, gimple stmt)
+tm_log_emit_stmt (tree addr, gimple *stmt)
 {
   tree type = TREE_TYPE (addr);
   tree size = TYPE_SIZE_UNIT (type);
   gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
-  gimple log;
+  gimple *log;
   enum built_in_function code = BUILT_IN_TM_LOG;
 
   if (type == float_type_node)
@@ -1237,7 +1237,7 @@ tm_log_emit (void)
   FOR_EACH_HASH_TABLE_ELEMENT (tm_log, lp, tm_log_entry_t, hi)
     {
       size_t i;
-      gimple stmt;
+      gimple *stmt;
 
       if (dump_file)
 	{
@@ -1270,7 +1270,7 @@ tm_log_emit_saves (basic_block entry_block, basic_block bb)
 {
   size_t i;
   gimple_stmt_iterator gsi = gsi_last_bb (bb);
-  gimple stmt;
+  gimple *stmt;
   struct tm_log_entry l, *lp;
 
   for (i = 0; i < tm_log_save_addresses.length (); ++i)
@@ -1307,7 +1307,7 @@ tm_log_emit_restores (basic_block entry_block, basic_block bb)
   int i;
   struct tm_log_entry l, *lp;
   gimple_stmt_iterator gsi;
-  gimple stmt;
+  gimple *stmt;
 
   for (i = tm_log_save_addresses.length () - 1; i >= 0; i--)
     {
@@ -1347,7 +1347,7 @@ static tree lower_sequence_no_tm (gimple_stmt_iterator *, bool *,
 static enum thread_memory_type
 thread_private_new_memory (basic_block entry_block, tree x)
 {
-  gimple stmt = NULL;
+  gimple *stmt = NULL;
   enum tree_code code;
   tm_new_mem_map_t **slot;
   tm_new_mem_map_t elt, *elt_p;
@@ -1479,7 +1479,7 @@ thread_private_new_memory (basic_block entry_block, tree x)
    private memory instrumentation.  If no TPM instrumentation is
    desired, STMT should be null.  */
 static bool
-requires_barrier (basic_block entry_block, tree x, gimple stmt)
+requires_barrier (basic_block entry_block, tree x, gimple *stmt)
 {
   tree orig = x;
   while (handled_component_p (x))
@@ -1564,7 +1564,7 @@ requires_barrier (basic_block entry_block, tree x, gimple stmt)
 static void
 examine_assign_tm (unsigned *state, gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
 
   if (requires_barrier (/*entry_block=*/NULL, gimple_assign_rhs1 (stmt), NULL))
     *state |= GTMA_HAVE_LOAD;
@@ -1577,7 +1577,7 @@ examine_assign_tm (unsigned *state, gimple_stmt_iterator *gsi)
 static void
 examine_call_tm (unsigned *state, gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   tree fn;
 
   if (is_tm_pure_call (stmt))
@@ -1597,7 +1597,7 @@ examine_call_tm (unsigned *state, gimple_stmt_iterator *gsi)
 static void
 lower_transaction (gimple_stmt_iterator *gsi, struct walk_stmt_info *wi)
 {
-  gimple g, stmt = gsi_stmt (*gsi);
+  gimple *g, *stmt = gsi_stmt (*gsi);
   unsigned int *outer_state = (unsigned int *) wi->info;
   unsigned int this_state = 0;
   struct walk_stmt_info this_wi;
@@ -1680,7 +1680,7 @@ lower_sequence_tm (gimple_stmt_iterator *gsi, bool *handled_ops_p,
 		   struct walk_stmt_info *wi)
 {
   unsigned int *state = (unsigned int *) wi->info;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
 
   *handled_ops_p = true;
   switch (gimple_code (stmt))
@@ -1718,7 +1718,7 @@ static tree
 lower_sequence_no_tm (gimple_stmt_iterator *gsi, bool *handled_ops_p,
 		      struct walk_stmt_info * wi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
 
   if (gimple_code (stmt) == GIMPLE_TRANSACTION)
     {
@@ -1806,7 +1806,7 @@ struct tm_region
   /* The GIMPLE_TRANSACTION statement beginning this transaction.
      After TM_MARK, this gets replaced by a call to
      BUILT_IN_TM_START.  */
-  gimple transaction_stmt;
+  gimple *transaction_stmt;
 
   /* After TM_MARK expands the GIMPLE_TRANSACTION into a call to
      BUILT_IN_TM_START, this field is true if the transaction is an
@@ -1848,7 +1848,7 @@ static bitmap_obstack tm_obstack;
    GIMPLE_TRANSACTION statement in a tree of tm_region elements.  */
 
 static struct tm_region *
-tm_region_init_0 (struct tm_region *outer, basic_block bb, gimple stmt)
+tm_region_init_0 (struct tm_region *outer, basic_block bb, gimple *stmt)
 {
   struct tm_region *region;
 
@@ -1892,7 +1892,7 @@ static struct tm_region *
 tm_region_init_1 (struct tm_region *region, basic_block bb)
 {
   gimple_stmt_iterator gsi;
-  gimple g;
+  gimple *g;
 
   if (!region
       || (!region->irr_blocks && !region->exit_blocks))
@@ -1932,7 +1932,7 @@ tm_region_init_1 (struct tm_region *region, basic_block bb)
 static void
 tm_region_init (struct tm_region *region)
 {
-  gimple g;
+  gimple *g;
   edge_iterator ei;
   edge e;
   basic_block bb;
@@ -2085,12 +2085,12 @@ transaction_subcode_ior (struct tm_region *region, unsigned flags)
 
    LOC is the location to use for the new statement(s).  */
 
-static gimple
+static gimple *
 build_tm_load (location_t loc, tree lhs, tree rhs, gimple_stmt_iterator *gsi)
 {
   enum built_in_function code = END_BUILTINS;
   tree t, type = TREE_TYPE (rhs), decl;
-  gimple gcall;
+  gimple *gcall;
 
   if (type == float_type_node)
     code = BUILT_IN_TM_LOAD_FLOAT;
@@ -2139,7 +2139,7 @@ build_tm_load (location_t loc, tree lhs, tree rhs, gimple_stmt_iterator *gsi)
     }
   else
     {
-      gimple g;
+      gimple *g;
       tree temp;
 
       temp = create_tmp_reg (t, NULL);
@@ -2157,12 +2157,12 @@ build_tm_load (location_t loc, tree lhs, tree rhs, gimple_stmt_iterator *gsi)
 
 /* Similarly for storing TYPE in a transactional context.  */
 
-static gimple
+static gimple *
 build_tm_store (location_t loc, tree lhs, tree rhs, gimple_stmt_iterator *gsi)
 {
   enum built_in_function code = END_BUILTINS;
   tree t, fn, type = TREE_TYPE (rhs), simple_type;
-  gimple gcall;
+  gimple *gcall;
 
   if (type == float_type_node)
     code = BUILT_IN_TM_STORE_FLOAT;
@@ -2217,7 +2217,7 @@ build_tm_store (location_t loc, tree lhs, tree rhs, gimple_stmt_iterator *gsi)
     }
   else if (!useless_type_conversion_p (simple_type, type))
     {
-      gimple g;
+      gimple *g;
       tree temp;
 
       temp = create_tmp_reg (simple_type, NULL);
@@ -2243,13 +2243,13 @@ build_tm_store (location_t loc, tree lhs, tree rhs, gimple_stmt_iterator *gsi)
 static void
 expand_assign_tm (struct tm_region *region, gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   location_t loc = gimple_location (stmt);
   tree lhs = gimple_assign_lhs (stmt);
   tree rhs = gimple_assign_rhs1 (stmt);
   bool store_p = requires_barrier (region->entry_block, lhs, NULL);
   bool load_p = requires_barrier (region->entry_block, rhs, NULL);
-  gimple gcall = NULL;
+  gimple *gcall = NULL;
 
   if (!load_p && !store_p)
     {
@@ -2329,7 +2329,7 @@ static bool
 expand_call_tm (struct tm_region *region,
 		gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   tree lhs = gimple_call_lhs (stmt);
   tree fn_decl;
   struct cgraph_node *node;
@@ -2471,7 +2471,7 @@ expand_block_tm (struct tm_region *region, basic_block bb)
 
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); )
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       switch (gimple_code (stmt))
 	{
 	case GIMPLE_ASSIGN:
@@ -2718,7 +2718,7 @@ expand_transaction (struct tm_region *region, void *data ATTRIBUTE_UNUSED)
     if (subcode & GTMA_IS_OUTER)
       region->original_transaction_was_outer = true;
     tree t = build_int_cst (tm_state_type, flags);
-    gimple call = gimple_build_call (tm_start, 1, t);
+    gimple *call = gimple_build_call (tm_start, 1, t);
     gimple_call_set_lhs (call, tm_state);
     gimple_set_location (call, gimple_location (region->transaction_stmt));
 
@@ -2756,7 +2756,7 @@ expand_transaction (struct tm_region *region, void *data ATTRIBUTE_UNUSED)
 
       tree t1 = create_tmp_reg (tm_state_type, NULL);
       tree t2 = build_int_cst (tm_state_type, A_RESTORELIVEVARIABLES);
-      gimple stmt = gimple_build_assign_with_ops (BIT_AND_EXPR, t1,
+      gimple *stmt = gimple_build_assign_with_ops (BIT_AND_EXPR, t1,
 						  tm_state, t2);
       gimple_stmt_iterator gsi = gsi_last_bb (test_bb);
       gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
@@ -2798,7 +2798,7 @@ expand_transaction (struct tm_region *region, void *data ATTRIBUTE_UNUSED)
 
       tree t1 = create_tmp_reg (tm_state_type, NULL);
       tree t2 = build_int_cst (tm_state_type, A_ABORTTRANSACTION);
-      gimple stmt = gimple_build_assign_with_ops (BIT_AND_EXPR, t1,
+      gimple *stmt = gimple_build_assign_with_ops (BIT_AND_EXPR, t1,
 						  tm_state, t2);
       gimple_stmt_iterator gsi = gsi_last_bb (test_bb);
       gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
@@ -2842,7 +2842,7 @@ expand_transaction (struct tm_region *region, void *data ATTRIBUTE_UNUSED)
       tree t1 = create_tmp_reg (tm_state_type, NULL);
       tree t2 = build_int_cst (tm_state_type, A_RUNUNINSTRUMENTEDCODE);
 
-      gimple stmt = gimple_build_assign_with_ops (BIT_AND_EXPR, t1,
+      gimple *stmt = gimple_build_assign_with_ops (BIT_AND_EXPR, t1,
 						  tm_state, t2);
       gimple_stmt_iterator gsi = gsi_last_bb (test_bb);
       gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
@@ -3046,7 +3046,7 @@ make_pass_tm_mark (gcc::context *ctxt)
    as necessary.  Adjust *PNEXT as needed for the split block.  */
 
 static inline void
-split_bb_make_tm_edge (gimple stmt, basic_block dest_bb,
+split_bb_make_tm_edge (gimple *stmt, basic_block dest_bb,
                        gimple_stmt_iterator iter, gimple_stmt_iterator *pnext)
 {
   basic_block bb = gimple_bb (stmt);
@@ -3092,7 +3092,7 @@ expand_block_edges (struct tm_region *const region, basic_block bb)
 
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi = next_gsi)
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
 
       next_gsi = gsi;
       gsi_next (&next_gsi);
@@ -3373,7 +3373,7 @@ static hash_table <tm_memop_hasher> tm_memopt_value_numbers;
    it accesses.  */
 
 static unsigned int
-tm_memopt_value_number (gimple stmt, enum insert_option op)
+tm_memopt_value_number (gimple *stmt, enum insert_option op)
 {
   struct tm_memop tmpmem, *mem;
   tm_memop **slot;
@@ -3404,7 +3404,7 @@ tm_memopt_accumulate_memops (basic_block bb)
 
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       bitmap bits;
       unsigned int loc;
 
@@ -3745,7 +3745,7 @@ tm_memopt_compute_antic (struct tm_region *region,
 /* Inform about a load/store optimization.  */
 
 static void
-dump_tm_memopt_transform (gimple stmt)
+dump_tm_memopt_transform (gimple *stmt)
 {
   if (dump_file)
     {
@@ -3761,7 +3761,7 @@ dump_tm_memopt_transform (gimple stmt)
 
 static void
 tm_memopt_transform_stmt (unsigned int offset,
-			  gimple stmt,
+			  gimple *stmt,
 			  gimple_stmt_iterator *gsi)
 {
   tree fn = gimple_call_fn (stmt);
@@ -3789,7 +3789,7 @@ tm_memopt_transform_blocks (vec<basic_block> blocks)
     {
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  bitmap read_avail = READ_AVAIL_IN (bb);
 	  bitmap store_avail = STORE_AVAIL_IN (bb);
 	  bitmap store_antic = STORE_ANTIC_OUT (bb);
@@ -4093,7 +4093,7 @@ static void
 ipa_uninstrument_transaction (struct tm_region *region,
 			      vec<basic_block> queue)
 {
-  gimple transaction = region->transaction_stmt;
+  gimple *transaction = region->transaction_stmt;
   basic_block transaction_bb = gimple_bb (transaction);
   int n = queue.length ();
   basic_block *new_bbs = XNEWVEC (basic_block, n);
@@ -4122,7 +4122,7 @@ ipa_tm_scan_calls_block (cgraph_node_queue *callees_p,
 
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       if (is_gimple_call (stmt) && !is_tm_pure_call (stmt))
 	{
 	  tree fndecl = gimple_call_fndecl (stmt);
@@ -4262,7 +4262,7 @@ ipa_tm_scan_irr_block (basic_block bb)
 
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       switch (gimple_code (stmt))
 	{
 	case GIMPLE_ASSIGN:
@@ -4462,7 +4462,7 @@ ipa_tm_decrement_clone_counts (basic_block bb, bool for_clone)
 
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       if (is_gimple_call (stmt) && !is_tm_pure_call (stmt))
 	{
 	  tree fndecl = gimple_call_fndecl (stmt);
@@ -4692,7 +4692,7 @@ ipa_tm_diagnose_transaction (struct cgraph_node *node,
 	for (i = 0; bbs.iterate (i, &bb); ++i)
 	  for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	    {
-	      gimple stmt = gsi_stmt (gsi);
+	      gimple *stmt = gsi_stmt (gsi);
 	      tree fndecl;
 
 	      if (gimple_code (stmt) == GIMPLE_ASM)
@@ -4944,7 +4944,7 @@ ipa_tm_insert_irr_call (struct cgraph_node *node, struct tm_region *region,
 			basic_block bb)
 {
   gimple_stmt_iterator gsi;
-  gimple g;
+  gimple *g;
 
   transaction_subcode_ior (region, GTMA_MAY_ENTER_IRREVOCABLE);
 
@@ -4968,10 +4968,10 @@ ipa_tm_insert_irr_call (struct cgraph_node *node, struct tm_region *region,
 static bool
 ipa_tm_insert_gettmclone_call (struct cgraph_node *node,
 			       struct tm_region *region,
-			       gimple_stmt_iterator *gsi, gimple stmt)
+			       gimple_stmt_iterator *gsi, gimple *stmt)
 {
   tree gettm_fn, ret, old_fn, callfn;
-  gimple g, g2;
+  gimple *g, *g2;
   bool safe;
 
   old_fn = gimple_call_fn (stmt);
@@ -5064,7 +5064,7 @@ ipa_tm_transform_calls_redirect (struct cgraph_node *node,
 				 gimple_stmt_iterator *gsi,
 				 bool *need_ssa_rename_p)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   struct cgraph_node *new_node;
   struct cgraph_edge *e = cgraph_edge (node, stmt);
   tree fndecl = gimple_call_fndecl (stmt);
@@ -5162,7 +5162,7 @@ ipa_tm_transform_calls_1 (struct cgraph_node *node, struct tm_region *region,
 
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
 
       if (!is_gimple_call (stmt))
 	continue;
diff --git a/gcc/trans-mem.h b/gcc/trans-mem.h
index 3d3b618..1320c15 100644
--- a/gcc/trans-mem.h
+++ b/gcc/trans-mem.h
@@ -38,7 +38,7 @@
 #define PR_READONLY		0x4000
 
 extern void compute_transaction_bits (void);
-extern bool is_tm_ending (gimple);
+extern bool is_tm_ending (gimple *);
 extern tree build_tm_abort_call (location_t, bool);
 extern bool is_tm_safe (const_tree);
 extern bool is_tm_pure (const_tree);
diff --git a/gcc/tree-affine.c b/gcc/tree-affine.c
index 0b85778..ada5ec2 100644
--- a/gcc/tree-affine.c
+++ b/gcc/tree-affine.c
@@ -626,7 +626,7 @@ aff_combination_expand (aff_tree *comb ATTRIBUTE_UNUSED,
   unsigned i;
   aff_tree to_add, current, curre;
   tree e, rhs;
-  gimple def;
+  gimple *def;
   widest_int scale;
   void **slot;
   struct name_expansion *exp;
diff --git a/gcc/tree-call-cdce.c b/gcc/tree-call-cdce.c
index f62fb40..44a7193 100644
--- a/gcc/tree-call-cdce.c
+++ b/gcc/tree-call-cdce.c
@@ -174,7 +174,7 @@ check_target_format (tree arg)
 #define MAX_BASE_INT_BIT_SIZE 32
 
 static bool
-check_pow (gimple pow_call)
+check_pow (gimple *pow_call)
 {
   tree base, expn;
   enum tree_code bc, ec;
@@ -213,7 +213,7 @@ check_pow (gimple pow_call)
   else if (bc == SSA_NAME)
     {
       tree base_val0, type;
-      gimple base_def;
+      gimple *base_def;
       int bit_sz;
 
       /* Only handles cases where base value is converted
@@ -248,7 +248,7 @@ check_pow (gimple pow_call)
    Returns true if the function call is a candidate.  */
 
 static bool
-check_builtin_call (gimple bcall)
+check_builtin_call (gimple *bcall)
 {
   tree arg;
 
@@ -261,7 +261,7 @@ check_builtin_call (gimple bcall)
    is a candidate.  */
 
 static bool
-is_call_dce_candidate (gimple call)
+is_call_dce_candidate (gimple *call)
 {
   tree fn;
   enum built_in_function fnc;
@@ -327,12 +327,12 @@ gen_one_condition (tree arg, int lbub,
                    enum tree_code tcode,
                    const char *temp_name1,
 		   const char *temp_name2,
-                   vec<gimple> conds,
+                   vec<gimple *> conds,
                    unsigned *nconds)
 {
   tree lbub_real_cst, lbub_cst, float_type;
   tree temp, tempn, tempc, tempcn;
-  gimple stmt1, stmt2, stmt3;
+  gimple *stmt1, *stmt2, *stmt3;
 
   float_type = TREE_TYPE (arg);
   lbub_cst = build_int_cst (integer_type_node, lbub);
@@ -369,7 +369,7 @@ gen_one_condition (tree arg, int lbub,
 
 static void
 gen_conditions_for_domain (tree arg, inp_domain domain,
-                           vec<gimple> conds,
+                           vec<gimple *> conds,
                            unsigned *nconds)
 {
   if (domain.has_lb)
@@ -412,7 +412,7 @@ gen_conditions_for_domain (tree arg, inp_domain domain,
 
 static void
 gen_conditions_for_pow_cst_base (tree base, tree expn,
-                                 vec<gimple> conds,
+                                 vec<gimple *> conds,
                                  unsigned *nconds)
 {
   inp_domain exp_domain;
@@ -448,15 +448,15 @@ gen_conditions_for_pow_cst_base (tree base, tree expn,
 
 static void
 gen_conditions_for_pow_int_base (tree base, tree expn,
-                                 vec<gimple> conds,
+                                 vec<gimple *> conds,
                                  unsigned *nconds)
 {
-  gimple base_def;
+  gimple *base_def;
   tree base_val0;
   tree int_type;
   tree temp, tempn;
   tree cst0;
-  gimple stmt1, stmt2;
+  gimple *stmt1, *stmt2;
   int bit_sz, max_exp;
   inp_domain exp_domain;
 
@@ -537,7 +537,7 @@ gen_conditions_for_pow_int_base (tree base, tree expn,
    and *NCONDS is the number of logical conditions.  */
 
 static void
-gen_conditions_for_pow (gimple pow_call, vec<gimple> conds,
+gen_conditions_for_pow (gimple *pow_call, vec<gimple *> conds,
                         unsigned *nconds)
 {
   tree base, expn;
@@ -673,10 +673,10 @@ get_no_error_domain (enum built_in_function fnc)
    condition are separated by NULL tree in the vector.  */
 
 static void
-gen_shrink_wrap_conditions (gimple bi_call, vec<gimple> conds,
+gen_shrink_wrap_conditions (gimple *bi_call, vec<gimple *> conds,
                             unsigned int *nconds)
 {
-  gimple call;
+  gimple *call;
   tree fn;
   enum built_in_function fnc;
 
@@ -714,7 +714,7 @@ gen_shrink_wrap_conditions (gimple bi_call, vec<gimple> conds,
    transformation actually happens.  */
 
 static bool
-shrink_wrap_one_built_in_call (gimple bi_call)
+shrink_wrap_one_built_in_call (gimple *bi_call)
 {
   gimple_stmt_iterator bi_call_bsi;
   basic_block bi_call_bb, join_tgt_bb, guard_bb, guard_bb0;
@@ -722,12 +722,12 @@ shrink_wrap_one_built_in_call (gimple bi_call)
   edge bi_call_in_edge0, guard_bb_in_edge;
   unsigned tn_cond_stmts, nconds;
   unsigned ci;
-  gimple cond_expr = NULL;
-  gimple cond_expr_start;
+  gimple *cond_expr = NULL;
+  gimple *cond_expr_start;
   tree bi_call_label_decl;
-  gimple bi_call_label;
+  gimple *bi_call_label;
 
-  auto_vec<gimple, 12> conds;
+  auto_vec<gimple *, 12> conds;
   gen_shrink_wrap_conditions (bi_call, conds, &nconds);
 
   /* This can happen if the condition generator decides
@@ -763,7 +763,7 @@ shrink_wrap_one_built_in_call (gimple bi_call)
   cond_expr_start = conds[0];
   for (ci = 0; ci < tn_cond_stmts; ci++)
     {
-      gimple c = conds[ci];
+      gimple *c = conds[ci];
       gcc_assert (c || ci != 0);
       if (!c)
         break;
@@ -807,7 +807,7 @@ shrink_wrap_one_built_in_call (gimple bi_call)
       cond_expr_start = conds[ci0];
       for (; ci < tn_cond_stmts; ci++)
         {
-          gimple c = conds[ci];
+          gimple *c = conds[ci];
           gcc_assert (c || ci != ci0);
           if (!c)
             break;
@@ -849,7 +849,7 @@ shrink_wrap_one_built_in_call (gimple bi_call)
    wrapping transformation.  */
 
 static bool
-shrink_wrap_conditional_dead_built_in_calls (vec<gimple> calls)
+shrink_wrap_conditional_dead_built_in_calls (vec<gimple *> calls)
 {
   bool changed = false;
   unsigned i = 0;
@@ -860,7 +860,7 @@ shrink_wrap_conditional_dead_built_in_calls (vec<gimple> calls)
 
   for (; i < n ; i++)
     {
-      gimple bi_call = calls[i];
+      gimple *bi_call = calls[i];
       changed |= shrink_wrap_one_built_in_call (bi_call);
     }
 
@@ -910,13 +910,13 @@ pass_call_cdce::execute (function *fun)
   basic_block bb;
   gimple_stmt_iterator i;
   bool something_changed = false;
-  auto_vec<gimple> cond_dead_built_in_calls;
+  auto_vec<gimple *> cond_dead_built_in_calls;
   FOR_EACH_BB_FN (bb, fun)
     {
       /* Collect dead call candidates.  */
       for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
         {
-	  gimple stmt = gsi_stmt (i);
+	  gimple *stmt = gsi_stmt (i);
           if (is_gimple_call (stmt)
               && is_call_dce_candidate (stmt))
             {
diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c
index fee1ede..1e219d6 100644
--- a/gcc/tree-cfg.c
+++ b/gcc/tree-cfg.c
@@ -159,11 +159,11 @@ static edge gimple_redirect_edge_and_branch (edge, basic_block);
 static edge gimple_try_redirect_by_replacing_jump (edge, basic_block);
 
 /* Various helpers.  */
-static inline bool stmt_starts_bb_p (gimple, gimple);
+static inline bool stmt_starts_bb_p (gimple *, gimple *);
 static int gimple_verify_flow_info (void);
 static void gimple_make_forwarder_block (edge);
-static gimple first_non_label_stmt (basic_block);
-static bool verify_gimple_transaction (gimple);
+static gimple *first_non_label_stmt (basic_block);
+static bool verify_gimple_transaction (gimple *);
 
 /* Flowgraph optimization and cleanup.  */
 static void gimple_merge_blocks (basic_block, basic_block);
@@ -172,7 +172,7 @@ static void remove_bb (basic_block);
 static edge find_taken_edge_computed_goto (basic_block, tree);
 static edge find_taken_edge_cond_expr (basic_block, tree);
 static edge find_taken_edge_switch_expr (basic_block, tree);
-static tree find_case_label_for_value (gimple, tree);
+static tree find_case_label_for_value (gimple *, tree);
 
 void
 init_empty_tree_cfg_for_function (struct function *fn)
@@ -262,7 +262,7 @@ replace_loop_annotate ()
   struct loop *loop;
   basic_block bb;
   gimple_stmt_iterator gsi;
-  gimple stmt;
+  gimple *stmt;
 
   FOR_EACH_LOOP (loop, 0)
     {
@@ -386,7 +386,7 @@ make_pass_build_cfg (gcc::context *ctxt)
 /* Return true if T is a computed goto.  */
 
 bool
-computed_goto_p (gimple t)
+computed_goto_p (gimple *t)
 {
   return (gimple_code (t) == GIMPLE_GOTO
 	  && TREE_CODE (gimple_goto_dest (t)) != LABEL_DECL);
@@ -409,7 +409,7 @@ bool
 assert_unreachable_fallthru_edge_p (edge e)
 {
   basic_block pred_bb = e->src;
-  gimple last = last_stmt (pred_bb);
+  gimple *last = last_stmt (pred_bb);
   if (last && gimple_code (last) == GIMPLE_COND)
     {
       basic_block other_bb = EDGE_SUCC (pred_bb, 0)->dest;
@@ -418,7 +418,7 @@ assert_unreachable_fallthru_edge_p (edge e)
       if (EDGE_COUNT (other_bb->succs) == 0)
 	{
 	  gimple_stmt_iterator gsi = gsi_after_labels (other_bb);
-	  gimple stmt;
+	  gimple *stmt;
 
 	  if (gsi_end_p (gsi))
 	    return false;
@@ -443,14 +443,14 @@ static void
 make_blocks (gimple_seq seq)
 {
   gimple_stmt_iterator i = gsi_start (seq);
-  gimple stmt = NULL;
+  gimple *stmt = NULL;
   bool start_new_block = true;
   bool first_stmt_of_seq = true;
   basic_block bb = ENTRY_BLOCK_PTR_FOR_FN (cfun);
 
   while (!gsi_end_p (i))
     {
-      gimple prev_stmt;
+      gimple *prev_stmt;
 
       prev_stmt = stmt;
       stmt = gsi_stmt (i);
@@ -485,7 +485,7 @@ make_blocks (gimple_seq seq)
 	    {
 	      tree lhs = gimple_get_lhs (stmt);
 	      tree tmp = create_tmp_var (TREE_TYPE (lhs), NULL);
-	      gimple s = gimple_build_assign (lhs, tmp);
+	      gimple *s = gimple_build_assign (lhs, tmp);
 	      gimple_set_location (s, gimple_location (stmt));
 	      gimple_set_block (s, gimple_block (stmt));
 	      gimple_set_lhs (stmt, tmp);
@@ -557,7 +557,7 @@ fold_cond_expr_cond (void)
 
   FOR_EACH_BB_FN (bb, cfun)
     {
-      gimple stmt = last_stmt (bb);
+      gimple *stmt = last_stmt (bb);
 
       if (stmt && gimple_code (stmt) == GIMPLE_COND)
 	{
@@ -602,7 +602,7 @@ get_abnormal_succ_dispatcher (basic_block bb)
       {
 	gimple_stmt_iterator gsi
 	  = gsi_start_nondebug_after_labels_bb (e->dest);
-	gimple g = gsi_stmt (gsi);
+	gimple *g = gsi_stmt (gsi);
 	if (g
 	    && is_gimple_call (g)
 	    && gimple_call_internal_p (g)
@@ -674,12 +674,12 @@ handle_abnormal_edges (basic_block *dispatcher_bbs,
 	     factored computed goto.  */
 	  tree factored_label_decl
 	    = create_artificial_label (UNKNOWN_LOCATION);
-	  gimple factored_computed_goto_label
+	  gimple *factored_computed_goto_label
 	    = gimple_build_label (factored_label_decl);
 	  gsi_insert_after (&gsi, factored_computed_goto_label, GSI_NEW_STMT);
 
 	  /* Build our new computed goto.  */
-	  gimple factored_computed_goto = gimple_build_goto (var);
+	  gimple *factored_computed_goto = gimple_build_goto (var);
 	  gsi_insert_after (&gsi, factored_computed_goto, GSI_NEW_STMT);
 
 	  FOR_EACH_VEC_ELT (*bbs, idx, bb)
@@ -689,12 +689,12 @@ handle_abnormal_edges (basic_block *dispatcher_bbs,
 		continue;
 
 	      gsi = gsi_last_bb (bb);
-	      gimple last = gsi_stmt (gsi);
+	      gimple *last = gsi_stmt (gsi);
 
 	      gcc_assert (computed_goto_p (last));
 
 	      /* Copy the original computed goto's destination into VAR.  */
-	      gimple assignment
+	      gimple *assignment
 		= gimple_build_assign (var, gimple_goto_dest (last));
 	      gsi_insert_before (&gsi, assignment, GSI_SAME_STMT);
 
@@ -706,7 +706,7 @@ handle_abnormal_edges (basic_block *dispatcher_bbs,
       else
 	{
 	  tree arg = inner ? boolean_true_node : boolean_false_node;
-	  gimple g = gimple_build_call_internal (IFN_ABNORMAL_DISPATCHER,
+	  gimple *g = gimple_build_call_internal (IFN_ABNORMAL_DISPATCHER,
 						 1, arg);
 	  gimple_stmt_iterator gsi = gsi_after_labels (*dispatcher);
 	  gsi_insert_after (&gsi, g, GSI_NEW_STMT);
@@ -746,7 +746,7 @@ make_edges (void)
   /* Traverse the basic block array placing edges.  */
   FOR_EACH_BB_FN (bb, cfun)
     {
-      gimple last = last_stmt (bb);
+      gimple *last = last_stmt (bb);
       bool fallthru;
 
       if (bb_to_omp_idx)
@@ -874,7 +874,7 @@ make_edges (void)
 	{
 	  for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	    {
-	      gimple label_stmt = gsi_stmt (gsi);
+	      gimple *label_stmt = gsi_stmt (gsi);
 	      tree target;
 
 	      if (gimple_code (label_stmt) != GIMPLE_LABEL)
@@ -900,7 +900,7 @@ make_edges (void)
 	  if (!gsi_end_p (gsi))
 	    {
 	      /* Make an edge to every setjmp-like call.  */
-	      gimple call_stmt = gsi_stmt (gsi);
+	      gimple *call_stmt = gsi_stmt (gsi);
 	      if (is_gimple_call (call_stmt)
 		  && ((gimple_call_flags (call_stmt) & ECF_RETURNS_TWICE)
 		      || gimple_call_builtin_p (call_stmt,
@@ -982,7 +982,7 @@ assign_discriminators (void)
     {
       edge e;
       edge_iterator ei;
-      gimple last = last_stmt (bb);
+      gimple *last = last_stmt (bb);
       location_t locus = last ? gimple_location (last) : UNKNOWN_LOCATION;
 
       if (locus == UNKNOWN_LOCATION)
@@ -990,8 +990,8 @@ assign_discriminators (void)
 
       FOR_EACH_EDGE (e, ei, bb->succs)
 	{
-	  gimple first = first_non_label_stmt (e->dest);
-	  gimple last = last_stmt (e->dest);
+	  gimple *first = first_non_label_stmt (e->dest);
+	  gimple *last = last_stmt (e->dest);
 	  if ((first && same_line_p (locus, gimple_location (first)))
 	      || (last && same_line_p (locus, gimple_location (last))))
 	    {
@@ -1009,8 +1009,8 @@ assign_discriminators (void)
 static void
 make_cond_expr_edges (basic_block bb)
 {
-  gimple entry = last_stmt (bb);
-  gimple then_stmt, else_stmt;
+  gimple *entry = last_stmt (bb);
+  gimple *then_stmt, *else_stmt;
   basic_block then_bb, else_bb;
   tree then_label, else_label;
   edge e;
@@ -1094,7 +1094,7 @@ end_recording_case_labels (void)
       basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i);
       if (bb)
 	{
-	  gimple stmt = last_stmt (bb);
+	  gimple *stmt = last_stmt (bb);
 	  if (stmt && gimple_code (stmt) == GIMPLE_SWITCH)
 	    group_case_labels_stmt (stmt);
 	}
@@ -1108,7 +1108,7 @@ end_recording_case_labels (void)
    Otherwise return NULL.  */
 
 static tree
-get_cases_for_edge (edge e, gimple t)
+get_cases_for_edge (edge e, gimple *t)
 {
   void **slot;
   size_t i, n;
@@ -1149,7 +1149,7 @@ get_cases_for_edge (edge e, gimple t)
 static void
 make_gimple_switch_edges (basic_block bb)
 {
-  gimple entry = last_stmt (bb);
+  gimple *entry = last_stmt (bb);
   size_t i, n;
 
   n = gimple_switch_num_labels (entry);
@@ -1177,7 +1177,7 @@ label_to_block_fn (struct function *ifun, tree dest)
     {
       gimple_stmt_iterator gsi =
 	gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun, NUM_FIXED_BLOCKS));
-      gimple stmt;
+      gimple *stmt;
 
       stmt = gimple_build_label (dest);
       gsi_insert_before (&gsi, stmt, GSI_NEW_STMT);
@@ -1195,7 +1195,7 @@ static bool
 make_goto_expr_edges (basic_block bb)
 {
   gimple_stmt_iterator last = gsi_last_bb (bb);
-  gimple goto_t = gsi_stmt (last);
+  gimple *goto_t = gsi_stmt (last);
 
   /* A simple GOTO creates normal edges.  */
   if (simple_goto_p (goto_t))
@@ -1217,7 +1217,7 @@ make_goto_expr_edges (basic_block bb)
 static void
 make_gimple_asm_edges (basic_block bb)
 {
-  gimple stmt = last_stmt (bb);
+  gimple *stmt = last_stmt (bb);
   int i, n = gimple_asm_nlabels (stmt);
 
   for (i = 0; i < n; ++i)
@@ -1341,7 +1341,7 @@ cleanup_dead_labels (void)
       for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
 	{
 	  tree label;
-	  gimple stmt = gsi_stmt (i);
+	  gimple *stmt = gsi_stmt (i);
 
 	  if (gimple_code (stmt) != GIMPLE_LABEL)
 	    break;
@@ -1372,7 +1372,7 @@ cleanup_dead_labels (void)
      First do so for each block ending in a control statement.  */
   FOR_EACH_BB_FN (bb, cfun)
     {
-      gimple stmt = last_stmt (bb);
+      gimple *stmt = last_stmt (bb);
       tree label, new_label;
 
       if (!stmt)
@@ -1477,7 +1477,7 @@ cleanup_dead_labels (void)
       for (i = gsi_start_bb (bb); !gsi_end_p (i); )
 	{
 	  tree label;
-	  gimple stmt = gsi_stmt (i);
+	  gimple *stmt = gsi_stmt (i);
 
 	  if (gimple_code (stmt) != GIMPLE_LABEL)
 	    break;
@@ -1502,7 +1502,7 @@ cleanup_dead_labels (void)
    Eg. three separate entries 1: 2: 3: become one entry 1..3:  */
 
 void
-group_case_labels_stmt (gimple stmt)
+group_case_labels_stmt (gimple *stmt)
 {
   int old_size = gimple_switch_num_labels (stmt);
   int i, j, new_size = old_size;
@@ -1588,7 +1588,7 @@ group_case_labels (void)
 
   FOR_EACH_BB_FN (bb, cfun)
     {
-      gimple stmt = last_stmt (bb);
+      gimple *stmt = last_stmt (bb);
       if (stmt && gimple_code (stmt) == GIMPLE_SWITCH)
 	group_case_labels_stmt (stmt);
     }
@@ -1599,7 +1599,7 @@ group_case_labels (void)
 static bool
 gimple_can_merge_blocks_p (basic_block a, basic_block b)
 {
-  gimple stmt;
+  gimple *stmt;
   gimple_stmt_iterator gsi;
 
   if (!single_succ_p (a))
@@ -1652,7 +1652,7 @@ gimple_can_merge_blocks_p (basic_block a, basic_block b)
      any phis.  Symbols marked for renaming are never a problem though.  */
   for (gsi = gsi_start_phis (b); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple phi = gsi_stmt (gsi);
+      gimple *phi = gsi_stmt (gsi);
       /* Technically only new names matter.  */
       if (name_registered_for_update_p (PHI_RESULT (phi)))
 	return false;
@@ -1685,7 +1685,7 @@ replace_uses_by (tree name, tree val)
 {
   imm_use_iterator imm_iter;
   use_operand_p use;
-  gimple stmt;
+  gimple *stmt;
   edge e;
 
   FOR_EACH_IMM_USE_STMT (stmt, imm_iter, name)
@@ -1716,7 +1716,7 @@ replace_uses_by (tree name, tree val)
       if (gimple_code (stmt) != GIMPLE_PHI)
 	{
 	  gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
-	  gimple orig_stmt = stmt;
+	  gimple *orig_stmt = stmt;
 	  size_t i;
 
 	  /* FIXME.  It shouldn't be required to keep TREE_CONSTANT
@@ -1773,9 +1773,9 @@ gimple_merge_blocks (basic_block a, basic_block b)
   gsi = gsi_last_bb (a);
   for (psi = gsi_start_phis (b); !gsi_end_p (psi); )
     {
-      gimple phi = gsi_stmt (psi);
+      gimple *phi = gsi_stmt (psi);
       tree def = gimple_phi_result (phi), use = gimple_phi_arg_def (phi, 0);
-      gimple copy;
+      gimple *copy;
       bool may_replace_uses = (virtual_operand_p (def)
 			       || may_propagate_copy (def, use));
 
@@ -1809,7 +1809,7 @@ gimple_merge_blocks (basic_block a, basic_block b)
 	    {
 	      imm_use_iterator iter;
 	      use_operand_p use_p;
-	      gimple stmt;
+	      gimple *stmt;
 
 	      FOR_EACH_IMM_USE_STMT (stmt, iter, def)
 		FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
@@ -1834,7 +1834,7 @@ gimple_merge_blocks (basic_block a, basic_block b)
   /* Remove labels from B and set gimple_bb to A for other statements.  */
   for (gsi = gsi_start_bb (b); !gsi_end_p (gsi);)
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       if (gimple_code (stmt) == GIMPLE_LABEL)
 	{
 	  tree label = gimple_label_label (stmt);
@@ -1856,7 +1856,7 @@ gimple_merge_blocks (basic_block a, basic_block b)
 	  /* Other user labels keep around in a form of a debug stmt.  */
 	  else if (!DECL_ARTIFICIAL (label) && MAY_HAVE_DEBUG_STMTS)
 	    {
-	      gimple dbg = gimple_build_debug_bind (label,
+	      gimple *dbg = gimple_build_debug_bind (label,
 						    integer_zero_node,
 						    stmt);
 	      gimple_debug_bind_reset_value (dbg);
@@ -1912,7 +1912,7 @@ single_noncomplex_succ (basic_block bb)
 /* T is CALL_EXPR.  Set current_function_calls_* flags.  */
 
 void
-notice_special_calls (gimple call)
+notice_special_calls (gimple *call)
 {
   int flags = gimple_call_flags (call);
 
@@ -1985,7 +1985,7 @@ remove_bb (basic_block bb)
 	 details.  */
       for (i = gsi_last_bb (bb); !gsi_end_p (i);)
 	{
-	  gimple stmt = gsi_stmt (i);
+	  gimple *stmt = gsi_stmt (i);
 	  if (gimple_code (stmt) == GIMPLE_LABEL
 	      && (FORCED_LABEL (gimple_label_label (stmt))
 		  || DECL_NONLOCAL (gimple_label_label (stmt))))
@@ -2039,7 +2039,7 @@ remove_bb (basic_block bb)
 edge
 find_taken_edge (basic_block bb, tree val)
 {
-  gimple stmt;
+  gimple *stmt;
 
   stmt = last_stmt (bb);
 
@@ -2119,7 +2119,7 @@ find_taken_edge_switch_expr (basic_block bb, tree val)
 {
   basic_block dest_bb;
   edge e;
-  gimple switch_stmt;
+  gimple *switch_stmt;
   tree taken_case;
 
   switch_stmt = last_stmt (bb);
@@ -2137,7 +2137,7 @@ find_taken_edge_switch_expr (basic_block bb, tree val)
    sorted: We can do a binary search for a case matching VAL.  */
 
 static tree
-find_case_label_for_value (gimple switch_stmt, tree val)
+find_case_label_for_value (gimple *switch_stmt, tree val)
 {
   size_t low, high, n = gimple_switch_num_labels (switch_stmt);
   tree default_case = gimple_switch_default_label (switch_stmt);
@@ -2298,7 +2298,7 @@ debug_cfg_stats (void)
    flow.  Transfers of control flow associated with EH are excluded.  */
 
 static bool
-call_can_make_abnormal_goto (gimple t)
+call_can_make_abnormal_goto (gimple *t)
 {
   /* If the function has no non-local labels, then a call cannot make an
      abnormal transfer of control.  */
@@ -2322,7 +2322,7 @@ call_can_make_abnormal_goto (gimple t)
    Transfers of control flow associated with EH are excluded.  */
 
 bool
-stmt_can_make_abnormal_goto (gimple t)
+stmt_can_make_abnormal_goto (gimple *t)
 {
   if (computed_goto_p (t))
     return true;
@@ -2335,7 +2335,7 @@ stmt_can_make_abnormal_goto (gimple t)
 /* Return true if T represents a stmt that always transfers control.  */
 
 bool
-is_ctrl_stmt (gimple t)
+is_ctrl_stmt (gimple *t)
 {
   switch (gimple_code (t))
     {
@@ -2355,7 +2355,7 @@ is_ctrl_stmt (gimple t)
    (e.g., a call to a non-returning function).  */
 
 bool
-is_ctrl_altering_stmt (gimple t)
+is_ctrl_altering_stmt (gimple *t)
 {
   gcc_assert (t);
 
@@ -2417,7 +2417,7 @@ is_ctrl_altering_stmt (gimple t)
 /* Return true if T is a simple local goto.  */
 
 bool
-simple_goto_p (gimple t)
+simple_goto_p (gimple *t)
 {
   return (gimple_code (t) == GIMPLE_GOTO
 	  && TREE_CODE (gimple_goto_dest (t)) == LABEL_DECL);
@@ -2432,7 +2432,7 @@ simple_goto_p (gimple t)
    label.  */
 
 static inline bool
-stmt_starts_bb_p (gimple stmt, gimple prev_stmt)
+stmt_starts_bb_p (gimple *stmt, gimple *prev_stmt)
 {
   if (stmt == NULL)
     return false;
@@ -2471,7 +2471,7 @@ stmt_starts_bb_p (gimple stmt, gimple prev_stmt)
 /* Return true if T should end a basic block.  */
 
 bool
-stmt_ends_bb_p (gimple t)
+stmt_ends_bb_p (gimple *t)
 {
   return is_ctrl_stmt (t) || is_ctrl_altering_stmt (t);
 }
@@ -2487,11 +2487,11 @@ delete_tree_cfg_annotations (void)
 
 /* Return the first statement in basic block BB.  */
 
-gimple
+gimple *
 first_stmt (basic_block bb)
 {
   gimple_stmt_iterator i = gsi_start_bb (bb);
-  gimple stmt = NULL;
+  gimple *stmt = NULL;
 
   while (!gsi_end_p (i) && is_gimple_debug ((stmt = gsi_stmt (i))))
     {
@@ -2503,7 +2503,7 @@ first_stmt (basic_block bb)
 
 /* Return the first non-label statement in basic block BB.  */
 
-static gimple
+static gimple *
 first_non_label_stmt (basic_block bb)
 {
   gimple_stmt_iterator i = gsi_start_bb (bb);
@@ -2514,11 +2514,11 @@ first_non_label_stmt (basic_block bb)
 
 /* Return the last statement in basic block BB.  */
 
-gimple
+gimple *
 last_stmt (basic_block bb)
 {
   gimple_stmt_iterator i = gsi_last_bb (bb);
-  gimple stmt = NULL;
+  gimple *stmt = NULL;
 
   while (!gsi_end_p (i) && is_gimple_debug ((stmt = gsi_stmt (i))))
     {
@@ -2532,11 +2532,11 @@ last_stmt (basic_block bb)
    if the block is totally empty, or if it contains more than one
    statement.  */
 
-gimple
+gimple *
 last_and_only_stmt (basic_block bb)
 {
   gimple_stmt_iterator i = gsi_last_nondebug_bb (bb);
-  gimple last, prev;
+  gimple *last, *prev;
 
   if (gsi_end_p (i))
     return NULL;
@@ -2578,7 +2578,7 @@ reinstall_phi_args (edge new_edge, edge old_edge)
        v->iterate (i, &vm) && !gsi_end_p (phis);
        i++, gsi_next (&phis))
     {
-      gimple phi = gsi_stmt (phis);
+      gimple *phi = gsi_stmt (phis);
       tree result = redirect_edge_var_map_result (vm);
       tree arg = redirect_edge_var_map_def (vm);
 
@@ -3184,7 +3184,7 @@ valid_fixed_convert_types_p (tree type1, tree type2)
    is a problem, otherwise false.  */
 
 static bool
-verify_gimple_call (gimple stmt)
+verify_gimple_call (gimple *stmt)
 {
   tree fn = gimple_call_fn (stmt);
   tree fntype, fndecl;
@@ -3403,7 +3403,7 @@ verify_gimple_comparison (tree type, tree op0, tree op1)
    Returns true if anything is wrong.  */
 
 static bool
-verify_gimple_assign_unary (gimple stmt)
+verify_gimple_assign_unary (gimple *stmt)
 {
   enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
   tree lhs = gimple_assign_lhs (stmt);
@@ -3557,7 +3557,7 @@ verify_gimple_assign_unary (gimple stmt)
    Returns true if anything is wrong.  */
 
 static bool
-verify_gimple_assign_binary (gimple stmt)
+verify_gimple_assign_binary (gimple *stmt)
 {
   enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
   tree lhs = gimple_assign_lhs (stmt);
@@ -3831,7 +3831,7 @@ verify_gimple_assign_binary (gimple stmt)
    Returns true if anything is wrong.  */
 
 static bool
-verify_gimple_assign_ternary (gimple stmt)
+verify_gimple_assign_ternary (gimple *stmt)
 {
   enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
   tree lhs = gimple_assign_lhs (stmt);
@@ -3974,7 +3974,7 @@ verify_gimple_assign_ternary (gimple stmt)
    Returns true if anything is wrong.  */
 
 static bool
-verify_gimple_assign_single (gimple stmt)
+verify_gimple_assign_single (gimple *stmt)
 {
   enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
   tree lhs = gimple_assign_lhs (stmt);
@@ -4176,7 +4176,7 @@ verify_gimple_assign_single (gimple stmt)
    is a problem, otherwise false.  */
 
 static bool
-verify_gimple_assign (gimple stmt)
+verify_gimple_assign (gimple *stmt)
 {
   switch (gimple_assign_rhs_class (stmt))
     {
@@ -4201,7 +4201,7 @@ verify_gimple_assign (gimple stmt)
    is a problem, otherwise false.  */
 
 static bool
-verify_gimple_return (gimple stmt)
+verify_gimple_return (gimple *stmt)
 {
   tree op = gimple_return_retval (stmt);
   tree restype = TREE_TYPE (TREE_TYPE (cfun->decl));
@@ -4243,7 +4243,7 @@ verify_gimple_return (gimple stmt)
    is a problem, otherwise false.  */
 
 static bool
-verify_gimple_goto (gimple stmt)
+verify_gimple_goto (gimple *stmt)
 {
   tree dest = gimple_goto_dest (stmt);
 
@@ -4264,7 +4264,7 @@ verify_gimple_goto (gimple stmt)
    is a problem, otherwise false.  */
 
 static bool
-verify_gimple_switch (gimple stmt)
+verify_gimple_switch (gimple *stmt)
 {
   unsigned int i, n;
   tree elt, prev_upper_bound = NULL_TREE;
@@ -4353,7 +4353,7 @@ verify_gimple_switch (gimple stmt)
    Returns true if anything is wrong.  */
 
 static bool
-verify_gimple_debug (gimple stmt ATTRIBUTE_UNUSED)
+verify_gimple_debug (gimple *stmt ATTRIBUTE_UNUSED)
 {
   /* There isn't much that could be wrong in a gimple debug stmt.  A
      gimple debug bind stmt, for example, maps a tree, that's usually
@@ -4368,7 +4368,7 @@ verify_gimple_debug (gimple stmt ATTRIBUTE_UNUSED)
    Returns true if anything is wrong.  */
 
 static bool
-verify_gimple_label (gimple stmt)
+verify_gimple_label (gimple *stmt)
 {
   tree decl = gimple_label_label (stmt);
   int uid;
@@ -4410,7 +4410,7 @@ verify_gimple_label (gimple stmt)
    error, otherwise false.  */
 
 static bool
-verify_gimple_stmt (gimple stmt)
+verify_gimple_stmt (gimple *stmt)
 {
   switch (gimple_code (stmt))
     {
@@ -4486,7 +4486,7 @@ verify_gimple_stmt (gimple stmt)
    and false otherwise.  */
 
 static bool
-verify_gimple_phi (gimple phi)
+verify_gimple_phi (gimple *phi)
 {
   bool err = false;
   unsigned i;
@@ -4556,7 +4556,7 @@ verify_gimple_in_seq_2 (gimple_seq stmts)
 
   for (ittr = gsi_start (stmts); !gsi_end_p (ittr); gsi_next (&ittr))
     {
-      gimple stmt = gsi_stmt (ittr);
+      gimple *stmt = gsi_stmt (ittr);
 
       switch (gimple_code (stmt))
         {
@@ -4603,7 +4603,7 @@ verify_gimple_in_seq_2 (gimple_seq stmts)
    is a problem, otherwise false.  */
 
 static bool
-verify_gimple_transaction (gimple stmt)
+verify_gimple_transaction (gimple *stmt)
 {
   tree lab = gimple_transaction_label (stmt);
   if (lab != NULL && TREE_CODE (lab) != LABEL_DECL)
@@ -4811,7 +4811,7 @@ verify_gimple_in_cfg (struct function *fn, bool verify_nothrow)
 
       for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple phi = gsi_stmt (gsi);
+	  gimple *phi = gsi_stmt (gsi);
 	  bool err2 = false;
 	  unsigned i;
 
@@ -4866,7 +4866,7 @@ verify_gimple_in_cfg (struct function *fn, bool verify_nothrow)
 
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  bool err2 = false;
 	  struct walk_stmt_info wi;
 	  tree addr;
@@ -4971,7 +4971,7 @@ gimple_verify_flow_info (void)
   int err = 0;
   basic_block bb;
   gimple_stmt_iterator gsi;
-  gimple stmt;
+  gimple *stmt;
   edge e;
   edge_iterator ei;
 
@@ -5006,7 +5006,7 @@ gimple_verify_flow_info (void)
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
 	  tree label;
-	  gimple prev_stmt = stmt;
+	  gimple *prev_stmt = stmt;
 
 	  stmt = gsi_stmt (gsi);
 
@@ -5054,7 +5054,7 @@ gimple_verify_flow_info (void)
       /* Verify that body of basic block BB is free of control flow.  */
       for (; !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 
 	  if (found_ctrl_stmt)
 	    {
@@ -5297,7 +5297,7 @@ gimple_make_forwarder_block (edge fallthru)
      start of BB.  */
   for (gsi = gsi_start_phis (dummy); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple phi, new_phi;
+      gimple *phi, *new_phi;
 
       phi = gsi_stmt (gsi);
       var = gimple_phi_result (phi);
@@ -5327,7 +5327,7 @@ gimple_block_label (basic_block bb)
   gimple_stmt_iterator i, s = gsi_start_bb (bb);
   bool first = true;
   tree label;
-  gimple stmt;
+  gimple *stmt;
 
   for (i = s; !gsi_end_p (i); first = false, gsi_next (&i))
     {
@@ -5361,7 +5361,7 @@ gimple_try_redirect_by_replacing_jump (edge e, basic_block target)
 {
   basic_block src = e->src;
   gimple_stmt_iterator i;
-  gimple stmt;
+  gimple *stmt;
 
   /* We can replace or remove a complex jump only when we have exactly
      two edges.  */
@@ -5398,7 +5398,7 @@ gimple_redirect_edge_and_branch (edge e, basic_block dest)
   basic_block bb = e->src;
   gimple_stmt_iterator gsi;
   edge ret;
-  gimple stmt;
+  gimple *stmt;
 
   if (e->flags & EDGE_ABNORMAL)
     return NULL;
@@ -5569,7 +5569,7 @@ gimple_split_block (basic_block bb, void *stmt)
 {
   gimple_stmt_iterator gsi;
   gimple_stmt_iterator gsi_tgt;
-  gimple act;
+  gimple *act;
   gimple_seq list;
   basic_block new_bb;
   edge e;
@@ -5583,7 +5583,7 @@ gimple_split_block (basic_block bb, void *stmt)
   FOR_EACH_EDGE (e, ei, new_bb->succs)
     e->src = new_bb;
 
-  if (stmt && gimple_code ((gimple) stmt) == GIMPLE_LABEL)
+  if (stmt && gimple_code ((gimple *) stmt) == GIMPLE_LABEL)
     stmt = NULL;
 
   /* Move everything from GSI to the new basic block.  */
@@ -5659,7 +5659,7 @@ gimple_empty_block_p (basic_block bb)
 static basic_block
 gimple_split_block_before_cond_jump (basic_block bb)
 {
-  gimple last, split_point;
+  gimple *last, *split_point;
   gimple_stmt_iterator gsi = gsi_last_nondebug_bb (bb);
   if (gsi_end_p (gsi))
     return NULL;
@@ -5690,7 +5690,7 @@ gimple_duplicate_bb (basic_block bb)
   basic_block new_bb;
   gimple_stmt_iterator gsi, gsi_tgt;
   gimple_seq phis = phi_nodes (bb);
-  gimple phi, stmt, copy;
+  gimple *phi, *stmt, *copy;
 
   new_bb = create_empty_bb (EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb);
 
@@ -5765,7 +5765,7 @@ add_phi_args_after_copy_edge (edge e_copy)
   basic_block bb, bb_copy = e_copy->src, dest;
   edge e;
   edge_iterator ei;
-  gimple phi, phi_copy;
+  gimple *phi, *phi_copy;
   tree def;
   gimple_stmt_iterator psi, psi_copy;
 
@@ -6060,11 +6060,11 @@ gimple_duplicate_sese_tail (edge entry ATTRIBUTE_UNUSED, edge exit ATTRIBUTE_UNU
   gcov_type total_count = 0, exit_count = 0;
   edge exits[2], nexits[2], e;
   gimple_stmt_iterator gsi;
-  gimple cond_stmt;
+  gimple *cond_stmt;
   edge sorig, snew;
   basic_block exit_bb;
   gimple_stmt_iterator psi;
-  gimple phi;
+  gimple *phi;
   tree def;
   struct loop *target, *aloop, *cloop;
 
@@ -6425,7 +6425,7 @@ move_stmt_r (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
 	     struct walk_stmt_info *wi)
 {
   struct move_stmt_d *p = (struct move_stmt_d *) wi->info;
-  gimple stmt = gsi_stmt (*gsi_p);
+  gimple *stmt = gsi_stmt (*gsi_p);
   tree block = gimple_block (stmt);
 
   if (block == p->orig_block
@@ -6567,7 +6567,7 @@ move_block_to_fn (struct function *dest_cfun, basic_block bb,
   /* Remap the variables in phi nodes.  */
   for (si = gsi_start_phis (bb); !gsi_end_p (si); )
     {
-      gimple phi = gsi_stmt (si);
+      gimple *phi = gsi_stmt (si);
       use_operand_p use;
       tree op = PHI_RESULT (phi);
       ssa_op_iter oi;
@@ -6612,7 +6612,7 @@ move_block_to_fn (struct function *dest_cfun, basic_block bb,
 
   for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
     {
-      gimple stmt = gsi_stmt (si);
+      gimple *stmt = gsi_stmt (si);
       struct walk_stmt_info wi;
 
       memset (&wi, 0, sizeof (wi));
@@ -6679,7 +6679,7 @@ find_outermost_region_in_block (struct function *src_cfun,
 
   for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
     {
-      gimple stmt = gsi_stmt (si);
+      gimple *stmt = gsi_stmt (si);
       eh_region stmt_region;
       int lp_nr;
 
@@ -7466,7 +7466,7 @@ gimple_block_ends_with_call_p (basic_block bb)
 static bool
 gimple_block_ends_with_condjump_p (const_basic_block bb)
 {
-  gimple stmt = last_stmt (CONST_CAST_BB (bb));
+  gimple *stmt = last_stmt (CONST_CAST_BB (bb));
   return (stmt && gimple_code (stmt) == GIMPLE_COND);
 }
 
@@ -7475,7 +7475,7 @@ gimple_block_ends_with_condjump_p (const_basic_block bb)
    Helper function for gimple_flow_call_edges_add.  */
 
 static bool
-need_fake_edge_p (gimple t)
+need_fake_edge_p (gimple *t)
 {
   tree fndecl = NULL_TREE;
   int call_flags = 0;
@@ -7571,7 +7571,7 @@ gimple_flow_call_edges_add (sbitmap blocks)
     {
       basic_block bb = EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb;
       gimple_stmt_iterator gsi = gsi_last_nondebug_bb (bb);
-      gimple t = NULL;
+      gimple *t = NULL;
 
       if (!gsi_end_p (gsi))
 	t = gsi_stmt (gsi);
@@ -7596,7 +7596,7 @@ gimple_flow_call_edges_add (sbitmap blocks)
     {
       basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i);
       gimple_stmt_iterator gsi;
-      gimple stmt, last_stmt;
+      gimple *stmt, *last_stmt;
 
       if (!bb)
 	continue;
@@ -7784,7 +7784,7 @@ gimple_purge_dead_eh_edges (basic_block bb)
   bool changed = false;
   edge e;
   edge_iterator ei;
-  gimple stmt = last_stmt (bb);
+  gimple *stmt = last_stmt (bb);
 
   if (stmt && stmt_can_throw_internal (stmt))
     return false;
@@ -7834,7 +7834,7 @@ gimple_purge_dead_abnormal_call_edges (basic_block bb)
   bool changed = false;
   edge e;
   edge_iterator ei;
-  gimple stmt = last_stmt (bb);
+  gimple *stmt = last_stmt (bb);
 
   if (!cfun->has_nonlocal_label
       && !cfun->calls_setjmp)
@@ -7921,7 +7921,7 @@ static void
 gimple_lv_adjust_loop_header_phi (basic_block first, basic_block second,
 				  basic_block new_head, edge e)
 {
-  gimple phi1, phi2;
+  gimple *phi1, *phi2;
   gimple_stmt_iterator psi1, psi2;
   tree def;
   edge e2 = find_edge (new_head, second);
@@ -7956,7 +7956,7 @@ gimple_lv_add_condition_to_bb (basic_block first_head ATTRIBUTE_UNUSED,
 			       basic_block cond_bb, void *cond_e)
 {
   gimple_stmt_iterator gsi;
-  gimple new_cond_expr;
+  gimple *new_cond_expr;
   tree cond_expr = (tree) cond_e;
   edge e0;
 
@@ -8232,7 +8232,7 @@ unsigned int
 pass_warn_function_return::execute (function *fun)
 {
   source_location location;
-  gimple last;
+  gimple *last;
   edge e;
   edge_iterator ei;
 
@@ -8266,7 +8266,7 @@ pass_warn_function_return::execute (function *fun)
     {
       FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (fun)->preds)
 	{
-	  gimple last = last_stmt (e->src);
+	  gimple *last = last_stmt (e->src);
 	  if (gimple_code (last) == GIMPLE_RETURN
 	      && gimple_return_retval (last) == NULL
 	      && !gimple_no_warning_p (last))
@@ -8303,7 +8303,7 @@ do_warn_unused_result (gimple_seq seq)
 
   for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
     {
-      gimple g = gsi_stmt (i);
+      gimple *g = gsi_stmt (i);
 
       switch (gimple_code (g))
 	{
@@ -8433,7 +8433,7 @@ execute_fixup_cfg (void)
       bb->count = apply_scale (bb->count, count_scale);
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  tree decl = is_gimple_call (stmt)
 		      ? gimple_call_fndecl (stmt)
 		      : NULL;
@@ -8471,7 +8471,7 @@ execute_fixup_cfg (void)
 	 when inlining a noreturn call that does in fact return.  */
       if (EDGE_COUNT (bb->succs) == 0)
 	{
-	  gimple stmt = last_stmt (bb);
+	  gimple *stmt = last_stmt (bb);
 	  if (!stmt
 	      || (!is_ctrl_stmt (stmt)
 		  && (!is_gimple_call (stmt)
@@ -8542,7 +8542,7 @@ make_pass_fixup_cfg (gcc::context *ctxt)
 /* Garbage collection support for edge_def.  */
 
 extern void gt_ggc_mx (tree&);
-extern void gt_ggc_mx (gimple&);
+extern void gt_ggc_mx (gimple *&);
 extern void gt_ggc_mx (rtx&);
 extern void gt_ggc_mx (basic_block&);
 
@@ -8562,7 +8562,7 @@ gt_ggc_mx (edge_def *e)
 /* PCH support for edge_def.  */
 
 extern void gt_pch_nx (tree&);
-extern void gt_pch_nx (gimple&);
+extern void gt_pch_nx (gimple *&);
 extern void gt_pch_nx (rtx&);
 extern void gt_pch_nx (basic_block&);
 
diff --git a/gcc/tree-cfg.h b/gcc/tree-cfg.h
index 751d0a2..2bcfedf 100644
--- a/gcc/tree-cfg.h
+++ b/gcc/tree-cfg.h
@@ -32,11 +32,11 @@ extern void end_recording_case_labels (void);
 extern basic_block label_to_block_fn (struct function *, tree);
 #define label_to_block(t) (label_to_block_fn (cfun, t))
 extern void cleanup_dead_labels (void);
-extern void group_case_labels_stmt (gimple);
+extern void group_case_labels_stmt (gimple *);
 extern void group_case_labels (void);
 extern void replace_uses_by (tree, tree);
 extern basic_block single_noncomplex_succ (basic_block bb);
-extern void notice_special_calls (gimple);
+extern void notice_special_calls (gimple *);
 extern void clear_special_calls (void);
 extern edge find_taken_edge (basic_block, tree);
 extern void gimple_debug_bb (basic_block);
@@ -45,18 +45,18 @@ extern void gimple_debug_cfg (int);
 extern void gimple_dump_cfg (FILE *, int);
 extern void dump_cfg_stats (FILE *);
 extern void debug_cfg_stats (void);
-extern bool computed_goto_p (gimple);
-extern bool stmt_can_make_abnormal_goto (gimple);
+extern bool computed_goto_p (gimple *);
+extern bool stmt_can_make_abnormal_goto (gimple *);
 extern basic_block get_abnormal_succ_dispatcher (basic_block);
-extern bool is_ctrl_stmt (gimple);
-extern bool is_ctrl_altering_stmt (gimple);
-extern bool simple_goto_p (gimple);
-extern bool stmt_ends_bb_p (gimple);
+extern bool is_ctrl_stmt (gimple *);
+extern bool is_ctrl_altering_stmt (gimple *);
+extern bool simple_goto_p (gimple *);
+extern bool stmt_ends_bb_p (gimple *);
 extern bool assert_unreachable_fallthru_edge_p (edge);
 extern void delete_tree_cfg_annotations (void);
-extern gimple first_stmt (basic_block);
-extern gimple last_stmt (basic_block);
-extern gimple last_and_only_stmt (basic_block);
+extern gimple *first_stmt (basic_block);
+extern gimple *last_stmt (basic_block);
+extern gimple *last_and_only_stmt (basic_block);
 extern void verify_gimple_in_seq (gimple_seq);
 extern void verify_gimple_in_cfg (struct function *, bool);
 extern tree gimple_block_label (basic_block);
diff --git a/gcc/tree-cfgcleanup.c b/gcc/tree-cfgcleanup.c
index 71c294b..501eae3 100644
--- a/gcc/tree-cfgcleanup.c
+++ b/gcc/tree-cfgcleanup.c
@@ -91,7 +91,7 @@ cleanup_control_expr_graph (basic_block bb, gimple_stmt_iterator gsi)
 {
   edge taken_edge;
   bool retval = false;
-  gimple stmt = gsi_stmt (gsi);
+  gimple *stmt = gsi_stmt (gsi);
   tree val;
 
   if (!single_succ_p (bb))
@@ -170,7 +170,7 @@ cleanup_control_flow_bb (basic_block bb)
 {
   gimple_stmt_iterator gsi;
   bool retval = false;
-  gimple stmt;
+  gimple *stmt;
 
   /* If the last statement of the block could throw and now cannot,
      we need to prune cfg.  */
@@ -284,7 +284,7 @@ tree_forwarder_block_p (basic_block bb, bool phi_wanted)
      anything else means this is not a forwarder block.  */
   for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi_prev (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
 
       switch (gimple_code (stmt))
 	{
@@ -351,7 +351,7 @@ phi_alternatives_equal (basic_block dest, edge e1, edge e2)
 
   for (gsi = gsi_start_phis (dest); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple phi = gsi_stmt (gsi);
+      gimple *phi = gsi_stmt (gsi);
       tree val1 = gimple_phi_arg_def (phi, n1);
       tree val2 = gimple_phi_arg_def (phi, n2);
 
@@ -372,7 +372,7 @@ remove_forwarder_block (basic_block bb)
 {
   edge succ = single_succ_edge (bb), e, s;
   basic_block dest = succ->dest;
-  gimple label;
+  gimple *label;
   edge_iterator ei;
   gimple_stmt_iterator gsi, gsi_to;
   bool can_move_debug_stmts;
@@ -452,7 +452,7 @@ remove_forwarder_block (basic_block bb)
 	       !gsi_end_p (gsi);
 	       gsi_next (&gsi))
 	    {
-	      gimple phi = gsi_stmt (gsi);
+	      gimple *phi = gsi_stmt (gsi);
 	      source_location l = gimple_phi_arg_location_from_edge (phi, succ);
 	      tree def = gimple_phi_arg_def (phi, succ->dest_idx);
 	      add_phi_arg (phi, unshare_expr (def), s, l);
@@ -491,7 +491,7 @@ remove_forwarder_block (basic_block bb)
       gsi_to = gsi_after_labels (dest);
       for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi); )
 	{
-	  gimple debug = gsi_stmt (gsi);
+	  gimple *debug = gsi_stmt (gsi);
 	  if (!is_gimple_debug (debug))
 	    break;
 	  gsi_remove (&gsi, false);
@@ -535,7 +535,7 @@ remove_forwarder_block (basic_block bb)
    and remove LHS.  Return true if something changed.  */
 
 bool
-fixup_noreturn_call (gimple stmt)
+fixup_noreturn_call (gimple *stmt)
 {
   basic_block bb = gimple_bb (stmt);
   bool changed = false;
@@ -564,7 +564,7 @@ fixup_noreturn_call (gimple stmt)
 	{
 	  use_operand_p use_p;
           imm_use_iterator iter;
-	  gimple use_stmt;
+	  gimple *use_stmt;
 	  bitmap_iterator bi;
 	  unsigned int bb_index;
 
@@ -597,7 +597,7 @@ static bool
 split_bbs_on_noreturn_calls (void)
 {
   bool changed = false;
-  gimple stmt;
+  gimple *stmt;
   basic_block bb;
 
   /* Detect cases where a mid-block call is now known not to return.  */
@@ -800,7 +800,7 @@ remove_forwarder_block_with_phi (basic_block bb)
 {
   edge succ = single_succ_edge (bb);
   basic_block dest = succ->dest;
-  gimple label;
+  gimple *label;
   basic_block dombb, domdest, dom;
 
   /* We check for infinite loops already in tree_forwarder_block_p.
@@ -859,7 +859,7 @@ remove_forwarder_block_with_phi (basic_block bb)
 	   !gsi_end_p (gsi);
 	   gsi_next (&gsi))
 	{
-	  gimple phi = gsi_stmt (gsi);
+	  gimple *phi = gsi_stmt (gsi);
 	  tree def = gimple_phi_arg_def (phi, succ->dest_idx);
 	  source_location locus = gimple_phi_arg_location_from_edge (phi, succ);
 
@@ -1021,10 +1021,10 @@ pass_merge_phi::execute (function *fun)
 	  for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
 	       gsi_next (&gsi))
 	    {
-	      gimple phi = gsi_stmt (gsi);
+	      gimple *phi = gsi_stmt (gsi);
 	      tree result = gimple_phi_result (phi);
 	      use_operand_p imm_use;
-	      gimple use_stmt;
+	      gimple *use_stmt;
 
 	      /* If the PHI's result is never used, then we can just
 		 ignore it.  */
diff --git a/gcc/tree-cfgcleanup.h b/gcc/tree-cfgcleanup.h
index 19ff170..6f9db44 100644
--- a/gcc/tree-cfgcleanup.h
+++ b/gcc/tree-cfgcleanup.h
@@ -23,6 +23,6 @@ along with GCC; see the file COPYING3.  If not see
 /* In tree-cfgcleanup.c  */
 extern bitmap cfgcleanup_altered_bbs;
 extern bool cleanup_tree_cfg (void);
-extern bool fixup_noreturn_call (gimple stmt);
+extern bool fixup_noreturn_call (gimple *stmt);
 
 #endif /* GCC_TREE_CFGCLEANUP_H */
diff --git a/gcc/tree-chrec.c b/gcc/tree-chrec.c
index c78d941..37d8ab2 100644
--- a/gcc/tree-chrec.c
+++ b/gcc/tree-chrec.c
@@ -1158,7 +1158,7 @@ nb_vars_in_chrec (tree chrec)
     }
 }
 
-static tree chrec_convert_1 (tree, tree, gimple, bool);
+static tree chrec_convert_1 (tree, tree, gimple *, bool);
 
 /* Converts BASE and STEP of affine scev to TYPE.  LOOP is the loop whose iv
    the scev corresponds to.  AT_STMT is the statement at that the scev is
@@ -1170,7 +1170,7 @@ static tree chrec_convert_1 (tree, tree, gimple, bool);
 
 bool
 convert_affine_scev (struct loop *loop, tree type,
-		     tree *base, tree *step, gimple at_stmt,
+		     tree *base, tree *step, gimple *at_stmt,
 		     bool use_overflow_semantics)
 {
   tree ct = TREE_TYPE (*step);
@@ -1271,7 +1271,7 @@ convert_affine_scev (struct loop *loop, tree type,
    The increment for a pointer type is always sizetype.  */
 
 tree
-chrec_convert_rhs (tree type, tree chrec, gimple at_stmt)
+chrec_convert_rhs (tree type, tree chrec, gimple *at_stmt)
 {
   if (POINTER_TYPE_P (type))
     type = sizetype;
@@ -1304,7 +1304,7 @@ chrec_convert_rhs (tree type, tree chrec, gimple at_stmt)
 */
 
 tree
-chrec_convert (tree type, tree chrec, gimple at_stmt)
+chrec_convert (tree type, tree chrec, gimple *at_stmt)
 {
   return chrec_convert_1 (type, chrec, at_stmt, true);
 }
@@ -1322,7 +1322,7 @@ chrec_convert (tree type, tree chrec, gimple at_stmt)
    tests, but also to enforce that the result follows them.  */
 
 static tree
-chrec_convert_1 (tree type, tree chrec, gimple at_stmt,
+chrec_convert_1 (tree type, tree chrec, gimple *at_stmt,
 		 bool use_overflow_semantics)
 {
   tree ct, res;
diff --git a/gcc/tree-chrec.h b/gcc/tree-chrec.h
index 90cc7a7..478f1db 100644
--- a/gcc/tree-chrec.h
+++ b/gcc/tree-chrec.h
@@ -59,8 +59,8 @@ enum ev_direction scev_direction (const_tree);
 extern tree chrec_fold_plus (tree, tree, tree);
 extern tree chrec_fold_minus (tree, tree, tree);
 extern tree chrec_fold_multiply (tree, tree, tree);
-extern tree chrec_convert (tree, tree, gimple);
-extern tree chrec_convert_rhs (tree, tree, gimple);
+extern tree chrec_convert (tree, tree, gimple *);
+extern tree chrec_convert_rhs (tree, tree, gimple *);
 extern tree chrec_convert_aggressive (tree, tree);
 
 /* Operations.  */
@@ -74,7 +74,7 @@ extern tree hide_evolution_in_other_loops_than_loop (tree, unsigned);
 extern tree reset_evolution_in_loop (unsigned, tree, tree);
 extern tree chrec_merge (tree, tree);
 extern void for_each_scev_op (tree *, bool (*) (tree *, void *), void *);
-extern bool convert_affine_scev (struct loop *, tree, tree *, tree *, gimple,
+extern bool convert_affine_scev (struct loop *, tree, tree *, tree *, gimple *,
 				 bool);
 
 /* Observers.  */
diff --git a/gcc/tree-complex.c b/gcc/tree-complex.c
index cf542fd..509ed11 100644
--- a/gcc/tree-complex.c
+++ b/gcc/tree-complex.c
@@ -204,7 +204,7 @@ init_dont_simulate_again (void)
 {
   basic_block bb;
   gimple_stmt_iterator gsi;
-  gimple phi;
+  gimple *phi;
   bool saw_a_complex_op = false;
 
   FOR_EACH_BB_FN (bb, cfun)
@@ -218,7 +218,7 @@ init_dont_simulate_again (void)
 
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt;
+	  gimple *stmt;
 	  tree op0, op1;
 	  bool sim_again_p;
 
@@ -306,7 +306,7 @@ init_dont_simulate_again (void)
 /* Evaluate statement STMT against the complex lattice defined above.  */
 
 static enum ssa_prop_result
-complex_visit_stmt (gimple stmt, edge *taken_edge_p ATTRIBUTE_UNUSED,
+complex_visit_stmt (gimple *stmt, edge *taken_edge_p ATTRIBUTE_UNUSED,
 		    tree *result_p)
 {
   complex_lattice_t new_l, old_l, op1_l, op2_l;
@@ -401,7 +401,7 @@ complex_visit_stmt (gimple stmt, edge *taken_edge_p ATTRIBUTE_UNUSED,
 /* Evaluate a PHI node against the complex lattice defined above.  */
 
 static enum ssa_prop_result
-complex_visit_phi (gimple phi)
+complex_visit_phi (gimple *phi)
 {
   complex_lattice_t new_l, old_l;
   unsigned int ver;
@@ -534,7 +534,7 @@ set_component_ssa_name (tree ssa_name, bool imag_p, tree value)
   complex_lattice_t lattice = find_lattice_value (ssa_name);
   size_t ssa_name_index;
   tree comp;
-  gimple last;
+  gimple *last;
   gimple_seq list;
 
   /* We know the value must be zero, else there's a bug in our lattice
@@ -640,7 +640,7 @@ extract_component (gimple_stmt_iterator *gsi, tree t, bool imagpart_p,
 /* Update the complex components of the ssa name on the lhs of STMT.  */
 
 static void
-update_complex_components (gimple_stmt_iterator *gsi, gimple stmt, tree r,
+update_complex_components (gimple_stmt_iterator *gsi, gimple *stmt, tree r,
 			   tree i)
 {
   tree lhs;
@@ -677,7 +677,7 @@ update_complex_components_on_edge (edge e, tree lhs, tree r, tree i)
 static void
 update_complex_assignment (gimple_stmt_iterator *gsi, tree r, tree i)
 {
-  gimple stmt;
+  gimple *stmt;
 
   gimple_assign_set_rhs_with_ops (gsi, COMPLEX_EXPR, r, i);
   stmt = gsi_stmt (*gsi);
@@ -728,12 +728,12 @@ update_phi_components (basic_block bb)
 
   for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple phi = gsi_stmt (gsi);
+      gimple *phi = gsi_stmt (gsi);
 
       if (is_complex_reg (gimple_phi_result (phi)))
 	{
 	  tree lr, li;
-	  gimple pr = NULL, pi = NULL;
+	  gimple *pr = NULL, *pi = NULL;
 	  unsigned int i, n;
 
 	  lr = get_component_ssa_name (gimple_phi_result (phi), false);
@@ -769,7 +769,7 @@ expand_complex_move (gimple_stmt_iterator *gsi, tree type)
 {
   tree inner_type = TREE_TYPE (type);
   tree r, i, lhs, rhs;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
 
   if (is_gimple_assign (stmt))
     {
@@ -830,7 +830,7 @@ expand_complex_move (gimple_stmt_iterator *gsi, tree type)
   else if (rhs && TREE_CODE (rhs) == SSA_NAME && !TREE_SIDE_EFFECTS (lhs))
     {
       tree x;
-      gimple t;
+      gimple *t;
       location_t loc;
 
       loc = gimple_location (stmt);
@@ -952,7 +952,7 @@ expand_complex_libcall (gimple_stmt_iterator *gsi, tree ar, tree ai,
   enum machine_mode mode;
   enum built_in_function bcode;
   tree fn, type, lhs;
-  gimple old_stmt, stmt;
+  gimple *old_stmt, *stmt;
 
   old_stmt = gsi_stmt (*gsi);
   lhs = gimple_assign_lhs (old_stmt);
@@ -1117,7 +1117,7 @@ expand_complex_div_wide (gimple_stmt_iterator *gsi, tree inner_type,
 {
   tree rr, ri, ratio, div, t1, t2, tr, ti, compare;
   basic_block bb_cond, bb_true, bb_false, bb_join;
-  gimple stmt;
+  gimple *stmt;
 
   /* Examine |br| < |bi|, and branch.  */
   t1 = gimplify_build1 (gsi, ABS_EXPR, inner_type, br);
@@ -1131,7 +1131,7 @@ expand_complex_div_wide (gimple_stmt_iterator *gsi, tree inner_type,
   if (TREE_CODE (compare) != INTEGER_CST)
     {
       edge e;
-      gimple stmt;
+      gimple *stmt;
       tree cond, tmp;
 
       tmp = create_tmp_var (boolean_type_node, NULL);
@@ -1382,7 +1382,7 @@ expand_complex_comparison (gimple_stmt_iterator *gsi, tree ar, tree ai,
 			   tree br, tree bi, enum tree_code code)
 {
   tree cr, ci, cc, type;
-  gimple stmt;
+  gimple *stmt;
 
   cr = gimplify_build2 (gsi, code, boolean_type_node, ar, br);
   ci = gimplify_build2 (gsi, code, boolean_type_node, ai, bi);
@@ -1423,7 +1423,7 @@ expand_complex_comparison (gimple_stmt_iterator *gsi, tree ar, tree ai,
 static void
 expand_complex_asm (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   unsigned int i;
 
   for (i = 0; i < gimple_asm_noutputs (stmt); ++i)
@@ -1454,7 +1454,7 @@ expand_complex_asm (gimple_stmt_iterator *gsi)
 static void
 expand_complex_operations_1 (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   tree type, inner_type, lhs;
   tree ac, ar, ai, bc, br, bi;
   complex_lattice_t al, bl;
diff --git a/gcc/tree-core.h b/gcc/tree-core.h
index 72ef8e1..7a53b0d 100644
--- a/gcc/tree-core.h
+++ b/gcc/tree-core.h
@@ -1182,7 +1182,7 @@ struct GTY(()) ssa_use_operand_t {
      needs to point to the original SSA name.  Since statements and
      SSA names are of different data types, we need this union.  See
      the explanation in struct imm_use_iterator.  */
-  union { gimple stmt; tree ssa_name; } GTY((skip(""))) loc;
+  union { gimple *stmt; tree ssa_name; } GTY((skip(""))) loc;
   tree *GTY((skip(""))) use;
 };
 
@@ -1193,7 +1193,7 @@ struct GTY(()) tree_ssa_name {
   tree var;
 
   /* Statement that defines this SSA name.  */
-  gimple def_stmt;
+  gimple *def_stmt;
 
   /* Value range information.  */
   union ssa_name_info_type {
diff --git a/gcc/tree-data-ref.c b/gcc/tree-data-ref.c
index 55dbf6a..03075f3 100644
--- a/gcc/tree-data-ref.c
+++ b/gcc/tree-data-ref.c
@@ -663,7 +663,7 @@ split_constant_offset_1 (tree type, tree op0, enum tree_code code, tree op1,
 
     case SSA_NAME:
       {
-	gimple def_stmt = SSA_NAME_DEF_STMT (op0);
+	gimple *def_stmt = SSA_NAME_DEF_STMT (op0);
 	enum tree_code subcode;
 
 	if (gimple_code (def_stmt) != GIMPLE_ASSIGN)
@@ -754,7 +754,7 @@ canonicalize_base_object_address (tree addr)
 bool
 dr_analyze_innermost (struct data_reference *dr, struct loop *nest)
 {
-  gimple stmt = DR_STMT (dr);
+  gimple *stmt = DR_STMT (dr);
   struct loop *loop = loop_containing_stmt (stmt);
   tree ref = DR_REF (dr);
   HOST_WIDE_INT pbitsize, pbitpos;
@@ -1031,7 +1031,7 @@ free_data_ref (data_reference_p dr)
    which the data reference should be analyzed.  */
 
 struct data_reference *
-create_data_ref (loop_p nest, loop_p loop, tree memref, gimple stmt,
+create_data_ref (loop_p nest, loop_p loop, tree memref, gimple *stmt,
 		 bool is_read)
 {
   struct data_reference *dr;
@@ -4332,7 +4332,7 @@ typedef struct data_ref_loc_d
    true if STMT clobbers memory, false otherwise.  */
 
 static bool
-get_references_in_stmt (gimple stmt, vec<data_ref_loc, va_heap> *references)
+get_references_in_stmt (gimple *stmt, vec<data_ref_loc, va_heap> *references)
 {
   bool clobbers_memory = false;
   data_ref_loc ref;
@@ -4451,7 +4451,7 @@ get_references_in_stmt (gimple stmt, vec<data_ref_loc, va_heap> *references)
    loop of the loop nest in which the references should be analyzed.  */
 
 bool
-find_data_references_in_stmt (struct loop *nest, gimple stmt,
+find_data_references_in_stmt (struct loop *nest, gimple *stmt,
 			      vec<data_reference_p> *datarefs)
 {
   unsigned i;
@@ -4481,7 +4481,7 @@ find_data_references_in_stmt (struct loop *nest, gimple stmt,
    should be analyzed.  */
 
 bool
-graphite_find_data_references_in_stmt (loop_p nest, loop_p loop, gimple stmt,
+graphite_find_data_references_in_stmt (loop_p nest, loop_p loop, gimple *stmt,
 				       vec<data_reference_p> *datarefs)
 {
   unsigned i;
@@ -4516,7 +4516,7 @@ find_data_references_in_bb (struct loop *loop, basic_block bb,
 
   for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
     {
-      gimple stmt = gsi_stmt (bsi);
+      gimple *stmt = gsi_stmt (bsi);
 
       if (!find_data_references_in_stmt (loop, stmt, datarefs))
         {
diff --git a/gcc/tree-data-ref.h b/gcc/tree-data-ref.h
index 9d819e4..7319ec2 100644
--- a/gcc/tree-data-ref.h
+++ b/gcc/tree-data-ref.h
@@ -168,7 +168,7 @@ am_vector_index_for_loop (struct access_matrix *access_matrix, int loop_num)
 struct data_reference
 {
   /* A pointer to the statement that contains this DR.  */
-  gimple stmt;
+  gimple *stmt;
 
   /* A pointer to the memory reference.  */
   tree ref;
@@ -384,12 +384,12 @@ extern void free_dependence_relation (struct data_dependence_relation *);
 extern void free_dependence_relations (vec<ddr_p> );
 extern void free_data_ref (data_reference_p);
 extern void free_data_refs (vec<data_reference_p> );
-extern bool find_data_references_in_stmt (struct loop *, gimple,
+extern bool find_data_references_in_stmt (struct loop *, gimple *,
 					  vec<data_reference_p> *);
-extern bool graphite_find_data_references_in_stmt (loop_p, loop_p, gimple,
+extern bool graphite_find_data_references_in_stmt (loop_p, loop_p, gimple *,
 						   vec<data_reference_p> *);
 tree find_data_references_in_loop (struct loop *, vec<data_reference_p> *);
-struct data_reference *create_data_ref (loop_p, loop_p, tree, gimple, bool);
+struct data_reference *create_data_ref (loop_p, loop_p, tree, gimple *, bool);
 extern bool find_loop_nest (struct loop *, vec<loop_p> *);
 extern struct data_dependence_relation *initialize_data_dependence_relation
      (struct data_reference *, struct data_reference *, vec<loop_p>);
diff --git a/gcc/tree-dfa.c b/gcc/tree-dfa.c
index f289cec..d8a43ad 100644
--- a/gcc/tree-dfa.c
+++ b/gcc/tree-dfa.c
@@ -86,12 +86,12 @@ renumber_gimple_stmt_uids (void)
       gimple_stmt_iterator bsi;
       for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
 	{
-	  gimple stmt = gsi_stmt (bsi);
+	  gimple *stmt = gsi_stmt (bsi);
 	  gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
 	}
       for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
 	{
-	  gimple stmt = gsi_stmt (bsi);
+	  gimple *stmt = gsi_stmt (bsi);
 	  gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
 	}
     }
@@ -112,12 +112,12 @@ renumber_gimple_stmt_uids_in_blocks (basic_block *blocks, int n_blocks)
       gimple_stmt_iterator bsi;
       for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
 	{
-	  gimple stmt = gsi_stmt (bsi);
+	  gimple *stmt = gsi_stmt (bsi);
 	  gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
 	}
       for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
 	{
-	  gimple stmt = gsi_stmt (bsi);
+	  gimple *stmt = gsi_stmt (bsi);
 	  gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
 	}
     }
@@ -286,7 +286,7 @@ collect_dfa_stats (struct dfa_stats_d *dfa_stats_p ATTRIBUTE_UNUSED)
 
       for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
 	{
-	  gimple phi = gsi_stmt (si);
+	  gimple *phi = gsi_stmt (si);
 	  dfa_stats_p->num_phis++;
 	  dfa_stats_p->num_phi_args += gimple_phi_num_args (phi);
 	  if (gimple_phi_num_args (phi) > dfa_stats_p->max_num_phi_args)
@@ -295,7 +295,7 @@ collect_dfa_stats (struct dfa_stats_d *dfa_stats_p ATTRIBUTE_UNUSED)
 
       for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
 	{
-	  gimple stmt = gsi_stmt (si);
+	  gimple *stmt = gsi_stmt (si);
 	  dfa_stats_p->num_defs += NUM_SSA_OPERANDS (stmt, SSA_OP_DEF);
 	  dfa_stats_p->num_uses += NUM_SSA_OPERANDS (stmt, SSA_OP_USE);
 	  dfa_stats_p->num_vdefs += gimple_vdef (stmt) ? 1 : 0;
@@ -676,7 +676,7 @@ get_addr_base_and_unit_offset (tree exp, HOST_WIDE_INT *poffset)
    SSA_NAME_OCCURS_IN_ABNORMAL_PHI set, otherwise false.  */
 
 bool
-stmt_references_abnormal_ssa_name (gimple stmt)
+stmt_references_abnormal_ssa_name (gimple *stmt)
 {
   ssa_op_iter oi;
   use_operand_p use_p;
diff --git a/gcc/tree-dfa.h b/gcc/tree-dfa.h
index fe13587..b0125a2 100644
--- a/gcc/tree-dfa.h
+++ b/gcc/tree-dfa.h
@@ -32,7 +32,7 @@ extern tree get_or_create_ssa_default_def (struct function *, tree);
 extern tree get_ref_base_and_extent (tree, HOST_WIDE_INT *,
 				     HOST_WIDE_INT *, HOST_WIDE_INT *);
 extern tree get_addr_base_and_unit_offset (tree, HOST_WIDE_INT *);
-extern bool stmt_references_abnormal_ssa_name (gimple);
+extern bool stmt_references_abnormal_ssa_name (gimple *);
 extern void dump_enumerated_decls (FILE *, int);
 
 /* Returns the base object and a constant BITS_PER_UNIT offset in *POFFSET that
diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c
index 624f277..fd3057d 100644
--- a/gcc/tree-eh.c
+++ b/gcc/tree-eh.c
@@ -56,7 +56,7 @@ along with GCC; see the file COPYING3.  If not see
 
 /* In some instances a tree and a gimple need to be stored in a same table,
    i.e. in hash tables. This is a structure to do this. */
-typedef union {tree *tp; tree t; gimple g;} treemple;
+typedef union {tree *tp; tree t; gimple *g;} treemple;
 
 /* Misc functions used in this file.  */
 
@@ -75,7 +75,7 @@ typedef union {tree *tp; tree t; gimple g;} treemple;
 /* Add statement T in function IFUN to landing pad NUM.  */
 
 static void
-add_stmt_to_eh_lp_fn (struct function *ifun, gimple t, int num)
+add_stmt_to_eh_lp_fn (struct function *ifun, gimple *t, int num)
 {
   struct throw_stmt_node *n;
   void **slot;
@@ -99,7 +99,7 @@ add_stmt_to_eh_lp_fn (struct function *ifun, gimple t, int num)
 /* Add statement T in the current function (cfun) to EH landing pad NUM.  */
 
 void
-add_stmt_to_eh_lp (gimple t, int num)
+add_stmt_to_eh_lp (gimple *t, int num)
 {
   add_stmt_to_eh_lp_fn (cfun, t, num);
 }
@@ -107,7 +107,7 @@ add_stmt_to_eh_lp (gimple t, int num)
 /* Add statement T to the single EH landing pad in REGION.  */
 
 static void
-record_stmt_eh_region (eh_region region, gimple t)
+record_stmt_eh_region (eh_region region, gimple *t)
 {
   if (region == NULL)
     return;
@@ -128,7 +128,7 @@ record_stmt_eh_region (eh_region region, gimple t)
 /* Remove statement T in function IFUN from its EH landing pad.  */
 
 bool
-remove_stmt_from_eh_lp_fn (struct function *ifun, gimple t)
+remove_stmt_from_eh_lp_fn (struct function *ifun, gimple *t)
 {
   struct throw_stmt_node dummy;
   void **slot;
@@ -153,7 +153,7 @@ remove_stmt_from_eh_lp_fn (struct function *ifun, gimple t)
    EH landing pad.  */
 
 bool
-remove_stmt_from_eh_lp (gimple t)
+remove_stmt_from_eh_lp (gimple *t)
 {
   return remove_stmt_from_eh_lp_fn (cfun, t);
 }
@@ -164,7 +164,7 @@ remove_stmt_from_eh_lp (gimple t)
    statement is not recorded in the region table.  */
 
 int
-lookup_stmt_eh_lp_fn (struct function *ifun, gimple t)
+lookup_stmt_eh_lp_fn (struct function *ifun, gimple *t)
 {
   struct throw_stmt_node *p, n;
 
@@ -179,7 +179,7 @@ lookup_stmt_eh_lp_fn (struct function *ifun, gimple t)
 /* Likewise, but always use the current function.  */
 
 int
-lookup_stmt_eh_lp (gimple t)
+lookup_stmt_eh_lp (gimple *t)
 {
   /* We can get called from initialized data when -fnon-call-exceptions
      is on; prevent crash.  */
@@ -199,7 +199,7 @@ struct finally_tree_node
      tree) leaves the TRY block, its necessary to record a tree in
      this field.  Thus a treemple is used. */
   treemple child;
-  gimple parent;
+  gimple *parent;
 };
 
 /* Hashtable helpers.  */
@@ -228,7 +228,7 @@ finally_tree_hasher::equal (const value_type *v, const compare_type *c)
 static hash_table <finally_tree_hasher> finally_tree;
 
 static void
-record_in_finally_tree (treemple child, gimple parent)
+record_in_finally_tree (treemple child, gimple *parent)
 {
   struct finally_tree_node *n;
   finally_tree_node **slot;
@@ -243,13 +243,13 @@ record_in_finally_tree (treemple child, gimple parent)
 }
 
 static void
-collect_finally_tree (gimple stmt, gimple region);
+collect_finally_tree (gimple *stmt, gimple *region);
 
 /* Go through the gimple sequence.  Works with collect_finally_tree to
    record all GIMPLE_LABEL and GIMPLE_TRY statements. */
 
 static void
-collect_finally_tree_1 (gimple_seq seq, gimple region)
+collect_finally_tree_1 (gimple_seq seq, gimple *region)
 {
   gimple_stmt_iterator gsi;
 
@@ -258,7 +258,7 @@ collect_finally_tree_1 (gimple_seq seq, gimple region)
 }
 
 static void
-collect_finally_tree (gimple stmt, gimple region)
+collect_finally_tree (gimple *stmt, gimple *region)
 {
   treemple temp;
 
@@ -309,7 +309,7 @@ collect_finally_tree (gimple stmt, gimple region)
    would leave the try_finally node that START lives in.  */
 
 static bool
-outside_finally_tree (treemple start, gimple target)
+outside_finally_tree (treemple start, gimple *target)
 {
   struct finally_tree_node n, *p;
 
@@ -353,7 +353,7 @@ struct goto_queue_node
   treemple stmt;
   location_t location;
   gimple_seq repl_stmt;
-  gimple cont_stmt;
+  gimple *cont_stmt;
   int index;
   /* This is used when index >= 0 to indicate that stmt is a label (as
      opposed to a goto stmt).  */
@@ -386,8 +386,8 @@ struct leh_tf_state
      try_finally_expr is the original GIMPLE_TRY_FINALLY.  We need to retain
      this so that outside_finally_tree can reliably reference the tree used
      in the collect_finally_tree data structures.  */
-  gimple try_finally_expr;
-  gimple top_p;
+  gimple *try_finally_expr;
+  gimple *top_p;
 
   /* While lowering a top_p usually it is expanded into multiple statements,
      thus we need the following field to store them. */
@@ -427,7 +427,7 @@ struct leh_tf_state
   bool may_throw;
 };
 
-static gimple_seq lower_eh_must_not_throw (struct leh_state *, gimple);
+static gimple_seq lower_eh_must_not_throw (struct leh_state *, gimple *);
 
 /* Search for STMT in the goto queue.  Return the replacement,
    or null if the statement isn't in the queue.  */
@@ -512,7 +512,7 @@ replace_goto_queue_cond_clause (tree *tp, struct leh_tf_state *tf,
 static void replace_goto_queue_stmt_list (gimple_seq *, struct leh_tf_state *);
 
 static void
-replace_goto_queue_1 (gimple stmt, struct leh_tf_state *tf,
+replace_goto_queue_1 (gimple *stmt, struct leh_tf_state *tf,
 		      gimple_stmt_iterator *gsi)
 {
   gimple_seq seq;
@@ -671,7 +671,7 @@ record_in_goto_queue_label (struct leh_tf_state *tf, treemple stmt, tree label,
    try_finally node.  */
 
 static void
-maybe_record_in_goto_queue (struct leh_state *state, gimple stmt)
+maybe_record_in_goto_queue (struct leh_state *state, gimple *stmt)
 {
   struct leh_tf_state *tf = state->tf;
   treemple new_stmt;
@@ -713,7 +713,7 @@ maybe_record_in_goto_queue (struct leh_state *state, gimple stmt)
    of the labels will leave outer GIMPLE_TRY_FINALLY nodes. Verify this.  */
 
 static void
-verify_norecord_switch_expr (struct leh_state *state, gimple switch_expr)
+verify_norecord_switch_expr (struct leh_state *state, gimple *switch_expr)
 {
   struct leh_tf_state *tf = state->tf;
   size_t i, n;
@@ -741,7 +741,7 @@ verify_norecord_switch_expr (struct leh_state *state, gimple switch_expr)
 static void
 do_return_redirection (struct goto_queue_node *q, tree finlab, gimple_seq mod)
 {
-  gimple x;
+  gimple *x;
 
   /* In the case of a return, the queue node must be a gimple statement.  */
   gcc_assert (!q->is_label);
@@ -779,7 +779,7 @@ static void
 do_goto_redirection (struct goto_queue_node *q, tree finlab, gimple_seq mod,
 		     struct leh_tf_state *tf)
 {
-  gimple x;
+  gimple *x;
 
   gcc_assert (q->is_label);
 
@@ -799,7 +799,7 @@ static void
 emit_post_landing_pad (gimple_seq *seq, eh_region region)
 {
   eh_landing_pad lp = region->landing_pads;
-  gimple x;
+  gimple *x;
 
   if (lp == NULL)
     lp = gen_eh_landing_pad (region);
@@ -816,7 +816,7 @@ emit_post_landing_pad (gimple_seq *seq, eh_region region)
 static void
 emit_resx (gimple_seq *seq, eh_region region)
 {
-  gimple x = gimple_build_resx (region->index);
+  gimple *x = gimple_build_resx (region->index);
   gimple_seq_add_stmt (seq, x);
   if (region->outer)
     record_stmt_eh_region (region->outer, x);
@@ -827,7 +827,7 @@ emit_resx (gimple_seq *seq, eh_region region)
 static void
 emit_eh_dispatch (gimple_seq *seq, eh_region region)
 {
-  gimple x = gimple_build_eh_dispatch (region->index);
+  gimple *x = gimple_build_eh_dispatch (region->index);
   gimple_seq_add_stmt (seq, x);
 }
 
@@ -872,9 +872,9 @@ eh_region_may_contain_throw (eh_region r)
    an existing label that should be put at the exit, or NULL.  */
 
 static gimple_seq
-frob_into_branch_around (gimple tp, eh_region region, tree over)
+frob_into_branch_around (gimple *tp, eh_region region, tree over)
 {
-  gimple x;
+  gimple *x;
   gimple_seq cleanup, result;
   location_t loc = gimple_location (tp);
 
@@ -909,7 +909,7 @@ static gimple_seq
 lower_try_finally_dup_block (gimple_seq seq, struct leh_state *outer_state,
 			     location_t loc)
 {
-  gimple region = NULL;
+  gimple *region = NULL;
   gimple_seq new_seq;
   gimple_stmt_iterator gsi;
 
@@ -917,7 +917,7 @@ lower_try_finally_dup_block (gimple_seq seq, struct leh_state *outer_state,
 
   for (gsi = gsi_start (new_seq); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       if (LOCATION_LOCUS (gimple_location (stmt)) == UNKNOWN_LOCATION)
 	{
 	  tree block = gimple_block (stmt);
@@ -959,10 +959,10 @@ lower_try_finally_fallthru_label (struct leh_tf_state *tf)
 /* A subroutine of lower_try_finally.  If FINALLY consits of a
    GIMPLE_EH_ELSE node, return it.  */
 
-static inline gimple
+static inline gimple *
 get_eh_else (gimple_seq finally)
 {
-  gimple x = gimple_seq_first_stmt (finally);
+  gimple *x = gimple_seq_first_stmt (finally);
   if (gimple_code (x) == GIMPLE_EH_ELSE)
     {
       gcc_assert (gimple_seq_singleton_p (finally));
@@ -1000,7 +1000,7 @@ honor_protect_cleanup_actions (struct leh_state *outer_state,
   gimple_stmt_iterator gsi;
   bool finally_may_fallthru;
   gimple_seq finally;
-  gimple x, eh_else;
+  gimple *x, *eh_else;
 
   /* First check for nothing to do.  */
   if (lang_hooks.eh_protect_cleanup_actions == NULL)
@@ -1068,7 +1068,7 @@ lower_try_finally_nofallthru (struct leh_state *state,
 			      struct leh_tf_state *tf)
 {
   tree lab;
-  gimple x, eh_else;
+  gimple *x, *eh_else;
   gimple_seq finally;
   struct goto_queue_node *q, *qe;
 
@@ -1132,7 +1132,7 @@ static void
 lower_try_finally_onedest (struct leh_state *state, struct leh_tf_state *tf)
 {
   struct goto_queue_node *q, *qe;
-  gimple x;
+  gimple *x;
   gimple_seq finally;
   gimple_stmt_iterator gsi;
   tree finally_label;
@@ -1157,7 +1157,7 @@ lower_try_finally_onedest (struct leh_state *state, struct leh_tf_state *tf)
 
   for (gsi = gsi_start (finally); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       if (LOCATION_LOCUS (gimple_location (stmt)) == UNKNOWN_LOCATION)
 	{
 	  tree block = gimple_block (stmt);
@@ -1234,7 +1234,7 @@ lower_try_finally_copy (struct leh_state *state, struct leh_tf_state *tf)
   gimple_seq finally;
   gimple_seq new_stmt;
   gimple_seq seq;
-  gimple x, eh_else;
+  gimple *x, *eh_else;
   tree tmp;
   location_t tf_loc = gimple_location (tf->try_finally_expr);
 
@@ -1367,9 +1367,9 @@ lower_try_finally_switch (struct leh_state *state, struct leh_tf_state *tf)
   tree last_case;
   vec<tree> case_label_vec;
   gimple_seq switch_body = NULL;
-  gimple x, eh_else;
+  gimple *x, *eh_else;
   tree tmp;
-  gimple switch_stmt;
+  gimple *switch_stmt;
   gimple_seq finally;
   struct pointer_map_t *cont_map = NULL;
   /* The location of the TRY_FINALLY stmt.  */
@@ -1525,7 +1525,7 @@ lower_try_finally_switch (struct leh_state *state, struct leh_tf_state *tf)
     }
   for (j = last_case_index; j < last_case_index + nlabels; j++)
     {
-      gimple cont_stmt;
+      gimple *cont_stmt;
       void **slot;
 
       last_case = case_label_vec[j];
@@ -1535,7 +1535,7 @@ lower_try_finally_switch (struct leh_state *state, struct leh_tf_state *tf)
 
       slot = pointer_map_contains (cont_map, last_case);
       gcc_assert (slot);
-      cont_stmt = *(gimple *) slot;
+      cont_stmt = *(gimple **) slot;
 
       x = gimple_build_label (CASE_LABEL (last_case));
       gimple_seq_add_stmt (&switch_body, x);
@@ -1584,7 +1584,7 @@ static bool
 decide_copy_try_finally (int ndests, bool may_throw, gimple_seq finally)
 {
   int f_estimate, sw_estimate;
-  gimple eh_else;
+  gimple *eh_else;
 
   /* If there's an EH_ELSE involved, the exception path is separate
      and really doesn't come into play for this computation.  */
@@ -1604,7 +1604,7 @@ decide_copy_try_finally (int ndests, bool may_throw, gimple_seq finally)
 
       for (gsi = gsi_start (finally); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  if (!is_gimple_debug (stmt) && !gimple_clobber_p (stmt))
 	    return false;
 	}
@@ -1650,7 +1650,7 @@ cleanup_is_dead_in (eh_region reg)
    arrange for the FINALLY block to be executed on all exits.  */
 
 static gimple_seq
-lower_try_finally (struct leh_state *state, gimple tp)
+lower_try_finally (struct leh_state *state, gimple *tp)
 {
   struct leh_tf_state this_tf;
   struct leh_state this_state;
@@ -1726,7 +1726,7 @@ lower_try_finally (struct leh_state *state, gimple tp)
   if (this_tf.fallthru_label)
     {
       /* This must be reached only if ndests == 0. */
-      gimple x = gimple_build_label (this_tf.fallthru_label);
+      gimple *x = gimple_build_label (this_tf.fallthru_label);
       gimple_seq_add_stmt (&this_tf.top_p_seq, x);
     }
 
@@ -1757,14 +1757,14 @@ lower_try_finally (struct leh_state *state, gimple tp)
    exception region trees that records all the magic.  */
 
 static gimple_seq
-lower_catch (struct leh_state *state, gimple tp)
+lower_catch (struct leh_state *state, gimple *tp)
 {
   eh_region try_region = NULL;
   struct leh_state this_state = *state;
   gimple_stmt_iterator gsi;
   tree out_label;
   gimple_seq new_seq, cleanup;
-  gimple x;
+  gimple *x;
   location_t try_catch_loc = gimple_location (tp);
 
   if (flag_exceptions)
@@ -1792,7 +1792,7 @@ lower_catch (struct leh_state *state, gimple tp)
        gsi_next (&gsi))
     {
       eh_catch c;
-      gimple gcatch;
+      gimple *gcatch;
       gimple_seq handler;
 
       gcatch = gsi_stmt (gsi);
@@ -1829,11 +1829,11 @@ lower_catch (struct leh_state *state, gimple tp)
    region trees that record all the magic.  */
 
 static gimple_seq
-lower_eh_filter (struct leh_state *state, gimple tp)
+lower_eh_filter (struct leh_state *state, gimple *tp)
 {
   struct leh_state this_state = *state;
   eh_region this_region = NULL;
-  gimple inner, x;
+  gimple *inner, *x;
   gimple_seq new_seq;
 
   inner = gimple_seq_first_stmt (gimple_try_cleanup (tp));
@@ -1874,13 +1874,13 @@ lower_eh_filter (struct leh_state *state, gimple tp)
    plus the exception region trees that record all the magic.  */
 
 static gimple_seq
-lower_eh_must_not_throw (struct leh_state *state, gimple tp)
+lower_eh_must_not_throw (struct leh_state *state, gimple *tp)
 {
   struct leh_state this_state = *state;
 
   if (flag_exceptions)
     {
-      gimple inner = gimple_seq_first_stmt (gimple_try_cleanup (tp));
+      gimple *inner = gimple_seq_first_stmt (gimple_try_cleanup (tp));
       eh_region this_region;
 
       this_region = gen_eh_region_must_not_throw (state->cur_region);
@@ -1906,7 +1906,7 @@ lower_eh_must_not_throw (struct leh_state *state, gimple tp)
    except that we only execute the cleanup block for exception edges.  */
 
 static gimple_seq
-lower_cleanup (struct leh_state *state, gimple tp)
+lower_cleanup (struct leh_state *state, gimple *tp)
 {
   struct leh_state this_state = *state;
   eh_region this_region = NULL;
@@ -1952,7 +1952,7 @@ lower_cleanup (struct leh_state *state, gimple tp)
       result = gimple_try_eval (tp);
       if (fake_tf.fallthru_label)
 	{
-	  gimple x = gimple_build_label (fake_tf.fallthru_label);
+	  gimple *x = gimple_build_label (fake_tf.fallthru_label);
 	  gimple_seq_add_stmt (&result, x);
 	}
     }
@@ -1966,8 +1966,8 @@ static void
 lower_eh_constructs_2 (struct leh_state *state, gimple_stmt_iterator *gsi)
 {
   gimple_seq replace;
-  gimple x;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *x;
+  gimple *stmt = gsi_stmt (*gsi);
 
   switch (gimple_code (stmt))
     {
@@ -2033,7 +2033,7 @@ lower_eh_constructs_2 (struct leh_state *state, gimple_stmt_iterator *gsi)
 	{
 	  tree lhs = gimple_get_lhs (stmt);
 	  tree tmp = create_tmp_var (TREE_TYPE (lhs), NULL);
-	  gimple s = gimple_build_assign (lhs, tmp);
+	  gimple *s = gimple_build_assign (lhs, tmp);
 	  gimple_set_location (s, gimple_location (stmt));
 	  gimple_set_block (s, gimple_block (stmt));
 	  gimple_set_lhs (stmt, tmp);
@@ -2206,7 +2206,7 @@ make_pass_lower_eh (gcc::context *ctxt)
    no fallthru edge; false if there is.  */
 
 bool
-make_eh_dispatch_edges (gimple stmt)
+make_eh_dispatch_edges (gimple *stmt)
 {
   eh_region r;
   eh_catch c;
@@ -2245,7 +2245,7 @@ make_eh_dispatch_edges (gimple stmt)
    if there is such a landing pad within the current function.  */
 
 void
-make_eh_edges (gimple stmt)
+make_eh_edges (gimple *stmt)
 {
   basic_block src, dst;
   eh_landing_pad lp;
@@ -2277,7 +2277,7 @@ redirect_eh_edge_1 (edge edge_in, basic_block new_bb, bool change_region)
 {
   eh_landing_pad old_lp, new_lp;
   basic_block old_bb;
-  gimple throw_stmt;
+  gimple *throw_stmt;
   int old_lp_nr, new_lp_nr;
   tree old_label, new_label;
   edge_iterator ei;
@@ -2364,7 +2364,7 @@ redirect_eh_edge (edge edge_in, basic_block new_bb)
    The actual edge update will happen in the caller.  */
 
 void
-redirect_eh_dispatch_edge (gimple stmt, edge e, basic_block new_bb)
+redirect_eh_dispatch_edge (gimple *stmt, edge e, basic_block new_bb)
 {
   tree new_lab = gimple_block_label (new_bb);
   bool any_changed = false;
@@ -2724,7 +2724,7 @@ tree_could_trap_p (tree expr)
    an assignment or a conditional) may throw.  */
 
 static bool
-stmt_could_throw_1_p (gimple stmt)
+stmt_could_throw_1_p (gimple *stmt)
 {
   enum tree_code code = gimple_expr_code (stmt);
   bool honor_nans = false;
@@ -2777,7 +2777,7 @@ stmt_could_throw_1_p (gimple stmt)
 /* Return true if statement STMT could throw an exception.  */
 
 bool
-stmt_could_throw_p (gimple stmt)
+stmt_could_throw_p (gimple *stmt)
 {
   if (!flag_exceptions)
     return false;
@@ -2837,7 +2837,7 @@ tree_could_throw_p (tree t)
    the current function (CFUN).  */
 
 bool
-stmt_can_throw_external (gimple stmt)
+stmt_can_throw_external (gimple *stmt)
 {
   int lp_nr;
 
@@ -2852,7 +2852,7 @@ stmt_can_throw_external (gimple stmt)
    the current function (CFUN).  */
 
 bool
-stmt_can_throw_internal (gimple stmt)
+stmt_can_throw_internal (gimple *stmt)
 {
   int lp_nr;
 
@@ -2868,7 +2868,7 @@ stmt_can_throw_internal (gimple stmt)
    any change was made.  */
 
 bool
-maybe_clean_eh_stmt_fn (struct function *ifun, gimple stmt)
+maybe_clean_eh_stmt_fn (struct function *ifun, gimple *stmt)
 {
   if (stmt_could_throw_p (stmt))
     return false;
@@ -2878,7 +2878,7 @@ maybe_clean_eh_stmt_fn (struct function *ifun, gimple stmt)
 /* Likewise, but always use the current function.  */
 
 bool
-maybe_clean_eh_stmt (gimple stmt)
+maybe_clean_eh_stmt (gimple *stmt)
 {
   return maybe_clean_eh_stmt_fn (cfun, stmt);
 }
@@ -2889,7 +2889,7 @@ maybe_clean_eh_stmt (gimple stmt)
    done that my require an EH edge purge.  */
 
 bool
-maybe_clean_or_replace_eh_stmt (gimple old_stmt, gimple new_stmt)
+maybe_clean_or_replace_eh_stmt (gimple *old_stmt, gimple *new_stmt)
 {
   int lp_nr = lookup_stmt_eh_lp (old_stmt);
 
@@ -2918,8 +2918,8 @@ maybe_clean_or_replace_eh_stmt (gimple old_stmt, gimple new_stmt)
    operand is the return value of duplicate_eh_regions.  */
 
 bool
-maybe_duplicate_eh_stmt_fn (struct function *new_fun, gimple new_stmt,
-			    struct function *old_fun, gimple old_stmt,
+maybe_duplicate_eh_stmt_fn (struct function *new_fun, gimple *new_stmt,
+			    struct function *old_fun, gimple *old_stmt,
 			    struct pointer_map_t *map, int default_lp_nr)
 {
   int old_lp_nr, new_lp_nr;
@@ -2962,7 +2962,7 @@ maybe_duplicate_eh_stmt_fn (struct function *new_fun, gimple new_stmt,
    and thus no remapping is required.  */
 
 bool
-maybe_duplicate_eh_stmt (gimple new_stmt, gimple old_stmt)
+maybe_duplicate_eh_stmt (gimple *new_stmt, gimple *old_stmt)
 {
   int lp_nr;
 
@@ -2987,7 +2987,7 @@ static bool
 same_handler_p (gimple_seq oneh, gimple_seq twoh)
 {
   gimple_stmt_iterator gsi;
-  gimple ones, twos;
+  gimple *ones, *twos;
   unsigned int ai;
 
   gsi = gsi_start (oneh);
@@ -3029,9 +3029,9 @@ same_handler_p (gimple_seq oneh, gimple_seq twoh)
    temporary used in the initializer for A.  */
 
 static void
-optimize_double_finally (gimple one, gimple two)
+optimize_double_finally (gimple *one, gimple *two)
 {
-  gimple oneh;
+  gimple *oneh;
   gimple_stmt_iterator gsi;
   gimple_seq cleanup;
 
@@ -3064,7 +3064,7 @@ static void
 refactor_eh_r (gimple_seq seq)
 {
   gimple_stmt_iterator gsi;
-  gimple one, two;
+  gimple *one, *two;
 
   one = NULL;
   two = NULL;
@@ -3154,12 +3154,12 @@ make_pass_refactor_eh (gcc::context *ctxt)
 /* At the end of gimple optimization, we can lower RESX.  */
 
 static bool
-lower_resx (basic_block bb, gimple stmt, struct pointer_map_t *mnt_map)
+lower_resx (basic_block bb, gimple *stmt, struct pointer_map_t *mnt_map)
 {
   int lp_nr;
   eh_region src_r, dst_r;
   gimple_stmt_iterator gsi;
-  gimple x;
+  gimple *x;
   tree fn, src_nr;
   bool ret = false;
 
@@ -3344,7 +3344,7 @@ pass_lower_resx::execute (function *fun)
 
   FOR_EACH_BB_FN (bb, fun)
     {
-      gimple last = last_stmt (bb);
+      gimple *last = last_stmt (bb);
       if (last && is_gimple_resx (last))
 	{
 	  dominance_invalidated |= lower_resx (bb, last, mnt_map);
@@ -3389,7 +3389,7 @@ optimize_clobbers (basic_block bb)
      call, and has an incoming EH edge.  */
   for (gsi_prev (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       if (is_gimple_debug (stmt))
 	continue;
       if (gimple_clobber_p (stmt))
@@ -3417,7 +3417,7 @@ optimize_clobbers (basic_block bb)
   gsi = gsi_last_bb (bb);
   for (gsi_prev (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       if (!gimple_clobber_p (stmt))
 	continue;
       unlink_stmt_vdef (stmt);
@@ -3456,7 +3456,7 @@ sink_clobbers (basic_block bb)
   gsi = gsi_last_bb (bb);
   for (gsi_prev (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       if (is_gimple_debug (stmt))
 	continue;
       if (gimple_code (stmt) == GIMPLE_LABEL)
@@ -3473,7 +3473,7 @@ sink_clobbers (basic_block bb)
 
   /* See if there is a virtual PHI node to take an updated virtual
      operand from.  */
-  gimple vphi = NULL;
+  gimple *vphi = NULL;
   tree vuse = NULL_TREE;
   for (gsi = gsi_start_phis (succbb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
@@ -3490,7 +3490,7 @@ sink_clobbers (basic_block bb)
   gsi = gsi_last_bb (bb);
   for (gsi_prev (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       tree lhs;
       if (is_gimple_debug (stmt))
 	continue;
@@ -3521,7 +3521,7 @@ sink_clobbers (basic_block bb)
       /* But adjust virtual operands if we sunk across a PHI node.  */
       if (vuse)
 	{
-	  gimple use_stmt;
+	  gimple *use_stmt;
 	  imm_use_iterator iter;
 	  use_operand_p use_p;
 	  FOR_EACH_IMM_USE_STMT (use_stmt, iter, vuse)
@@ -3558,13 +3558,13 @@ sink_clobbers (basic_block bb)
    we have found some duplicate labels and removed some edges.  */
 
 static bool
-lower_eh_dispatch (basic_block src, gimple stmt)
+lower_eh_dispatch (basic_block src, gimple *stmt)
 {
   gimple_stmt_iterator gsi;
   int region_nr;
   eh_region r;
   tree filter, fn;
-  gimple x;
+  gimple *x;
   bool redirected = false;
 
   region_nr = gimple_eh_dispatch_region (stmt);
@@ -3743,7 +3743,7 @@ pass_lower_eh_dispatch::execute (function *fun)
 
   FOR_EACH_BB_FN (bb, fun)
     {
-      gimple last = last_stmt (bb);
+      gimple *last = last_stmt (bb);
       if (last == NULL)
 	continue;
       if (gimple_code (last) == GIMPLE_EH_DISPATCH)
@@ -3811,7 +3811,7 @@ mark_reachable_handlers (sbitmap *r_reachablep, sbitmap *lp_reachablep)
 
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 
 	  if (mark_landing_pads)
 	    {
@@ -4010,7 +4010,7 @@ unsplit_eh (eh_landing_pad lp)
      for a different region.  */
   for (gsi = gsi_start_bb (e_out->dest); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       tree lab;
       int lp_nr;
 
@@ -4035,7 +4035,7 @@ unsplit_eh (eh_landing_pad lp)
     {
       for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); )
 	{
-	  gimple use_stmt, phi = gsi_stmt (gsi);
+	  gimple *use_stmt, *phi = gsi_stmt (gsi);
 	  tree lhs = gimple_phi_result (phi);
 	  tree rhs = gimple_phi_arg_def (phi, 0);
 	  use_operand_p use_p;
@@ -4129,7 +4129,7 @@ cleanup_empty_eh_merge_phis (basic_block new_bb, basic_block old_bb,
      for the edges we're going to move.  */
   for (ngsi = gsi_start_phis (new_bb); !gsi_end_p (ngsi); gsi_next (&ngsi))
     {
-      gimple ophi, nphi = gsi_stmt (ngsi);
+      gimple *ophi, *nphi = gsi_stmt (ngsi);
       tree nresult, nop;
 
       nresult = gimple_phi_result (nphi);
@@ -4193,7 +4193,7 @@ cleanup_empty_eh_merge_phis (basic_block new_bb, basic_block old_bb,
      we don't know what values from the other edges into NEW_BB to use.  */
   for (ogsi = gsi_start_phis (old_bb); !gsi_end_p (ogsi); gsi_next (&ogsi))
     {
-      gimple ophi = gsi_stmt (ogsi);
+      gimple *ophi = gsi_stmt (ogsi);
       tree oresult = gimple_phi_result (ophi);
       if (!bitmap_bit_p (ophi_handled, SSA_NAME_VERSION (oresult)))
 	goto fail;
@@ -4283,7 +4283,7 @@ cleanup_empty_eh_unsplit (basic_block bb, edge e_out, eh_landing_pad lp)
   lab = NULL;
   for (gsi = gsi_start_bb (e_out->dest); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       int lp_nr;
 
       if (gimple_code (stmt) != GIMPLE_LABEL)
@@ -4354,7 +4354,7 @@ cleanup_empty_eh (eh_landing_pad lp)
 {
   basic_block bb = label_to_block (lp->post_landing_pad);
   gimple_stmt_iterator gsi;
-  gimple resx;
+  gimple *resx;
   eh_region new_region;
   edge_iterator ei;
   edge e, e_out;
@@ -4437,7 +4437,7 @@ cleanup_empty_eh (eh_landing_pad lp)
       for (ei = ei_start (bb->preds); (e = ei_safe_edge (ei)); )
 	if (e->flags & EDGE_EH)
 	  {
-	    gimple stmt = last_stmt (e->src);
+	    gimple *stmt = last_stmt (e->src);
 	    remove_stmt_from_eh_lp (stmt);
 	    remove_edge (e);
 	  }
@@ -4453,7 +4453,7 @@ cleanup_empty_eh (eh_landing_pad lp)
       for (ei = ei_start (bb->preds); (e = ei_safe_edge (ei)); )
 	if (e->flags & EDGE_EH)
 	  {
-	    gimple stmt = last_stmt (e->src);
+	    gimple *stmt = last_stmt (e->src);
 	    remove_stmt_from_eh_lp (stmt);
 	    add_stmt_to_eh_lp (stmt, new_lp_nr);
 	    remove_edge (e);
@@ -4623,7 +4623,7 @@ make_pass_cleanup_eh (gcc::context *ctxt)
    edge that make_eh_edges would create.  */
 
 DEBUG_FUNCTION bool
-verify_eh_edges (gimple stmt)
+verify_eh_edges (gimple *stmt)
 {
   basic_block bb = gimple_bb (stmt);
   eh_landing_pad lp = NULL;
@@ -4684,7 +4684,7 @@ verify_eh_edges (gimple stmt)
 /* Similarly, but handle GIMPLE_EH_DISPATCH specifically.  */
 
 DEBUG_FUNCTION bool
-verify_eh_dispatch_edge (gimple stmt)
+verify_eh_dispatch_edge (gimple *stmt)
 {
   eh_region r;
   eh_catch c;
diff --git a/gcc/tree-eh.h b/gcc/tree-eh.h
index cd9b40d..3ce76d7 100644
--- a/gcc/tree-eh.h
+++ b/gcc/tree-eh.h
@@ -21,32 +21,32 @@ along with GCC; see the file COPYING3.  If not see
 #define GCC_TREE_EH_H
 
 extern void using_eh_for_cleanups (void);
-extern void add_stmt_to_eh_lp (gimple, int);
-extern bool remove_stmt_from_eh_lp_fn (struct function *, gimple);
-extern bool remove_stmt_from_eh_lp (gimple);
-extern int lookup_stmt_eh_lp_fn (struct function *, gimple);
-extern int lookup_stmt_eh_lp (gimple);
-extern bool make_eh_dispatch_edges (gimple);
-extern void make_eh_edges (gimple);
+extern void add_stmt_to_eh_lp (gimple *, int);
+extern bool remove_stmt_from_eh_lp_fn (struct function *, gimple *);
+extern bool remove_stmt_from_eh_lp (gimple *);
+extern int lookup_stmt_eh_lp_fn (struct function *, gimple *);
+extern int lookup_stmt_eh_lp (gimple *);
+extern bool make_eh_dispatch_edges (gimple *);
+extern void make_eh_edges (gimple *);
 extern edge redirect_eh_edge (edge, basic_block);
-extern void redirect_eh_dispatch_edge (gimple, edge, basic_block);
+extern void redirect_eh_dispatch_edge (gimple *, edge, basic_block);
 extern bool operation_could_trap_helper_p (enum tree_code, bool, bool, bool,
 					   bool, tree, bool *);
 extern bool operation_could_trap_p (enum tree_code, bool, bool, tree);
 extern bool tree_could_trap_p (tree);
-extern bool stmt_could_throw_p (gimple);
+extern bool stmt_could_throw_p (gimple *);
 extern bool tree_could_throw_p (tree);
-extern bool stmt_can_throw_external (gimple);
-extern bool stmt_can_throw_internal (gimple);
-extern bool maybe_clean_eh_stmt_fn (struct function *, gimple);
-extern bool maybe_clean_eh_stmt (gimple);
-extern bool maybe_clean_or_replace_eh_stmt (gimple, gimple);
-extern bool maybe_duplicate_eh_stmt_fn (struct function *, gimple,
-					struct function *, gimple,
+extern bool stmt_can_throw_external (gimple *);
+extern bool stmt_can_throw_internal (gimple *);
+extern bool maybe_clean_eh_stmt_fn (struct function *, gimple *);
+extern bool maybe_clean_eh_stmt (gimple *);
+extern bool maybe_clean_or_replace_eh_stmt (gimple *, gimple *);
+extern bool maybe_duplicate_eh_stmt_fn (struct function *, gimple *,
+					struct function *, gimple *,
 					struct pointer_map_t *, int);
-extern bool maybe_duplicate_eh_stmt (gimple, gimple);
+extern bool maybe_duplicate_eh_stmt (gimple *, gimple *);
 extern void maybe_remove_unreachable_handlers (void);
-extern bool verify_eh_edges (gimple);
-extern bool verify_eh_dispatch_edge (gimple);
+extern bool verify_eh_edges (gimple *);
+extern bool verify_eh_dispatch_edge (gimple *);
 
 #endif /* GCC_TREE_EH_H */
diff --git a/gcc/tree-emutls.c b/gcc/tree-emutls.c
index 4d7598d..c16360c 100644
--- a/gcc/tree-emutls.c
+++ b/gcc/tree-emutls.c
@@ -437,7 +437,7 @@ gen_emutls_addr (tree decl, struct lower_emutls_data *d)
     {
       varpool_node *cvar;
       tree cdecl;
-      gimple x;
+      gimple *x;
 
       cvar = control_vars[index];
       cdecl = cvar->decl;
@@ -510,7 +510,7 @@ lower_emutls_1 (tree *ptr, int *walk_subtrees, void *cb_data)
 	     new assignment statement, and substitute yet another SSA_NAME.  */
 	  if (wi->changed)
 	    {
-	      gimple x;
+	      gimple *x;
 
 	      addr = create_tmp_var (TREE_TYPE (t), NULL);
 	      x = gimple_build_assign (addr, t);
@@ -570,7 +570,7 @@ lower_emutls_1 (tree *ptr, int *walk_subtrees, void *cb_data)
 /* Lower all of the operands of STMT.  */
 
 static void
-lower_emutls_stmt (gimple stmt, struct lower_emutls_data *d)
+lower_emutls_stmt (gimple *stmt, struct lower_emutls_data *d)
 {
   struct walk_stmt_info wi;
 
@@ -588,7 +588,7 @@ lower_emutls_stmt (gimple stmt, struct lower_emutls_data *d)
 /* Lower the I'th operand of PHI.  */
 
 static void
-lower_emutls_phi_arg (gimple phi, unsigned int i, struct lower_emutls_data *d)
+lower_emutls_phi_arg (gimple *phi, unsigned int i, struct lower_emutls_data *d)
 {
   struct walk_stmt_info wi;
   struct phi_arg_d *pd = gimple_phi_arg (phi, i);
diff --git a/gcc/tree-if-conv.c b/gcc/tree-if-conv.c
index 69f1e1f..2f7de22 100644
--- a/gcc/tree-if-conv.c
+++ b/gcc/tree-if-conv.c
@@ -251,7 +251,7 @@ static tree
 ifc_temp_var (tree type, tree expr, gimple_stmt_iterator *gsi)
 {
   tree new_name = make_temp_ssa_name (type, NULL, "_ifc_");
-  gimple stmt = gimple_build_assign (new_name, expr);
+  gimple *stmt = gimple_build_assign (new_name, expr);
   gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
   return new_name;
 }
@@ -281,7 +281,7 @@ is_predicated (basic_block bb)
 static enum tree_code
 parse_predicate (tree cond, tree *op0, tree *op1)
 {
-  gimple s;
+  gimple *s;
 
   if (TREE_CODE (cond) == SSA_NAME
       && is_gimple_assign (s = SSA_NAME_DEF_STMT (cond)))
@@ -485,7 +485,7 @@ bb_with_exit_edge_p (struct loop *loop, basic_block bb)
    - there is a virtual PHI in a BB other than the loop->header.  */
 
 static bool
-if_convertible_phi_p (struct loop *loop, basic_block bb, gimple phi,
+if_convertible_phi_p (struct loop *loop, basic_block bb, gimple *phi,
 		      bool any_mask_load_store)
 {
   if (dump_file && (dump_flags & TDF_DETAILS))
@@ -556,7 +556,7 @@ struct ifc_dr {
    (read or written) on every iteration of the if-converted loop.  */
 
 static bool
-memrefs_read_or_written_unconditionally (gimple stmt,
+memrefs_read_or_written_unconditionally (gimple *stmt,
 					 vec<data_reference_p> drs)
 {
   int i, j;
@@ -628,7 +628,7 @@ memrefs_read_or_written_unconditionally (gimple stmt,
    every iteration of the if-converted loop.  */
 
 static bool
-write_memrefs_written_at_least_once (gimple stmt,
+write_memrefs_written_at_least_once (gimple *stmt,
 				     vec<data_reference_p> drs)
 {
   int i, j;
@@ -696,7 +696,7 @@ write_memrefs_written_at_least_once (gimple stmt,
    iteration unconditionally.  */
 
 static bool
-ifcvt_memrefs_wont_trap (gimple stmt, vec<data_reference_p> refs)
+ifcvt_memrefs_wont_trap (gimple *stmt, vec<data_reference_p> refs)
 {
   return write_memrefs_written_at_least_once (stmt, refs)
     && memrefs_read_or_written_unconditionally (stmt, refs);
@@ -707,7 +707,7 @@ ifcvt_memrefs_wont_trap (gimple stmt, vec<data_reference_p> refs)
    not trap in the innermost loop containing STMT.  */
 
 static bool
-ifcvt_could_trap_p (gimple stmt, vec<data_reference_p> refs)
+ifcvt_could_trap_p (gimple *stmt, vec<data_reference_p> refs)
 {
   if (gimple_vuse (stmt)
       && !gimple_could_trap_p_1 (stmt, false, false)
@@ -721,7 +721,7 @@ ifcvt_could_trap_p (gimple stmt, vec<data_reference_p> refs)
    (conditional load or store based on a mask computed from bb predicate).  */
 
 static bool
-ifcvt_can_use_mask_load_store (gimple stmt)
+ifcvt_can_use_mask_load_store (gimple *stmt)
 {
   tree lhs, ref;
   enum machine_mode mode;
@@ -775,7 +775,7 @@ ifcvt_can_use_mask_load_store (gimple stmt)
    - LHS is not var decl.  */
 
 static bool
-if_convertible_gimple_assign_stmt_p (gimple stmt,
+if_convertible_gimple_assign_stmt_p (gimple *stmt,
 				     vec<data_reference_p> refs,
 				     bool *any_mask_load_store)
 {
@@ -868,7 +868,7 @@ if_convertible_gimple_assign_stmt_p (gimple stmt,
    - it is a GIMPLE_LABEL or a GIMPLE_COND.  */
 
 static bool
-if_convertible_stmt_p (gimple stmt, vec<data_reference_p> refs,
+if_convertible_stmt_p (gimple *stmt, vec<data_reference_p> refs,
 		       bool *any_mask_load_store)
 {
   switch (gimple_code (stmt))
@@ -1094,7 +1094,7 @@ predicate_bbs (loop_p loop)
     {
       basic_block bb = ifc_bbs[i];
       tree cond;
-      gimple stmt;
+      gimple *stmt;
 
       /* The loop latch is always executed and has no extra conditions
 	 to be processed: skip it.  */
@@ -1399,13 +1399,13 @@ find_phi_replacement_condition (basic_block bb, tree *cond,
    REDUC, OP0 and OP1 contain reduction stmt and its operands.  */
 
 static bool
-is_cond_scalar_reduction (gimple phi, gimple *reduc,
+is_cond_scalar_reduction (gimple *phi, gimple **reduc,
 			  tree *op0, tree *op1)
 {
   tree lhs, r_op1, r_op2;
   tree arg_0, arg_1;
-  gimple stmt;
-  gimple header_phi = NULL;
+  gimple *stmt;
+  gimple *header_phi = NULL;
   enum tree_code reduction_op;
   struct loop *loop = gimple_bb (phi)->loop_father;
   edge latch_e = loop_latch_edge (loop);
@@ -1486,11 +1486,11 @@ is_cond_scalar_reduction (gimple phi, gimple *reduc,
   Returns rhs of resulting PHI assignment.  */
 
 static tree
-convert_scalar_cond_reduction (gimple reduc, gimple_stmt_iterator *gsi,
+convert_scalar_cond_reduction (gimple *reduc, gimple_stmt_iterator *gsi,
 			       tree cond, tree op0, tree op1, bool swap)
 {
   gimple_stmt_iterator stmt_it;
-  gimple new_assign;
+  gimple *new_assign;
   tree rhs;
   tree rhs1 = gimple_assign_rhs1 (reduc);
   tree tmp = make_temp_ssa_name (TREE_TYPE (rhs1), NULL, "_ifc_");
@@ -1538,11 +1538,11 @@ convert_scalar_cond_reduction (gimple reduc, gimple_stmt_iterator *gsi,
    TRUE_BB is selected.  */
 
 static void
-predicate_scalar_phi (gimple phi, tree cond,
+predicate_scalar_phi (gimple *phi, tree cond,
 		      basic_block true_bb,
 		      gimple_stmt_iterator *gsi)
 {
-  gimple new_stmt;
+  gimple *new_stmt;
   basic_block bb;
   tree rhs, res, arg, scev;
 
@@ -1567,7 +1567,7 @@ predicate_scalar_phi (gimple phi, tree cond,
     {
       tree arg_0, arg_1;
       tree op0, op1;
-      gimple reduc;
+      gimple *reduc;
 
       /* Use condition that is not TRUTH_NOT_EXPR in conditional modify expr.  */
       if (EDGE_PRED (bb, 1)->src == true_bb)
@@ -1613,7 +1613,7 @@ predicate_all_scalar_phis (struct loop *loop)
 
   for (i = 1; i < orig_loop_num_nodes; i++)
     {
-      gimple phi;
+      gimple *phi;
       tree cond = NULL_TREE;
       gimple_stmt_iterator gsi, phi_gsi;
       basic_block true_bb = NULL;
@@ -1815,7 +1815,7 @@ predicate_mem_writes (loop_p loop)
       basic_block bb = ifc_bbs[i];
       tree cond = bb_predicate (bb);
       bool swap;
-      gimple stmt;
+      gimple *stmt;
 
       if (is_true_predicate (cond))
 	continue;
@@ -1835,7 +1835,7 @@ predicate_mem_writes (loop_p loop)
 	    tree lhs = gimple_assign_lhs (stmt);
 	    tree rhs = gimple_assign_rhs1 (stmt);
 	    tree ref, addr, ptr, masktype, mask_op0, mask_op1, mask;
-	    gimple new_stmt;
+	    gimple *new_stmt;
 	    int bitsize = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (lhs)));
 
 	    masktype = build_nonstandard_integer_type (bitsize, 1);
@@ -2055,7 +2055,7 @@ version_loop_for_if_conversion (struct loop *loop)
   basic_block cond_bb;
   tree cond = make_ssa_name (boolean_type_node, NULL);
   struct loop *new_loop;
-  gimple g;
+  gimple *g;
   gimple_stmt_iterator gsi;
 
   g = gimple_build_call_internal (IFN_LOOP_VECTORIZED, 2,
diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index 9207e9f..5b72441 100644
--- a/gcc/tree-inline.c
+++ b/gcc/tree-inline.c
@@ -139,7 +139,7 @@ static void prepend_lexical_block (tree current_block, tree new_block);
 static tree copy_decl_to_var (tree, copy_body_data *);
 static tree copy_result_decl_to_var (tree, copy_body_data *);
 static tree copy_decl_maybe_to_var (tree, copy_body_data *);
-static gimple remap_gimple_stmt (gimple, copy_body_data *);
+static gimple *remap_gimple_stmt (gimple *, copy_body_data *);
 static bool delete_unreachable_blocks_update_callgraph (copy_body_data *id);
 
 /* Insert a tree->tree mapping for ID.  Despite the name suggests
@@ -208,7 +208,7 @@ remap_ssa_name (tree name, copy_body_data *id)
 	  && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (cfun)))
 	{
 	  tree vexpr = make_node (DEBUG_EXPR_DECL);
-	  gimple def_temp;
+	  gimple *def_temp;
 	  gimple_stmt_iterator gsi;
 	  tree val = SSA_NAME_VAR (name);
 
@@ -311,7 +311,7 @@ remap_ssa_name (tree name, copy_body_data *id)
 		  || EDGE_COUNT (id->entry_bb->preds) != 1))
 	    {
 	      gimple_stmt_iterator gsi = gsi_last_bb (id->entry_bb);
-	      gimple init_stmt;
+	      gimple *init_stmt;
 	      tree zero = build_zero_cst (TREE_TYPE (new_tree));
 
 	      init_stmt = gimple_build_assign (new_tree, zero);
@@ -732,7 +732,7 @@ remap_gimple_seq (gimple_seq body, copy_body_data *id)
 
   for (si = gsi_start (body); !gsi_end_p (si); gsi_next (&si))
     {
-      gimple new_stmt = remap_gimple_stmt (gsi_stmt (si), id);
+      gimple *new_stmt = remap_gimple_stmt (gsi_stmt (si), id);
       gimple_seq_add_stmt (&new_body, new_stmt);
     }
 
@@ -743,10 +743,10 @@ remap_gimple_seq (gimple_seq body, copy_body_data *id)
 /* Copy a GIMPLE_BIND statement STMT, remapping all the symbols in its
    block using the mapping information in ID.  */
 
-static gimple
-copy_gimple_bind (gimple stmt, copy_body_data *id)
+static gimple *
+copy_gimple_bind (gimple *stmt, copy_body_data *id)
 {
-  gimple new_bind;
+  gimple *new_bind;
   tree new_block, new_vars;
   gimple_seq body, new_body;
 
@@ -1239,10 +1239,10 @@ remap_eh_region_tree_nr (tree old_t_nr, copy_body_data *id)
 /* Helper for copy_bb.  Remap statement STMT using the inlining
    information in ID.  Return the new statement copy.  */
 
-static gimple
-remap_gimple_stmt (gimple stmt, copy_body_data *id)
+static gimple *
+remap_gimple_stmt (gimple *stmt, copy_body_data *id)
 {
-  gimple copy = NULL;
+  gimple *copy = NULL;
   struct walk_stmt_info wi;
   bool skip_first = false;
 
@@ -1455,7 +1455,7 @@ remap_gimple_stmt (gimple stmt, copy_body_data *id)
 	  if (TREE_CODE (lhs) == MEM_REF
 	      && TREE_CODE (TREE_OPERAND (lhs, 0)) == SSA_NAME)
 	    {
-	      gimple def_stmt = SSA_NAME_DEF_STMT (TREE_OPERAND (lhs, 0));
+	      gimple *def_stmt = SSA_NAME_DEF_STMT (TREE_OPERAND (lhs, 0));
 	      if (gimple_bb (def_stmt)
 		  && !bitmap_bit_p (id->blocks_to_copy,
 				    gimple_bb (def_stmt)->index))
@@ -1615,8 +1615,8 @@ copy_bb (copy_body_data *id, basic_block bb, int frequency_scale,
 
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
-      gimple orig_stmt = stmt;
+      gimple *stmt = gsi_stmt (gsi);
+      gimple *orig_stmt = stmt;
 
       id->regimplify = false;
       stmt = remap_gimple_stmt (stmt, id);
@@ -1668,7 +1668,7 @@ copy_bb (copy_body_data *id, basic_block bb, int frequency_scale,
 	      /* __builtin_va_arg_pack () should be replaced by
 		 all arguments corresponding to ... in the caller.  */
 	      tree p;
-	      gimple new_call;
+	      gimple *new_call;
 	      vec<tree> argarray;
 	      size_t nargs = gimple_call_num_args (id->gimple_call);
 	      size_t n;
@@ -1718,7 +1718,7 @@ copy_bb (copy_body_data *id, basic_block bb, int frequency_scale,
 		 the number of anonymous arguments.  */
 	      size_t nargs = gimple_call_num_args (id->gimple_call);
 	      tree count, p;
-	      gimple new_stmt;
+	      gimple *new_stmt;
 
 	      for (p = DECL_ARGUMENTS (id->src_fn); p; p = DECL_CHAIN (p))
 		nargs--;
@@ -1925,7 +1925,7 @@ update_ssa_across_abnormal_edges (basic_block bb, basic_block ret_bb,
     if (!e->dest->aux
 	|| ((basic_block)e->dest->aux)->index == ENTRY_BLOCK)
       {
-	gimple phi;
+	gimple *phi;
 	gimple_stmt_iterator si;
 
 	if (!nonlocal_goto)
@@ -1997,7 +1997,7 @@ copy_edges_for_bb (basic_block bb, gcov_type count_scale, basic_block ret_bb,
 
   for (si = gsi_start_bb (new_bb); !gsi_end_p (si);)
     {
-      gimple copy_stmt;
+      gimple *copy_stmt;
       bool can_throw, nonlocal_goto;
 
       copy_stmt = gsi_stmt (si);
@@ -2091,7 +2091,7 @@ copy_phis_for_bb (basic_block bb, copy_body_data *id)
 {
   basic_block const new_bb = (basic_block) bb->aux;
   edge_iterator ei;
-  gimple phi;
+  gimple *phi;
   gimple_stmt_iterator si;
   edge new_edge;
   bool inserted = false;
@@ -2099,7 +2099,7 @@ copy_phis_for_bb (basic_block bb, copy_body_data *id)
   for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
     {
       tree res, new_res;
-      gimple new_phi;
+      gimple *new_phi;
 
       phi = gsi_stmt (si);
       res = PHI_RESULT (phi);
@@ -2273,7 +2273,7 @@ maybe_move_debug_stmts_to_successors (copy_body_data *id, basic_block new_bb)
       gimple_stmt_iterator dsi = gsi_after_labels (e->dest);
       while (is_gimple_debug (gsi_stmt (ssi)))
 	{
-	  gimple stmt = gsi_stmt (ssi), new_stmt;
+	  gimple *stmt = gsi_stmt (ssi), *new_stmt;
 	  tree var;
 	  tree value;
 
@@ -2604,7 +2604,7 @@ copy_cfg_body (copy_body_data * id, gcov_type count, int frequency_scale,
    this arises, we drop the VALUE expression altogether.  */
 
 static void
-copy_debug_stmt (gimple stmt, copy_body_data *id)
+copy_debug_stmt (gimple *stmt, copy_body_data *id)
 {
   tree t, *n;
   struct walk_stmt_info wi;
@@ -2696,7 +2696,7 @@ static void
 copy_debug_stmts (copy_body_data *id)
 {
   size_t i;
-  gimple stmt;
+  gimple *stmt;
 
   if (!id->debug_stmts.exists ())
     return;
@@ -2761,12 +2761,12 @@ self_inlining_addr_expr (tree value, tree fn)
    lexical block and line number information from base_stmt, if given,
    or from the last stmt of the block otherwise.  */
 
-static gimple
+static gimple *
 insert_init_debug_bind (copy_body_data *id,
 			basic_block bb, tree var, tree value,
-			gimple base_stmt)
+			gimple *base_stmt)
 {
-  gimple note;
+  gimple *note;
   gimple_stmt_iterator gsi;
   tree tracked_var;
 
@@ -2801,7 +2801,7 @@ insert_init_debug_bind (copy_body_data *id,
 }
 
 static void
-insert_init_stmt (copy_body_data *id, basic_block bb, gimple init_stmt)
+insert_init_stmt (copy_body_data *id, basic_block bb, gimple *init_stmt)
 {
   /* If VAR represents a zero-sized variable, it's possible that the
      assignment statement may result in no gimple statements.  */
@@ -2840,11 +2840,11 @@ insert_init_stmt (copy_body_data *id, basic_block bb, gimple init_stmt)
 /* Initialize parameter P with VALUE.  If needed, produce init statement
    at the end of BB.  When BB is NULL, we return init statement to be
    output later.  */
-static gimple
+static gimple *
 setup_one_parameter (copy_body_data *id, tree p, tree value, tree fn,
 		     basic_block bb, tree *vars)
 {
-  gimple init_stmt = NULL;
+  gimple *init_stmt = NULL;
   tree var;
   tree rhs = value;
   tree def = (gimple_in_ssa_p (cfun)
@@ -3002,7 +3002,7 @@ setup_one_parameter (copy_body_data *id, tree p, tree value, tree fn,
    top of the stack in ID from the GIMPLE_CALL STMT.  */
 
 static void
-initialize_inlined_parameters (copy_body_data *id, gimple stmt,
+initialize_inlined_parameters (copy_body_data *id, gimple *stmt,
 			       tree fn, basic_block bb)
 {
   tree parms;
@@ -3339,7 +3339,7 @@ inline_forbidden_p_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
 {
   tree fn = (tree) wip->info;
   tree t;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
 
   switch (gimple_code (stmt))
     {
@@ -3477,7 +3477,7 @@ inline_forbidden_p (tree fndecl)
 
   FOR_EACH_BB_FN (bb, fun)
     {
-      gimple ret;
+      gimple *ret;
       gimple_seq seq = bb_seq (bb);
       ret = walk_gimple_seq (seq, inline_forbidden_p_stmt, NULL, &wi);
       forbidden_p = (ret != NULL);
@@ -3760,7 +3760,7 @@ int estimate_num_insns_seq (gimple_seq stmts, eni_weights *weights)
    WEIGHTS contains weights attributed to various constructs.  */
 
 int
-estimate_num_insns (gimple stmt, eni_weights *weights)
+estimate_num_insns (gimple *stmt, eni_weights *weights)
 {
   unsigned cost, i;
   enum gimple_code code = gimple_code (stmt);
@@ -4081,7 +4081,7 @@ add_local_variables (struct function *callee, struct function *caller,
 /* If STMT is a GIMPLE_CALL, replace it with its inline expansion.  */
 
 static bool
-expand_call_inline (basic_block bb, gimple stmt, copy_body_data *id)
+expand_call_inline (basic_block bb, gimple *stmt, copy_body_data *id)
 {
   tree use_retvar;
   tree fn;
@@ -4383,7 +4383,7 @@ expand_call_inline (basic_block bb, gimple stmt, copy_body_data *id)
      'a = foo (...)', substitute the call with 'a = USE_RETVAR'.  */
   if (use_retvar && gimple_call_lhs (stmt))
     {
-      gimple old_stmt = stmt;
+      gimple *old_stmt = stmt;
       stmt = gimple_build_assign (gimple_call_lhs (stmt), use_retvar);
       gsi_replace (&stmt_gsi, stmt, false);
       maybe_clean_or_replace_eh_stmt (old_stmt, stmt);
@@ -4463,7 +4463,7 @@ gimple_expand_calls_inline (basic_block bb, copy_body_data *id)
 
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
 
       if (is_gimple_call (stmt)
 	  && !gimple_call_internal_p (stmt)
@@ -4491,7 +4491,7 @@ fold_marked_statements (int first, struct pointer_set_t *statements)
 	     gsi_next (&gsi))
 	  if (pointer_set_contains (statements, gsi_stmt (gsi)))
 	    {
-	      gimple old_stmt = gsi_stmt (gsi);
+	      gimple *old_stmt = gsi_stmt (gsi);
 	      tree old_decl = is_gimple_call (old_stmt) ? gimple_call_fndecl (old_stmt) : 0;
 
 	      if (old_decl && DECL_BUILT_IN (old_decl))
@@ -4502,7 +4502,7 @@ fold_marked_statements (int first, struct pointer_set_t *statements)
 		  gsi_prev (&i2);
 		  if (fold_stmt (&gsi))
 		    {
-		      gimple new_stmt;
+		      gimple *new_stmt;
 		      /* If a builtin at the end of a bb folded into nothing,
 			 the following loop won't work.  */
 		      if (gsi_end_p (gsi))
@@ -4548,7 +4548,7 @@ fold_marked_statements (int first, struct pointer_set_t *statements)
 		{
 		  /* Re-read the statement from GSI as fold_stmt() may
 		     have changed it.  */
-		  gimple new_stmt = gsi_stmt (gsi);
+		  gimple *new_stmt = gsi_stmt (gsi);
 		  update_stmt (new_stmt);
 
 		  if (is_gimple_call (old_stmt)
@@ -4762,7 +4762,7 @@ mark_local_labels_stmt (gimple_stmt_iterator *gsip,
 		        struct walk_stmt_info *wi)
 {
   copy_body_data *id = (copy_body_data *) wi->info;
-  gimple stmt = gsi_stmt (*gsip);
+  gimple *stmt = gsi_stmt (*gsip);
 
   if (gimple_code (stmt) == GIMPLE_LABEL)
     {
@@ -4836,7 +4836,7 @@ replace_locals_stmt (gimple_stmt_iterator *gsip,
 		     struct walk_stmt_info *wi)
 {
   copy_body_data *id = (copy_body_data *) wi->info;
-  gimple stmt = gsi_stmt (*gsip);
+  gimple *stmt = gsi_stmt (*gsip);
 
   if (gimple_code (stmt) == GIMPLE_BIND)
     {
@@ -5276,7 +5276,7 @@ tree_function_versioning (tree old_decl, tree new_decl,
   unsigned i;
   struct ipa_replace_map *replace_info;
   basic_block old_entry_block, bb;
-  auto_vec<gimple, 10> init_stmts;
+  auto_vec<gimple *, 10> init_stmts;
   tree vars = NULL_TREE;
 
   gcc_assert (TREE_CODE (old_decl) == FUNCTION_DECL
@@ -5357,7 +5357,7 @@ tree_function_versioning (tree old_decl, tree new_decl,
   if (tree_map)
     for (i = 0; i < tree_map->length (); i++)
       {
-	gimple init;
+	gimple *init;
 	replace_info = (*tree_map)[i];
 	if (replace_info->replace_p)
 	  {
diff --git a/gcc/tree-inline.h b/gcc/tree-inline.h
index 13c5516..595c0fb 100644
--- a/gcc/tree-inline.h
+++ b/gcc/tree-inline.h
@@ -72,7 +72,7 @@ struct copy_body_data
 
   /* GIMPLE_CALL if va arg parameter packs should be expanded or NULL
      is not.  */
-  gimple gimple_call;
+  gimple *gimple_call;
 
   /* Exception landing pad the inlined call lies in.  */
   int eh_lp_nr;
@@ -124,7 +124,7 @@ struct copy_body_data
   bitmap blocks_to_copy;
 
   /* Debug statements that need processing.  */
-  vec<gimple> debug_stmts;
+  vec<gimple *> debug_stmts;
 
   /* A map from local declarations in the inlined function to
      equivalents in the function into which it is being inlined, where
@@ -192,7 +192,7 @@ bool tree_inlinable_function_p (tree);
 tree copy_tree_r (tree *, int *, void *);
 tree copy_decl_no_change (tree decl, copy_body_data *id);
 int estimate_move_cost (tree type);
-int estimate_num_insns (gimple, eni_weights *);
+int estimate_num_insns (gimple *, eni_weights *);
 int estimate_num_insns_fn (tree, eni_weights *);
 int count_insns_seq (gimple_seq, eni_weights *);
 bool tree_versionable_function_p (tree);
diff --git a/gcc/tree-into-ssa.c b/gcc/tree-into-ssa.c
index 5b54103..cb1e6f4 100644
--- a/gcc/tree-into-ssa.c
+++ b/gcc/tree-into-ssa.c
@@ -299,7 +299,7 @@ marked_for_renaming (tree sym)
    decided in mark_def_sites.  */
 
 static inline bool
-rewrite_uses_p (gimple stmt)
+rewrite_uses_p (gimple *stmt)
 {
   return gimple_visited_p (stmt);
 }
@@ -308,7 +308,7 @@ rewrite_uses_p (gimple stmt)
 /* Set the rewrite marker on STMT to the value given by REWRITE_P.  */
 
 static inline void
-set_rewrite_uses (gimple stmt, bool rewrite_p)
+set_rewrite_uses (gimple *stmt, bool rewrite_p)
 {
   gimple_set_visited (stmt, rewrite_p);
 }
@@ -323,7 +323,7 @@ set_rewrite_uses (gimple stmt, bool rewrite_p)
    registered, but they don't need to have their uses renamed.  */
 
 static inline bool
-register_defs_p (gimple stmt)
+register_defs_p (gimple *stmt)
 {
   return gimple_plf (stmt, GF_PLF_1) != 0;
 }
@@ -332,7 +332,7 @@ register_defs_p (gimple stmt)
 /* If REGISTER_DEFS_P is true, mark STMT to have its DEFs registered.  */
 
 static inline void
-set_register_defs (gimple stmt, bool register_defs_p)
+set_register_defs (gimple *stmt, bool register_defs_p)
 {
   gimple_set_plf (stmt, GF_PLF_1, register_defs_p);
 }
@@ -443,12 +443,12 @@ set_current_def (tree var, tree def)
 static void
 initialize_flags_in_bb (basic_block bb)
 {
-  gimple stmt;
+  gimple *stmt;
   gimple_stmt_iterator gsi;
 
   for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple phi = gsi_stmt (gsi);
+      gimple *phi = gsi_stmt (gsi);
       set_rewrite_uses (phi, false);
       set_register_defs (phi, false);
     }
@@ -664,7 +664,7 @@ add_new_name_mapping (tree new_tree, tree old)
    we create.  */
 
 static void
-mark_def_sites (basic_block bb, gimple stmt, bitmap kills)
+mark_def_sites (basic_block bb, gimple *stmt, bitmap kills)
 {
   tree def;
   use_operand_p use_p;
@@ -949,7 +949,7 @@ find_def_blocks_for (tree var)
 /* Marks phi node PHI in basic block BB for rewrite.  */
 
 static void
-mark_phi_for_rewrite (basic_block bb, gimple phi)
+mark_phi_for_rewrite (basic_block bb, gimple *phi)
 {
   gimple_vec phis;
   unsigned n, idx = bb->index;
@@ -990,7 +990,7 @@ insert_phi_nodes_for (tree var, bitmap phi_insertion_points, bool update_p)
 {
   unsigned bb_index;
   edge e;
-  gimple phi;
+  gimple *phi;
   basic_block bb;
   bitmap_iterator bi;
   struct def_blocks_d *def_map = find_def_blocks_for (var);
@@ -1050,7 +1050,7 @@ insert_phi_nodes_for (tree var, bitmap phi_insertion_points, bool update_p)
 	  tracked_var = target_for_debug_bind (var);
 	  if (tracked_var)
 	    {
-	      gimple note = gimple_build_debug_bind (tracked_var,
+	      gimple *note = gimple_build_debug_bind (tracked_var,
 						     PHI_RESULT (phi),
 						     phi);
 	      gimple_stmt_iterator si = gsi_after_labels (bb);
@@ -1207,7 +1207,7 @@ get_reaching_def (tree var)
 /* Helper function for rewrite_stmt.  Rewrite uses in a debug stmt.  */
 
 static void
-rewrite_debug_stmt_uses (gimple stmt)
+rewrite_debug_stmt_uses (gimple *stmt)
 {
   use_operand_p use_p;
   ssa_op_iter iter;
@@ -1234,7 +1234,7 @@ rewrite_debug_stmt_uses (gimple stmt)
 		   !gsi_end_p (gsi) && lim > 0;
 		   gsi_next (&gsi), lim--)
 		{
-		  gimple gstmt = gsi_stmt (gsi);
+		  gimple *gstmt = gsi_stmt (gsi);
 		  if (!gimple_debug_source_bind_p (gstmt))
 		    break;
 		  if (gimple_debug_source_bind_get_value (gstmt) == var)
@@ -1249,7 +1249,7 @@ rewrite_debug_stmt_uses (gimple stmt)
 	      /* If not, add a new source bind stmt.  */
 	      if (def == NULL_TREE)
 		{
-		  gimple def_temp;
+		  gimple *def_temp;
 		  def = make_node (DEBUG_EXPR_DECL);
 		  def_temp = gimple_build_debug_source_bind (def, var, NULL);
 		  DECL_ARTIFICIAL (def) = 1;
@@ -1316,7 +1316,7 @@ rewrite_stmt (gimple_stmt_iterator *si)
   use_operand_p use_p;
   def_operand_p def_p;
   ssa_op_iter iter;
-  gimple stmt = gsi_stmt (*si);
+  gimple *stmt = gsi_stmt (*si);
 
   /* If mark_def_sites decided that we don't need to rewrite this
      statement, ignore it.  */
@@ -1374,7 +1374,7 @@ rewrite_stmt (gimple_stmt_iterator *si)
 	tracked_var = target_for_debug_bind (var);
 	if (tracked_var)
 	  {
-	    gimple note = gimple_build_debug_bind (tracked_var, name, stmt);
+	    gimple *note = gimple_build_debug_bind (tracked_var, name, stmt);
 	    gsi_insert_after (si, note, GSI_SAME_STMT);
 	  }
       }
@@ -1394,7 +1394,7 @@ rewrite_add_phi_arguments (basic_block bb)
 
   FOR_EACH_EDGE (e, ei, bb->succs)
     {
-      gimple phi;
+      gimple *phi;
       gimple_stmt_iterator gsi;
 
       for (gsi = gsi_start_phis (e->dest); !gsi_end_p (gsi);
@@ -1825,7 +1825,7 @@ maybe_replace_use_in_debug_stmt (use_operand_p use_p)
    DEF_P.  */
 
 static inline void
-maybe_register_def (def_operand_p def_p, gimple stmt,
+maybe_register_def (def_operand_p def_p, gimple *stmt,
 		    gimple_stmt_iterator gsi)
 {
   tree def = DEF_FROM_PTR (def_p);
@@ -1845,7 +1845,7 @@ maybe_register_def (def_operand_p def_p, gimple stmt,
 	  tracked_var = target_for_debug_bind (sym);
 	  if (tracked_var)
 	    {
-	      gimple note = gimple_build_debug_bind (tracked_var, def, stmt);
+	      gimple *note = gimple_build_debug_bind (tracked_var, def, stmt);
 	      /* If stmt ends the bb, insert the debug stmt on the single
 		 non-EH edge from the stmt.  */
 	      if (gsi_one_before_end_p (gsi) && stmt_ends_bb_p (stmt))
@@ -1911,7 +1911,7 @@ maybe_register_def (def_operand_p def_p, gimple stmt,
    in OLD_SSA_NAMES.  */
 
 static void
-rewrite_update_stmt (gimple stmt, gimple_stmt_iterator gsi)
+rewrite_update_stmt (gimple *stmt, gimple_stmt_iterator gsi)
 {
   use_operand_p use_p;
   def_operand_p def_p;
@@ -1990,7 +1990,7 @@ rewrite_update_phi_arguments (basic_block bb)
 
   FOR_EACH_EDGE (e, ei, bb->succs)
     {
-      gimple phi;
+      gimple *phi;
       gimple_vec phis;
 
       if (!bitmap_bit_p (blocks_with_phis_to_rewrite, e->dest->index))
@@ -2043,7 +2043,7 @@ rewrite_update_phi_arguments (basic_block bb)
 		locus = UNKNOWN_LOCATION;
 	      else
 		{
-		  gimple stmt = SSA_NAME_DEF_STMT (reaching_def);
+		  gimple *stmt = SSA_NAME_DEF_STMT (reaching_def);
 
 		  /* Single element PHI nodes  behave like copies, so get the
 		     location from the phi argument.  */
@@ -2106,7 +2106,7 @@ rewrite_update_dom_walker::before_dom_children (basic_block bb)
   for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
       tree lhs, lhs_sym;
-      gimple phi = gsi_stmt (gsi);
+      gimple *phi = gsi_stmt (gsi);
 
       if (!register_defs_p (phi))
 	continue;
@@ -2412,7 +2412,7 @@ make_pass_build_ssa (gcc::context *ctxt)
    renamer.  BLOCKS is the set of blocks that need updating.  */
 
 static void
-mark_def_interesting (tree var, gimple stmt, basic_block bb, bool insert_phi_p)
+mark_def_interesting (tree var, gimple *stmt, basic_block bb, bool insert_phi_p)
 {
   gcc_checking_assert (bitmap_bit_p (blocks_to_update, bb->index));
   set_register_defs (stmt, true);
@@ -2443,7 +2443,7 @@ mark_def_interesting (tree var, gimple stmt, basic_block bb, bool insert_phi_p)
    nodes.  */
 
 static inline void
-mark_use_interesting (tree var, gimple stmt, basic_block bb, bool insert_phi_p)
+mark_use_interesting (tree var, gimple *stmt, basic_block bb, bool insert_phi_p)
 {
   basic_block def_bb = gimple_bb (stmt);
 
@@ -2503,7 +2503,7 @@ prepare_block_for_update (basic_block bb, bool insert_phi_p)
      the symbols that we are interested in.  */
   for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
     {
-      gimple phi = gsi_stmt (si);
+      gimple *phi = gsi_stmt (si);
       tree lhs_sym, lhs = gimple_phi_result (phi);
 
       if (TREE_CODE (lhs) == SSA_NAME
@@ -2529,7 +2529,7 @@ prepare_block_for_update (basic_block bb, bool insert_phi_p)
   /* Process the statements.  */
   for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
     {
-      gimple stmt;
+      gimple *stmt;
       ssa_op_iter i;
       use_operand_p use_p;
       def_operand_p def_p;
@@ -2593,7 +2593,7 @@ prepare_use_sites_for (tree name, bool insert_phi_p)
 
   FOR_EACH_IMM_USE_FAST (use_p, iter, name)
     {
-      gimple stmt = USE_STMT (use_p);
+      gimple *stmt = USE_STMT (use_p);
       basic_block bb = gimple_bb (stmt);
 
       if (gimple_code (stmt) == GIMPLE_PHI)
@@ -2619,7 +2619,7 @@ prepare_use_sites_for (tree name, bool insert_phi_p)
 static void
 prepare_def_site_for (tree name, bool insert_phi_p)
 {
-  gimple stmt;
+  gimple *stmt;
   basic_block bb;
 
   gcc_checking_assert (names_to_release == NULL
@@ -2830,7 +2830,7 @@ delete_update_ssa (void)
    update_ssa's tables.  */
 
 tree
-create_new_def_for (tree old_name, gimple stmt, def_operand_p def)
+create_new_def_for (tree old_name, gimple *stmt, def_operand_p def)
 {
   tree new_name;
 
@@ -2888,7 +2888,7 @@ mark_virtual_operand_for_renaming (tree name)
   bool used = false;
   imm_use_iterator iter;
   use_operand_p use_p;
-  gimple stmt;
+  gimple *stmt;
 
   gcc_assert (VAR_DECL_IS_VIRTUAL_OPERAND (name_var));
   FOR_EACH_IMM_USE_STMT (stmt, iter, name)
@@ -2906,7 +2906,7 @@ mark_virtual_operand_for_renaming (tree name)
    removed.  */
 
 void
-mark_virtual_phi_result_for_renaming (gimple phi)
+mark_virtual_phi_result_for_renaming (gimple *phi)
 {
   if (dump_file && (dump_flags & TDF_DETAILS))
     {
diff --git a/gcc/tree-into-ssa.h b/gcc/tree-into-ssa.h
index 977f6e7..95f6394 100644
--- a/gcc/tree-into-ssa.h
+++ b/gcc/tree-into-ssa.h
@@ -23,10 +23,10 @@ along with GCC; see the file COPYING3.  If not see
 extern tree get_current_def (tree);
 extern void set_current_def (tree, tree);
 void delete_update_ssa (void);
-tree create_new_def_for (tree, gimple, def_operand_p);
+tree create_new_def_for (tree, gimple *, def_operand_p);
 void mark_virtual_operands_for_renaming (struct function *);
 void mark_virtual_operand_for_renaming (tree);
-void mark_virtual_phi_result_for_renaming (gimple);
+void mark_virtual_phi_result_for_renaming (gimple *);
 bool need_ssa_update_p (struct function *);
 bool name_registered_for_update_p (tree);
 void release_ssa_name_after_update_ssa (tree);
diff --git a/gcc/tree-loop-distribution.c b/gcc/tree-loop-distribution.c
index 00cf24c..282d5db 100644
--- a/gcc/tree-loop-distribution.c
+++ b/gcc/tree-loop-distribution.c
@@ -77,7 +77,7 @@ along with GCC; see the file COPYING3.  If not see
 typedef struct rdg_vertex
 {
   /* The statement represented by this vertex.  */
-  gimple stmt;
+  gimple *stmt;
 
   /* Vector of data-references in this statement.  */
   vec<data_reference_p> datarefs;
@@ -244,7 +244,7 @@ dot_rdg (struct graph *rdg)
 /* Returns the index of STMT in RDG.  */
 
 static int
-rdg_vertex_for_stmt (struct graph *rdg ATTRIBUTE_UNUSED, gimple stmt)
+rdg_vertex_for_stmt (struct graph *rdg ATTRIBUTE_UNUSED, gimple *stmt)
 {
   int index = gimple_uid (stmt);
   gcc_checking_assert (index == -1 || RDG_STMT (rdg, index) == stmt);
@@ -286,7 +286,7 @@ create_edge_for_control_dependence (struct graph *rdg, basic_block bb,
 			    0, edge_n, bi)
     {
       basic_block cond_bb = cd->get_edge (edge_n)->src;
-      gimple stmt = last_stmt (cond_bb);
+      gimple *stmt = last_stmt (cond_bb);
       if (stmt && is_ctrl_stmt (stmt))
 	{
 	  struct graph_edge *e;
@@ -325,7 +325,7 @@ create_rdg_cd_edges (struct graph *rdg, control_dependences *cd)
 
   for (i = 0; i < rdg->n_vertices; i++)
     {
-      gimple stmt = RDG_STMT (rdg, i);
+      gimple *stmt = RDG_STMT (rdg, i);
       if (gimple_code (stmt) == GIMPLE_PHI)
 	{
 	  edge_iterator ei;
@@ -342,11 +342,11 @@ create_rdg_cd_edges (struct graph *rdg, control_dependences *cd)
    if that failed.  */
 
 static bool
-create_rdg_vertices (struct graph *rdg, vec<gimple> stmts, loop_p loop,
+create_rdg_vertices (struct graph *rdg, vec<gimple *> stmts, loop_p loop,
 		     vec<data_reference_p> *datarefs)
 {
   int i;
-  gimple stmt;
+  gimple *stmt;
 
   FOR_EACH_VEC_ELT (stmts, i, stmt)
     {
@@ -385,7 +385,7 @@ create_rdg_vertices (struct graph *rdg, vec<gimple> stmts, loop_p loop,
    identifying statements in loop copies.  */
 
 static void
-stmts_from_loop (struct loop *loop, vec<gimple> *stmts)
+stmts_from_loop (struct loop *loop, vec<gimple *> *stmts)
 {
   unsigned int i;
   basic_block *bbs = get_loop_body_in_dom_order (loop);
@@ -394,7 +394,7 @@ stmts_from_loop (struct loop *loop, vec<gimple> *stmts)
     {
       basic_block bb = bbs[i];
       gimple_stmt_iterator bsi;
-      gimple stmt;
+      gimple *stmt;
 
       for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
 	if (!virtual_operand_p (gimple_phi_result (gsi_stmt (bsi))))
@@ -448,7 +448,7 @@ build_rdg (vec<loop_p> loop_nest, control_dependences *cd)
   vec<data_reference_p> datarefs;
 
   /* Create the RDG vertices from the stmts of the loop nest.  */
-  auto_vec<gimple, 10> stmts;
+  auto_vec<gimple *, 10> stmts;
   stmts_from_loop (loop_nest[0], &stmts);
   rdg = new_graph (stmts.length ());
   datarefs.create (10);
@@ -551,7 +551,7 @@ ssa_name_has_uses_outside_loop_p (tree def, loop_p loop)
 
   FOR_EACH_IMM_USE_FAST (use_p, imm_iter, def)
     {
-      gimple use_stmt = USE_STMT (use_p);
+      gimple *use_stmt = USE_STMT (use_p);
       if (!is_gimple_debug (use_stmt)
 	  && loop != loop_containing_stmt (use_stmt))
 	return true;
@@ -564,7 +564,7 @@ ssa_name_has_uses_outside_loop_p (tree def, loop_p loop)
    loop LOOP.  */
 
 static bool
-stmt_has_scalar_dependences_outside_loop (loop_p loop, gimple stmt)
+stmt_has_scalar_dependences_outside_loop (loop_p loop, gimple *stmt)
 {
   def_operand_p def_p;
   ssa_op_iter op_iter;
@@ -641,7 +641,7 @@ generate_loops_for_partition (struct loop *loop, partition_t partition,
 
 	for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
 	  {
-	    gimple phi = gsi_stmt (bsi);
+	    gimple *phi = gsi_stmt (bsi);
 	    if (!virtual_operand_p (gimple_phi_result (phi))
 		&& !bitmap_bit_p (partition->stmts, gimple_uid (phi)))
 	      reset_debug_uses (phi);
@@ -649,7 +649,7 @@ generate_loops_for_partition (struct loop *loop, partition_t partition,
 
 	for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
 	  {
-	    gimple stmt = gsi_stmt (bsi);
+	    gimple *stmt = gsi_stmt (bsi);
 	    if (gimple_code (stmt) != GIMPLE_LABEL
 		&& !is_gimple_debug (stmt)
 		&& !bitmap_bit_p (partition->stmts, gimple_uid (stmt)))
@@ -663,7 +663,7 @@ generate_loops_for_partition (struct loop *loop, partition_t partition,
 
       for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi);)
 	{
-	  gimple phi = gsi_stmt (bsi);
+	  gimple *phi = gsi_stmt (bsi);
 	  if (!virtual_operand_p (gimple_phi_result (phi))
 	      && !bitmap_bit_p (partition->stmts, gimple_uid (phi)))
 	    remove_phi_node (&bsi, true);
@@ -673,7 +673,7 @@ generate_loops_for_partition (struct loop *loop, partition_t partition,
 
       for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi);)
 	{
-	  gimple stmt = gsi_stmt (bsi);
+	  gimple *stmt = gsi_stmt (bsi);
 	  if (gimple_code (stmt) != GIMPLE_LABEL
 	      && !is_gimple_debug (stmt)
 	      && !bitmap_bit_p (partition->stmts, gimple_uid (stmt)))
@@ -779,7 +779,7 @@ static void
 generate_memset_builtin (struct loop *loop, partition_t partition)
 {
   gimple_stmt_iterator gsi;
-  gimple stmt, fn_call;
+  gimple *stmt, *fn_call;
   tree mem, fn, nb_bytes;
   location_t loc;
   tree val;
@@ -809,7 +809,7 @@ generate_memset_builtin (struct loop *loop, partition_t partition)
     val = fold_convert (integer_type_node, val);
   else if (!useless_type_conversion_p (integer_type_node, TREE_TYPE (val)))
     {
-      gimple cstmt;
+      gimple *cstmt;
       tree tem = make_ssa_name (integer_type_node, NULL);
       cstmt = gimple_build_assign_with_ops (NOP_EXPR, tem, val, NULL_TREE);
       gsi_insert_after (&gsi, cstmt, GSI_CONTINUE_LINKING);
@@ -836,7 +836,7 @@ static void
 generate_memcpy_builtin (struct loop *loop, partition_t partition)
 {
   gimple_stmt_iterator gsi;
-  gimple stmt, fn_call;
+  gimple *stmt, *fn_call;
   tree dest, src, fn, nb_bytes;
   location_t loc;
   enum built_in_function kind;
@@ -904,13 +904,13 @@ destroy_loop (struct loop *loop)
       gimple_stmt_iterator gsi;
       for (gsi = gsi_start_phis (bbs[i]); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple phi = gsi_stmt (gsi);
+	  gimple *phi = gsi_stmt (gsi);
 	  if (virtual_operand_p (gimple_phi_result (phi)))
 	    mark_virtual_phi_result_for_renaming (phi);
 	}
       for (gsi = gsi_start_bb (bbs[i]); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  tree vdef = gimple_vdef (stmt);
 	  if (vdef && TREE_CODE (vdef) == SSA_NAME)
 	    mark_virtual_operand_for_renaming (vdef);
@@ -1001,7 +1001,7 @@ classify_partition (loop_p loop, struct graph *rdg, partition_t partition)
 
   EXECUTE_IF_SET_IN_BITMAP (partition->stmts, 0, i, bi)
     {
-      gimple stmt = RDG_STMT (rdg, i);
+      gimple *stmt = RDG_STMT (rdg, i);
 
       if (gimple_has_volatile_ops (stmt))
 	volatiles_p = true;
@@ -1024,7 +1024,7 @@ classify_partition (loop_p loop, struct graph *rdg, partition_t partition)
   single_store = NULL;
   EXECUTE_IF_SET_IN_BITMAP (partition->stmts, 0, i, bi)
     {
-      gimple stmt = RDG_STMT (rdg, i);
+      gimple *stmt = RDG_STMT (rdg, i);
       data_reference_p dr;
       unsigned j;
 
@@ -1069,7 +1069,7 @@ classify_partition (loop_p loop, struct graph *rdg, partition_t partition)
 
   if (single_store && !single_load)
     {
-      gimple stmt = DR_STMT (single_store);
+      gimple *stmt = DR_STMT (single_store);
       tree rhs = gimple_assign_rhs1 (stmt);
       if (const_with_all_bytes_same (rhs) == -1
 	  && (!INTEGRAL_TYPE_P (TREE_TYPE (rhs))
@@ -1091,8 +1091,8 @@ classify_partition (loop_p loop, struct graph *rdg, partition_t partition)
     }
   else if (single_store && single_load)
     {
-      gimple store = DR_STMT (single_store);
-      gimple load = DR_STMT (single_load);
+      gimple *store = DR_STMT (single_store);
+      gimple *load = DR_STMT (single_load);
       /* Direct aggregate copy or via an SSA name temporary.  */
       if (load != store
 	  && gimple_assign_lhs (load) != gimple_assign_rhs1 (store))
@@ -1209,12 +1209,12 @@ similar_memory_accesses (struct graph *rdg, partition_t partition1,
 
 static void
 rdg_build_partitions (struct graph *rdg,
-		      vec<gimple> starting_stmts,
+		      vec<gimple *> starting_stmts,
 		      vec<partition_t> *partitions)
 {
   bitmap processed = BITMAP_ALLOC (NULL);
   int i;
-  gimple stmt;
+  gimple *stmt;
 
   FOR_EACH_VEC_ELT (starting_stmts, i, stmt)
     {
@@ -1407,7 +1407,7 @@ pgcmp (const void *v1_, const void *v2_)
    Returns the number of distributed loops.  */
 
 static int
-distribute_loop (struct loop *loop, vec<gimple> stmts,
+distribute_loop (struct loop *loop, vec<gimple *> stmts,
 		 control_dependences *cd, int *nb_calls)
 {
   struct graph *rdg;
@@ -1724,7 +1724,7 @@ pass_loop_distribution::execute (function *fun)
      walking to innermost loops.  */
   FOR_EACH_LOOP (loop, LI_ONLY_INNERMOST)
     {
-      auto_vec<gimple> work_list;
+      auto_vec<gimple *> work_list;
       basic_block *bbs;
       int num = loop->num;
       unsigned int i;
@@ -1745,7 +1745,7 @@ pass_loop_distribution::execute (function *fun)
 	  gimple_stmt_iterator gsi;
 	  for (gsi = gsi_start_phis (bbs[i]); !gsi_end_p (gsi); gsi_next (&gsi))
 	    {
-	      gimple phi = gsi_stmt (gsi);
+	      gimple *phi = gsi_stmt (gsi);
 	      if (virtual_operand_p (gimple_phi_result (phi)))
 		continue;
 	      /* Distribute stmts which have defs that are used outside of
@@ -1756,7 +1756,7 @@ pass_loop_distribution::execute (function *fun)
 	    }
 	  for (gsi = gsi_start_bb (bbs[i]); !gsi_end_p (gsi); gsi_next (&gsi))
 	    {
-	      gimple stmt = gsi_stmt (gsi);
+	      gimple *stmt = gsi_stmt (gsi);
 
 	      /* If there is a stmt with side-effects bail out - we
 		 cannot and should not distribute this loop.  */
diff --git a/gcc/tree-nested.c b/gcc/tree-nested.c
index ba2cc76..0cb0613 100644
--- a/gcc/tree-nested.c
+++ b/gcc/tree-nested.c
@@ -411,7 +411,7 @@ get_chain_field (struct nesting_info *info)
 
 static tree
 init_tmp_var_with_call (struct nesting_info *info, gimple_stmt_iterator *gsi,
-		        gimple call)
+		        gimple *call)
 {
   tree t;
 
@@ -432,7 +432,7 @@ static tree
 init_tmp_var (struct nesting_info *info, tree exp, gimple_stmt_iterator *gsi)
 {
   tree t;
-  gimple stmt;
+  gimple *stmt;
 
   t = create_tmp_var_for (info, TREE_TYPE (exp), NULL);
   stmt = gimple_build_assign (t, exp);
@@ -463,7 +463,7 @@ static tree
 save_tmp_var (struct nesting_info *info, tree exp, gimple_stmt_iterator *gsi)
 {
   tree t;
-  gimple stmt;
+  gimple *stmt;
 
   t = create_tmp_var_for (info, TREE_TYPE (exp), NULL);
   stmt = gimple_build_assign (exp, t);
@@ -618,7 +618,7 @@ walk_function (walk_stmt_fn callback_stmt, walk_tree_fn callback_op,
 /* Invoke CALLBACK on a GIMPLE_OMP_FOR's init, cond, incr and pre-body.  */
 
 static void
-walk_gimple_omp_for (gimple for_stmt,
+walk_gimple_omp_for (gimple *for_stmt,
     		     walk_stmt_fn callback_stmt, walk_tree_fn callback_op,
     		     struct nesting_info *info)
 {
@@ -1245,7 +1245,7 @@ convert_nonlocal_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
   struct nesting_info *info = (struct nesting_info *) wi->info;
   tree save_local_var_chain;
   bitmap save_suppress;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
 
   switch (gimple_code (stmt))
     {
@@ -1728,7 +1728,7 @@ convert_local_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
   struct nesting_info *info = (struct nesting_info *) wi->info;
   tree save_local_var_chain;
   bitmap save_suppress;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
 
   switch (gimple_code (stmt))
     {
@@ -1884,8 +1884,8 @@ convert_nl_goto_reference (gimple_stmt_iterator *gsi, bool *handled_ops_p,
   struct nesting_info *const info = (struct nesting_info *) wi->info, *i;
   tree label, new_label, target_context, x, field;
   void **slot;
-  gimple call;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *call;
+  gimple *stmt = gsi_stmt (*gsi);
 
   if (gimple_code (stmt) != GIMPLE_GOTO)
     {
@@ -1956,7 +1956,7 @@ convert_nl_goto_receiver (gimple_stmt_iterator *gsi, bool *handled_ops_p,
   tree label, new_label;
   gimple_stmt_iterator tmp_gsi;
   void **slot;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
 
   if (gimple_code (stmt) != GIMPLE_LABEL)
     {
@@ -1979,7 +1979,7 @@ convert_nl_goto_receiver (gimple_stmt_iterator *gsi, bool *handled_ops_p,
   gsi_prev (&tmp_gsi);
   if (gsi_end_p (tmp_gsi) || gimple_stmt_may_fallthru (gsi_stmt (tmp_gsi)))
     {
-      gimple stmt = gimple_build_goto (label);
+      gimple *stmt = gimple_build_goto (label);
       gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
     }
 
@@ -2002,7 +2002,7 @@ convert_tramp_reference_op (tree *tp, int *walk_subtrees, void *data)
   struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
   struct nesting_info *const info = (struct nesting_info *) wi->info, *i;
   tree t = *tp, decl, target_context, x, builtin;
-  gimple call;
+  gimple *call;
 
   *walk_subtrees = 0;
   switch (TREE_CODE (t))
@@ -2076,7 +2076,7 @@ convert_tramp_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
 			      struct walk_stmt_info *wi)
 {
   struct nesting_info *info = (struct nesting_info *) wi->info;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
 
   switch (gimple_code (stmt))
     {
@@ -2132,7 +2132,7 @@ convert_gimple_call (gimple_stmt_iterator *gsi, bool *handled_ops_p,
   tree decl, target_context;
   char save_static_chain_added;
   int i;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
 
   switch (gimple_code (stmt))
     {
@@ -2440,7 +2440,7 @@ static void
 finalize_nesting_tree_1 (struct nesting_info *root)
 {
   gimple_seq stmt_list;
-  gimple stmt;
+  gimple *stmt;
   tree context = root->context;
   struct function *sf;
 
@@ -2550,7 +2550,7 @@ finalize_nesting_tree_1 (struct nesting_info *root)
   /* If we created initialization statements, insert them.  */
   if (stmt_list)
     {
-      gimple bind;
+      gimple *bind;
       annotate_all_with_location (stmt_list, DECL_SOURCE_LOCATION (context));
       bind = gimple_seq_first_stmt (gimple_body (context));
       gimple_seq_add_seq (&stmt_list, gimple_bind_body (bind));
@@ -2581,7 +2581,7 @@ finalize_nesting_tree_1 (struct nesting_info *root)
   if (root->debug_var_chain)
     {
       tree debug_var;
-      gimple scope;
+      gimple *scope;
 
       remap_vla_decls (DECL_INITIAL (root->context), root);
 
diff --git a/gcc/tree-nrv.c b/gcc/tree-nrv.c
index 45b16f4..02bc113 100644
--- a/gcc/tree-nrv.c
+++ b/gcc/tree-nrv.c
@@ -178,7 +178,7 @@ pass_nrv::execute (function *fun)
     {
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  tree ret_val;
 
 	  if (gimple_code (stmt) == GIMPLE_RETURN)
@@ -272,7 +272,7 @@ pass_nrv::execute (function *fun)
     {
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); )
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  /* If this is a copy from VAR to RESULT, remove it.  */
 	  if (gimple_assign_copy_p (stmt)
 	      && gimple_assign_lhs (stmt) == result
@@ -317,7 +317,7 @@ make_pass_nrv (gcc::context *ctxt)
    DEST is available if it is not clobbered or used by the call.  */
 
 static bool
-dest_safe_for_nrv_p (gimple call)
+dest_safe_for_nrv_p (gimple *call)
 {
   tree dest = gimple_call_lhs (call);
 
@@ -385,7 +385,7 @@ pass_return_slot::execute (function *fun)
       gimple_stmt_iterator gsi;
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  bool slot_opt_p;
 
 	  if (is_gimple_call (stmt)
diff --git a/gcc/tree-object-size.c b/gcc/tree-object-size.c
index 3c606b0..b981fa0 100644
--- a/gcc/tree-object-size.c
+++ b/gcc/tree-object-size.c
@@ -58,14 +58,14 @@ static const unsigned HOST_WIDE_INT unknown[4] = { -1, -1, 0, 0 };
 static tree compute_object_offset (const_tree, const_tree);
 static unsigned HOST_WIDE_INT addr_object_size (struct object_size_info *,
 						const_tree, int);
-static unsigned HOST_WIDE_INT alloc_object_size (const_gimple, int);
-static tree pass_through_call (const_gimple);
+static unsigned HOST_WIDE_INT alloc_object_size (const gimple *, int);
+static tree pass_through_call (const gimple *);
 static void collect_object_sizes_for (struct object_size_info *, tree);
 static void expr_object_size (struct object_size_info *, tree, tree);
 static bool merge_object_sizes (struct object_size_info *, tree, tree,
 				unsigned HOST_WIDE_INT);
-static bool plus_stmt_object_size (struct object_size_info *, tree, gimple);
-static bool cond_expr_object_size (struct object_size_info *, tree, gimple);
+static bool plus_stmt_object_size (struct object_size_info *, tree, gimple *);
+static bool cond_expr_object_size (struct object_size_info *, tree, gimple *);
 static void init_offset_limit (void);
 static void check_for_plus_in_loops (struct object_size_info *, tree);
 static void check_for_plus_in_loops_1 (struct object_size_info *, tree,
@@ -391,7 +391,7 @@ addr_object_size (struct object_size_info *osi, const_tree ptr,
    unknown[object_size_type].  */
 
 static unsigned HOST_WIDE_INT
-alloc_object_size (const_gimple call, int object_size_type)
+alloc_object_size (const gimple *call, int object_size_type)
 {
   tree callee, bytes = NULL_TREE;
   tree alloc_size;
@@ -454,7 +454,7 @@ alloc_object_size (const_gimple call, int object_size_type)
    Otherwise return NULL.  */
 
 static tree
-pass_through_call (const_gimple call)
+pass_through_call (const gimple *call)
 {
   tree callee = gimple_call_fndecl (call);
 
@@ -668,7 +668,7 @@ expr_object_size (struct object_size_info *osi, tree ptr, tree value)
 /* Compute object_sizes for PTR, defined to the result of a call.  */
 
 static void
-call_object_size (struct object_size_info *osi, tree ptr, gimple call)
+call_object_size (struct object_size_info *osi, tree ptr, gimple *call)
 {
   int object_size_type = osi->object_size_type;
   unsigned int varno = SSA_NAME_VERSION (ptr);
@@ -775,7 +775,7 @@ merge_object_sizes (struct object_size_info *osi, tree dest, tree orig,
    need reexamination  later.  */
 
 static bool
-plus_stmt_object_size (struct object_size_info *osi, tree var, gimple stmt)
+plus_stmt_object_size (struct object_size_info *osi, tree var, gimple *stmt)
 {
   int object_size_type = osi->object_size_type;
   unsigned int varno = SSA_NAME_VERSION (var);
@@ -847,7 +847,7 @@ plus_stmt_object_size (struct object_size_info *osi, tree var, gimple stmt)
    later.  */
 
 static bool
-cond_expr_object_size (struct object_size_info *osi, tree var, gimple stmt)
+cond_expr_object_size (struct object_size_info *osi, tree var, gimple *stmt)
 {
   tree then_, else_;
   int object_size_type = osi->object_size_type;
@@ -900,7 +900,7 @@ collect_object_sizes_for (struct object_size_info *osi, tree var)
 {
   int object_size_type = osi->object_size_type;
   unsigned int varno = SSA_NAME_VERSION (var);
-  gimple stmt;
+  gimple *stmt;
   bool reexamine;
 
   if (bitmap_bit_p (computed[object_size_type], varno))
@@ -1043,7 +1043,7 @@ static void
 check_for_plus_in_loops_1 (struct object_size_info *osi, tree var,
 			   unsigned int depth)
 {
-  gimple stmt = SSA_NAME_DEF_STMT (var);
+  gimple *stmt = SSA_NAME_DEF_STMT (var);
   unsigned int varno = SSA_NAME_VERSION (var);
 
   if (osi->depths[varno])
@@ -1142,7 +1142,7 @@ check_for_plus_in_loops_1 (struct object_size_info *osi, tree var,
 static void
 check_for_plus_in_loops (struct object_size_info *osi, tree var)
 {
-  gimple stmt = SSA_NAME_DEF_STMT (var);
+  gimple *stmt = SSA_NAME_DEF_STMT (var);
 
   /* NOTE: In the pre-tuples code, we handled a CALL_EXPR here,
      and looked for a POINTER_PLUS_EXPR in the pass-through
@@ -1245,7 +1245,7 @@ pass_object_sizes::execute (function *fun)
       for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
 	{
 	  tree result;
-	  gimple call = gsi_stmt (i);
+	  gimple *call = gsi_stmt (i);
 	  if (!gimple_call_builtin_p (call, BUILT_IN_OBJECT_SIZE))
 	    continue;
 
@@ -1291,7 +1291,7 @@ pass_object_sizes::execute (function *fun)
 	    continue;
 
 	  /* Propagate into all uses and fold those stmts.  */
-	  gimple use_stmt;
+	  gimple *use_stmt;
 	  imm_use_iterator iter;
 	  FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs)
 	    {
diff --git a/gcc/tree-outof-ssa.c b/gcc/tree-outof-ssa.c
index d5a635b..27f7cd28 100644
--- a/gcc/tree-outof-ssa.c
+++ b/gcc/tree-outof-ssa.c
@@ -55,11 +55,11 @@ along with GCC; see the file COPYING3.  If not see
 /* Return TRUE if expression STMT is suitable for replacement.  */
 
 bool
-ssa_is_replaceable_p (gimple stmt)
+ssa_is_replaceable_p (gimple *stmt)
 {
   use_operand_p use_p;
   tree def;
-  gimple use_stmt;
+  gimple *use_stmt;
 
   /* Only consider modify stmts.  */
   if (!is_gimple_assign (stmt))
@@ -187,7 +187,7 @@ set_location_for_edge (edge e)
 	{
 	  for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi_prev (&gsi))
 	    {
-	      gimple stmt = gsi_stmt (gsi);
+	      gimple *stmt = gsi_stmt (gsi);
 	      if (is_gimple_debug (stmt))
 		continue;
 	      if (gimple_has_location (stmt) || gimple_block (stmt))
@@ -587,7 +587,7 @@ eliminate_build (elim_graph g)
 
   for (gsi = gsi_start_phis (g->e->dest); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple phi = gsi_stmt (gsi);
+      gimple *phi = gsi_stmt (gsi);
       source_location locus;
 
       p0 = var_to_partition (g->map, gimple_phi_result (phi));
@@ -788,7 +788,7 @@ eliminate_phi (edge e, elim_graph g)
    check to see if this allows another PHI node to be removed.  */
 
 static void
-remove_gimple_phi_args (gimple phi)
+remove_gimple_phi_args (gimple *phi)
 {
   use_operand_p arg_p;
   ssa_op_iter iter;
@@ -808,7 +808,7 @@ remove_gimple_phi_args (gimple phi)
 	  SET_USE (arg_p, NULL_TREE);
 	  if (has_zero_uses (arg))
 	    {
-	      gimple stmt;
+	      gimple *stmt;
 	      gimple_stmt_iterator gsi;
 
 	      stmt = SSA_NAME_DEF_STMT (arg);
@@ -839,7 +839,7 @@ eliminate_useless_phis (void)
     {
       for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); )
         {
-	  gimple phi = gsi_stmt (gsi);
+	  gimple *phi = gsi_stmt (gsi);
 	  result = gimple_phi_result (phi);
 	  if (virtual_operand_p (result))
 	    {
@@ -898,7 +898,7 @@ rewrite_trees (var_map map ATTRIBUTE_UNUSED)
       gimple_stmt_iterator gsi;
       for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple phi = gsi_stmt (gsi);
+	  gimple *phi = gsi_stmt (gsi);
 	  tree T0 = var_to_partition_to_var (map, gimple_phi_result (phi));
 	  if (T0 == NULL_TREE)
 	    {
@@ -1035,7 +1035,7 @@ maybe_renumber_stmts_bb (basic_block bb)
   bb->aux = NULL;
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       gimple_set_uid (stmt, i);
       i++;
     }
@@ -1051,7 +1051,7 @@ trivially_conflicts_p (basic_block bb, tree result, tree arg)
 {
   use_operand_p use;
   imm_use_iterator imm_iter;
-  gimple defa = SSA_NAME_DEF_STMT (arg);
+  gimple *defa = SSA_NAME_DEF_STMT (arg);
 
   /* If ARG isn't defined in the same block it's too complicated for
      our little mind.  */
@@ -1060,7 +1060,7 @@ trivially_conflicts_p (basic_block bb, tree result, tree arg)
 
   FOR_EACH_IMM_USE_FAST (use, imm_iter, result)
     {
-      gimple use_stmt = USE_STMT (use);
+      gimple *use_stmt = USE_STMT (use);
       if (is_gimple_debug (use_stmt))
 	continue;
       /* Now, if there's a use of RESULT that lies outside this basic block,
@@ -1108,7 +1108,7 @@ insert_backedge_copies (void)
 
       for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple phi = gsi_stmt (gsi);
+	  gimple *phi = gsi_stmt (gsi);
 	  tree result = gimple_phi_result (phi);
 	  size_t i;
 
@@ -1130,7 +1130,7 @@ insert_backedge_copies (void)
 		      || trivially_conflicts_p (bb, result, arg)))
 		{
 		  tree name;
-		  gimple stmt, last = NULL;
+		  gimple *stmt, *last = NULL;
 		  gimple_stmt_iterator gsi2;
 
 		  gsi2 = gsi_last_bb (gimple_phi_arg_edge (phi, i)->src);
diff --git a/gcc/tree-outof-ssa.h b/gcc/tree-outof-ssa.h
index a8c3194..a1db8f9 100644
--- a/gcc/tree-outof-ssa.h
+++ b/gcc/tree-outof-ssa.h
@@ -61,7 +61,7 @@ get_rtx_for_ssa_name (tree exp)
 
 /* If TER decided to forward the definition of SSA name EXP this function
    returns the defining statement, otherwise NULL.  */
-static inline gimple
+static inline gimple *
 get_gimple_for_ssa_name (tree exp)
 {
   int v = SSA_NAME_VERSION (exp);
@@ -70,7 +70,7 @@ get_gimple_for_ssa_name (tree exp)
   return NULL;
 }
 
-extern bool ssa_is_replaceable_p (gimple stmt);
+extern bool ssa_is_replaceable_p (gimple *stmt);
 extern void finish_out_of_ssa (struct ssaexpand *sa);
 extern unsigned int rewrite_out_of_ssa (struct ssaexpand *sa);
 extern void expand_phi_nodes (struct ssaexpand *sa);
diff --git a/gcc/tree-parloops.c b/gcc/tree-parloops.c
index 3bc6a2b..7765fe9 100644
--- a/gcc/tree-parloops.c
+++ b/gcc/tree-parloops.c
@@ -187,17 +187,17 @@ parloop
    reduction in the current loop.  */
 struct reduction_info
 {
-  gimple reduc_stmt;		/* reduction statement.  */
-  gimple reduc_phi;		/* The phi node defining the reduction.  */
+  gimple *reduc_stmt;		/* reduction statement.  */
+  gimple *reduc_phi;		/* The phi node defining the reduction.  */
   enum tree_code reduction_code;/* code for the reduction operation.  */
   unsigned reduc_version;	/* SSA_NAME_VERSION of original reduc_phi
 				   result.  */
-  gimple keep_res;		/* The PHI_RESULT of this phi is the resulting value
+  gimple *keep_res;		/* The PHI_RESULT of this phi is the resulting value
 				   of the reduction variable when existing the loop. */
   tree initial_value;		/* The initial value of the reduction var before entering the loop.  */
   tree field;			/*  the name of the field in the parloop data structure intended for reduction.  */
   tree init;			/* reduction initialization value.  */
-  gimple new_phi;		/* (helper field) Newly created phi node whose result
+  gimple *new_phi;		/* (helper field) Newly created phi node whose result
 				   will be passed to the atomic operation.  Represents
 				   the local result each thread computed for the reduction
 				   operation.  */
@@ -231,7 +231,7 @@ typedef hash_table <reduction_hasher> reduction_info_table_type;
 
 
 static struct reduction_info *
-reduction_phi (reduction_info_table_type reduction_list, gimple phi)
+reduction_phi (reduction_info_table_type reduction_list, gimple *phi)
 {
   struct reduction_info tmpred, *red;
 
@@ -492,7 +492,7 @@ take_address_of (tree obj, tree type, edge entry,
   int_tree_map **dslot;
   struct int_tree_map ielt, *nielt;
   tree *var_p, name, addr;
-  gimple stmt;
+  gimple *stmt;
   gimple_seq stmts;
 
   /* Since the address of OBJ is invariant, the trees may be shared.
@@ -702,7 +702,7 @@ eliminate_local_variables_stmt (edge entry, gimple_stmt_iterator *gsi,
 				int_tree_htab_type decl_address)
 {
   struct elv_data dta;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
 
   memset (&dta.info, '\0', sizeof (dta.info));
   dta.entry = entry;
@@ -896,7 +896,7 @@ separate_decls_in_region_name (tree name, name_to_copy_table_type name_copies,
    replacement decls are stored in DECL_COPIES.  */
 
 static void
-separate_decls_in_region_stmt (edge entry, edge exit, gimple stmt,
+separate_decls_in_region_stmt (edge entry, edge exit, gimple *stmt,
 			       name_to_copy_table_type name_copies,
 			       int_tree_htab_type decl_copies)
 {
@@ -936,7 +936,7 @@ separate_decls_in_region_stmt (edge entry, edge exit, gimple stmt,
    replacement decls are stored in DECL_COPIES.  */
 
 static bool
-separate_decls_in_region_debug (gimple stmt,
+separate_decls_in_region_debug (gimple *stmt,
 				name_to_copy_table_type name_copies,
 				int_tree_htab_type decl_copies)
 {
@@ -1036,7 +1036,7 @@ create_phi_for_local_result (reduction_info **slot, struct loop *loop)
 {
   struct reduction_info *const reduc = *slot;
   edge e;
-  gimple new_phi;
+  gimple *new_phi;
   basic_block store_bb;
   tree local_res;
   source_location locus;
@@ -1092,7 +1092,7 @@ create_call_for_reduction_1 (reduction_info **slot, struct clsn_data *clsn_data)
   edge e;
   tree t, addr, ref, x;
   tree tmp_load, name;
-  gimple load;
+  gimple *load;
 
   load_struct = build_simple_mem_ref (clsn_data->load);
   t = build3 (COMPONENT_REF, type, load_struct, reduc->field, NULL_TREE);
@@ -1150,7 +1150,7 @@ int
 create_loads_for_reductions (reduction_info **slot, struct clsn_data *clsn_data)
 {
   struct reduction_info *const red = *slot;
-  gimple stmt;
+  gimple *stmt;
   gimple_stmt_iterator gsi;
   tree type = TREE_TYPE (gimple_assign_lhs (red->reduc_stmt));
   tree load_struct;
@@ -1187,7 +1187,7 @@ create_final_loads_for_reduction (reduction_info_table_type reduction_list,
 {
   gimple_stmt_iterator gsi;
   tree t;
-  gimple stmt;
+  gimple *stmt;
 
   gsi = gsi_after_labels (ld_st_data->load_bb);
   t = build_fold_addr_expr (ld_st_data->store);
@@ -1211,7 +1211,7 @@ create_stores_for_reduction (reduction_info **slot, struct clsn_data *clsn_data)
 {
   struct reduction_info *const red = *slot;
   tree t;
-  gimple stmt;
+  gimple *stmt;
   gimple_stmt_iterator gsi;
   tree type = TREE_TYPE (gimple_assign_lhs (red->reduc_stmt));
 
@@ -1233,7 +1233,7 @@ create_loads_and_stores_for_name (name_to_copy_elt **slot,
 {
   struct name_to_copy_elt *const elt = *slot;
   tree t;
-  gimple stmt;
+  gimple *stmt;
   gimple_stmt_iterator gsi;
   tree type = TREE_TYPE (elt->new_name);
   tree load_struct;
@@ -1322,7 +1322,7 @@ separate_decls_in_region (edge entry, edge exit,
 
 	  for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	    {
-	      gimple stmt = gsi_stmt (gsi);
+	      gimple *stmt = gsi_stmt (gsi);
 
 	      if (is_gimple_debug (stmt))
 		has_debug_stmt = true;
@@ -1345,7 +1345,7 @@ separate_decls_in_region (edge entry, edge exit,
 	{
 	  for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
 	    {
-	      gimple stmt = gsi_stmt (gsi);
+	      gimple *stmt = gsi_stmt (gsi);
 
 	      if (is_gimple_debug (stmt))
 		{
@@ -1512,7 +1512,7 @@ transform_to_exit_first_loop (struct loop *loop,
   bool ok;
   edge exit = single_dom_exit (loop), hpred;
   tree control, control_name, res, t;
-  gimple phi, nphi, cond_stmt, stmt, cond_nit;
+  gimple *phi, *nphi, *cond_stmt, *stmt, *cond_nit;
   gimple_stmt_iterator gsi;
   tree nit_1;
 
@@ -1619,7 +1619,7 @@ create_parallel_loop (struct loop *loop, tree loop_fn, tree data,
   gimple_stmt_iterator gsi;
   basic_block bb, paral_bb, for_bb, ex_bb;
   tree t, param;
-  gimple stmt, for_stmt, phi, cond_stmt;
+  gimple *stmt, *for_stmt, *phi, *cond_stmt;
   tree cvar, cvar_init, initvar, cvar_next, cvar_base, type;
   edge exit, nexit, guard, end, e;
 
@@ -1760,7 +1760,7 @@ gen_parallel_loop (struct loop *loop, reduction_info_table_type reduction_list,
   struct clsn_data clsn_data;
   unsigned prob;
   location_t loc;
-  gimple cond_stmt;
+  gimple *cond_stmt;
   unsigned int m_p_thread=2;
 
   /* From
@@ -1943,7 +1943,7 @@ loop_has_vector_phi_nodes (struct loop *loop ATTRIBUTE_UNUSED)
 
 static void
 build_new_reduction (reduction_info_table_type reduction_list,
-		     gimple reduc_stmt, gimple phi)
+		     gimple *reduc_stmt, gimple *phi)
 {
   reduction_info **slot;
   struct reduction_info *new_reduction;
@@ -1990,7 +1990,7 @@ gather_scalar_reductions (loop_p loop, reduction_info_table_type reduction_list)
 
   for (gsi = gsi_start_phis (loop->header); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple phi = gsi_stmt (gsi);
+      gimple *phi = gsi_stmt (gsi);
       affine_iv iv;
       tree res = PHI_RESULT (phi);
       bool double_reduc;
@@ -2001,7 +2001,7 @@ gather_scalar_reductions (loop_p loop, reduction_info_table_type reduction_list)
       if (!simple_iv (loop, loop, res, &iv, true)
 	&& simple_loop_info)
 	{
-           gimple reduc_stmt = vect_force_simple_reduction (simple_loop_info,
+           gimple *reduc_stmt = vect_force_simple_reduction (simple_loop_info,
 							    phi, true,
 							    &double_reduc);
 	   if (reduc_stmt && !double_reduc)
@@ -2055,11 +2055,11 @@ try_create_reduction_list (loop_p loop,
 
   for (gsi = gsi_start_phis (exit->dest); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple phi = gsi_stmt (gsi);
+      gimple *phi = gsi_stmt (gsi);
       struct reduction_info *red;
       imm_use_iterator imm_iter;
       use_operand_p use_p;
-      gimple reduc_phi;
+      gimple *reduc_phi;
       tree val = PHI_ARG_DEF_FROM_EDGE (phi, exit);
 
       if (!virtual_operand_p (val))
@@ -2113,7 +2113,7 @@ try_create_reduction_list (loop_p loop,
      iteration space can be distributed efficiently.  */
   for (gsi = gsi_start_phis (loop->header); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple phi = gsi_stmt (gsi);
+      gimple *phi = gsi_stmt (gsi);
       tree def = PHI_RESULT (phi);
       affine_iv iv;
 
diff --git a/gcc/tree-pass.h b/gcc/tree-pass.h
index c025b1f..85589fa 100644
--- a/gcc/tree-pass.h
+++ b/gcc/tree-pass.h
@@ -167,7 +167,7 @@ public:
 
   /* Hook to convert gimple stmt uids into true gimple statements.  The second
      parameter is an array of statements indexed by their uid. */
-  void (*stmt_fixup) (struct cgraph_node *, gimple *);
+  void (*stmt_fixup) (struct cgraph_node *, gimple **);
 
   /* Results of interprocedural propagation of an IPA pass is applied to
      function body via this hook.  */
@@ -182,7 +182,7 @@ protected:
 		  void (*read_summary) (void),
 		  void (*write_optimization_summary) (void),
 		  void (*read_optimization_summary) (void),
-		  void (*stmt_fixup) (struct cgraph_node *, gimple *),
+		  void (*stmt_fixup) (struct cgraph_node *, gimple **),
 		  unsigned int function_transform_todo_flags_start,
 		  unsigned int (*function_transform) (struct cgraph_node *),
 		  void (*variable_transform) (varpool_node *))
@@ -586,7 +586,7 @@ extern void execute_pass_list (function *, opt_pass *);
 extern void execute_ipa_pass_list (opt_pass *);
 extern void execute_ipa_summary_passes (ipa_opt_pass_d *);
 extern void execute_all_ipa_transforms (void);
-extern void execute_all_ipa_stmt_fixups (struct cgraph_node *, gimple *);
+extern void execute_all_ipa_stmt_fixups (struct cgraph_node *, gimple **);
 extern bool pass_init_dump_file (opt_pass *);
 extern void pass_fini_dump_file (opt_pass *);
 
diff --git a/gcc/tree-phinodes.c b/gcc/tree-phinodes.c
index 03c9ebf..c23e300 100644
--- a/gcc/tree-phinodes.c
+++ b/gcc/tree-phinodes.c
@@ -76,7 +76,7 @@ along with GCC; see the file COPYING3.  If not see
    the -2 on all the calculations below.  */
 
 #define NUM_BUCKETS 10
-static GTY ((deletable (""))) vec<gimple, va_gc> *free_phinodes[NUM_BUCKETS - 2];
+static GTY ((deletable (""))) vec<gimple *, va_gc> *free_phinodes[NUM_BUCKETS - 2];
 static unsigned long free_phinode_count;
 
 static int ideal_phi_node_len (int);
@@ -171,7 +171,7 @@ ideal_phi_node_len (int len)
 
 /* Return a PHI node with LEN argument slots for variable VAR.  */
 
-static gimple
+static gimple *
 make_phi_node (tree var, int len)
 {
   gphi *phi;
@@ -216,7 +216,7 @@ make_phi_node (tree var, int len)
 /* We no longer need PHI, release it so that it may be reused.  */
 
 void
-release_phi_node (gimple phi)
+release_phi_node (gimple *phi)
 {
   size_t bucket;
   size_t len = gimple_phi_capacity (phi);
@@ -325,7 +325,7 @@ reserve_phi_args_for_new_edge (basic_block bb)
 /* Adds PHI to BB.  */
 
 void
-add_phi_node_to_bb (gimple phi, basic_block bb)
+add_phi_node_to_bb (gimple *phi, basic_block bb)
 {
   gimple_seq seq = phi_nodes (bb);
   /* Add the new PHI node to the list of PHI nodes for block BB.  */
@@ -344,10 +344,10 @@ add_phi_node_to_bb (gimple phi, basic_block bb)
 
 /* Create a new PHI node for variable VAR at basic block BB.  */
 
-gimple
+gimple *
 create_phi_node (tree var, basic_block bb)
 {
-  gimple phi = make_phi_node (var, EDGE_COUNT (bb->preds));
+  gimple *phi = make_phi_node (var, EDGE_COUNT (bb->preds));
 
   add_phi_node_to_bb (phi, bb);
   return phi;
@@ -361,7 +361,7 @@ create_phi_node (tree var, basic_block bb)
    PHI points to the reallocated phi node when we return.  */
 
 void
-add_phi_arg (gimple phi, tree def, edge e, source_location locus)
+add_phi_arg (gimple *phi, tree def, edge e, source_location locus)
 {
   basic_block bb = e->dest;
 
@@ -446,7 +446,7 @@ remove_phi_args (edge e)
 void
 remove_phi_node (gimple_stmt_iterator *gsi, bool release_lhs_p)
 {
-  gimple phi = gsi_stmt (*gsi);
+  gimple *phi = gsi_stmt (*gsi);
 
   if (release_lhs_p)
     insert_debug_temps_for_defs (gsi);
@@ -477,7 +477,7 @@ remove_phi_nodes (basic_block bb)
    NULL.  */
 
 tree
-degenerate_phi_result (gimple phi)
+degenerate_phi_result (gimple *phi)
 {
   tree lhs = gimple_phi_result (phi);
   tree val = NULL;
diff --git a/gcc/tree-phinodes.h b/gcc/tree-phinodes.h
index 1e5df83..b58a027 100644
--- a/gcc/tree-phinodes.h
+++ b/gcc/tree-phinodes.h
@@ -21,19 +21,19 @@ along with GCC; see the file COPYING3.  If not see
 #define GCC_TREE_PHINODES_H
 
 extern void phinodes_print_statistics (void);
-extern void release_phi_node (gimple);
+extern void release_phi_node (gimple *);
 extern void reserve_phi_args_for_new_edge (basic_block);
-extern void add_phi_node_to_bb (gimple phi, basic_block bb);
-extern gimple create_phi_node (tree, basic_block);
-extern void add_phi_arg (gimple, tree, edge, source_location);
+extern void add_phi_node_to_bb (gimple *phi, basic_block bb);
+extern gimple *create_phi_node (tree, basic_block);
+extern void add_phi_arg (gimple *, tree, edge, source_location);
 extern void remove_phi_args (edge);
 extern void remove_phi_node (gimple_stmt_iterator *, bool);
 extern void remove_phi_nodes (basic_block);
-extern tree degenerate_phi_result (gimple);
+extern tree degenerate_phi_result (gimple *);
 extern void set_phi_nodes (basic_block, gimple_seq);
 
 static inline use_operand_p
-gimple_phi_arg_imm_use_ptr (gimple gs, int i)
+gimple_phi_arg_imm_use_ptr (gimple *gs, int i)
 {
   return &gimple_phi_arg (gs, i)->imm_use;
 }
@@ -45,7 +45,7 @@ phi_arg_index_from_use (use_operand_p use)
 {
   struct phi_arg_d *element, *root;
   size_t index;
-  gimple phi;
+  gimple *phi;
 
   /* Since the use is the first thing in a PHI argument element, we can
      calculate its index based on casting it to an argument, and performing
diff --git a/gcc/tree-predcom.c b/gcc/tree-predcom.c
index 2cb47db..a29eaef 100644
--- a/gcc/tree-predcom.c
+++ b/gcc/tree-predcom.c
@@ -238,7 +238,7 @@ typedef struct dref_d
   struct data_reference *ref;
 
   /* The statement in that the reference appears.  */
-  gimple stmt;
+  gimple *stmt;
 
   /* In case that STMT is a phi node, this field is set to the SSA name
      defined by it in replace_phis_by_defined_names (in order to avoid
@@ -1112,11 +1112,11 @@ valid_initializer_p (struct data_reference *ref,
    iteration), returns the phi node.  Otherwise, NULL_TREE is returned.  ROOT
    is the root of the current chain.  */
 
-static gimple
+static gimple *
 find_looparound_phi (struct loop *loop, dref ref, dref root)
 {
   tree name, init, init_ref;
-  gimple phi = NULL, init_stmt;
+  gimple *phi = NULL, *init_stmt;
   edge latch = loop_latch_edge (loop);
   struct data_reference init_dr;
   gimple_stmt_iterator psi;
@@ -1173,7 +1173,7 @@ find_looparound_phi (struct loop *loop, dref ref, dref root)
 /* Adds a reference for the looparound copy of REF in PHI to CHAIN.  */
 
 static void
-insert_looparound_copy (chain_p chain, dref ref, gimple phi)
+insert_looparound_copy (chain_p chain, dref ref, gimple *phi)
 {
   dref nw = XCNEW (struct dref_d), aref;
   unsigned i;
@@ -1204,7 +1204,7 @@ add_looparound_copies (struct loop *loop, chain_p chain)
 {
   unsigned i;
   dref ref, root = get_chain_root (chain);
-  gimple phi;
+  gimple *phi;
 
   FOR_EACH_VEC_ELT (chain->refs, i, ref)
     {
@@ -1289,10 +1289,10 @@ determine_roots (struct loop *loop,
    is in the lhs of STMT, false if it is in rhs.  */
 
 static void
-replace_ref_with (gimple stmt, tree new_tree, bool set, bool in_lhs)
+replace_ref_with (gimple *stmt, tree new_tree, bool set, bool in_lhs)
 {
   tree val;
-  gimple new_stmt;
+  gimple *new_stmt;
   gimple_stmt_iterator bsi, psi;
 
   if (gimple_code (stmt) == GIMPLE_PHI)
@@ -1456,7 +1456,7 @@ initialize_root_vars (struct loop *loop, chain_p chain, bitmap tmp_vars)
   dref root = get_chain_root (chain);
   bool reuse_first = !chain->has_max_use_after;
   tree ref, init, var, next;
-  gimple phi;
+  gimple *phi;
   gimple_seq stmts;
   edge entry = loop_preheader_edge (loop), latch = loop_latch_edge (loop);
 
@@ -1530,7 +1530,7 @@ initialize_root_vars_lm (struct loop *loop, dref root, bool written,
   unsigned i;
   tree ref = DR_REF (root->ref), init, var, next;
   gimple_seq stmts;
-  gimple phi;
+  gimple *phi;
   edge entry = loop_preheader_edge (loop), latch = loop_latch_edge (loop);
 
   /* Find the initializer for the variable, and check that it cannot
@@ -1561,7 +1561,7 @@ initialize_root_vars_lm (struct loop *loop, dref root, bool written,
     }
   else
     {
-      gimple init_stmt = gimple_build_assign (var, init);
+      gimple *init_stmt = gimple_build_assign (var, init);
       gsi_insert_on_edge_immediate (entry, init_stmt);
     }
 }
@@ -1618,12 +1618,12 @@ execute_load_motion (struct loop *loop, chain_p chain, bitmap tmp_vars)
    the looparound phi nodes contained in one of the chains.  If there is no
    such statement, or more statements, NULL is returned.  */
 
-static gimple
+static gimple *
 single_nonlooparound_use (tree name)
 {
   use_operand_p use;
   imm_use_iterator it;
-  gimple stmt, ret = NULL;
+  gimple *stmt, *ret = NULL;
 
   FOR_EACH_IMM_USE_FAST (use, it, name)
     {
@@ -1654,10 +1654,10 @@ single_nonlooparound_use (tree name)
    used.  */
 
 static void
-remove_stmt (gimple stmt)
+remove_stmt (gimple *stmt)
 {
   tree name;
-  gimple next;
+  gimple *next;
   gimple_stmt_iterator psi;
 
   if (gimple_code (stmt) == GIMPLE_PHI)
@@ -1853,7 +1853,7 @@ execute_pred_commoning_cbck (struct loop *loop, void *data)
 static void
 base_names_in_chain_on (struct loop *loop, tree name, tree var)
 {
-  gimple stmt, phi;
+  gimple *stmt, *phi;
   imm_use_iterator iter;
 
   replace_ssa_name_symbol (name, var);
@@ -1887,7 +1887,7 @@ static void
 eliminate_temp_copies (struct loop *loop, bitmap tmp_vars)
 {
   edge e;
-  gimple phi, stmt;
+  gimple *phi, *stmt;
   tree name, use, var;
   gimple_stmt_iterator psi;
 
@@ -1934,10 +1934,10 @@ chain_can_be_combined_p (chain_p chain)
    statements, NAME is replaced with the actual name used in the returned
    statement.  */
 
-static gimple
+static gimple *
 find_use_stmt (tree *name)
 {
-  gimple stmt;
+  gimple *stmt;
   tree rhs, lhs;
 
   /* Skip over assignments.  */
@@ -1987,11 +1987,11 @@ may_reassociate_p (tree type, enum tree_code code)
    tree of the same operations and returns its root.  Distance to the root
    is stored in DISTANCE.  */
 
-static gimple
-find_associative_operation_root (gimple stmt, unsigned *distance)
+static gimple *
+find_associative_operation_root (gimple *stmt, unsigned *distance)
 {
   tree lhs;
-  gimple next;
+  gimple *next;
   enum tree_code code = gimple_assign_rhs_code (stmt);
   tree type = TREE_TYPE (gimple_assign_lhs (stmt));
   unsigned dist = 0;
@@ -2024,10 +2024,10 @@ find_associative_operation_root (gimple stmt, unsigned *distance)
    tree formed by this operation instead of the statement that uses NAME1 or
    NAME2.  */
 
-static gimple
+static gimple *
 find_common_use_stmt (tree *name1, tree *name2)
 {
-  gimple stmt1, stmt2;
+  gimple *stmt1, *stmt2;
 
   stmt1 = find_use_stmt (name1);
   if (!stmt1)
@@ -2062,7 +2062,7 @@ combinable_refs_p (dref r1, dref r2,
   bool aswap;
   tree atype;
   tree name1, name2;
-  gimple stmt;
+  gimple *stmt;
 
   name1 = name_for_ref (r1);
   name2 = name_for_ref (r2);
@@ -2099,7 +2099,7 @@ combinable_refs_p (dref r1, dref r2,
    an assignment of the remaining operand.  */
 
 static void
-remove_name_from_operation (gimple stmt, tree op)
+remove_name_from_operation (gimple *stmt, tree op)
 {
   tree other_op;
   gimple_stmt_iterator si;
@@ -2123,11 +2123,11 @@ remove_name_from_operation (gimple stmt, tree op)
 /* Reassociates the expression in that NAME1 and NAME2 are used so that they
    are combined in a single statement, and returns this statement.  */
 
-static gimple
+static gimple *
 reassociate_to_the_same_stmt (tree name1, tree name2)
 {
-  gimple stmt1, stmt2, root1, root2, s1, s2;
-  gimple new_stmt, tmp_stmt;
+  gimple *stmt1, *stmt2, *root1, *root2, *s1, *s2;
+  gimple *new_stmt, *tmp_stmt;
   tree new_name, tmp_name, var, r1, r2;
   unsigned dist1, dist2;
   enum tree_code code;
@@ -2209,10 +2209,10 @@ reassociate_to_the_same_stmt (tree name1, tree name2)
    associative and commutative operation in the same expression, reassociate
    the expression so that they are used in the same statement.  */
 
-static gimple
+static gimple *
 stmt_combining_refs (dref r1, dref r2)
 {
-  gimple stmt1, stmt2;
+  gimple *stmt1, *stmt2;
   tree name1 = name_for_ref (r1);
   tree name2 = name_for_ref (r2);
 
@@ -2235,7 +2235,7 @@ combine_chains (chain_p ch1, chain_p ch2)
   bool swap = false;
   chain_p new_chain;
   unsigned i;
-  gimple root_stmt;
+  gimple *root_stmt;
   tree rslt_type = NULL_TREE;
 
   if (ch1 == ch2)
diff --git a/gcc/tree-profile.c b/gcc/tree-profile.c
index deefa8b..0dc49d1 100644
--- a/gcc/tree-profile.c
+++ b/gcc/tree-profile.c
@@ -287,7 +287,7 @@ void
 gimple_gen_edge_profiler (int edgeno, edge e)
 {
   tree ref, one, gcov_type_tmp_var;
-  gimple stmt1, stmt2, stmt3;
+  gimple *stmt1, *stmt2, *stmt3;
 
   ref = tree_coverage_counter_ref (GCOV_COUNTER_ARCS, edgeno);
   one = build_int_cst (gcov_type_node, 1);
@@ -325,10 +325,10 @@ prepare_instrumented_value (gimple_stmt_iterator *gsi, histogram_value value)
 void
 gimple_gen_interval_profiler (histogram_value value, unsigned tag, unsigned base)
 {
-  gimple stmt = value->hvalue.stmt;
+  gimple *stmt = value->hvalue.stmt;
   gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
   tree ref = tree_coverage_counter_ref (tag, base), ref_ptr;
-  gimple call;
+  gimple *call;
   tree val;
   tree start = build_int_cst_type (integer_type_node,
 				   value->hdata.intvl.int_start);
@@ -351,10 +351,10 @@ gimple_gen_interval_profiler (histogram_value value, unsigned tag, unsigned base
 void
 gimple_gen_pow2_profiler (histogram_value value, unsigned tag, unsigned base)
 {
-  gimple stmt = value->hvalue.stmt;
+  gimple *stmt = value->hvalue.stmt;
   gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
   tree ref_ptr = tree_coverage_counter_addr (tag, base);
-  gimple call;
+  gimple *call;
   tree val;
 
   ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
@@ -371,10 +371,10 @@ gimple_gen_pow2_profiler (histogram_value value, unsigned tag, unsigned base)
 void
 gimple_gen_one_value_profiler (histogram_value value, unsigned tag, unsigned base)
 {
-  gimple stmt = value->hvalue.stmt;
+  gimple *stmt = value->hvalue.stmt;
   gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
   tree ref_ptr = tree_coverage_counter_addr (tag, base);
-  gimple call;
+  gimple *call;
   tree val;
 
   ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
@@ -395,8 +395,8 @@ void
 gimple_gen_ic_profiler (histogram_value value, unsigned tag, unsigned base)
 {
   tree tmp1;
-  gimple stmt1, stmt2, stmt3;
-  gimple stmt = value->hvalue.stmt;
+  gimple *stmt1, *stmt2, *stmt3;
+  gimple *stmt = value->hvalue.stmt;
   gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
   tree ref_ptr = tree_coverage_counter_addr (tag, base);
 
@@ -431,7 +431,7 @@ gimple_gen_ic_func_profiler (void)
 {
   struct cgraph_node * c_node = cgraph_get_node (current_function_decl);
   gimple_stmt_iterator gsi;
-  gimple stmt1, stmt2;
+  gimple *stmt1, *stmt2;
   tree tree_uid, cur_func, void0;
 
   if (cgraph_only_called_directly_p (c_node))
@@ -492,7 +492,7 @@ gimple_gen_time_profiler (unsigned tag, unsigned base,
                           gimple_stmt_iterator &gsi)
 {
   tree ref_ptr = tree_coverage_counter_addr (tag, base);
-  gimple call;
+  gimple *call;
 
   ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
 				      true, NULL_TREE, true, GSI_SAME_STMT);
@@ -524,10 +524,10 @@ gimple_gen_const_delta_profiler (histogram_value value ATTRIBUTE_UNUSED,
 void
 gimple_gen_average_profiler (histogram_value value, unsigned tag, unsigned base)
 {
-  gimple stmt = value->hvalue.stmt;
+  gimple *stmt = value->hvalue.stmt;
   gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
   tree ref_ptr = tree_coverage_counter_addr (tag, base);
-  gimple call;
+  gimple *call;
   tree val;
 
   ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
@@ -545,10 +545,10 @@ gimple_gen_average_profiler (histogram_value value, unsigned tag, unsigned base)
 void
 gimple_gen_ior_profiler (histogram_value value, unsigned tag, unsigned base)
 {
-  gimple stmt = value->hvalue.stmt;
+  gimple *stmt = value->hvalue.stmt;
   gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
   tree ref_ptr = tree_coverage_counter_addr (tag, base);
-  gimple call;
+  gimple *call;
   tree val;
 
   ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
@@ -642,7 +642,7 @@ tree_profiling (void)
 	  gimple_stmt_iterator gsi;
 	  for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	    {
-	      gimple stmt = gsi_stmt (gsi);
+	      gimple *stmt = gsi_stmt (gsi);
 	      if (is_gimple_call (stmt))
 		update_stmt (stmt);
 	    }
diff --git a/gcc/tree-scalar-evolution.c b/gcc/tree-scalar-evolution.c
index af72308..112840d 100644
--- a/gcc/tree-scalar-evolution.c
+++ b/gcc/tree-scalar-evolution.c
@@ -407,7 +407,7 @@ chrec_contains_symbols_defined_in_loop (const_tree chrec, unsigned loop_nb)
 
   if (TREE_CODE (chrec) == SSA_NAME)
     {
-      gimple def;
+      gimple *def;
       loop_p def_loop, loop;
 
       if (SSA_NAME_IS_DEFAULT_DEF (chrec))
@@ -437,7 +437,7 @@ chrec_contains_symbols_defined_in_loop (const_tree chrec, unsigned loop_nb)
 /* Return true when PHI is a loop-phi-node.  */
 
 static bool
-loop_phi_node_p (gimple phi)
+loop_phi_node_p (gimple *phi)
 {
   /* The implementation of this function is based on the following
      property: "all the loop-phi-nodes of a loop are contained in the
@@ -619,7 +619,7 @@ get_scalar_evolution (basic_block instantiated_below, tree scalar)
 
 static tree
 add_to_evolution_1 (unsigned loop_nb, tree chrec_before, tree to_add,
-		    gimple at_stmt)
+		    gimple *at_stmt)
 {
   tree type, left, right;
   struct loop *loop = get_loop (cfun, loop_nb), *chloop;
@@ -816,7 +816,7 @@ add_to_evolution_1 (unsigned loop_nb, tree chrec_before, tree to_add,
 
 static tree
 add_to_evolution (unsigned loop_nb, tree chrec_before, enum tree_code code,
-		  tree to_add, gimple at_stmt)
+		  tree to_add, gimple *at_stmt)
 {
   tree type = chrec_type (to_add);
   tree res = NULL_TREE;
@@ -868,10 +868,10 @@ add_to_evolution (unsigned loop_nb, tree chrec_before, enum tree_code code,
    guards the exit edge.  If the expression is too difficult to
    analyze, then give up.  */
 
-gimple
+gimple *
 get_loop_exit_condition (const struct loop *loop)
 {
-  gimple res = NULL;
+  gimple *res = NULL;
   edge exit_edge = single_exit (loop);
 
   if (dump_file && (dump_flags & TDF_SCEV))
@@ -879,7 +879,7 @@ get_loop_exit_condition (const struct loop *loop)
 
   if (exit_edge)
     {
-      gimple stmt;
+      gimple *stmt;
 
       stmt = last_stmt (exit_edge->src);
       if (gimple_code (stmt) == GIMPLE_COND)
@@ -905,15 +905,15 @@ typedef enum t_bool {
 } t_bool;
 
 
-static t_bool follow_ssa_edge (struct loop *loop, gimple, gimple, tree *, int);
+static t_bool follow_ssa_edge (struct loop *loop, gimple *, gimple *, tree *, int);
 
 /* Follow the ssa edge into the binary expression RHS0 CODE RHS1.
    Return true if the strongly connected component has been found.  */
 
 static t_bool
-follow_ssa_edge_binary (struct loop *loop, gimple at_stmt,
+follow_ssa_edge_binary (struct loop *loop, gimple *at_stmt,
 			tree type, tree rhs0, enum tree_code code, tree rhs1,
-			gimple halting_phi, tree *evolution_of_loop, int limit)
+			gimple *halting_phi, tree *evolution_of_loop, int limit)
 {
   t_bool res = t_false;
   tree evol;
@@ -1047,8 +1047,8 @@ follow_ssa_edge_binary (struct loop *loop, gimple at_stmt,
    Return true if the strongly connected component has been found.  */
 
 static t_bool
-follow_ssa_edge_expr (struct loop *loop, gimple at_stmt, tree expr,
-		      gimple halting_phi, tree *evolution_of_loop, int limit)
+follow_ssa_edge_expr (struct loop *loop, gimple *at_stmt, tree expr,
+		      gimple *halting_phi, tree *evolution_of_loop, int limit)
 {
   enum tree_code code = TREE_CODE (expr);
   tree type = TREE_TYPE (expr), rhs0, rhs1;
@@ -1137,8 +1137,8 @@ follow_ssa_edge_expr (struct loop *loop, gimple at_stmt, tree expr,
    Return true if the strongly connected component has been found.  */
 
 static t_bool
-follow_ssa_edge_in_rhs (struct loop *loop, gimple stmt,
-			gimple halting_phi, tree *evolution_of_loop, int limit)
+follow_ssa_edge_in_rhs (struct loop *loop, gimple *stmt,
+			gimple *halting_phi, tree *evolution_of_loop, int limit)
 {
   enum tree_code code = gimple_assign_rhs_code (stmt);
   tree type = gimple_expr_type (stmt), rhs1, rhs2;
@@ -1178,7 +1178,7 @@ follow_ssa_edge_in_rhs (struct loop *loop, gimple stmt,
 /* Checks whether the I-th argument of a PHI comes from a backedge.  */
 
 static bool
-backedge_phi_arg_p (gimple phi, int i)
+backedge_phi_arg_p (gimple *phi, int i)
 {
   const_edge e = gimple_phi_arg_edge (phi, i);
 
@@ -1198,8 +1198,8 @@ backedge_phi_arg_p (gimple phi, int i)
 static inline t_bool
 follow_ssa_edge_in_condition_phi_branch (int i,
 					 struct loop *loop,
-					 gimple condition_phi,
-					 gimple halting_phi,
+					 gimple *condition_phi,
+					 gimple *halting_phi,
 					 tree *evolution_of_branch,
 					 tree init_cond, int limit)
 {
@@ -1233,8 +1233,8 @@ follow_ssa_edge_in_condition_phi_branch (int i,
 
 static t_bool
 follow_ssa_edge_in_condition_phi (struct loop *loop,
-				  gimple condition_phi,
-				  gimple halting_phi,
+				  gimple *condition_phi,
+				  gimple *halting_phi,
 				  tree *evolution_of_loop, int limit)
 {
   int i, n;
@@ -1280,8 +1280,8 @@ follow_ssa_edge_in_condition_phi (struct loop *loop,
 
 static t_bool
 follow_ssa_edge_inner_loop_phi (struct loop *outer_loop,
-				gimple loop_phi_node,
-				gimple halting_phi,
+				gimple *loop_phi_node,
+				gimple *halting_phi,
 				tree *evolution_of_loop, int limit)
 {
   struct loop *loop = loop_containing_stmt (loop_phi_node);
@@ -1326,7 +1326,7 @@ follow_ssa_edge_inner_loop_phi (struct loop *outer_loop,
    path that is analyzed on the return walk.  */
 
 static t_bool
-follow_ssa_edge (struct loop *loop, gimple def, gimple halting_phi,
+follow_ssa_edge (struct loop *loop, gimple *def, gimple *halting_phi,
 		 tree *evolution_of_loop, int limit)
 {
   struct loop *def_loop;
@@ -1447,7 +1447,7 @@ simplify_peeled_chrec (struct loop *loop, tree arg, tree init_cond)
    function from LOOP_PHI_NODE to LOOP_PHI_NODE in the loop.  */
 
 static tree
-analyze_evolution_in_loop (gimple loop_phi_node,
+analyze_evolution_in_loop (gimple *loop_phi_node,
 			   tree init_cond)
 {
   int i, n = gimple_phi_num_args (loop_phi_node);
@@ -1467,7 +1467,7 @@ analyze_evolution_in_loop (gimple loop_phi_node,
   for (i = 0; i < n; i++)
     {
       tree arg = PHI_ARG_DEF (loop_phi_node, i);
-      gimple ssa_chain;
+      gimple *ssa_chain;
       tree ev_fn;
       t_bool res;
 
@@ -1542,7 +1542,7 @@ analyze_evolution_in_loop (gimple loop_phi_node,
    loop, and leaves this task to the on-demand tree reconstructor.  */
 
 static tree
-analyze_initial_condition (gimple loop_phi_node)
+analyze_initial_condition (gimple *loop_phi_node)
 {
   int i, n;
   tree init_cond = chrec_not_analyzed_yet;
@@ -1590,7 +1590,7 @@ analyze_initial_condition (gimple loop_phi_node)
      Handle degenerate PHIs here to not miss important unrollings.  */
   if (TREE_CODE (init_cond) == SSA_NAME)
     {
-      gimple def = SSA_NAME_DEF_STMT (init_cond);
+      gimple *def = SSA_NAME_DEF_STMT (init_cond);
       tree res;
       if (gimple_code (def) == GIMPLE_PHI
 	  && (res = degenerate_phi_result (def)) != NULL_TREE
@@ -1613,7 +1613,7 @@ analyze_initial_condition (gimple loop_phi_node)
 /* Analyze the scalar evolution for LOOP_PHI_NODE.  */
 
 static tree
-interpret_loop_phi (struct loop *loop, gimple loop_phi_node)
+interpret_loop_phi (struct loop *loop, gimple *loop_phi_node)
 {
   tree res;
   struct loop *phi_loop = loop_containing_stmt (loop_phi_node);
@@ -1662,7 +1662,7 @@ interpret_loop_phi (struct loop *loop, gimple loop_phi_node)
    analyzed.  */
 
 static tree
-interpret_condition_phi (struct loop *loop, gimple condition_phi)
+interpret_condition_phi (struct loop *loop, gimple *condition_phi)
 {
   int i, n = gimple_phi_num_args (condition_phi);
   tree res = chrec_not_analyzed_yet;
@@ -1694,11 +1694,11 @@ interpret_condition_phi (struct loop *loop, gimple condition_phi)
    analyze the effect of an inner loop: see interpret_loop_phi.  */
 
 static tree
-interpret_rhs_expr (struct loop *loop, gimple at_stmt,
+interpret_rhs_expr (struct loop *loop, gimple *at_stmt,
 		    tree type, tree rhs1, enum tree_code code, tree rhs2)
 {
   tree res, chrec1, chrec2;
-  gimple def;
+  gimple *def;
 
   if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS)
     {
@@ -1875,7 +1875,7 @@ interpret_rhs_expr (struct loop *loop, gimple at_stmt,
 /* Interpret the expression EXPR.  */
 
 static tree
-interpret_expr (struct loop *loop, gimple at_stmt, tree expr)
+interpret_expr (struct loop *loop, gimple *at_stmt, tree expr)
 {
   enum tree_code code;
   tree type = TREE_TYPE (expr), op0, op1;
@@ -1896,7 +1896,7 @@ interpret_expr (struct loop *loop, gimple at_stmt, tree expr)
 /* Interpret the rhs of the assignment STMT.  */
 
 static tree
-interpret_gimple_assign (struct loop *loop, gimple stmt)
+interpret_gimple_assign (struct loop *loop, gimple *stmt)
 {
   tree type = TREE_TYPE (gimple_assign_lhs (stmt));
   enum tree_code code = gimple_assign_rhs_code (stmt);
@@ -1943,7 +1943,7 @@ static tree
 analyze_scalar_evolution_1 (struct loop *loop, tree var, tree res)
 {
   tree type = TREE_TYPE (var);
-  gimple def;
+  gimple *def;
   basic_block bb;
   struct loop *def_loop;
 
@@ -2239,7 +2239,7 @@ loop_closed_phi_def (tree var)
 {
   struct loop *loop;
   edge exit;
-  gimple phi;
+  gimple *phi;
   gimple_stmt_iterator psi;
 
   if (var == NULL_TREE
@@ -3342,7 +3342,7 @@ scev_const_prop (void)
 {
   basic_block bb;
   tree name, type, ev;
-  gimple phi, ass;
+  gimple *phi, *ass;
   struct loop *loop, *ex_loop;
   bitmap ssa_names_to_remove = NULL;
   unsigned i;
@@ -3500,7 +3500,7 @@ scev_const_prop (void)
 	      gsi2 = gsi_start (stmts);
 	      while (!gsi_end_p (gsi2))
 		{
-		  gimple stmt = gsi_stmt (gsi2);
+		  gimple *stmt = gsi_stmt (gsi2);
 		  gimple_stmt_iterator gsi3 = gsi2;
 		  gsi_next (&gsi2);
 		  gsi_remove (&gsi3, false);
diff --git a/gcc/tree-scalar-evolution.h b/gcc/tree-scalar-evolution.h
index 5569976..d075631 100644
--- a/gcc/tree-scalar-evolution.h
+++ b/gcc/tree-scalar-evolution.h
@@ -22,7 +22,7 @@ along with GCC; see the file COPYING3.  If not see
 #define GCC_TREE_SCALAR_EVOLUTION_H
 
 extern tree number_of_latch_executions (struct loop *);
-extern gimple get_loop_exit_condition (const struct loop *);
+extern gimple *get_loop_exit_condition (const struct loop *);
 
 extern void scev_initialize (void);
 extern bool scev_initialized_p (void);
diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c
index 72c485b..58e5def 100644
--- a/gcc/tree-sra.c
+++ b/gcc/tree-sra.c
@@ -157,7 +157,7 @@ struct access
   tree type;
 
   /* The statement this access belongs to.  */
-  gimple stmt;
+  gimple *stmt;
 
   /* Next group representative for this aggregate. */
   struct access *next_grp;
@@ -820,7 +820,7 @@ get_ssa_base_param (tree t)
    final.  */
 
 static void
-mark_parm_dereference (tree base, HOST_WIDE_INT dist, gimple stmt)
+mark_parm_dereference (tree base, HOST_WIDE_INT dist, gimple *stmt)
 {
   basic_block bb = gimple_bb (stmt);
   int idx, parm_index = 0;
@@ -876,7 +876,7 @@ create_access_1 (tree base, HOST_WIDE_INT offset, HOST_WIDE_INT size)
    not possible.  */
 
 static struct access *
-create_access (tree expr, gimple stmt, bool write)
+create_access (tree expr, gimple *stmt, bool write)
 {
   struct access *access;
   HOST_WIDE_INT offset, size, max_size;
@@ -1064,7 +1064,7 @@ disqualify_base_of_expr (tree t, const char *reason)
    created.  */
 
 static struct access *
-build_access_from_expr_1 (tree expr, gimple stmt, bool write)
+build_access_from_expr_1 (tree expr, gimple *stmt, bool write)
 {
   struct access *ret = NULL;
   bool partial_ref;
@@ -1125,7 +1125,7 @@ build_access_from_expr_1 (tree expr, gimple stmt, bool write)
    true if the expression is a store and false otherwise. */
 
 static bool
-build_access_from_expr (tree expr, gimple stmt, bool write)
+build_access_from_expr (tree expr, gimple *stmt, bool write)
 {
   struct access *access;
 
@@ -1169,7 +1169,7 @@ single_non_eh_succ (basic_block bb)
    NULL, in that case ignore it.  */
 
 static bool
-disqualify_if_bad_bb_terminating_stmt (gimple stmt, tree lhs, tree rhs)
+disqualify_if_bad_bb_terminating_stmt (gimple *stmt, tree lhs, tree rhs)
 {
   if ((sra_mode == SRA_MODE_EARLY_INTRA || sra_mode == SRA_MODE_INTRA)
       && stmt_ends_bb_p (stmt))
@@ -1191,7 +1191,7 @@ disqualify_if_bad_bb_terminating_stmt (gimple stmt, tree lhs, tree rhs)
    true if any access has been inserted.  */
 
 static bool
-build_accesses_from_assign (gimple stmt)
+build_accesses_from_assign (gimple *stmt)
 {
   tree lhs, rhs;
   struct access *lacc, *racc;
@@ -1247,7 +1247,7 @@ build_accesses_from_assign (gimple stmt)
    GIMPLE_ASM operands with memory constrains which cannot be scalarized.  */
 
 static bool
-asm_visit_addr (gimple, tree op, tree, void *)
+asm_visit_addr (gimple *, tree op, tree, void *)
 {
   op = get_base_address (op);
   if (op
@@ -1262,7 +1262,7 @@ asm_visit_addr (gimple, tree op, tree, void *)
    that their types match.  */
 
 static inline bool
-callsite_arguments_match_p (gimple call)
+callsite_arguments_match_p (gimple *call)
 {
   if (gimple_call_num_args (call) < (unsigned) func_param_count)
     return false;
@@ -1294,7 +1294,7 @@ scan_function (void)
       gimple_stmt_iterator gsi;
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  tree t;
 	  unsigned i;
 
@@ -1551,7 +1551,7 @@ build_ref_for_offset (location_t loc, tree base, HOST_WIDE_INT offset,
      offset such as array[var_index].  */
   if (!base)
     {
-      gimple stmt;
+      gimple *stmt;
       tree tmp, addr;
 
       gcc_checking_assert (gsi);
@@ -2633,7 +2633,7 @@ generate_subtree_copies (struct access *access, tree agg,
 	      || access->offset + access->size > start_offset))
 	{
 	  tree expr, repl = get_access_replacement (access);
-	  gimple stmt;
+	  gimple *stmt;
 
 	  expr = build_ref_for_model (loc, agg, access->offset - top_offset,
 				      access, gsi, insert_after);
@@ -2671,7 +2671,7 @@ generate_subtree_copies (struct access *access, tree agg,
 	       && (chunk_size == 0
 		   || access->offset + access->size > start_offset))
 	{
-	  gimple ds;
+	  gimple *ds;
 	  tree drhs = build_debug_ref_for_model (loc, agg,
 						 access->offset - top_offset,
 						 access);
@@ -2707,7 +2707,7 @@ init_subtree_with_zero (struct access *access, gimple_stmt_iterator *gsi,
 
   if (access->grp_to_be_replaced)
     {
-      gimple stmt;
+      gimple *stmt;
 
       stmt = gimple_build_assign (get_access_replacement (access),
 				  build_zero_cst (access->type));
@@ -2720,7 +2720,7 @@ init_subtree_with_zero (struct access *access, gimple_stmt_iterator *gsi,
     }
   else if (access->grp_to_be_debug_replaced)
     {
-      gimple ds = gimple_build_debug_bind (get_access_replacement (access),
+      gimple *ds = gimple_build_debug_bind (get_access_replacement (access),
 					   build_zero_cst (access->type),
 					   gsi_stmt (*gsi));
       if (insert_after)
@@ -2816,7 +2816,7 @@ sra_modify_expr (tree *expr, gimple_stmt_iterator *gsi, bool write)
 
 	  if (write)
 	    {
-	      gimple stmt;
+	      gimple *stmt;
 
 	      if (access->grp_partial_lhs)
 		ref = force_gimple_operand_gsi (gsi, ref, true, NULL_TREE,
@@ -2827,7 +2827,7 @@ sra_modify_expr (tree *expr, gimple_stmt_iterator *gsi, bool write)
 	    }
 	  else
 	    {
-	      gimple stmt;
+	      gimple *stmt;
 
 	      if (access->grp_partial_lhs)
 		repl = force_gimple_operand_gsi (gsi, repl, true, NULL_TREE,
@@ -2843,7 +2843,7 @@ sra_modify_expr (tree *expr, gimple_stmt_iterator *gsi, bool write)
     }
   else if (write && access->grp_to_be_debug_replaced)
     {
-      gimple ds = gimple_build_debug_bind (get_access_replacement (access),
+      gimple *ds = gimple_build_debug_bind (get_access_replacement (access),
 					   NULL_TREE,
 					   gsi_stmt (*gsi));
       gsi_insert_after (gsi, ds, GSI_NEW_STMT);
@@ -2945,7 +2945,7 @@ load_assign_lhs_subreplacements (struct access *lacc,
       if (lacc->grp_to_be_replaced)
 	{
 	  struct access *racc;
-	  gimple stmt;
+	  gimple *stmt;
 	  tree rhs;
 
 	  racc = find_access_in_subtree (sad->top_racc, offset, lacc->size);
@@ -2995,7 +2995,7 @@ load_assign_lhs_subreplacements (struct access *lacc,
 
 	  if (lacc && lacc->grp_to_be_debug_replaced)
 	    {
-	      gimple ds;
+	      gimple *ds;
 	      tree drhs;
 	      struct access *racc = find_access_in_subtree (sad->top_racc,
 							    offset,
@@ -3042,7 +3042,7 @@ enum assignment_mod_result { SRA_AM_NONE,       /* nothing done for the stmt */
    the same values as sra_modify_assign.  */
 
 static enum assignment_mod_result
-sra_modify_constructor_assign (gimple *stmt, gimple_stmt_iterator *gsi)
+sra_modify_constructor_assign (gimple **stmt, gimple_stmt_iterator *gsi)
 {
   tree lhs = gimple_assign_lhs (*stmt);
   struct access *acc;
@@ -3132,7 +3132,7 @@ contains_vce_or_bfcref_p (const_tree ref)
    copying.  */
 
 static enum assignment_mod_result
-sra_modify_assign (gimple *stmt, gimple_stmt_iterator *gsi)
+sra_modify_assign (gimple **stmt, gimple_stmt_iterator *gsi)
 {
   struct access *lacc, *racc;
   tree lhs, rhs;
@@ -3237,7 +3237,7 @@ sra_modify_assign (gimple *stmt, gimple_stmt_iterator *gsi)
 	    drhs = fold_build1_loc (loc, VIEW_CONVERT_EXPR,
 				    TREE_TYPE (dlhs), drhs);
 	}
-      gimple ds = gimple_build_debug_bind (dlhs, drhs, *stmt);
+      gimple *ds = gimple_build_debug_bind (dlhs, drhs, *stmt);
       gsi_insert_before (gsi, ds, GSI_SAME_STMT);
     }
 
@@ -3398,7 +3398,7 @@ sra_modify_function_body (void)
       gimple_stmt_iterator gsi = gsi_start_bb (bb);
       while (!gsi_end_p (gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  enum assignment_mod_result assign_result;
 	  bool modified = false, deleted = false;
 	  tree *t;
@@ -3662,7 +3662,7 @@ static bool
 ptr_parm_has_direct_uses (tree parm)
 {
   imm_use_iterator ui;
-  gimple stmt;
+  gimple *stmt;
   tree name = ssa_default_def (cfun, parm);
   bool ret = false;
 
@@ -4529,7 +4529,7 @@ get_adjustment_for_base (ipa_parm_adjustment_vec adjustments, tree base)
    ADJUSTMENTS is a pointer to an adjustments vector.  */
 
 static bool
-replace_removed_params_ssa_names (gimple stmt,
+replace_removed_params_ssa_names (gimple *stmt,
 				  ipa_parm_adjustment_vec adjustments)
 {
   struct ipa_parm_adjustment *adj;
@@ -4587,10 +4587,10 @@ replace_removed_params_ssa_names (gimple stmt,
    was modified.  */
 
 static bool
-sra_ipa_modify_assign (gimple *stmt_ptr, gimple_stmt_iterator *gsi,
+sra_ipa_modify_assign (gimple **stmt_ptr, gimple_stmt_iterator *gsi,
 		       ipa_parm_adjustment_vec adjustments)
 {
-  gimple stmt = *stmt_ptr;
+  gimple *stmt = *stmt_ptr;
   tree *lhs_p, *rhs_p;
   bool any;
 
@@ -4663,7 +4663,7 @@ ipa_sra_modify_function_body (ipa_parm_adjustment_vec adjustments)
       gsi = gsi_start_bb (bb);
       while (!gsi_end_p (gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  bool modified = false;
 	  tree *t;
 	  unsigned i;
@@ -4748,7 +4748,7 @@ sra_ipa_reset_debug_stmts (ipa_parm_adjustment_vec adjustments)
     {
       struct ipa_parm_adjustment *adj;
       imm_use_iterator ui;
-      gimple stmt, def_temp;
+      gimple *stmt, *def_temp;
       tree name, vexpr, copy = NULL_TREE;
       use_operand_p use_p;
 
@@ -4899,7 +4899,7 @@ convert_callers (struct cgraph_node *node, tree old_decl,
 
       for (gsi = gsi_start_bb (this_block); !gsi_end_p (gsi); gsi_next (&gsi))
         {
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  tree call_fndecl;
 	  if (gimple_code (stmt) != GIMPLE_CALL)
 	    continue;
diff --git a/gcc/tree-ssa-alias.c b/gcc/tree-ssa-alias.c
index 479fa9c..2f21cb0 100644
--- a/gcc/tree-ssa-alias.c
+++ b/gcc/tree-ssa-alias.c
@@ -347,7 +347,7 @@ ref_may_alias_global_p (tree ref)
 /* Return true whether STMT may clobber global memory.  */
 
 bool
-stmt_may_clobber_global_p (gimple stmt)
+stmt_may_clobber_global_p (gimple *stmt)
 {
   tree lhs;
 
@@ -584,7 +584,7 @@ ao_ref_init_from_ptr_and_size (ao_ref *ref, tree ptr, tree size)
   ref->ref = NULL_TREE;
   if (TREE_CODE (ptr) == SSA_NAME)
     {
-      gimple stmt = SSA_NAME_DEF_STMT (ptr);
+      gimple *stmt = SSA_NAME_DEF_STMT (ptr);
       if (gimple_assign_single_p (stmt)
 	  && gimple_assign_rhs_code (stmt) == ADDR_EXPR)
 	ptr = gimple_assign_rhs1 (stmt);
@@ -1458,7 +1458,7 @@ refs_output_dependent_p (tree store1, tree store2)
    otherwise return false.  */
 
 static bool
-ref_maybe_used_by_call_p_1 (gimple call, ao_ref *ref)
+ref_maybe_used_by_call_p_1 (gimple *call, ao_ref *ref)
 {
   tree base, callee;
   unsigned i;
@@ -1770,7 +1770,7 @@ process_args:
 }
 
 static bool
-ref_maybe_used_by_call_p (gimple call, tree ref)
+ref_maybe_used_by_call_p (gimple *call, tree ref)
 {
   ao_ref r;
   bool res;
@@ -1788,7 +1788,7 @@ ref_maybe_used_by_call_p (gimple call, tree ref)
    true, otherwise return false.  */
 
 bool
-ref_maybe_used_by_stmt_p (gimple stmt, tree ref)
+ref_maybe_used_by_stmt_p (gimple *stmt, tree ref)
 {
   if (is_gimple_assign (stmt))
     {
@@ -1836,7 +1836,7 @@ ref_maybe_used_by_stmt_p (gimple stmt, tree ref)
    return true, otherwise return false.  */
 
 bool
-call_may_clobber_ref_p_1 (gimple call, ao_ref *ref)
+call_may_clobber_ref_p_1 (gimple *call, ao_ref *ref)
 {
   tree base;
   tree callee;
@@ -2100,7 +2100,7 @@ call_may_clobber_ref_p_1 (gimple call, ao_ref *ref)
    return true, otherwise return false.  */
 
 bool
-call_may_clobber_ref_p (gimple call, tree ref)
+call_may_clobber_ref_p (gimple *call, tree ref)
 {
   bool res;
   ao_ref r;
@@ -2118,7 +2118,7 @@ call_may_clobber_ref_p (gimple call, tree ref)
    otherwise return false.  */
 
 bool
-stmt_may_clobber_ref_p_1 (gimple stmt, ao_ref *ref)
+stmt_may_clobber_ref_p_1 (gimple *stmt, ao_ref *ref)
 {
   if (is_gimple_call (stmt))
     {
@@ -2151,7 +2151,7 @@ stmt_may_clobber_ref_p_1 (gimple stmt, ao_ref *ref)
 }
 
 bool
-stmt_may_clobber_ref_p (gimple stmt, tree ref)
+stmt_may_clobber_ref_p (gimple *stmt, tree ref)
 {
   ao_ref r;
   ao_ref_init (&r, ref);
@@ -2162,7 +2162,7 @@ stmt_may_clobber_ref_p (gimple stmt, tree ref)
    return false.  */
 
 static bool
-stmt_kills_ref_p_1 (gimple stmt, ao_ref *ref)
+stmt_kills_ref_p_1 (gimple *stmt, ao_ref *ref)
 {
   /* For a must-alias check we need to be able to constrain
      the access properly.
@@ -2303,7 +2303,7 @@ stmt_kills_ref_p_1 (gimple stmt, ao_ref *ref)
 }
 
 bool
-stmt_kills_ref_p (gimple stmt, tree ref)
+stmt_kills_ref_p (gimple *stmt, tree ref)
 {
   ao_ref r;
   ao_ref_init (&r, ref);
@@ -2316,7 +2316,7 @@ stmt_kills_ref_p (gimple stmt, tree ref)
    case false is returned.  The walk starts with VUSE, one argument of PHI.  */
 
 static bool
-maybe_skip_until (gimple phi, tree target, ao_ref *ref,
+maybe_skip_until (gimple *phi, tree target, ao_ref *ref,
 		  tree vuse, unsigned int *cnt, bitmap *visited,
 		  bool abort_on_visited,
 		  void *(*translate)(ao_ref *, tree, void *, bool),
@@ -2332,7 +2332,7 @@ maybe_skip_until (gimple phi, tree target, ao_ref *ref,
   /* Walk until we hit the target.  */
   while (vuse != target)
     {
-      gimple def_stmt = SSA_NAME_DEF_STMT (vuse);
+      gimple *def_stmt = SSA_NAME_DEF_STMT (vuse);
       /* Recurse for PHI nodes.  */
       if (gimple_code (def_stmt) == GIMPLE_PHI)
 	{
@@ -2379,14 +2379,14 @@ maybe_skip_until (gimple phi, tree target, ao_ref *ref,
    Return that, or NULL_TREE if there is no such definition.  */
 
 static tree
-get_continuation_for_phi_1 (gimple phi, tree arg0, tree arg1,
+get_continuation_for_phi_1 (gimple *phi, tree arg0, tree arg1,
 			    ao_ref *ref, unsigned int *cnt,
 			    bitmap *visited, bool abort_on_visited,
 			    void *(*translate)(ao_ref *, tree, void *, bool),
 			    void *data)
 {
-  gimple def0 = SSA_NAME_DEF_STMT (arg0);
-  gimple def1 = SSA_NAME_DEF_STMT (arg1);
+  gimple *def0 = SSA_NAME_DEF_STMT (arg0);
+  gimple *def1 = SSA_NAME_DEF_STMT (arg1);
   tree common_vuse;
 
   if (arg0 == arg1)
@@ -2445,7 +2445,7 @@ get_continuation_for_phi_1 (gimple phi, tree arg0, tree arg1,
    Returns NULL_TREE if no suitable virtual operand can be found.  */
 
 tree
-get_continuation_for_phi (gimple phi, ao_ref *ref,
+get_continuation_for_phi (gimple *phi, ao_ref *ref,
 			  unsigned int *cnt, bitmap *visited,
 			  bool abort_on_visited,
 			  void *(*translate)(ao_ref *, tree, void *, bool),
@@ -2532,7 +2532,7 @@ walk_non_aliased_vuses (ao_ref *ref, tree vuse,
 
   do
     {
-      gimple def_stmt;
+      gimple *def_stmt;
 
       /* ???  Do we want to account this to TV_ALIAS_STMT_WALK?  */
       res = (*walker) (ref, vuse, cnt, data);
@@ -2606,7 +2606,7 @@ walk_aliased_vdefs_1 (ao_ref *ref, tree vdef,
 {
   do
     {
-      gimple def_stmt = SSA_NAME_DEF_STMT (vdef);
+      gimple *def_stmt = SSA_NAME_DEF_STMT (vdef);
 
       if (*visited
 	  && !bitmap_set_bit (*visited, SSA_NAME_VERSION (vdef)))
diff --git a/gcc/tree-ssa-alias.h b/gcc/tree-ssa-alias.h
index c0b472b..2e024c6 100644
--- a/gcc/tree-ssa-alias.h
+++ b/gcc/tree-ssa-alias.h
@@ -105,14 +105,14 @@ extern bool refs_may_alias_p (tree, tree);
 extern bool refs_may_alias_p_1 (ao_ref *, ao_ref *, bool);
 extern bool refs_anti_dependent_p (tree, tree);
 extern bool refs_output_dependent_p (tree, tree);
-extern bool ref_maybe_used_by_stmt_p (gimple, tree);
-extern bool stmt_may_clobber_global_p (gimple);
-extern bool stmt_may_clobber_ref_p (gimple, tree);
-extern bool stmt_may_clobber_ref_p_1 (gimple, ao_ref *);
-extern bool call_may_clobber_ref_p (gimple, tree);
-extern bool call_may_clobber_ref_p_1 (gimple, ao_ref *);
-extern bool stmt_kills_ref_p (gimple, tree);
-extern tree get_continuation_for_phi (gimple, ao_ref *,
+extern bool ref_maybe_used_by_stmt_p (gimple *, tree);
+extern bool stmt_may_clobber_global_p (gimple *);
+extern bool stmt_may_clobber_ref_p (gimple *, tree);
+extern bool stmt_may_clobber_ref_p_1 (gimple *, ao_ref *);
+extern bool call_may_clobber_ref_p (gimple *, tree);
+extern bool call_may_clobber_ref_p_1 (gimple *, ao_ref *);
+extern bool stmt_kills_ref_p (gimple *, tree);
+extern tree get_continuation_for_phi (gimple *, ao_ref *,
 				      unsigned int *, bitmap *, bool,
 				      void *(*)(ao_ref *, tree, void *, bool),
 				      void *);
diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c
index 7311f5e..065dbd3 100644
--- a/gcc/tree-ssa-ccp.c
+++ b/gcc/tree-ssa-ccp.c
@@ -275,7 +275,7 @@ static prop_value_t
 get_default_value (tree var)
 {
   prop_value_t val = { UNINITIALIZED, NULL_TREE, 0 };
-  gimple stmt;
+  gimple *stmt;
 
   stmt = SSA_NAME_DEF_STMT (var);
 
@@ -626,7 +626,7 @@ get_value_for_expr (tree expr, bool for_bits_p)
    Else return VARYING.  */
 
 static ccp_lattice_t
-likely_value (gimple stmt)
+likely_value (gimple *stmt)
 {
   bool has_constant_operand, has_undefined_operand, all_undefined_operands;
   tree use;
@@ -745,7 +745,7 @@ likely_value (gimple stmt)
 /* Returns true if STMT cannot be constant.  */
 
 static bool
-surely_varying_stmt_p (gimple stmt)
+surely_varying_stmt_p (gimple *stmt)
 {
   /* If the statement has operands that we cannot handle, it cannot be
      constant.  */
@@ -800,7 +800,7 @@ ccp_initialize (void)
 
       for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
         {
-	  gimple stmt = gsi_stmt (i);
+	  gimple *stmt = gsi_stmt (i);
 	  bool is_varying;
 
 	  /* If the statement is a control insn, then we do not
@@ -834,7 +834,7 @@ ccp_initialize (void)
 
       for (i = gsi_start_phis (bb); !gsi_end_p (i); gsi_next (&i))
         {
-          gimple phi = gsi_stmt (i);
+          gimple *phi = gsi_stmt (i);
 
 	  if (virtual_operand_p (gimple_phi_result (phi)))
             prop_set_simulate_again (phi, false);
@@ -1019,7 +1019,7 @@ ccp_lattice_meet (prop_value_t *val1, prop_value_t *val2)
    of the PHI node that are incoming via executable edges.  */
 
 static enum ssa_prop_result
-ccp_visit_phi_node (gimple phi)
+ccp_visit_phi_node (gimple *phi)
 {
   unsigned i;
   prop_value_t *old_val, new_val;
@@ -1127,7 +1127,7 @@ valueize_op (tree op)
    otherwise return the original RHS or NULL_TREE.  */
 
 static tree
-ccp_fold (gimple stmt)
+ccp_fold (gimple *stmt)
 {
   location_t loc = gimple_location (stmt);
   switch (gimple_code (stmt))
@@ -1532,7 +1532,7 @@ bit_value_binop (enum tree_code code, tree type, tree rhs1, tree rhs2)
    ALLOC_ALIGNED is true.  */
 
 static prop_value_t
-bit_value_assume_aligned (gimple stmt, tree attr, prop_value_t ptrval,
+bit_value_assume_aligned (gimple *stmt, tree attr, prop_value_t ptrval,
 			  bool alloc_aligned)
 {
   tree align, misalign = NULL_TREE, type;
@@ -1632,7 +1632,7 @@ bit_value_assume_aligned (gimple stmt, tree attr, prop_value_t ptrval,
    Valid only for assignments, calls, conditionals, and switches. */
 
 static prop_value_t
-evaluate_stmt (gimple stmt)
+evaluate_stmt (gimple *stmt)
 {
   prop_value_t val;
   tree simplified = NULL_TREE;
@@ -1904,11 +1904,11 @@ static void
 insert_clobber_before_stack_restore (tree saved_val, tree var,
 				     gimple_htab *visited)
 {
-  gimple stmt, clobber_stmt;
+  gimple *stmt, *clobber_stmt;
   tree clobber;
   imm_use_iterator iter;
   gimple_stmt_iterator i;
-  gimple *slot;
+  gimple **slot;
 
   FOR_EACH_IMM_USE_STMT (stmt, iter, saved_val)
     if (gimple_call_builtin_p (stmt, BUILT_IN_STACK_RESTORE))
@@ -1970,7 +1970,7 @@ gsi_prev_dom_bb_nondebug (gimple_stmt_iterator *i)
 static void
 insert_clobbers_for_var (gimple_stmt_iterator i, tree var)
 {
-  gimple stmt;
+  gimple *stmt;
   tree saved_val;
   gimple_htab visited;
 
@@ -1998,7 +1998,7 @@ insert_clobbers_for_var (gimple_stmt_iterator i, tree var)
    NULL_TREE.  */
 
 static tree
-fold_builtin_alloca_with_align (gimple stmt)
+fold_builtin_alloca_with_align (gimple *stmt)
 {
   unsigned HOST_WIDE_INT size, threshold, n_elem;
   tree lhs, arg, block, var, elem_type, array_type;
@@ -2056,7 +2056,7 @@ fold_builtin_alloca_with_align (gimple stmt)
 static bool
 ccp_fold_stmt (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
 
   switch (gimple_code (stmt))
     {
@@ -2195,7 +2195,7 @@ ccp_fold_stmt (gimple_stmt_iterator *gsi)
    are handled here.  */
 
 static enum ssa_prop_result
-visit_assignment (gimple stmt, tree *output_p)
+visit_assignment (gimple *stmt, tree *output_p)
 {
   prop_value_t val;
   enum ssa_prop_result retval;
@@ -2240,7 +2240,7 @@ visit_assignment (gimple stmt, tree *output_p)
    SSA_PROP_VARYING.  */
 
 static enum ssa_prop_result
-visit_cond_stmt (gimple stmt, edge *taken_edge_p)
+visit_cond_stmt (gimple *stmt, edge *taken_edge_p)
 {
   prop_value_t val;
   basic_block block;
@@ -2273,7 +2273,7 @@ visit_cond_stmt (gimple stmt, edge *taken_edge_p)
    value, return SSA_PROP_VARYING.  */
 
 static enum ssa_prop_result
-ccp_visit_stmt (gimple stmt, edge *taken_edge_p, tree *output_p)
+ccp_visit_stmt (gimple *stmt, edge *taken_edge_p, tree *output_p)
 {
   tree def;
   ssa_op_iter iter;
@@ -2394,10 +2394,10 @@ static tree
 optimize_stack_restore (gimple_stmt_iterator i)
 {
   tree callee;
-  gimple stmt;
+  gimple *stmt;
 
   basic_block bb = gsi_bb (i);
-  gimple call = gsi_stmt (i);
+  gimple *call = gsi_stmt (i);
 
   if (gimple_code (call) != GIMPLE_CALL
       || gimple_call_num_args (call) != 1
@@ -2448,7 +2448,7 @@ optimize_stack_restore (gimple_stmt_iterator i)
      or not is irrelevant to removing the call to __builtin_stack_restore.  */
   if (has_single_use (gimple_call_arg (call, 0)))
     {
-      gimple stack_save = SSA_NAME_DEF_STMT (gimple_call_arg (call, 0));
+      gimple *stack_save = SSA_NAME_DEF_STMT (gimple_call_arg (call, 0));
       if (is_gimple_call (stack_save))
 	{
 	  callee = gimple_call_fndecl (stack_save);
@@ -2476,7 +2476,7 @@ optimize_stack_restore (gimple_stmt_iterator i)
    pointer assignment.  */
 
 static tree
-optimize_stdarg_builtin (gimple call)
+optimize_stdarg_builtin (gimple *call)
 {
   tree callee, lhs, rhs, cfun_va_list;
   bool va_list_simple_ptr;
@@ -2554,7 +2554,7 @@ optimize_unreachable (gimple_stmt_iterator i)
 {
   basic_block bb = gsi_bb (i);
   gimple_stmt_iterator gsi;
-  gimple stmt;
+  gimple *stmt;
   edge_iterator ei;
   edge e;
   bool ret;
@@ -2656,7 +2656,7 @@ pass_fold_builtins::execute (function *fun)
       gimple_stmt_iterator i;
       for (i = gsi_start_bb (bb); !gsi_end_p (i); )
 	{
-          gimple stmt, old_stmt;
+          gimple *stmt, *old_stmt;
 	  tree callee, result;
 	  enum built_in_function fcode;
 
diff --git a/gcc/tree-ssa-coalesce.c b/gcc/tree-ssa-coalesce.c
index 9a1ac67..9757f12 100644
--- a/gcc/tree-ssa-coalesce.c
+++ b/gcc/tree-ssa-coalesce.c
@@ -831,7 +831,7 @@ build_ssa_conflict_graph (tree_live_info_p liveinfo)
       for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi_prev (&gsi))
         {
 	  tree var;
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 
 	  /* A copy between 2 partitions does not introduce an interference
 	     by itself.  If they did, you would never be able to coalesce
@@ -867,7 +867,7 @@ build_ssa_conflict_graph (tree_live_info_p liveinfo)
 	 may create incorrect code.  */
       for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple phi = gsi_stmt (gsi);
+	  gimple *phi = gsi_stmt (gsi);
 	  tree result = PHI_RESULT (phi);
 	  if (live_track_live_p (live, result))
 	    live_track_process_def (live, result, graph);
@@ -920,7 +920,7 @@ create_outofssa_var_map (coalesce_list_p cl, bitmap used_in_copy)
   gimple_stmt_iterator gsi;
   basic_block bb;
   tree var;
-  gimple stmt;
+  gimple *stmt;
   tree first;
   var_map map;
   ssa_op_iter iter;
@@ -935,7 +935,7 @@ create_outofssa_var_map (coalesce_list_p cl, bitmap used_in_copy)
 
       for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple phi = gsi_stmt (gsi);
+	  gimple *phi = gsi_stmt (gsi);
 	  size_t i;
 	  int ver;
 	  tree res;
@@ -1192,7 +1192,7 @@ coalesce_partitions (var_map map, ssa_conflicts_p graph, coalesce_list_p cl,
 	    for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
 		 gsi_next (&gsi))
 	      {
-		gimple phi = gsi_stmt (gsi);
+		gimple *phi = gsi_stmt (gsi);
 		tree res = PHI_RESULT (phi);
 	        tree arg = PHI_ARG_DEF (phi, e->dest_idx);
 		int v1 = SSA_NAME_VERSION (res);
diff --git a/gcc/tree-ssa-copy.c b/gcc/tree-ssa-copy.c
index 0c14216..e2e5974 100644
--- a/gcc/tree-ssa-copy.c
+++ b/gcc/tree-ssa-copy.c
@@ -87,7 +87,7 @@ static unsigned n_copy_of;
 /* Return true if this statement may generate a useful copy.  */
 
 static bool
-stmt_may_generate_copy (gimple stmt)
+stmt_may_generate_copy (gimple *stmt)
 {
   if (gimple_code (stmt) == GIMPLE_PHI)
     return !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_phi_result (stmt));
@@ -200,7 +200,7 @@ dump_copy_of (FILE *file, tree var)
    value and store the LHS into *RESULT_P.  */
 
 static enum ssa_prop_result
-copy_prop_visit_assignment (gimple stmt, tree *result_p)
+copy_prop_visit_assignment (gimple *stmt, tree *result_p)
 {
   tree lhs, rhs;
 
@@ -230,7 +230,7 @@ copy_prop_visit_assignment (gimple stmt, tree *result_p)
    SSA_PROP_VARYING.  */
 
 static enum ssa_prop_result
-copy_prop_visit_cond_stmt (gimple stmt, edge *taken_edge_p)
+copy_prop_visit_cond_stmt (gimple *stmt, edge *taken_edge_p)
 {
   enum ssa_prop_result retval = SSA_PROP_VARYING;
   location_t loc = gimple_location (stmt);
@@ -288,7 +288,7 @@ copy_prop_visit_cond_stmt (gimple stmt, edge *taken_edge_p)
    SSA_PROP_VARYING.  */
 
 static enum ssa_prop_result
-copy_prop_visit_stmt (gimple stmt, edge *taken_edge_p, tree *result_p)
+copy_prop_visit_stmt (gimple *stmt, edge *taken_edge_p, tree *result_p)
 {
   enum ssa_prop_result retval;
 
@@ -342,7 +342,7 @@ copy_prop_visit_stmt (gimple stmt, edge *taken_edge_p, tree *result_p)
    set it to be the value of the LHS of PHI.  */
 
 static enum ssa_prop_result
-copy_prop_visit_phi_node (gimple phi)
+copy_prop_visit_phi_node (gimple *phi)
 {
   enum ssa_prop_result retval;
   unsigned i;
@@ -476,7 +476,7 @@ init_copy_prop (void)
 
       for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
 	{
-	  gimple stmt = gsi_stmt (si);
+	  gimple *stmt = gsi_stmt (si);
 	  ssa_op_iter iter;
           tree def;
 
@@ -511,7 +511,7 @@ init_copy_prop (void)
 
       for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
 	{
-          gimple phi = gsi_stmt (si);
+          gimple *phi = gsi_stmt (si);
           tree def;
 
 	  def = gimple_phi_result (phi);
diff --git a/gcc/tree-ssa-copyrename.c b/gcc/tree-ssa-copyrename.c
index 89437d9..4c9fa15 100644
--- a/gcc/tree-ssa-copyrename.c
+++ b/gcc/tree-ssa-copyrename.c
@@ -342,7 +342,7 @@ pass_rename_ssa_copies::execute (function *fun)
   basic_block bb;
   gimple_stmt_iterator gsi;
   tree var, part_var;
-  gimple stmt, phi;
+  gimple *stmt, *phi;
   unsigned x;
   FILE *debug;
 
diff --git a/gcc/tree-ssa-dce.c b/gcc/tree-ssa-dce.c
index 4969b11..ce053f0 100644
--- a/gcc/tree-ssa-dce.c
+++ b/gcc/tree-ssa-dce.c
@@ -84,7 +84,7 @@ static struct stmt_stats
 
 #define STMT_NECESSARY GF_PLF_1
 
-static vec<gimple> worklist;
+static vec<gimple *> worklist;
 
 /* Vector indicating an SSA name has already been processed and marked
    as necessary.  */
@@ -122,7 +122,7 @@ static bool cfg_altered;
    worklist if ADD_TO_WORKLIST is true.  */
 
 static inline void
-mark_stmt_necessary (gimple stmt, bool add_to_worklist)
+mark_stmt_necessary (gimple *stmt, bool add_to_worklist)
 {
   gcc_assert (stmt);
 
@@ -149,7 +149,7 @@ mark_stmt_necessary (gimple stmt, bool add_to_worklist)
 static inline void
 mark_operand_necessary (tree op)
 {
-  gimple stmt;
+  gimple *stmt;
   int ver;
 
   gcc_assert (op);
@@ -192,7 +192,7 @@ mark_operand_necessary (tree op)
    necessary.  */
 
 static void
-mark_stmt_if_obviously_necessary (gimple stmt, bool aggressive)
+mark_stmt_if_obviously_necessary (gimple *stmt, bool aggressive)
 {
   /* With non-call exceptions, we have to assume that all statements could
      throw.  If a statement could throw, it can be deemed necessary.  */
@@ -311,7 +311,7 @@ mark_stmt_if_obviously_necessary (gimple stmt, bool aggressive)
 static void
 mark_last_stmt_necessary (basic_block bb)
 {
-  gimple stmt = last_stmt (bb);
+  gimple *stmt = last_stmt (bb);
 
   bitmap_set_bit (last_stmt_necessary, bb->index);
   bitmap_set_bit (bb_contains_live_stmts, bb->index);
@@ -372,7 +372,7 @@ find_obviously_necessary_stmts (bool aggressive)
   basic_block bb;
   gimple_stmt_iterator gsi;
   edge e;
-  gimple phi, stmt;
+  gimple *phi, *stmt;
   int flags;
 
   FOR_EACH_BB_FN (bb, cfun)
@@ -462,7 +462,7 @@ static bool chain_ovfl = false;
 static bool
 mark_aliased_reaching_defs_necessary_1 (ao_ref *ref, tree vdef, void *data)
 {
-  gimple def_stmt = SSA_NAME_DEF_STMT (vdef);
+  gimple *def_stmt = SSA_NAME_DEF_STMT (vdef);
 
   /* All stmts we visit are necessary.  */
   mark_operand_necessary (vdef);
@@ -518,7 +518,7 @@ mark_aliased_reaching_defs_necessary_1 (ao_ref *ref, tree vdef, void *data)
 }
 
 static void
-mark_aliased_reaching_defs_necessary (gimple stmt, tree ref)
+mark_aliased_reaching_defs_necessary (gimple *stmt, tree ref)
 {
   unsigned int chain;
   ao_ref refd;
@@ -543,7 +543,7 @@ static bool
 mark_all_reaching_defs_necessary_1 (ao_ref *ref ATTRIBUTE_UNUSED,
 				    tree vdef, void *data ATTRIBUTE_UNUSED)
 {
-  gimple def_stmt = SSA_NAME_DEF_STMT (vdef);
+  gimple *def_stmt = SSA_NAME_DEF_STMT (vdef);
 
   /* We have to skip already visited (and thus necessary) statements
      to make the chaining work after we dropped back to simple mode.  */
@@ -591,7 +591,7 @@ mark_all_reaching_defs_necessary_1 (ao_ref *ref ATTRIBUTE_UNUSED,
 }
 
 static void
-mark_all_reaching_defs_necessary (gimple stmt)
+mark_all_reaching_defs_necessary (gimple *stmt)
 {
   walk_aliased_vdefs (NULL, gimple_vuse (stmt),
 		      mark_all_reaching_defs_necessary_1, NULL, &visited);
@@ -600,7 +600,7 @@ mark_all_reaching_defs_necessary (gimple stmt)
 /* Return true for PHI nodes with one or identical arguments
    can be removed.  */
 static bool
-degenerate_phi_p (gimple phi)
+degenerate_phi_p (gimple *phi)
 {
   unsigned int i;
   tree op = gimple_phi_arg_def (phi, 0);
@@ -620,7 +620,7 @@ degenerate_phi_p (gimple phi)
 static void
 propagate_necessity (bool aggressive)
 {
-  gimple stmt;
+  gimple *stmt;
 
   if (dump_file && (dump_flags & TDF_DETAILS))
     fprintf (dump_file, "\nProcessing worklist:\n");
@@ -770,7 +770,7 @@ propagate_necessity (bool aggressive)
 	  if (gimple_call_builtin_p (stmt, BUILT_IN_FREE))
 	    {
 	      tree ptr = gimple_call_arg (stmt, 0);
-	      gimple def_stmt;
+	      gimple *def_stmt;
 	      tree def_callee;
 	      /* If the pointer we free is defined by an allocation
 		 function do not add the call to the worklist.  */
@@ -933,7 +933,7 @@ static bool
 remove_dead_phis (basic_block bb)
 {
   bool something_changed = false;
-  gimple phi;
+  gimple *phi;
   gimple_stmt_iterator gsi;
 
   for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi);)
@@ -954,7 +954,7 @@ remove_dead_phis (basic_block bb)
 
 	      use_operand_p use_p;
 	      imm_use_iterator iter;
-	      gimple use_stmt;
+	      gimple *use_stmt;
 	      FOR_EACH_IMM_USE_STMT (use_stmt, iter, vdef)
 		FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
 		  SET_USE (use_p, vuse);
@@ -1015,7 +1015,7 @@ forward_edge_to_pdom (edge e, basic_block post_dom_bb)
 	  break;
       for (gsi = gsi_start_phis (post_dom_bb); !gsi_end_p (gsi);)
 	{
-	  gimple phi = gsi_stmt (gsi);
+	  gimple *phi = gsi_stmt (gsi);
 	  tree op;
 	  source_location locus;
 
@@ -1052,7 +1052,7 @@ forward_edge_to_pdom (edge e, basic_block post_dom_bb)
 static void
 remove_dead_stmt (gimple_stmt_iterator *i, basic_block bb)
 {
-  gimple stmt = gsi_stmt (*i);
+  gimple *stmt = gsi_stmt (*i);
 
   if (dump_file && (dump_flags & TDF_DETAILS))
     {
@@ -1125,7 +1125,7 @@ remove_dead_stmt (gimple_stmt_iterator *i, basic_block bb)
 	  && !DECL_HAS_VALUE_EXPR_P (lhs))
 	{
 	  tree rhs = gimple_assign_rhs1 (stmt);
-	  gimple note
+	  gimple *note
 	    = gimple_build_debug_bind (lhs, unshare_expr (rhs), stmt);
 	  gsi_insert_after (i, note, GSI_SAME_STMT);
 	}
@@ -1145,7 +1145,7 @@ eliminate_unnecessary_stmts (void)
   bool something_changed = false;
   basic_block bb;
   gimple_stmt_iterator gsi, psi;
-  gimple stmt;
+  gimple *stmt;
   tree call;
   vec<basic_block> h;
 
@@ -1203,7 +1203,7 @@ eliminate_unnecessary_stmts (void)
 	      tree ptr = gimple_call_arg (stmt, 0);
 	      if (TREE_CODE (ptr) == SSA_NAME)
 		{
-		  gimple def_stmt = SSA_NAME_DEF_STMT (ptr);
+		  gimple *def_stmt = SSA_NAME_DEF_STMT (ptr);
 		  if (!gimple_nop_p (def_stmt)
 		      && !gimple_plf (def_stmt, STMT_NECESSARY))
 		    gimple_set_plf (stmt, STMT_NECESSARY, false);
diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c
index 5b5adca..7683fb6 100644
--- a/gcc/tree-ssa-dom.c
+++ b/gcc/tree-ssa-dom.c
@@ -79,7 +79,7 @@ struct hashable_expr
     struct { enum tree_code op;  tree opnd; } unary;
     struct { enum tree_code op;  tree opnd0, opnd1; } binary;
     struct { enum tree_code op;  tree opnd0, opnd1, opnd2; } ternary;
-    struct { gimple fn_from; bool pure; size_t nargs; tree *args; } call;
+    struct { gimple *fn_from; bool pure; size_t nargs; tree *args; } call;
     struct { size_t nargs; tree *args; } phi;
   } ops;
 };
@@ -140,7 +140,7 @@ struct expr_hash_elt
   struct hashable_expr expr;
 
   /* The stmt pointer if this element corresponds to a statement.  */
-  gimple stmt;
+  gimple *stmt;
 
   /* The hash value for RHS.  */
   hashval_t hash;
@@ -174,10 +174,10 @@ expr_elt_hasher::hash (const value_type *p)
 inline bool
 expr_elt_hasher::equal (const value_type *p1, const compare_type *p2)
 {
-  gimple stmt1 = p1->stmt;
+  gimple *stmt1 = p1->stmt;
   const struct hashable_expr *expr1 = &p1->expr;
   const struct expr_hash_elt *stamp1 = p1->stamp;
-  gimple stmt2 = p2->stmt;
+  gimple *stmt2 = p2->stmt;
   const struct hashable_expr *expr2 = &p2->expr;
   const struct expr_hash_elt *stamp2 = p2->stamp;
 
@@ -252,7 +252,7 @@ static struct opt_stats_d opt_stats;
 
 /* Local functions.  */
 static void optimize_stmt (basic_block, gimple_stmt_iterator);
-static tree lookup_avail_expr (gimple, bool);
+static tree lookup_avail_expr (gimple *, bool);
 static hashval_t avail_expr_hash (const void *);
 static void htab_statistics (FILE *, hash_table <expr_elt_hasher>);
 static void record_cond (cond_equivalence *);
@@ -261,7 +261,7 @@ static void record_equality (tree, tree);
 static void record_equivalences_from_phis (basic_block);
 static void record_equivalences_from_incoming_edge (basic_block);
 static void eliminate_redundant_computations (gimple_stmt_iterator *);
-static void record_equivalences_from_stmt (gimple, int);
+static void record_equivalences_from_stmt (gimple *, int);
 static void remove_local_expressions_from_table (void);
 static void restore_vars_to_original_value (void);
 static edge single_incoming_edge_ignoring_loop_edges (basic_block);
@@ -271,7 +271,7 @@ static edge single_incoming_edge_ignoring_loop_edges (basic_block);
    by ELEMENT.  */
 
 static void
-initialize_hash_element (gimple stmt, tree lhs,
+initialize_hash_element (gimple *stmt, tree lhs,
                          struct expr_hash_elt *element)
 {
   enum gimple_code code = gimple_code (stmt);
@@ -626,7 +626,7 @@ iterative_hash_hashable_expr (const struct hashable_expr *expr, hashval_t val)
       {
         size_t i;
         enum tree_code code = CALL_EXPR;
-        gimple fn_from;
+        gimple *fn_from;
 
         val = iterative_hash_object (code, val);
         fn_from = expr->ops.call.fn_from;
@@ -703,7 +703,7 @@ print_expr_hash_elt (FILE * stream, const struct expr_hash_elt *element)
         {
           size_t i;
           size_t nargs = element->expr.ops.call.nargs;
-          gimple fn_from;
+          gimple *fn_from;
 
           fn_from = element->expr.ops.call.fn_from;
           if (gimple_call_internal_p (fn_from))
@@ -823,7 +823,7 @@ public:
 private:
   void thread_across_edge (edge);
 
-  gimple m_dummy_cond;
+  gimple *m_dummy_cond;
 };
 
 /* Jump threading, redundancy elimination and const/copy propagation.
@@ -995,7 +995,7 @@ make_pass_dominator (gcc::context *ctxt)
    condition to a canonical form.  */
 
 static void
-canonicalize_comparison (gimple condstmt)
+canonicalize_comparison (gimple *condstmt)
 {
   tree op0;
   tree op1;
@@ -1101,8 +1101,8 @@ restore_vars_to_original_value (void)
 /* A trivial wrapper so that we can present the generic jump
    threading code with a simple API for simplifying statements.  */
 static tree
-simplify_stmt_for_jump_threading (gimple stmt,
-				  gimple within_stmt ATTRIBUTE_UNUSED)
+simplify_stmt_for_jump_threading (gimple *stmt,
+				  gimple *within_stmt ATTRIBUTE_UNUSED)
 {
   return lookup_avail_expr (stmt, false);
 }
@@ -1185,7 +1185,7 @@ record_equivalences_from_phis (basic_block bb)
 
   for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple phi = gsi_stmt (gsi);
+      gimple *phi = gsi_stmt (gsi);
 
       tree lhs = gimple_phi_result (phi);
       tree rhs = NULL;
@@ -1299,7 +1299,7 @@ record_equivalences_from_incoming_edge (basic_block bb)
 	      && is_gimple_constant (rhs)
 	      && TREE_CODE (rhs) == INTEGER_CST)
 	    {
-	      gimple defstmt = SSA_NAME_DEF_STMT (lhs);
+	      gimple *defstmt = SSA_NAME_DEF_STMT (lhs);
 
 	      if (defstmt
 		  && is_gimple_assign (defstmt)
@@ -1567,7 +1567,7 @@ record_const_or_copy_1 (tree x, tree y, tree prev_x)
 int
 loop_depth_of_name (tree x)
 {
-  gimple defstmt;
+  gimple *defstmt;
   basic_block defbb;
 
   /* If it's not an SSA_NAME, we have no clue where the definition is.  */
@@ -1655,11 +1655,11 @@ record_equality (tree x, tree y)
    i_2 = i_1 +/- ...  */
 
 bool
-simple_iv_increment_p (gimple stmt)
+simple_iv_increment_p (gimple *stmt)
 {
   enum tree_code code;
   tree lhs, preinc;
-  gimple phi;
+  gimple *phi;
   size_t i;
 
   if (gimple_code (stmt) != GIMPLE_ASSIGN)
@@ -1744,7 +1744,7 @@ cprop_into_successor_phis (basic_block bb)
 	  tree new_val;
 	  use_operand_p orig_p;
 	  tree orig_val;
-          gimple phi = gsi_stmt (gsi);
+          gimple *phi = gsi_stmt (gsi);
 
 	  /* The alternative may be associated with a constant, so verify
 	     it is an SSA_NAME before doing anything with it.  */
@@ -1779,7 +1779,7 @@ record_edge_info (basic_block bb)
 
   if (! gsi_end_p (gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       location_t loc = gimple_location (stmt);
 
       if (gimple_code (stmt) == GIMPLE_SWITCH)
@@ -1979,7 +1979,7 @@ dom_opt_dom_walker::before_dom_children (basic_block bb)
 void
 dom_opt_dom_walker::after_dom_children (basic_block bb)
 {
-  gimple last;
+  gimple *last;
 
   /* If we have an outgoing edge to a block with multiple incoming and
      outgoing edges, then we may be able to thread the edge, i.e., we
@@ -2032,7 +2032,7 @@ eliminate_redundant_computations (gimple_stmt_iterator* gsi)
   bool insert = true;
   bool assigns_var_p = false;
 
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
 
   if (gimple_code (stmt) == GIMPLE_PHI)
     def = gimple_phi_result (stmt);
@@ -2131,7 +2131,7 @@ eliminate_redundant_computations (gimple_stmt_iterator* gsi)
    lifing is done by eliminate_redundant_computations.  */
 
 static void
-record_equivalences_from_stmt (gimple stmt, int may_optimize_p)
+record_equivalences_from_stmt (gimple *stmt, int may_optimize_p)
 {
   tree lhs;
   enum tree_code lhs_code;
@@ -2181,7 +2181,7 @@ record_equivalences_from_stmt (gimple stmt, int may_optimize_p)
       && !is_gimple_reg (lhs))
     {
       tree rhs = gimple_assign_rhs1 (stmt);
-      gimple new_stmt;
+      gimple *new_stmt;
 
       /* Build a new statement with the RHS and LHS exchanged.  */
       if (TREE_CODE (rhs) == SSA_NAME)
@@ -2195,7 +2195,7 @@ record_equivalences_from_stmt (gimple stmt, int may_optimize_p)
              generate here may in fact be ill-formed, but it is simply
              used as an internal device in this pass, and never becomes
              part of the CFG.  */
-          gimple defstmt = SSA_NAME_DEF_STMT (rhs);
+          gimple *defstmt = SSA_NAME_DEF_STMT (rhs);
           new_stmt = gimple_build_assign (rhs, lhs);
           SSA_NAME_DEF_STMT (rhs) = defstmt;
         }
@@ -2214,7 +2214,7 @@ record_equivalences_from_stmt (gimple stmt, int may_optimize_p)
    CONST_AND_COPIES.  */
 
 static void
-cprop_operand (gimple stmt, use_operand_p op_p)
+cprop_operand (gimple *stmt, use_operand_p op_p)
 {
   tree val;
   tree op = USE_FROM_PTR (op_p);
@@ -2290,7 +2290,7 @@ cprop_operand (gimple stmt, use_operand_p op_p)
    vdef_ops of STMT.  */
 
 static void
-cprop_into_stmt (gimple stmt)
+cprop_into_stmt (gimple *stmt)
 {
   use_operand_p op_p;
   ssa_op_iter iter;
@@ -2317,7 +2317,7 @@ cprop_into_stmt (gimple stmt)
 static void
 optimize_stmt (basic_block bb, gimple_stmt_iterator si)
 {
-  gimple stmt, old_stmt;
+  gimple *stmt, *old_stmt;
   bool may_optimize_p;
   bool modified_p = false;
 
@@ -2413,7 +2413,7 @@ optimize_stmt (basic_block bb, gimple_stmt_iterator si)
 	  tree lhs = gimple_assign_lhs (stmt);
 	  tree rhs = gimple_assign_rhs1 (stmt);
 	  tree cached_lhs;
-	  gimple new_stmt;
+	  gimple *new_stmt;
 	  if (TREE_CODE (rhs) == SSA_NAME)
 	    {
 	      tree tem = SSA_NAME_VALUE (rhs);
@@ -2423,7 +2423,7 @@ optimize_stmt (basic_block bb, gimple_stmt_iterator si)
 	  /* Build a new statement with the RHS and LHS exchanged.  */
 	  if (TREE_CODE (rhs) == SSA_NAME)
 	    {
-	      gimple defstmt = SSA_NAME_DEF_STMT (rhs);
+	      gimple *defstmt = SSA_NAME_DEF_STMT (rhs);
 	      new_stmt = gimple_build_assign (rhs, lhs);
 	      SSA_NAME_DEF_STMT (rhs) = defstmt;
 	    }
@@ -2513,7 +2513,7 @@ optimize_stmt (basic_block bb, gimple_stmt_iterator si)
    we finish processing this block and its children.  */
 
 static tree
-lookup_avail_expr (gimple stmt, bool insert)
+lookup_avail_expr (gimple *stmt, bool insert)
 {
   expr_hash_elt **slot;
   tree lhs;
@@ -2599,7 +2599,7 @@ lookup_avail_expr (gimple stmt, bool insert)
 static hashval_t
 avail_expr_hash (const void *p)
 {
-  gimple stmt = ((const struct expr_hash_elt *)p)->stmt;
+  gimple *stmt = ((const struct expr_hash_elt *)p)->stmt;
   const struct hashable_expr *expr = &((const struct expr_hash_elt *)p)->expr;
   tree vuse;
   hashval_t val = 0;
@@ -2629,7 +2629,7 @@ avail_expr_hash (const void *p)
    remove it from the IL.  */
 
 static void
-remove_stmt_or_phi (gimple stmt)
+remove_stmt_or_phi (gimple *stmt)
 {
   gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
 
@@ -2647,7 +2647,7 @@ remove_stmt_or_phi (gimple stmt)
    phi, NULL is returned.  */
 
 static tree
-get_rhs_or_phi_arg (gimple stmt)
+get_rhs_or_phi_arg (gimple *stmt)
 {
   if (gimple_code (stmt) == GIMPLE_PHI)
     return degenerate_phi_result (stmt);
@@ -2662,7 +2662,7 @@ get_rhs_or_phi_arg (gimple stmt)
    return the "lhs" of the node.  */
 
 static tree
-get_lhs_or_phi_result (gimple stmt)
+get_lhs_or_phi_result (gimple *stmt)
 {
   if (gimple_code (stmt) == GIMPLE_PHI)
     return gimple_phi_result (stmt);
@@ -2684,7 +2684,7 @@ get_lhs_or_phi_result (gimple stmt)
    opportunities.  */
 
 static void
-propagate_rhs_into_lhs (gimple stmt, tree lhs, tree rhs, bitmap interesting_names)
+propagate_rhs_into_lhs (gimple *stmt, tree lhs, tree rhs, bitmap interesting_names)
 {
   /* First verify that propagation is valid and isn't going to move a
      loop variant variable outside its loop.  */
@@ -2696,7 +2696,7 @@ propagate_rhs_into_lhs (gimple stmt, tree lhs, tree rhs, bitmap interesting_name
     {
       use_operand_p use_p;
       imm_use_iterator iter;
-      gimple use_stmt;
+      gimple *use_stmt;
       bool all = true;
 
       /* Dump details.  */
@@ -2869,7 +2869,7 @@ propagate_rhs_into_lhs (gimple stmt, tree lhs, tree rhs, bitmap interesting_name
                                !gsi_end_p (psi);
                                gsi_next (&psi))
                             {
-                              gimple phi = gsi_stmt (psi);
+                              gimple *phi = gsi_stmt (psi);
 
 			      tree result = gimple_phi_result (phi);
 			      int version = SSA_NAME_VERSION (result);
@@ -2921,7 +2921,7 @@ propagate_rhs_into_lhs (gimple stmt, tree lhs, tree rhs, bitmap interesting_name
    of STMT.  */
 
 static void
-eliminate_const_or_copy (gimple stmt, bitmap interesting_names)
+eliminate_const_or_copy (gimple *stmt, bitmap interesting_names)
 {
   tree lhs = get_lhs_or_phi_result (stmt);
   tree rhs;
@@ -2952,7 +2952,7 @@ eliminate_const_or_copy (gimple stmt, bitmap interesting_names)
     propagate_rhs_into_lhs (stmt, lhs, rhs, interesting_names);
   else
     {
-      gimple use_stmt;
+      gimple *use_stmt;
       imm_use_iterator iter;
       use_operand_p use_p;
       /* For virtual operands we have to propagate into all uses as
@@ -2984,7 +2984,7 @@ eliminate_degenerate_phis_1 (basic_block bb, bitmap interesting_names)
 
   for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple phi = gsi_stmt (gsi);
+      gimple *phi = gsi_stmt (gsi);
 
       eliminate_const_or_copy (phi, interesting_names);
     }
diff --git a/gcc/tree-ssa-dom.h b/gcc/tree-ssa-dom.h
index af2f128..bdb4d5f 100644
--- a/gcc/tree-ssa-dom.h
+++ b/gcc/tree-ssa-dom.h
@@ -23,6 +23,6 @@ along with GCC; see the file COPYING3.  If not see
 extern void dump_dominator_optimization_stats (FILE *);
 extern void debug_dominator_optimization_stats (void);
 extern int loop_depth_of_name (tree);
-extern bool simple_iv_increment_p (gimple);
+extern bool simple_iv_increment_p (gimple *);
 
 #endif /* GCC_TREE_SSA_DOM_H */
diff --git a/gcc/tree-ssa-dse.c b/gcc/tree-ssa-dse.c
index 4632add..63efa2d 100644
--- a/gcc/tree-ssa-dse.c
+++ b/gcc/tree-ssa-dse.c
@@ -87,9 +87,9 @@ static bitmap need_eh_cleanup;
    Return TRUE if the above conditions are met, otherwise FALSE.  */
 
 static bool
-dse_possible_dead_store_p (gimple stmt, gimple *use_stmt)
+dse_possible_dead_store_p (gimple *stmt, gimple **use_stmt)
 {
-  gimple temp;
+  gimple *temp;
   unsigned cnt = 0;
 
   *use_stmt = NULL;
@@ -108,7 +108,7 @@ dse_possible_dead_store_p (gimple stmt, gimple *use_stmt)
   temp = stmt;
   do
     {
-      gimple use_stmt, defvar_def;
+      gimple *use_stmt, *defvar_def;
       imm_use_iterator ui;
       bool fail = false;
       tree defvar;
@@ -223,7 +223,7 @@ dse_possible_dead_store_p (gimple stmt, gimple *use_stmt)
 static void
 dse_optimize_stmt (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
 
   /* If this statement has no virtual defs, then there is nothing
      to do.  */
@@ -243,7 +243,7 @@ dse_optimize_stmt (gimple_stmt_iterator *gsi)
 
   if (is_gimple_assign (stmt))
     {
-      gimple use_stmt;
+      gimple *use_stmt;
 
       if (!dse_possible_dead_store_p (stmt, &use_stmt))
 	return;
diff --git a/gcc/tree-ssa-forwprop.c b/gcc/tree-ssa-forwprop.c
index 563abe0..d990100 100644
--- a/gcc/tree-ssa-forwprop.c
+++ b/gcc/tree-ssa-forwprop.c
@@ -184,7 +184,7 @@ static bool forward_propagate_addr_expr (tree, tree, bool);
 /* Set to true if we delete dead edges during the optimization.  */
 static bool cfg_changed;
 
-static tree rhs_to_tree (tree type, gimple stmt);
+static tree rhs_to_tree (tree type, gimple *stmt);
 
 /* Get the next statement we can propagate NAME's value into skipping
    trivial copies.  Returns the statement that is suitable as a
@@ -192,11 +192,11 @@ static tree rhs_to_tree (tree type, gimple stmt);
    This only returns destinations in a single-use chain.  FINAL_NAME_P
    if non-NULL is written to the ssa name that represents the use.  */
 
-static gimple
+static gimple *
 get_prop_dest_stmt (tree name, tree *final_name_p)
 {
   use_operand_p use;
-  gimple use_stmt;
+  gimple *use_stmt;
 
   do {
     /* If name has multiple uses, bail out.  */
@@ -226,13 +226,13 @@ get_prop_dest_stmt (tree name, tree *final_name_p)
    it is set to whether the chain to NAME is a single use chain
    or not.  SINGLE_USE_P is not written to if SINGLE_USE_ONLY is set.  */
 
-static gimple
+static gimple *
 get_prop_source_stmt (tree name, bool single_use_only, bool *single_use_p)
 {
   bool single_use = true;
 
   do {
-    gimple def_stmt = SSA_NAME_DEF_STMT (name);
+    gimple *def_stmt = SSA_NAME_DEF_STMT (name);
 
     if (!has_single_use (name))
       {
@@ -262,7 +262,7 @@ get_prop_source_stmt (tree name, bool single_use_only, bool *single_use_p)
    propagation source.  Returns true if so, otherwise false.  */
 
 static bool
-can_propagate_from (gimple def_stmt)
+can_propagate_from (gimple *def_stmt)
 {
   gcc_assert (is_gimple_assign (def_stmt));
 
@@ -310,7 +310,7 @@ static bool
 remove_prop_source_from_use (tree name)
 {
   gimple_stmt_iterator gsi;
-  gimple stmt;
+  gimple *stmt;
   bool cfg_changed = false;
 
   do {
@@ -347,7 +347,7 @@ remove_prop_source_from_use (tree name)
    routines that deal with gimple exclusively . */
 
 static tree
-rhs_to_tree (tree type, gimple stmt)
+rhs_to_tree (tree type, gimple *stmt)
 {
   location_t loc = gimple_location (stmt);
   enum tree_code code = gimple_assign_rhs_code (stmt);
@@ -373,7 +373,7 @@ rhs_to_tree (tree type, gimple stmt)
    considered simplified.  */
 
 static tree
-combine_cond_expr_cond (gimple stmt, enum tree_code code, tree type,
+combine_cond_expr_cond (gimple *stmt, enum tree_code code, tree type,
 			tree op0, tree op1, bool invariant_only)
 {
   tree t;
@@ -411,7 +411,7 @@ combine_cond_expr_cond (gimple stmt, enum tree_code code, tree type,
    were no simplifying combines.  */
 
 static tree
-forward_propagate_into_comparison_1 (gimple stmt,
+forward_propagate_into_comparison_1 (gimple *stmt,
 				     enum tree_code code, tree type,
 				     tree op0, tree op1)
 {
@@ -423,7 +423,7 @@ forward_propagate_into_comparison_1 (gimple stmt,
      simplify comparisons against constants.  */
   if (TREE_CODE (op0) == SSA_NAME)
     {
-      gimple def_stmt = get_prop_source_stmt (op0, false, &single_use0_p);
+      gimple *def_stmt = get_prop_source_stmt (op0, false, &single_use0_p);
       if (def_stmt && can_propagate_from (def_stmt))
 	{
 	  rhs0 = rhs_to_tree (TREE_TYPE (op1), def_stmt);
@@ -437,7 +437,7 @@ forward_propagate_into_comparison_1 (gimple stmt,
   /* If that wasn't successful, try the second operand.  */
   if (TREE_CODE (op1) == SSA_NAME)
     {
-      gimple def_stmt = get_prop_source_stmt (op1, false, &single_use1_p);
+      gimple *def_stmt = get_prop_source_stmt (op1, false, &single_use1_p);
       if (def_stmt && can_propagate_from (def_stmt))
 	{
 	  rhs1 = rhs_to_tree (TREE_TYPE (op0), def_stmt);
@@ -466,7 +466,7 @@ forward_propagate_into_comparison_1 (gimple stmt,
 static int 
 forward_propagate_into_comparison (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   tree tmp;
   bool cfg_changed = false;
   tree type = TREE_TYPE (gimple_assign_lhs (stmt));
@@ -501,7 +501,7 @@ forward_propagate_into_comparison (gimple_stmt_iterator *gsi)
    This must be kept in sync with forward_propagate_into_cond.  */
 
 static int
-forward_propagate_into_gimple_cond (gimple stmt)
+forward_propagate_into_gimple_cond (gimple *stmt)
 {
   tree tmp;
   enum tree_code code = gimple_cond_code (stmt);
@@ -565,7 +565,7 @@ forward_propagate_into_gimple_cond (gimple stmt)
 static bool
 forward_propagate_into_cond (gimple_stmt_iterator *gsi_p)
 {
-  gimple stmt = gsi_stmt (*gsi_p);
+  gimple *stmt = gsi_stmt (*gsi_p);
   tree tmp = NULL_TREE;
   tree cond = gimple_assign_rhs1 (stmt);
   enum tree_code code = gimple_assign_rhs_code (stmt);
@@ -581,7 +581,7 @@ forward_propagate_into_cond (gimple_stmt_iterator *gsi_p)
     {
       enum tree_code def_code;
       tree name = cond;
-      gimple def_stmt = get_prop_source_stmt (name, true, NULL);
+      gimple *def_stmt = get_prop_source_stmt (name, true, NULL);
       if (!def_stmt || !can_propagate_from (def_stmt))
 	return 0;
 
@@ -647,7 +647,7 @@ forward_propagate_into_cond (gimple_stmt_iterator *gsi_p)
 static bool
 combine_cond_exprs (gimple_stmt_iterator *gsi_p)
 {
-  gimple stmt = gsi_stmt (*gsi_p);
+  gimple *stmt = gsi_stmt (*gsi_p);
   tree cond, val1, val2;
   bool changed = false;
 
@@ -655,7 +655,7 @@ combine_cond_exprs (gimple_stmt_iterator *gsi_p)
   val1 = gimple_assign_rhs2 (stmt);
   if (TREE_CODE (val1) == SSA_NAME)
     {
-      gimple def_stmt = SSA_NAME_DEF_STMT (val1);
+      gimple *def_stmt = SSA_NAME_DEF_STMT (val1);
       if (is_gimple_assign (def_stmt)
 	  && gimple_assign_rhs_code (def_stmt) == gimple_assign_rhs_code (stmt)
 	  && operand_equal_p (gimple_assign_rhs1 (def_stmt), cond, 0))
@@ -668,7 +668,7 @@ combine_cond_exprs (gimple_stmt_iterator *gsi_p)
   val2 = gimple_assign_rhs3 (stmt);
   if (TREE_CODE (val2) == SSA_NAME)
     {
-      gimple def_stmt = SSA_NAME_DEF_STMT (val2);
+      gimple *def_stmt = SSA_NAME_DEF_STMT (val2);
       if (is_gimple_assign (def_stmt)
 	  && gimple_assign_rhs_code (def_stmt) == gimple_assign_rhs_code (stmt)
 	  && operand_equal_p (gimple_assign_rhs1 (def_stmt), cond, 0))
@@ -695,7 +695,7 @@ combine_cond_exprs (gimple_stmt_iterator *gsi_p)
    relevant data structures to match.  */
 
 static void
-tidy_after_forward_propagate_addr (gimple stmt)
+tidy_after_forward_propagate_addr (gimple *stmt)
 {
   /* We may have turned a trapping insn into a non-trapping insn.  */
   if (maybe_clean_or_replace_eh_stmt (stmt, stmt)
@@ -722,7 +722,7 @@ forward_propagate_addr_expr_1 (tree name, tree def_rhs,
 			       bool single_use_p)
 {
   tree lhs, rhs, rhs2, array_ref;
-  gimple use_stmt = gsi_stmt (*use_stmt_gsi);
+  gimple *use_stmt = gsi_stmt (*use_stmt_gsi);
   enum tree_code rhs_code;
   bool res = true;
 
@@ -1034,7 +1034,7 @@ static bool
 forward_propagate_addr_expr (tree name, tree rhs, bool parent_single_use_p)
 {
   imm_use_iterator iter;
-  gimple use_stmt;
+  gimple *use_stmt;
   bool all = true;
   bool single_use_p = parent_single_use_p && has_single_use (name);
 
@@ -1093,9 +1093,9 @@ forward_propagate_addr_expr (tree name, tree rhs, bool parent_single_use_p)
 static bool
 forward_propagate_comparison (gimple_stmt_iterator *defgsi)
 {
-  gimple stmt = gsi_stmt (*defgsi);
+  gimple *stmt = gsi_stmt (*defgsi);
   tree name = gimple_assign_lhs (stmt);
-  gimple use_stmt;
+  gimple *use_stmt;
   tree tmp = NULL_TREE;
   gimple_stmt_iterator gsi;
   enum tree_code code;
@@ -1191,8 +1191,8 @@ bailout:
 static bool 
 simplify_conversion_from_bitmask (gimple_stmt_iterator *gsi_p)
 {
-  gimple stmt = gsi_stmt (*gsi_p);
-  gimple rhs_def_stmt = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (stmt));
+  gimple *stmt = gsi_stmt (*gsi_p);
+  gimple *rhs_def_stmt = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (stmt));
 
   /* See if the input for the conversion was set via a BIT_AND_EXPR and
      the only use of the BIT_AND_EXPR result is the conversion.  */
@@ -1256,9 +1256,9 @@ simplify_conversion_from_bitmask (gimple_stmt_iterator *gsi_p)
 static bool 
 simplify_not_neg_expr (gimple_stmt_iterator *gsi_p)
 {
-  gimple stmt = gsi_stmt (*gsi_p);
+  gimple *stmt = gsi_stmt (*gsi_p);
   tree rhs = gimple_assign_rhs1 (stmt);
-  gimple rhs_def_stmt = SSA_NAME_DEF_STMT (rhs);
+  gimple *rhs_def_stmt = SSA_NAME_DEF_STMT (rhs);
 
   /* See if the RHS_DEF_STMT has the same form as our statement.  */
   if (is_gimple_assign (rhs_def_stmt)
@@ -1284,7 +1284,7 @@ simplify_not_neg_expr (gimple_stmt_iterator *gsi_p)
    have values outside the range of the new type.  */
 
 static void
-simplify_gimple_switch_label_vec (gimple stmt, tree index_type)
+simplify_gimple_switch_label_vec (gimple *stmt, tree index_type)
 {
   unsigned int branch_num = gimple_switch_num_labels (stmt);
   auto_vec<tree> labels (branch_num);
@@ -1354,7 +1354,7 @@ simplify_gimple_switch_label_vec (gimple stmt, tree index_type)
    the condition which we may be able to optimize better.  */
 
 static bool
-simplify_gimple_switch (gimple stmt)
+simplify_gimple_switch (gimple *stmt)
 {
   /* The optimization that we really care about is removing unnecessary
      casts.  That will let us do much better in propagating the inferred
@@ -1362,7 +1362,7 @@ simplify_gimple_switch (gimple stmt)
   tree cond = gimple_switch_index (stmt);
   if (TREE_CODE (cond) == SSA_NAME)
     {
-      gimple def_stmt = SSA_NAME_DEF_STMT (cond);
+      gimple *def_stmt = SSA_NAME_DEF_STMT (cond);
       if (gimple_assign_cast_p (def_stmt))
 	{
 	  tree def = gimple_assign_rhs1 (def_stmt);
@@ -1417,7 +1417,7 @@ constant_pointer_difference (tree p1, tree p2)
     {
       tree p = i ? p1 : p2;
       tree off = size_zero_node;
-      gimple stmt;
+      gimple *stmt;
       enum tree_code code;
 
       /* For each of p1 and p2 we need to iterate at least
@@ -1500,7 +1500,7 @@ constant_pointer_difference (tree p1, tree p2)
 static bool
 simplify_builtin_call (gimple_stmt_iterator *gsi_p, tree callee2)
 {
-  gimple stmt1, stmt2 = gsi_stmt (*gsi_p);
+  gimple *stmt1, *stmt2 = gsi_stmt (*gsi_p);
   tree vuse = gimple_vuse (stmt2);
   if (vuse == NULL)
     return false;
@@ -1522,7 +1522,7 @@ simplify_builtin_call (gimple_stmt_iterator *gsi_p, tree callee2)
 	  tree val2 = gimple_call_arg (stmt2, 1);
 	  tree len2 = gimple_call_arg (stmt2, 2);
 	  tree diff, vdef, new_str_cst;
-	  gimple use_stmt;
+	  gimple *use_stmt;
 	  unsigned int ptr1_align;
 	  unsigned HOST_WIDE_INT src_len;
 	  char *src_buf;
@@ -1703,7 +1703,7 @@ simplify_builtin_call (gimple_stmt_iterator *gsi_p, tree callee2)
 static bool
 truth_valued_ssa_name (tree name)
 {
-  gimple def;
+  gimple *def;
   tree type = TREE_TYPE (name);
 
   if (!INTEGRAL_TYPE_P (type))
@@ -1729,7 +1729,7 @@ lookup_logical_inverted_value (tree name)
 {
   tree op1, op2;
   enum tree_code code;
-  gimple def;
+  gimple *def;
 
   /* If name has none-intergal type, or isn't a SSA_NAME, then
      return.  */
@@ -1825,7 +1825,7 @@ simplify_bitwise_binary_1 (enum tree_code code, tree type,
 static inline void
 defcodefor_name (tree name, enum tree_code *code, tree *arg1, tree *arg2)
 {
-  gimple def;
+  gimple *def;
   enum tree_code code1;
   tree arg11;
   tree arg21;
@@ -1903,7 +1903,7 @@ simplify_bitwise_binary_boolean (gimple_stmt_iterator *gsi,
 				 enum tree_code code,
 				 tree op0, tree op1)
 {
-  gimple op0_def_stmt = SSA_NAME_DEF_STMT (op0);
+  gimple *op0_def_stmt = SSA_NAME_DEF_STMT (op0);
 
   if (!is_gimple_assign (op0_def_stmt)
       || (gimple_assign_rhs_code (op0_def_stmt) != BIT_NOT_EXPR))
@@ -1917,7 +1917,7 @@ simplify_bitwise_binary_boolean (gimple_stmt_iterator *gsi,
     {
       enum tree_code newcode;
 
-      gimple stmt = gsi_stmt (*gsi);
+      gimple *stmt = gsi_stmt (*gsi);
       gimple_assign_set_rhs1 (stmt, x);
       gimple_assign_set_rhs2 (stmt, op1);
       if (code == BIT_AND_EXPR)
@@ -1938,7 +1938,7 @@ simplify_bitwise_binary_boolean (gimple_stmt_iterator *gsi,
 static bool
 simplify_bitwise_binary (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   tree arg1 = gimple_assign_rhs1 (stmt);
   tree arg2 = gimple_assign_rhs2 (stmt);
   enum tree_code code = gimple_assign_rhs_code (stmt);
@@ -1957,7 +1957,7 @@ simplify_bitwise_binary (gimple_stmt_iterator *gsi)
       && INTEGRAL_TYPE_P (TREE_TYPE (def1_arg1))
       && int_fits_type_p (arg2, TREE_TYPE (def1_arg1)))
     {
-      gimple newop;
+      gimple *newop;
       tree tem = make_ssa_name (TREE_TYPE (def1_arg1), NULL);
       newop =
         gimple_build_assign_with_ops (code, tem, def1_arg1,
@@ -1980,7 +1980,7 @@ simplify_bitwise_binary (gimple_stmt_iterator *gsi)
       && types_compatible_p (TREE_TYPE (def1_arg1), TREE_TYPE (def2_arg1))
       && hoist_conversion_for_bitop_p (TREE_TYPE (arg1), TREE_TYPE (def1_arg1)))
     {
-      gimple newop;
+      gimple *newop;
       tree tem = make_ssa_name (TREE_TYPE (def1_arg1), NULL);
       newop = gimple_build_assign_with_ops (code, tem, def1_arg1, def2_arg1);
       gimple_set_location (newop, gimple_location (stmt));
@@ -2022,7 +2022,7 @@ simplify_bitwise_binary (gimple_stmt_iterator *gsi)
 	}
       else
 	{
-	  gimple newop;
+	  gimple *newop;
 	  tree tem;
 	  tem = make_ssa_name (TREE_TYPE (arg2), NULL);
 	  newop = gimple_build_assign_with_ops (code, tem, a, c);
@@ -2046,7 +2046,7 @@ simplify_bitwise_binary (gimple_stmt_iterator *gsi)
       tree cst = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg2),
 			      arg2, def1_arg2);
       tree tem;
-      gimple newop;
+      gimple *newop;
       if (integer_zerop (cst))
 	{
 	  gimple_assign_set_rhs1 (stmt, def1_arg1);
@@ -2200,7 +2200,7 @@ simplify_bitwise_binary (gimple_stmt_iterator *gsi)
 	      == TYPE_UNSIGNED (TREE_TYPE (arg2))))
 	{
 	  use_operand_p use_p;
-          gimple use_stmt;
+          gimple *use_stmt;
 
 	  if (single_imm_use (gimple_assign_lhs (stmt), &use_p, &use_stmt))
 	    {
@@ -2247,14 +2247,14 @@ simplify_bitwise_binary (gimple_stmt_iterator *gsi)
 static bool
 simplify_rotate (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   tree arg[2], rtype, rotcnt = NULL_TREE;
   tree def_arg1[2], def_arg2[2];
   enum tree_code def_code[2];
   tree lhs;
   int i;
   bool swapped_p = false;
-  gimple g;
+  gimple *g;
 
   arg[0] = gimple_assign_rhs1 (stmt);
   arg[1] = gimple_assign_rhs2 (stmt);
@@ -2464,7 +2464,7 @@ simplify_rotate (gimple_stmt_iterator *gsi)
 static bool
 associate_plusminus (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   tree rhs1 = gimple_assign_rhs1 (stmt);
   tree rhs2 = gimple_assign_rhs2 (stmt);
   enum tree_code code = gimple_assign_rhs_code (stmt);
@@ -2482,7 +2482,7 @@ associate_plusminus (gimple_stmt_iterator *gsi)
       /* A +- (-B) -> A -+ B.  */
       if (TREE_CODE (rhs2) == SSA_NAME)
 	{
-	  gimple def_stmt = SSA_NAME_DEF_STMT (rhs2);
+	  gimple *def_stmt = SSA_NAME_DEF_STMT (rhs2);
 	  if (is_gimple_assign (def_stmt)
 	      && gimple_assign_rhs_code (def_stmt) == NEGATE_EXPR
 	      && can_propagate_from (def_stmt))
@@ -2500,7 +2500,7 @@ associate_plusminus (gimple_stmt_iterator *gsi)
       if (TREE_CODE (rhs1) == SSA_NAME
 	  && code == PLUS_EXPR)
 	{
-	  gimple def_stmt = SSA_NAME_DEF_STMT (rhs1);
+	  gimple *def_stmt = SSA_NAME_DEF_STMT (rhs1);
 	  if (is_gimple_assign (def_stmt)
 	      && gimple_assign_rhs_code (def_stmt) == NEGATE_EXPR
 	      && can_propagate_from (def_stmt))
@@ -2545,7 +2545,7 @@ associate_plusminus (gimple_stmt_iterator *gsi)
 
   if (TREE_CODE (rhs1) == SSA_NAME)
     {
-      gimple def_stmt = SSA_NAME_DEF_STMT (rhs1);
+      gimple *def_stmt = SSA_NAME_DEF_STMT (rhs1);
       if (is_gimple_assign (def_stmt) && can_propagate_from (def_stmt))
 	{
 	  enum tree_code def_code = gimple_assign_rhs_code (def_stmt);
@@ -2646,7 +2646,7 @@ associate_plusminus (gimple_stmt_iterator *gsi)
 		   && TREE_CODE (rhs2) == SSA_NAME)
 	    {
 	      /* (T)(ptr + adj) - (T)ptr -> (T)adj.  */
-	      gimple def_stmt2 = SSA_NAME_DEF_STMT (rhs2);
+	      gimple *def_stmt2 = SSA_NAME_DEF_STMT (rhs2);
 	      if (TREE_CODE (gimple_assign_rhs1 (def_stmt)) == SSA_NAME
 		  && is_gimple_assign (def_stmt2)
 		  && can_propagate_from (def_stmt2)
@@ -2696,7 +2696,7 @@ associate_plusminus (gimple_stmt_iterator *gsi)
 
   if (rhs2 && TREE_CODE (rhs2) == SSA_NAME)
     {
-      gimple def_stmt = SSA_NAME_DEF_STMT (rhs2);
+      gimple *def_stmt = SSA_NAME_DEF_STMT (rhs2);
       if (is_gimple_assign (def_stmt) && can_propagate_from (def_stmt))
 	{
 	  enum tree_code def_code = gimple_assign_rhs_code (def_stmt);
@@ -2799,8 +2799,8 @@ out:
 static bool
 associate_pointerplus_align (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
-  gimple def_stmt;
+  gimple *stmt = gsi_stmt (*gsi);
+  gimple *def_stmt;
   tree ptr, rhs, algn;
 
   /* Pattern match
@@ -2851,8 +2851,8 @@ associate_pointerplus_align (gimple_stmt_iterator *gsi)
 static bool
 associate_pointerplus_diff (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
-  gimple def_stmt;
+  gimple *stmt = gsi_stmt (*gsi);
+  gimple *def_stmt;
   tree ptr1, rhs;
 
   /* Pattern match
@@ -2867,7 +2867,7 @@ associate_pointerplus_diff (gimple_stmt_iterator *gsi)
   rhs = gimple_assign_rhs2 (stmt);
   if (TREE_CODE (rhs) != SSA_NAME)
     return false;
-  gimple minus = SSA_NAME_DEF_STMT (rhs);
+  gimple *minus = SSA_NAME_DEF_STMT (rhs);
   /* Conditionally look through a sign-changing conversion.  */
   if (is_gimple_assign (minus)
       && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (minus))
@@ -2910,8 +2910,8 @@ associate_pointerplus_diff (gimple_stmt_iterator *gsi)
 static bool
 associate_pointerplus (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
-  gimple def_stmt;
+  gimple *stmt = gsi_stmt (*gsi);
+  gimple *def_stmt;
   tree ptr, off1, off2;
 
   if (associate_pointerplus_align (gsi)
@@ -2935,7 +2935,7 @@ associate_pointerplus (gimple_stmt_iterator *gsi)
     return false;
 
   tree off = make_ssa_name (TREE_TYPE (off1), NULL);
-  gimple ostmt = gimple_build_assign_with_ops (PLUS_EXPR, off, off1, off2);
+  gimple *ostmt = gimple_build_assign_with_ops (PLUS_EXPR, off, off1, off2);
   gsi_insert_before (gsi, ostmt, GSI_SAME_STMT);
 
   gimple_assign_set_rhs_with_ops (gsi, POINTER_PLUS_EXPR, ptr, off);
@@ -2951,8 +2951,8 @@ associate_pointerplus (gimple_stmt_iterator *gsi)
 static int
 combine_conversions (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
-  gimple def_stmt;
+  gimple *stmt = gsi_stmt (*gsi);
+  gimple *def_stmt;
   tree op0, lhs;
   enum tree_code code = gimple_assign_rhs_code (stmt);
   enum tree_code code2;
@@ -3146,7 +3146,7 @@ combine_conversions (gimple_stmt_iterator *gsi)
 static bool
 simplify_vce (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   tree type = TREE_TYPE (gimple_assign_lhs (stmt));
 
   /* Drop useless VIEW_CONVERT_EXPRs.  */
@@ -3161,7 +3161,7 @@ simplify_vce (gimple_stmt_iterator *gsi)
   if (TREE_CODE (op) != SSA_NAME)
     return false;
 
-  gimple def_stmt = SSA_NAME_DEF_STMT (op);
+  gimple *def_stmt = SSA_NAME_DEF_STMT (op);
   if (!is_gimple_assign (def_stmt))
     return false;
 
@@ -3210,8 +3210,8 @@ simplify_vce (gimple_stmt_iterator *gsi)
 static bool
 simplify_bitfield_ref (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
-  gimple def_stmt;
+  gimple *stmt = gsi_stmt (*gsi);
+  gimple *def_stmt;
   tree op, op0, op1, op2;
   tree elem_type;
   unsigned idx, n, size;
@@ -3323,8 +3323,8 @@ is_combined_permutation_identity (tree mask1, tree mask2)
 static int
 simplify_permutation (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
-  gimple def_stmt;
+  gimple *stmt = gsi_stmt (*gsi);
+  gimple *def_stmt;
   tree op0, op1, op2, op3, arg0, arg1;
   enum tree_code code;
   bool single_use_op0 = false;
@@ -3394,7 +3394,7 @@ simplify_permutation (gimple_stmt_iterator *gsi)
 	    {
 	      enum tree_code code2;
 
-	      gimple def_stmt2 = get_prop_source_stmt (op1, true, NULL);
+	      gimple *def_stmt2 = get_prop_source_stmt (op1, true, NULL);
 	      if (!def_stmt2 || !can_propagate_from (def_stmt2))
 		return 0;
 
@@ -3434,8 +3434,8 @@ simplify_permutation (gimple_stmt_iterator *gsi)
 static bool
 simplify_vector_constructor (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
-  gimple def_stmt;
+  gimple *stmt = gsi_stmt (*gsi);
+  gimple *def_stmt;
   tree op, op2, orig, type, elem_type;
   unsigned elem_size, nelts, i;
   enum tree_code code;
@@ -3525,14 +3525,14 @@ simplify_vector_constructor (gimple_stmt_iterator *gsi)
 static bool
 simplify_mult (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   tree arg1 = gimple_assign_rhs1 (stmt);
   tree arg2 = gimple_assign_rhs2 (stmt);
 
   if (TREE_CODE (arg1) != SSA_NAME)
     return false;
 
-  gimple def_stmt = SSA_NAME_DEF_STMT (arg1);
+  gimple *def_stmt = SSA_NAME_DEF_STMT (arg1);
   if (!is_gimple_assign (def_stmt))
     return false;
 
@@ -3615,7 +3615,7 @@ pass_forwprop::execute (function *fun)
 	 Note we update GSI within the loop as necessary.  */
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); )
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  tree lhs, rhs;
 	  enum tree_code code;
 
@@ -3702,7 +3702,7 @@ pass_forwprop::execute (function *fun)
 	 Note we update GSI within the loop as necessary.  */
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  bool changed = false;
 
 	  /* Mark stmt as potentially needing revisiting.  */
diff --git a/gcc/tree-ssa-ifcombine.c b/gcc/tree-ssa-ifcombine.c
index fae389b..b3d2f7e 100644
--- a/gcc/tree-ssa-ifcombine.c
+++ b/gcc/tree-ssa-ifcombine.c
@@ -125,7 +125,7 @@ bb_no_side_effects_p (basic_block bb)
 
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
 
       if (gimple_has_side_effects (stmt)
 	  || gimple_vuse (stmt))
@@ -155,7 +155,7 @@ same_phi_args_p (basic_block bb1, basic_block bb2, basic_block dest)
   edge e1 = find_edge (bb1, dest);
   edge e2 = find_edge (bb2, dest);
   gimple_stmt_iterator gsi;
-  gimple phi;
+  gimple *phi;
 
   for (gsi = gsi_start_phis (dest); !gsi_end_p (gsi); gsi_next (&gsi))
     {
@@ -179,7 +179,7 @@ get_name_for_bit_test (tree candidate)
   if (TREE_CODE (candidate) == SSA_NAME
       && has_single_use (candidate))
     {
-      gimple def_stmt = SSA_NAME_DEF_STMT (candidate);
+      gimple *def_stmt = SSA_NAME_DEF_STMT (candidate);
       if (is_gimple_assign (def_stmt)
 	  && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt)))
 	{
@@ -198,9 +198,9 @@ get_name_for_bit_test (tree candidate)
    Returns true if the pattern matched, false otherwise.  */
 
 static bool
-recognize_single_bit_test (gimple cond, tree *name, tree *bit, bool inv)
+recognize_single_bit_test (gimple *cond, tree *name, tree *bit, bool inv)
 {
-  gimple stmt;
+  gimple *stmt;
 
   /* Get at the definition of the result of the bit test.  */
   if (gimple_cond_code (cond) != (inv ? EQ_EXPR : NE_EXPR)
@@ -272,7 +272,7 @@ recognize_single_bit_test (gimple cond, tree *name, tree *bit, bool inv)
       && TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
       && TREE_CODE (gimple_assign_rhs2 (stmt)) == SSA_NAME)
     {
-      gimple tmp;
+      gimple *tmp;
 
       /* Both arguments of the BIT_AND_EXPR can be the single-bit
 	 specifying expression.  */
@@ -306,9 +306,9 @@ recognize_single_bit_test (gimple cond, tree *name, tree *bit, bool inv)
    Returns true if the pattern matched, false otherwise.  */
 
 static bool
-recognize_bits_test (gimple cond, tree *name, tree *bits, bool inv)
+recognize_bits_test (gimple *cond, tree *name, tree *bits, bool inv)
 {
-  gimple stmt;
+  gimple *stmt;
 
   /* Get at the definition of the result of the bit test.  */
   if (gimple_cond_code (cond) != (inv ? EQ_EXPR : NE_EXPR)
@@ -337,7 +337,7 @@ ifcombine_ifandif (basic_block inner_cond_bb, bool inner_inv,
 		   basic_block outer_cond_bb, bool outer_inv, bool result_inv)
 {
   gimple_stmt_iterator gsi;
-  gimple inner_cond, outer_cond;
+  gimple *inner_cond, *outer_cond;
   tree name1, name2, bit1, bit2, bits1, bits2;
 
   inner_cond = last_stmt (inner_cond_bb);
@@ -772,7 +772,7 @@ pass_tree_ifcombine::execute (function *fun)
   for (i = n_basic_blocks_for_fn (fun) - NUM_FIXED_BLOCKS - 1; i >= 0; i--)
     {
       basic_block bb = bbs[i];
-      gimple stmt = last_stmt (bb);
+      gimple *stmt = last_stmt (bb);
 
       if (stmt
 	  && gimple_code (stmt) == GIMPLE_COND)
diff --git a/gcc/tree-ssa-live.c b/gcc/tree-ssa-live.c
index 3cd3613..c046565 100644
--- a/gcc/tree-ssa-live.c
+++ b/gcc/tree-ssa-live.c
@@ -679,7 +679,7 @@ clear_unused_block_pointer (void)
       {
 	unsigned i;
 	tree b;
-	gimple stmt = gsi_stmt (gsi);
+	gimple *stmt = gsi_stmt (gsi);
 
 	if (!is_gimple_debug (stmt) && !gimple_clobber_p (stmt))
 	  continue;
@@ -802,7 +802,7 @@ remove_unused_locals (void)
       /* Walk the statements.  */
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  tree b = gimple_block (stmt);
 
 	  if (is_gimple_debug (stmt))
@@ -826,7 +826,7 @@ remove_unused_locals (void)
           use_operand_p arg_p;
           ssa_op_iter i;
 	  tree def;
-	  gimple phi = gsi_stmt (gsi);
+	  gimple *phi = gsi_stmt (gsi);
 
 	  if (virtual_operand_p (gimple_phi_result (phi)))
 	    continue;
@@ -863,7 +863,7 @@ remove_unused_locals (void)
 
 	for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
 	  {
-	    gimple stmt = gsi_stmt (gsi);
+	    gimple *stmt = gsi_stmt (gsi);
 	    tree b = gimple_block (stmt);
 
 	    if (gimple_clobber_p (stmt))
@@ -1074,7 +1074,7 @@ static void
 set_var_live_on_entry (tree ssa_name, tree_live_info_p live)
 {
   int p;
-  gimple stmt;
+  gimple *stmt;
   use_operand_p use;
   basic_block def_bb = NULL;
   imm_use_iterator imm_iter;
@@ -1099,7 +1099,7 @@ set_var_live_on_entry (tree ssa_name, tree_live_info_p live)
      add it to the list of live on entry blocks.  */
   FOR_EACH_IMM_USE_FAST (use, imm_iter, ssa_name)
     {
-      gimple use_stmt = USE_STMT (use);
+      gimple *use_stmt = USE_STMT (use);
       basic_block add_block = NULL;
 
       if (gimple_code (use_stmt) == GIMPLE_PHI)
@@ -1162,7 +1162,7 @@ calculate_live_on_exit (tree_live_info_p liveinfo)
       /* Mark the PHI arguments which are live on exit to the pred block.  */
       for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple phi = gsi_stmt (gsi);
+	  gimple *phi = gsi_stmt (gsi);
 	  for (i = 0; i < gimple_phi_num_args (phi); i++)
 	    {
 	      tree t = PHI_ARG_DEF (phi, i);
@@ -1365,7 +1365,7 @@ verify_live_on_entry (tree_live_info_p live)
 {
   unsigned i;
   tree var;
-  gimple stmt;
+  gimple *stmt;
   basic_block bb;
   edge e;
   int num;
@@ -1440,7 +1440,7 @@ verify_live_on_entry (tree_live_info_p live)
 		     !gsi_end_p (gsi) && !ok;
 		     gsi_next (&gsi))
 		  {
-		    gimple phi = gsi_stmt (gsi);
+		    gimple *phi = gsi_stmt (gsi);
 		    for (z = 0; z < gimple_phi_num_args (phi); z++)
 		      if (var == gimple_phi_arg_def (phi, z))
 			{
diff --git a/gcc/tree-ssa-loop-ch.c b/gcc/tree-ssa-loop-ch.c
index e44f9de..da24162a 100644
--- a/gcc/tree-ssa-loop-ch.c
+++ b/gcc/tree-ssa-loop-ch.c
@@ -53,7 +53,7 @@ should_duplicate_loop_header_p (basic_block header, struct loop *loop,
 				int *limit)
 {
   gimple_stmt_iterator bsi;
-  gimple last;
+  gimple *last;
 
   /* Do not copy one block more than once (we do not really want to do
      loop peeling here).  */
@@ -111,7 +111,7 @@ should_duplicate_loop_header_p (basic_block header, struct loop *loop,
 static bool
 do_while_loop_p (struct loop *loop)
 {
-  gimple stmt = last_stmt (loop->latch);
+  gimple *stmt = last_stmt (loop->latch);
 
   /* If the latch of the loop is not empty, it is not a do-while loop.  */
   if (stmt
@@ -259,7 +259,7 @@ pass_ch::execute (function *fun)
 		   !gsi_end_p (bsi);
 		   gsi_next (&bsi))
 		{
-		  gimple stmt = gsi_stmt (bsi);
+		  gimple *stmt = gsi_stmt (bsi);
 		  if (gimple_code (stmt) == GIMPLE_COND)
 		    gimple_set_no_warning (stmt, true);
 		  else if (is_gimple_assign (stmt))
diff --git a/gcc/tree-ssa-loop-im.c b/gcc/tree-ssa-loop-im.c
index 5863127..38a4e5d 100644
--- a/gcc/tree-ssa-loop-im.c
+++ b/gcc/tree-ssa-loop-im.c
@@ -94,7 +94,7 @@ struct lim_aux_data
   unsigned cost;		/* Cost of the computation performed by the
 				   statement.  */
 
-  vec<gimple> depends;		/* Vector of statements that must be also
+  vec<gimple *> depends;		/* Vector of statements that must be also
 				   hoisted out of the loop when this statement
 				   is hoisted; i.e. those that define the
 				   operands of the statement and are inside of
@@ -110,7 +110,7 @@ static struct pointer_map_t *lim_aux_data_map;
 typedef struct mem_ref_loc
 {
   tree *ref;			/* The reference itself.  */
-  gimple stmt;			/* The statement in that it occurs.  */
+  gimple *stmt;			/* The statement in that it occurs.  */
 } *mem_ref_loc_p;
 
 
@@ -223,7 +223,7 @@ static bool ref_indep_loop_p (struct loop *, mem_ref_p);
 #define MEM_ANALYZABLE(REF) ((REF)->id != UNANALYZABLE_MEM_ID)
 
 static struct lim_aux_data *
-init_lim_data (gimple stmt)
+init_lim_data (gimple *stmt)
 {
   void **p = pointer_map_insert (lim_aux_data_map, stmt);
 
@@ -232,7 +232,7 @@ init_lim_data (gimple stmt)
 }
 
 static struct lim_aux_data *
-get_lim_data (gimple stmt)
+get_lim_data (gimple *stmt)
 {
   void **p = pointer_map_contains (lim_aux_data_map, stmt);
   if (!p)
@@ -251,7 +251,7 @@ free_lim_aux_data (struct lim_aux_data *data)
 }
 
 static void
-clear_lim_data (gimple stmt)
+clear_lim_data (gimple *stmt)
 {
   void **p = pointer_map_contains (lim_aux_data_map, stmt);
   if (!p)
@@ -280,7 +280,7 @@ enum move_pos
    Otherwise return MOVE_IMPOSSIBLE.  */
 
 enum move_pos
-movement_possibility (gimple stmt)
+movement_possibility (gimple *stmt)
 {
   tree lhs;
   enum move_pos ret = MOVE_POSSIBLE;
@@ -378,7 +378,7 @@ movement_possibility (gimple stmt)
 static struct loop *
 outermost_invariant_loop (tree def, struct loop *loop)
 {
-  gimple def_stmt;
+  gimple *def_stmt;
   basic_block def_bb;
   struct loop *max_loop;
   struct lim_aux_data *lim_data;
@@ -426,7 +426,7 @@ static bool
 add_dependency (tree def, struct lim_aux_data *data, struct loop *loop,
 		bool add_cost)
 {
-  gimple def_stmt = SSA_NAME_DEF_STMT (def);
+  gimple *def_stmt = SSA_NAME_DEF_STMT (def);
   basic_block def_bb = gimple_bb (def_stmt);
   struct loop *max_loop;
   struct lim_aux_data *def_data;
@@ -462,7 +462,7 @@ add_dependency (tree def, struct lim_aux_data *data, struct loop *loop,
    are just ad-hoc constants, similar to costs for inlining.  */
 
 static unsigned
-stmt_cost (gimple stmt)
+stmt_cost (gimple *stmt)
 {
   /* Always try to create possibilities for unswitching.  */
   if (gimple_code (stmt) == GIMPLE_COND
@@ -568,7 +568,7 @@ outermost_indep_loop (struct loop *outer, struct loop *loop, mem_ref_p ref)
    it is a store or load.  Otherwise, returns NULL.  */
 
 static tree *
-simple_mem_ref_in_stmt (gimple stmt, bool *is_store)
+simple_mem_ref_in_stmt (gimple *stmt, bool *is_store)
 {
   tree *lhs, *rhs;
 
@@ -597,7 +597,7 @@ simple_mem_ref_in_stmt (gimple stmt, bool *is_store)
 /* Returns the memory reference contained in STMT.  */
 
 static mem_ref_p
-mem_ref_in_stmt (gimple stmt)
+mem_ref_in_stmt (gimple *stmt)
 {
   bool store;
   tree *mem = simple_mem_ref_in_stmt (stmt, &store);
@@ -622,7 +622,7 @@ mem_ref_in_stmt (gimple stmt)
    else return false.  */
 
 static bool
-extract_true_false_args_from_phi (basic_block dom, gimple phi,
+extract_true_false_args_from_phi (basic_block dom, gimple *phi,
 				  tree *true_arg_p, tree *false_arg_p)
 {
   basic_block bb = gimple_bb (phi);
@@ -690,7 +690,7 @@ extract_true_false_args_from_phi (basic_block dom, gimple phi,
    is defined in, and true otherwise.  */
 
 static bool
-determine_max_movement (gimple stmt, bool must_preserve_exec)
+determine_max_movement (gimple *stmt, bool must_preserve_exec)
 {
   basic_block bb = gimple_bb (stmt);
   struct loop *loop = bb->loop_father;
@@ -736,7 +736,7 @@ determine_max_movement (gimple stmt, bool must_preserve_exec)
       if (gimple_phi_num_args (stmt) > 1)
 	{
 	  basic_block dom = get_immediate_dominator (CDI_DOMINATORS, bb);
-	  gimple cond;
+	  gimple *cond;
 	  if (gsi_end_p (gsi_last_bb (dom)))
 	    return false;
 	  cond = gsi_stmt (gsi_last_bb (dom));
@@ -813,11 +813,11 @@ determine_max_movement (gimple stmt, bool must_preserve_exec)
    operands) is hoisted at least out of the loop LEVEL.  */
 
 static void
-set_level (gimple stmt, struct loop *orig_loop, struct loop *level)
+set_level (gimple *stmt, struct loop *orig_loop, struct loop *level)
 {
   struct loop *stmt_loop = gimple_bb (stmt)->loop_father;
   struct lim_aux_data *lim_data;
-  gimple dep_stmt;
+  gimple *dep_stmt;
   unsigned i;
 
   stmt_loop = find_common_loop (orig_loop, stmt_loop);
@@ -841,7 +841,7 @@ set_level (gimple stmt, struct loop *orig_loop, struct loop *level)
    information to set it more sanely.  */
 
 static void
-set_profitable_level (gimple stmt)
+set_profitable_level (gimple *stmt)
 {
   set_level (stmt, gimple_bb (stmt)->loop_father, get_lim_data (stmt)->max_loop);
 }
@@ -849,7 +849,7 @@ set_profitable_level (gimple stmt)
 /* Returns true if STMT is a call that has side effects.  */
 
 static bool
-nonpure_call_p (gimple stmt)
+nonpure_call_p (gimple *stmt)
 {
   if (gimple_code (stmt) != GIMPLE_CALL)
     return false;
@@ -859,10 +859,10 @@ nonpure_call_p (gimple stmt)
 
 /* Rewrite a/b to a*(1/b).  Return the invariant stmt to process.  */
 
-static gimple
+static gimple *
 rewrite_reciprocal (gimple_stmt_iterator *bsi)
 {
-  gimple stmt, stmt1, stmt2;
+  gimple *stmt, *stmt1, *stmt2;
   tree name, lhs, type;
   tree real_one;
   gimple_stmt_iterator gsi;
@@ -894,10 +894,10 @@ rewrite_reciprocal (gimple_stmt_iterator *bsi)
 /* Check if the pattern at *BSI is a bittest of the form
    (A >> B) & 1 != 0 and in this case rewrite it to A & (1 << B) != 0.  */
 
-static gimple
+static gimple *
 rewrite_bittest (gimple_stmt_iterator *bsi)
 {
-  gimple stmt, use_stmt, stmt1, stmt2;
+  gimple *stmt, *use_stmt, *stmt1, *stmt2;
   tree lhs, name, t, a, b;
   use_operand_p use;
 
@@ -999,7 +999,7 @@ invariantness_dom_walker::before_dom_children (basic_block bb)
 {
   enum move_pos pos;
   gimple_stmt_iterator bsi;
-  gimple stmt;
+  gimple *stmt;
   bool maybe_never = ALWAYS_EXECUTED_IN (bb) == NULL;
   struct loop *outermost = ALWAYS_EXECUTED_IN (bb);
   struct lim_aux_data *lim_data;
@@ -1145,7 +1145,7 @@ move_computations_dom_walker::before_dom_children (basic_block bb)
 {
   struct loop *level;
   gimple_stmt_iterator bsi;
-  gimple stmt;
+  gimple *stmt;
   unsigned cost = 0;
   struct lim_aux_data *lim_data;
 
@@ -1154,7 +1154,7 @@ move_computations_dom_walker::before_dom_children (basic_block bb)
 
   for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); )
     {
-      gimple new_stmt;
+      gimple *new_stmt;
       stmt = gsi_stmt (bsi);
 
       lim_data = get_lim_data (stmt);
@@ -1192,7 +1192,7 @@ move_computations_dom_walker::before_dom_children (basic_block bb)
       else
 	{
 	  basic_block dom = get_immediate_dominator (CDI_DOMINATORS, bb);
-	  gimple cond = gsi_stmt (gsi_last_bb (dom));
+	  gimple *cond = gsi_stmt (gsi_last_bb (dom));
 	  tree arg0 = NULL_TREE, arg1 = NULL_TREE, t;
 	  /* Get the PHI arguments corresponding to the true and false
 	     edges of COND.  */
@@ -1255,7 +1255,7 @@ move_computations_dom_walker::before_dom_children (basic_block bb)
 	  for (gsi2 = gsi_start_phis (e->dest);
 	       !gsi_end_p (gsi2); gsi_next (&gsi2))
 	    {
-	      gimple phi = gsi_stmt (gsi2);
+	      gimple *phi = gsi_stmt (gsi2);
 	      if (virtual_operand_p (gimple_phi_result (phi)))
 		{
 		  gimple_set_vuse (stmt, PHI_ARG_DEF_FROM_EDGE (phi, e));
@@ -1335,7 +1335,7 @@ may_move_till (tree ref, tree *index, void *data)
 static void
 force_move_till_op (tree op, struct loop *orig_loop, struct loop *loop)
 {
-  gimple stmt;
+  gimple *stmt;
 
   if (!op
       || is_gimple_min_invariant (op))
@@ -1409,7 +1409,7 @@ mem_ref_alloc (tree mem, unsigned hash, unsigned id)
    description REF.  The reference occurs in statement STMT.  */
 
 static void
-record_mem_ref_loc (mem_ref_p ref, gimple stmt, tree *loc)
+record_mem_ref_loc (mem_ref_p ref, gimple *stmt, tree *loc)
 {
   mem_ref_loc aref;
   aref.stmt = stmt;
@@ -1444,7 +1444,7 @@ mark_ref_stored (mem_ref_p ref, struct loop *loop)
    well.  */
 
 static void
-gather_mem_refs_stmt (struct loop *loop, gimple stmt)
+gather_mem_refs_stmt (struct loop *loop, gimple *stmt)
 {
   tree *mem = NULL;
   hashval_t hash;
@@ -1796,7 +1796,7 @@ execute_sm_if_changed (edge ex, tree mem, tree tmp_var, tree flag)
   bool loop_has_only_one_exit;
   edge then_old_edge, orig_ex = ex;
   gimple_stmt_iterator gsi;
-  gimple stmt;
+  gimple *stmt;
   struct prev_flag_edges *prev_edges = (struct prev_flag_edges *) ex->aux;
   bool irr = ex->flags & EDGE_IRREDUCIBLE_LOOP;
 
@@ -1864,7 +1864,7 @@ execute_sm_if_changed (edge ex, tree mem, tree tmp_var, tree flag)
   if (!loop_has_only_one_exit)
     for (gsi = gsi_start_phis (old_dest); !gsi_end_p (gsi); gsi_next (&gsi))
       {
-	gimple phi = gsi_stmt (gsi);
+	gimple *phi = gsi_stmt (gsi);
 	unsigned i;
 
 	for (i = 0; i < gimple_phi_num_args (phi); i++)
@@ -1897,7 +1897,7 @@ sm_set_flag_if_changed::operator () (mem_ref_loc_p loc)
       && gimple_assign_lhs_ptr (loc->stmt) == loc->ref)
     {
       gimple_stmt_iterator gsi = gsi_for_stmt (loc->stmt);
-      gimple stmt = gimple_build_assign (flag, boolean_true_node);
+      gimple *stmt = gimple_build_assign (flag, boolean_true_node);
       gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
     }
   return false;
@@ -1926,7 +1926,7 @@ execute_sm (struct loop *loop, vec<edge> exits, mem_ref_p ref)
 {
   tree tmp_var, store_flag = NULL_TREE;
   unsigned i;
-  gimple load;
+  gimple *load;
   struct fmt_data fmt_data;
   edge ex;
   struct lim_aux_data *lim_data;
@@ -1983,7 +1983,7 @@ execute_sm (struct loop *loop, vec<edge> exits, mem_ref_p ref)
   FOR_EACH_VEC_ELT (exits, i, ex)
     if (!multi_threaded_model_p)
       {
-	gimple store;
+	gimple *store;
 	store = gimple_build_assign (unshare_expr (ref->mem.ref), tmp_var);
 	gsi_insert_on_edge (ex, store);
       }
diff --git a/gcc/tree-ssa-loop-ivcanon.c b/gcc/tree-ssa-loop-ivcanon.c
index e332918..eb9838c 100644
--- a/gcc/tree-ssa-loop-ivcanon.c
+++ b/gcc/tree-ssa-loop-ivcanon.c
@@ -88,7 +88,7 @@ create_canonical_iv (struct loop *loop, edge exit, tree niter)
 {
   edge in;
   tree type, var;
-  gimple cond;
+  gimple *cond;
   gimple_stmt_iterator incr_at;
   enum tree_code cmp;
 
@@ -160,7 +160,7 @@ struct loop_size
 /* Return true if OP in STMT will be constant after peeling LOOP.  */
 
 static bool
-constant_after_peeling (tree op, gimple stmt, struct loop *loop)
+constant_after_peeling (tree op, gimple *stmt, struct loop *loop)
 {
   affine_iv iv;
 
@@ -245,7 +245,7 @@ tree_estimate_loop_size (struct loop *loop, edge exit, edge edge_to_cancel, stru
 
       for (gsi = gsi_start_bb (body[i]); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  int num = estimate_num_insns (stmt, &eni_size_weights);
 	  bool likely_eliminated = false;
 	  bool likely_eliminated_last = false;
@@ -335,7 +335,7 @@ tree_estimate_loop_size (struct loop *loop, edge exit, edge edge_to_cancel, stru
       basic_block bb = path.pop ();
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  if (gimple_code (stmt) == GIMPLE_CALL)
 	    {
 	      int flags = gimple_call_flags (stmt);
@@ -493,7 +493,7 @@ remove_exits_and_undefined_stmts (struct loop *loop, unsigned int npeeled)
 	  && wi::ltu_p (elt->bound, npeeled))
 	{
 	  gimple_stmt_iterator gsi = gsi_for_stmt (elt->stmt);
-	  gimple stmt = gimple_build_call
+	  gimple *stmt = gimple_build_call
 	      (builtin_decl_implicit (BUILT_IN_UNREACHABLE), 0);
 
 	  gimple_set_location (stmt, gimple_location (elt->stmt));
@@ -612,7 +612,7 @@ unloop_loops (bitmap loop_closed_ssa_invalidated,
       edge latch_edge = loop_latch_edge (loop);
       int flags = latch_edge->flags;
       location_t locus = latch_edge->goto_locus;
-      gimple stmt;
+      gimple *stmt;
       gimple_stmt_iterator gsi;
 
       remove_exits_and_undefined_stmts (loop, n_unroll);
@@ -657,7 +657,7 @@ try_unroll_loop_completely (struct loop *loop,
 			    location_t locus)
 {
   unsigned HOST_WIDE_INT n_unroll, ninsns, max_unroll, unr_insns;
-  gimple cond;
+  gimple *cond;
   struct loop_size size;
   bool n_unroll_found = false;
   edge edge_to_cancel = NULL;
@@ -1032,7 +1032,7 @@ static void
 propagate_into_all_uses (tree ssa_name, tree val)
 {
   imm_use_iterator iter;
-  gimple use_stmt;
+  gimple *use_stmt;
 
   FOR_EACH_IMM_USE_STMT (use_stmt, iter, ssa_name)
     {
@@ -1068,7 +1068,7 @@ propagate_constants_for_unrolling (basic_block bb)
   /* Look for degenerate PHI nodes with constant argument.  */
   for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); )
     {
-      gimple phi = gsi_stmt (gsi);
+      gimple *phi = gsi_stmt (gsi);
       tree result = gimple_phi_result (phi);
       tree arg = gimple_phi_arg_def (phi, 0);
 
@@ -1085,7 +1085,7 @@ propagate_constants_for_unrolling (basic_block bb)
   /* Look for assignments to SSA names with constant RHS.  */
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); )
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       tree lhs;
 
       if (is_gimple_assign (stmt)
diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c
index b24463d..7bd00c1 100644
--- a/gcc/tree-ssa-loop-ivopts.c
+++ b/gcc/tree-ssa-loop-ivopts.c
@@ -199,7 +199,7 @@ struct iv_use
   unsigned id;		/* The id of the use.  */
   enum use_type type;	/* Type of the use.  */
   struct iv *iv;	/* The induction variable it is based on.  */
-  gimple stmt;		/* Statement in that it occurs.  */
+  gimple *stmt;		/* Statement in that it occurs.  */
   tree *op_p;		/* The place where it occurs.  */
   bitmap related_cands;	/* The set of "related" iv candidates, plus the common
 			   important ones.  */
@@ -229,7 +229,7 @@ struct iv_cand
   bool important;	/* Whether this is an "important" candidate, i.e. such
 			   that it should be considered by all uses.  */
   ENUM_BITFIELD(iv_position) pos : 8;	/* Where it is computed.  */
-  gimple incremented_at;/* For original biv, the statement where it is
+  gimple *incremented_at;/* For original biv, the statement where it is
 			   incremented.  */
   tree var_before;	/* The variable used for it before increment.  */
   tree var_after;	/* The variable used for it after increment.  */
@@ -658,7 +658,7 @@ name_info (struct ivopts_data *data, tree name)
    emitted in LOOP.  */
 
 static bool
-stmt_after_ip_normal_pos (struct loop *loop, gimple stmt)
+stmt_after_ip_normal_pos (struct loop *loop, gimple *stmt)
 {
   basic_block bb = ip_normal_pos (loop), sbb = gimple_bb (stmt);
 
@@ -678,7 +678,7 @@ stmt_after_ip_normal_pos (struct loop *loop, gimple stmt)
    if the positions are identical.  */
 
 static bool
-stmt_after_inc_pos (struct iv_cand *cand, gimple stmt, bool true_if_equal)
+stmt_after_inc_pos (struct iv_cand *cand, gimple *stmt, bool true_if_equal)
 {
   basic_block cand_bb = gimple_bb (cand->incremented_at);
   basic_block stmt_bb = gimple_bb (stmt);
@@ -699,7 +699,7 @@ stmt_after_inc_pos (struct iv_cand *cand, gimple stmt, bool true_if_equal)
    CAND is incremented in LOOP.  */
 
 static bool
-stmt_after_increment (struct loop *loop, struct iv_cand *cand, gimple stmt)
+stmt_after_increment (struct loop *loop, struct iv_cand *cand, gimple *stmt)
 {
   switch (cand->pos)
     {
@@ -1033,7 +1033,7 @@ get_iv (struct ivopts_data *data, tree var)
    not define a simple affine biv with nonzero step.  */
 
 static tree
-determine_biv_step (gimple phi)
+determine_biv_step (gimple *phi)
 {
   struct loop *loop = gimple_bb (phi)->loop_father;
   tree name = PHI_RESULT (phi);
@@ -1053,7 +1053,7 @@ determine_biv_step (gimple phi)
 static bool
 find_bivs (struct ivopts_data *data)
 {
-  gimple phi;
+  gimple *phi;
   tree step, type, base;
   bool found = false;
   struct loop *loop = data->current_loop;
@@ -1098,7 +1098,7 @@ find_bivs (struct ivopts_data *data)
 static void
 mark_bivs (struct ivopts_data *data)
 {
-  gimple phi, def;
+  gimple *phi, *def;
   tree var;
   struct iv *iv, *incr_iv;
   struct loop *loop = data->current_loop;
@@ -1140,7 +1140,7 @@ mark_bivs (struct ivopts_data *data)
    parameters to IV.  */
 
 static bool
-find_givs_in_stmt_scev (struct ivopts_data *data, gimple stmt, affine_iv *iv)
+find_givs_in_stmt_scev (struct ivopts_data *data, gimple *stmt, affine_iv *iv)
 {
   tree lhs;
   struct loop *loop = data->current_loop;
@@ -1175,7 +1175,7 @@ find_givs_in_stmt_scev (struct ivopts_data *data, gimple stmt, affine_iv *iv)
 /* Finds general ivs in statement STMT.  */
 
 static void
-find_givs_in_stmt (struct ivopts_data *data, gimple stmt)
+find_givs_in_stmt (struct ivopts_data *data, gimple *stmt)
 {
   affine_iv iv;
 
@@ -1257,7 +1257,7 @@ find_induction_variables (struct ivopts_data *data)
 
 static struct iv_use *
 record_use (struct ivopts_data *data, tree *use_p, struct iv *iv,
-	    gimple stmt, enum use_type use_type)
+	    gimple *stmt, enum use_type use_type)
 {
   struct iv_use *use = XCNEW (struct iv_use);
 
@@ -1314,7 +1314,7 @@ find_interesting_uses_op (struct ivopts_data *data, tree op)
 {
   struct iv *iv;
   struct iv *civ;
-  gimple stmt;
+  gimple *stmt;
   struct iv_use *use;
 
   if (TREE_CODE (op) != SSA_NAME)
@@ -1361,7 +1361,7 @@ find_interesting_uses_op (struct ivopts_data *data, tree op)
    condition and false is returned.  */
 
 static bool
-extract_cond_operands (struct ivopts_data *data, gimple stmt,
+extract_cond_operands (struct ivopts_data *data, gimple *stmt,
 		       tree **control_var, tree **bound,
 		       struct iv **iv_var, struct iv **iv_bound)
 {
@@ -1421,7 +1421,7 @@ end:
    records it.  */
 
 static void
-find_interesting_uses_cond (struct ivopts_data *data, gimple stmt)
+find_interesting_uses_cond (struct ivopts_data *data, gimple *stmt)
 {
   tree *var_p, *bound_p;
   struct iv *var_iv, *civ;
@@ -1530,7 +1530,7 @@ expr_invariant_in_loop_p (struct loop *loop, tree expr)
 struct ifs_ivopts_data
 {
   struct ivopts_data *ivopts_data;
-  gimple stmt;
+  gimple *stmt;
   tree step;
 };
 
@@ -1764,7 +1764,7 @@ may_be_nonaddressable_p (tree expr)
 /* Finds addresses in *OP_P inside STMT.  */
 
 static void
-find_interesting_uses_address (struct ivopts_data *data, gimple stmt, tree *op_p)
+find_interesting_uses_address (struct ivopts_data *data, gimple *stmt, tree *op_p)
 {
   tree base = *op_p, step = size_zero_node;
   struct iv *civ;
@@ -1881,7 +1881,7 @@ fail:
 /* Finds and records invariants used in STMT.  */
 
 static void
-find_invariants_stmt (struct ivopts_data *data, gimple stmt)
+find_invariants_stmt (struct ivopts_data *data, gimple *stmt)
 {
   ssa_op_iter iter;
   use_operand_p use_p;
@@ -1897,7 +1897,7 @@ find_invariants_stmt (struct ivopts_data *data, gimple stmt)
 /* Finds interesting uses of induction variables in the statement STMT.  */
 
 static void
-find_interesting_uses_stmt (struct ivopts_data *data, gimple stmt)
+find_interesting_uses_stmt (struct ivopts_data *data, gimple *stmt)
 {
   struct iv *iv;
   tree op, *lhs, *rhs;
@@ -1988,7 +1988,7 @@ find_interesting_uses_stmt (struct ivopts_data *data, gimple stmt)
 static void
 find_interesting_uses_outside (struct ivopts_data *data, edge exit)
 {
-  gimple phi;
+  gimple *phi;
   gimple_stmt_iterator psi;
   tree def;
 
@@ -2289,7 +2289,7 @@ find_depends (tree *expr_p, int *ws ATTRIBUTE_UNUSED, void *data)
 static struct iv_cand *
 add_candidate_1 (struct ivopts_data *data,
 		 tree base, tree step, bool important, enum iv_position pos,
-		 struct iv_use *use, gimple incremented_at)
+		 struct iv_use *use, gimple *incremented_at)
 {
   unsigned i;
   struct iv_cand *cand = NULL;
@@ -2518,7 +2518,7 @@ add_standard_iv_candidates (struct ivopts_data *data)
 static void
 add_old_iv_candidates (struct ivopts_data *data, struct iv *iv)
 {
-  gimple phi;
+  gimple *phi;
   tree def;
   struct iv_cand *cand;
 
@@ -2981,7 +2981,7 @@ computation_cost (tree expr, bool speed)
 /* Returns variable containing the value of candidate CAND at statement AT.  */
 
 static tree
-var_at_stmt (struct loop *loop, struct iv_cand *cand, gimple stmt)
+var_at_stmt (struct loop *loop, struct iv_cand *cand, gimple *stmt)
 {
   if (stmt_after_increment (loop, cand, stmt))
     return cand->var_after;
@@ -3031,7 +3031,7 @@ determine_common_wider_type (tree *a, tree *b)
 
 static bool
 get_computation_aff (struct loop *loop,
-		     struct iv_use *use, struct iv_cand *cand, gimple at,
+		     struct iv_use *use, struct iv_cand *cand, gimple *at,
 		     struct aff_tree *aff)
 {
   tree ubase = use->iv->base;
@@ -3128,7 +3128,7 @@ get_use_type (struct iv_use *use)
 
 static tree
 get_computation_at (struct loop *loop,
-		    struct iv_use *use, struct iv_cand *cand, gimple at)
+		    struct iv_use *use, struct iv_cand *cand, gimple *at)
 {
   aff_tree aff;
   tree type = get_use_type (use);
@@ -4080,7 +4080,7 @@ get_loop_invariant_expr_id (struct ivopts_data *data, tree ubase,
 static comp_cost
 get_computation_cost_at (struct ivopts_data *data,
 			 struct iv_use *use, struct iv_cand *cand,
-			 bool address_p, bitmap *depends_on, gimple at,
+			 bool address_p, bitmap *depends_on, gimple *at,
 			 bool *can_autoinc,
                          int *inv_expr_id)
 {
@@ -4378,7 +4378,7 @@ determine_use_iv_cost_address (struct ivopts_data *data,
    stores it to VAL.  */
 
 static void
-cand_value_at (struct loop *loop, struct iv_cand *cand, gimple at, tree niter,
+cand_value_at (struct loop *loop, struct iv_cand *cand, gimple *at, tree niter,
 	       aff_tree *val)
 {
   aff_tree step, delta, nit;
@@ -4464,7 +4464,7 @@ strip_wrap_conserving_type_conversions (tree exp)
 static bool
 expr_equal_p (tree e, tree what)
 {
-  gimple stmt;
+  gimple *stmt;
   enum tree_code code;
 
   e = strip_wrap_conserving_type_conversions (e);
@@ -4525,7 +4525,7 @@ difference_cannot_overflow_p (tree base, tree offset)
 
   if (TREE_CODE (base) == SSA_NAME)
     {
-      gimple stmt = SSA_NAME_DEF_STMT (base);
+      gimple *stmt = SSA_NAME_DEF_STMT (base);
 
       if (gimple_code (stmt) != GIMPLE_ASSIGN)
 	return false;
@@ -5206,7 +5206,7 @@ static void
 determine_set_costs (struct ivopts_data *data)
 {
   unsigned j, n;
-  gimple phi;
+  gimple *phi;
   gimple_stmt_iterator psi;
   tree op;
   struct loop *loop = data->current_loop;
@@ -6253,7 +6253,7 @@ rewrite_use_nonlinear_expr (struct ivopts_data *data,
 {
   tree comp;
   tree op, tgt;
-  gimple ass;
+  gimple *ass;
   gimple_stmt_iterator bsi;
 
   /* An important special case -- if we are asked to express value of
@@ -6380,7 +6380,7 @@ static void
 adjust_iv_update_pos (struct iv_cand *cand, struct iv_use *use)
 {
   tree var_after;
-  gimple iv_update, stmt;
+  gimple *iv_update, *stmt;
   basic_block bb;
   gimple_stmt_iterator gsi, gsi_iv;
 
@@ -6599,7 +6599,7 @@ remove_unused_ivs (struct ivopts_data *data)
 	    {
 	      imm_use_iterator imm_iter;
 	      use_operand_p use_p;
-	      gimple stmt;
+	      gimple *stmt;
 	      int count = 0;
 
 	      FOR_EACH_IMM_USE_STMT (stmt, imm_iter, def)
@@ -6670,7 +6670,7 @@ remove_unused_ivs (struct ivopts_data *data)
 		    DECL_MODE (vexpr) = DECL_MODE (SSA_NAME_VAR (def));
 		  else
 		    DECL_MODE (vexpr) = TYPE_MODE (TREE_TYPE (vexpr));
-		  gimple def_temp = gimple_build_debug_bind (vexpr, comp, NULL);
+		  gimple *def_temp = gimple_build_debug_bind (vexpr, comp, NULL);
 		  gimple_stmt_iterator gsi;
 
 		  if (gimple_code (SSA_NAME_DEF_STMT (def)) == GIMPLE_PHI)
@@ -6816,7 +6816,7 @@ loop_body_includes_call (basic_block *body, unsigned num_nodes)
   for (i = 0; i < num_nodes; i++)
     for (gsi = gsi_start_bb (body[i]); !gsi_end_p (gsi); gsi_next (&gsi))
       {
-	gimple stmt = gsi_stmt (gsi);
+	gimple *stmt = gsi_stmt (gsi);
 	if (is_gimple_call (stmt)
 	    && !is_inexpensive_builtin (gimple_call_fndecl (stmt)))
 	  return true;
diff --git a/gcc/tree-ssa-loop-manip.c b/gcc/tree-ssa-loop-manip.c
index 6de2e4e..5d8d130 100644
--- a/gcc/tree-ssa-loop-manip.c
+++ b/gcc/tree-ssa-loop-manip.c
@@ -71,7 +71,7 @@ create_iv (tree base, tree step, tree var, struct loop *loop,
 	   gimple_stmt_iterator *incr_pos, bool after,
 	   tree *var_before, tree *var_after)
 {
-  gimple stmt;
+  gimple *stmt;
   tree initial, step1;
   gimple_seq stmts;
   tree vb, va;
@@ -276,14 +276,14 @@ compute_live_loop_exits (bitmap live_exits, bitmap use_blocks,
 static void
 add_exit_phi (basic_block exit, tree var)
 {
-  gimple phi;
+  gimple *phi;
   edge e;
   edge_iterator ei;
 
 #ifdef ENABLE_CHECKING
   /* Check that at least one of the edges entering the EXIT block exits
      the loop, or a superloop of that loop, that VAR is defined in.  */
-  gimple def_stmt = SSA_NAME_DEF_STMT (var);
+  gimple *def_stmt = SSA_NAME_DEF_STMT (var);
   basic_block def_bb = gimple_bb (def_stmt);
   FOR_EACH_EDGE (e, ei, exit->preds)
     {
@@ -409,7 +409,7 @@ find_uses_to_rename_use (basic_block bb, tree use, bitmap *use_blocks,
    NEED_PHIS.  */
 
 static void
-find_uses_to_rename_stmt (gimple stmt, bitmap *use_blocks, bitmap need_phis)
+find_uses_to_rename_stmt (gimple *stmt, bitmap *use_blocks, bitmap need_phis)
 {
   ssa_op_iter iter;
   tree var;
@@ -437,7 +437,7 @@ find_uses_to_rename_bb (basic_block bb, bitmap *use_blocks, bitmap need_phis)
   FOR_EACH_EDGE (e, ei, bb->succs)
     for (bsi = gsi_start_phis (e->dest); !gsi_end_p (bsi); gsi_next (&bsi))
       {
-        gimple phi = gsi_stmt (bsi);
+        gimple *phi = gsi_stmt (bsi);
 	if (! virtual_operand_p (gimple_phi_result (phi)))
 	  find_uses_to_rename_use (bb, PHI_ARG_DEF_FROM_EDGE (phi, e),
 				   use_blocks, need_phis);
@@ -555,7 +555,7 @@ rewrite_into_loop_closed_ssa (bitmap changed_bbs, unsigned update_flag)
 static void
 check_loop_closed_ssa_use (basic_block bb, tree use)
 {
-  gimple def;
+  gimple *def;
   basic_block def_bb;
 
   if (TREE_CODE (use) != SSA_NAME || virtual_operand_p (use))
@@ -570,7 +570,7 @@ check_loop_closed_ssa_use (basic_block bb, tree use)
 /* Checks invariants of loop closed ssa form in statement STMT in BB.  */
 
 static void
-check_loop_closed_ssa_stmt (basic_block bb, gimple stmt)
+check_loop_closed_ssa_stmt (basic_block bb, gimple *stmt)
 {
   ssa_op_iter iter;
   tree var;
@@ -590,7 +590,7 @@ verify_loop_closed_ssa (bool verify_ssa_p)
 {
   basic_block bb;
   gimple_stmt_iterator bsi;
-  gimple phi;
+  gimple *phi;
   edge e;
   edge_iterator ei;
 
@@ -627,7 +627,7 @@ split_loop_exit_edge (edge exit)
 {
   basic_block dest = exit->dest;
   basic_block bb = split_edge (exit);
-  gimple phi, new_phi;
+  gimple *phi, *new_phi;
   tree new_name, name;
   use_operand_p op_p;
   gimple_stmt_iterator psi;
@@ -672,7 +672,7 @@ ip_end_pos (struct loop *loop)
 basic_block
 ip_normal_pos (struct loop *loop)
 {
-  gimple last;
+  gimple *last;
   basic_block bb;
   edge exit;
 
@@ -705,7 +705,7 @@ standard_iv_increment_position (struct loop *loop, gimple_stmt_iterator *bsi,
 				bool *insert_after)
 {
   basic_block bb = ip_normal_pos (loop), latch = ip_end_pos (loop);
-  gimple last = last_stmt (latch);
+  gimple *last = last_stmt (latch);
 
   if (!bb
       || (last && gimple_code (last) != GIMPLE_LABEL))
@@ -1030,11 +1030,11 @@ tree_transform_and_unroll_loop (struct loop *loop, unsigned factor,
 				transform_callback transform,
 				void *data)
 {
-  gimple exit_if;
+  gimple *exit_if;
   tree ctr_before, ctr_after;
   tree enter_main_cond, exit_base, exit_step, exit_bound;
   enum tree_code exit_cmp;
-  gimple phi_old_loop, phi_new_loop, phi_rest;
+  gimple *phi_old_loop, *phi_new_loop, *phi_rest;
   gimple_stmt_iterator psi_old_loop, psi_new_loop;
   tree init, next, new_init;
   struct loop *new_loop;
@@ -1264,7 +1264,7 @@ rewrite_phi_with_iv (loop_p loop,
 		     tree main_iv)
 {
   affine_iv iv;
-  gimple stmt, phi = gsi_stmt (*psi);
+  gimple *stmt, *phi = gsi_stmt (*psi);
   tree atype, mtype, val, res = PHI_RESULT (phi);
 
   if (virtual_operand_p (res) || res == main_iv)
@@ -1336,7 +1336,7 @@ canonicalize_loop_ivs (struct loop *loop, tree *nit, bool bump_in_latch)
   unsigned original_precision = precision;
   tree type, var_before;
   gimple_stmt_iterator gsi, psi;
-  gimple stmt;
+  gimple *stmt;
   edge exit = single_dom_exit (loop);
   gimple_seq stmts;
   enum machine_mode mode;
@@ -1345,7 +1345,7 @@ canonicalize_loop_ivs (struct loop *loop, tree *nit, bool bump_in_latch)
   for (psi = gsi_start_phis (loop->header);
        !gsi_end_p (psi); gsi_next (&psi))
     {
-      gimple phi = gsi_stmt (psi);
+      gimple *phi = gsi_stmt (psi);
       tree res = PHI_RESULT (phi);
       bool uns;
 
diff --git a/gcc/tree-ssa-loop-niter.c b/gcc/tree-ssa-loop-niter.c
index a48ad10..00182e5 100644
--- a/gcc/tree-ssa-loop-niter.c
+++ b/gcc/tree-ssa-loop-niter.c
@@ -155,7 +155,7 @@ determine_value_range (struct loop *loop, tree type, tree var, mpz_t off,
 	 PHI argument from the loop preheader edge.  */
       for (gsi = gsi_start_phis (loop->header); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple phi = gsi_stmt (gsi);
+	  gimple *phi = gsi_stmt (gsi);
 	  wide_int minc, maxc;
 	  if (PHI_ARG_DEF_FROM_EDGE (phi, e) == var
 	      && (get_range_info (gimple_phi_result (phi), &minc, &maxc)
@@ -457,7 +457,7 @@ bound_difference (struct loop *loop, tree x, tree y, bounds *bnds)
   edge e;
   basic_block bb;
   tree c0, c1;
-  gimple cond;
+  gimple *cond;
   enum tree_code cmp;
 
   /* Get rid of unnecessary casts, but preserve the value of
@@ -1545,7 +1545,7 @@ expand_simple_operations (tree expr)
   unsigned i, n;
   tree ret = NULL_TREE, e, ee, e1;
   enum tree_code code;
-  gimple stmt;
+  gimple *stmt;
 
   if (expr == NULL_TREE)
     return expr;
@@ -1779,7 +1779,7 @@ simplify_using_initial_conditions (struct loop *loop, tree expr)
 {
   edge e;
   basic_block bb;
-  gimple stmt;
+  gimple *stmt;
   tree cond;
   int cnt = 0;
 
@@ -1877,7 +1877,7 @@ loop_only_exit_p (const struct loop *loop, const_edge exit)
   basic_block *body;
   gimple_stmt_iterator bsi;
   unsigned i;
-  gimple call;
+  gimple *call;
 
   if (exit != single_exit (loop))
     return false;
@@ -1919,7 +1919,7 @@ number_of_iterations_exit (struct loop *loop, edge exit,
 			   struct tree_niter_desc *niter,
 			   bool warn, bool every_iteration)
 {
-  gimple stmt;
+  gimple *stmt;
   tree type;
   tree op0, op1;
   enum tree_code code;
@@ -2152,10 +2152,10 @@ finite_loop_p (struct loop *loop)
    result by a chain of operations such that all but exactly one of their
    operands are constants.  */
 
-static gimple
+static gimple *
 chain_of_csts_start (struct loop *loop, tree x)
 {
-  gimple stmt = SSA_NAME_DEF_STMT (x);
+  gimple *stmt = SSA_NAME_DEF_STMT (x);
   tree use;
   basic_block bb = gimple_bb (stmt);
   enum tree_code code;
@@ -2200,10 +2200,10 @@ chain_of_csts_start (struct loop *loop, tree x)
 
    If such phi node exists, it is returned, otherwise NULL is returned.  */
 
-static gimple
+static gimple *
 get_base_for (struct loop *loop, tree x)
 {
-  gimple phi;
+  gimple *phi;
   tree init, next;
 
   if (is_gimple_min_invariant (x))
@@ -2239,7 +2239,7 @@ get_base_for (struct loop *loop, tree x)
 static tree
 get_val_for (tree x, tree base)
 {
-  gimple stmt;
+  gimple *stmt;
 
   gcc_checking_assert (is_gimple_min_invariant (base));
 
@@ -2294,7 +2294,7 @@ loop_niter_by_eval (struct loop *loop, edge exit)
 {
   tree acnd;
   tree op[2], val[2], next[2], aval[2];
-  gimple phi, cond;
+  gimple *phi, *cond;
   unsigned i, j;
   enum tree_code cmp;
 
@@ -2434,7 +2434,7 @@ static widest_int derive_constant_upper_bound_ops (tree, tree,
    an assignment statement STMT.  */
 
 static widest_int
-derive_constant_upper_bound_assign (gimple stmt)
+derive_constant_upper_bound_assign (gimple *stmt)
 {
   enum tree_code code = gimple_assign_rhs_code (stmt);
   tree op0 = gimple_assign_rhs1 (stmt);
@@ -2468,7 +2468,7 @@ derive_constant_upper_bound_ops (tree type, tree op0,
 {
   tree subtype, maxt;
   widest_int bnd, max, mmax, cst;
-  gimple stmt;
+  gimple *stmt;
 
   if (INTEGRAL_TYPE_P (type))
     maxt = TYPE_MAX_VALUE (type);
@@ -2601,7 +2601,7 @@ derive_constant_upper_bound_ops (tree type, tree op0,
 
 static void
 do_warn_aggressive_loop_optimizations (struct loop *loop,
-				       widest_int i_bound, gimple stmt)
+				       widest_int i_bound, gimple *stmt)
 {
   /* Don't warn if the loop doesn't have known constant bound.  */
   if (!loop->nb_iterations
@@ -2623,7 +2623,7 @@ do_warn_aggressive_loop_optimizations (struct loop *loop,
   if (e == NULL)
     return;
 
-  gimple estmt = last_stmt (e->src);
+  gimple *estmt = last_stmt (e->src);
   if (warning_at (gimple_location (stmt), OPT_Waggressive_loop_optimizations,
 		  "iteration %E invokes undefined behavior",
 		  wide_int_to_tree (TREE_TYPE (loop->nb_iterations),
@@ -2641,7 +2641,7 @@ do_warn_aggressive_loop_optimizations (struct loop *loop,
 
 static void
 record_estimate (struct loop *loop, tree bound, const widest_int &i_bound,
-		 gimple at_stmt, bool is_exit, bool realistic, bool upper)
+		 gimple *at_stmt, bool is_exit, bool realistic, bool upper)
 {
   widest_int delta;
 
@@ -2714,7 +2714,7 @@ record_estimate (struct loop *loop, tree bound, const widest_int &i_bound,
    UPPER is true if we are sure the induction variable does not wrap.  */
 
 static void
-record_nonwrapping_iv (struct loop *loop, tree base, tree step, gimple stmt,
+record_nonwrapping_iv (struct loop *loop, tree base, tree step, gimple *stmt,
 		       tree low, tree high, bool realistic, bool upper)
 {
   tree niter_bound, extreme, delta;
@@ -2771,7 +2771,7 @@ record_nonwrapping_iv (struct loop *loop, tree base, tree step, gimple stmt,
 struct ilb_data
 {
   struct loop *loop;
-  gimple stmt;
+  gimple *stmt;
 };
 
 static bool
@@ -2870,7 +2870,7 @@ idx_infer_loop_bounds (tree base, tree *idx, void *dta)
    STMT is guaranteed to be executed in every iteration of LOOP.*/
 
 static void
-infer_loop_bounds_from_ref (struct loop *loop, gimple stmt, tree ref)
+infer_loop_bounds_from_ref (struct loop *loop, gimple *stmt, tree ref)
 {
   struct ilb_data data;
 
@@ -2884,7 +2884,7 @@ infer_loop_bounds_from_ref (struct loop *loop, gimple stmt, tree ref)
    executed in every iteration of LOOP.  */
 
 static void
-infer_loop_bounds_from_array (struct loop *loop, gimple stmt)
+infer_loop_bounds_from_array (struct loop *loop, gimple *stmt)
 {
   if (is_gimple_assign (stmt))
     {
@@ -2921,7 +2921,7 @@ infer_loop_bounds_from_array (struct loop *loop, gimple stmt)
    that pointer arithmetics in STMT does not overflow.  */
 
 static void
-infer_loop_bounds_from_pointer_arith (struct loop *loop, gimple stmt)
+infer_loop_bounds_from_pointer_arith (struct loop *loop, gimple *stmt)
 {
   tree def, base, step, scev, type, low, high;
   tree var, ptr;
@@ -2979,7 +2979,7 @@ infer_loop_bounds_from_pointer_arith (struct loop *loop, gimple stmt)
    that signed arithmetics in STMT does not overflow.  */
 
 static void
-infer_loop_bounds_from_signedness (struct loop *loop, gimple stmt)
+infer_loop_bounds_from_signedness (struct loop *loop, gimple *stmt)
 {
   tree def, base, step, scev, type, low, high;
 
@@ -3047,7 +3047,7 @@ infer_loop_bounds_from_undefined (struct loop *loop)
 
       for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
 	{
-	  gimple stmt = gsi_stmt (bsi);
+	  gimple *stmt = gsi_stmt (bsi);
 
 	  infer_loop_bounds_from_array (loop, stmt);
 
@@ -3327,7 +3327,7 @@ maybe_lower_iteration_bound (struct loop *loop)
       /* Loop for possible exits and statements bounding the execution.  */
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  if (pointer_set_contains (not_executed_last_iteration, stmt))
 	    {
 	      stmt_found = true;
@@ -3604,7 +3604,7 @@ estimate_numbers_of_iterations (void)
 /* Returns true if statement S1 dominates statement S2.  */
 
 bool
-stmt_dominates_stmt_p (gimple s1, gimple s2)
+stmt_dominates_stmt_p (gimple *s1, gimple *s2)
 {
   basic_block bb1 = gimple_bb (s1), bb2 = gimple_bb (s2);
 
@@ -3646,7 +3646,7 @@ stmt_dominates_stmt_p (gimple s1, gimple s2)
    bounds computed by discover_iteration_bound_by_body_walk.  */
 
 static bool
-n_of_executions_at_most (gimple stmt,
+n_of_executions_at_most (gimple *stmt,
 			 struct nb_iter_bound *niter_bound,
 			 tree niter)
 {
@@ -3741,7 +3741,7 @@ nowrap_type_p (tree type)
 
 bool
 scev_probably_wraps_p (tree base, tree step,
-		       gimple at_stmt, struct loop *loop,
+		       gimple *at_stmt, struct loop *loop,
 		       bool use_overflow_semantics)
 {
   tree delta, step_abs;
diff --git a/gcc/tree-ssa-loop-niter.h b/gcc/tree-ssa-loop-niter.h
index a143040..35d4c61 100644
--- a/gcc/tree-ssa-loop-niter.h
+++ b/gcc/tree-ssa-loop-niter.h
@@ -38,9 +38,9 @@ extern HOST_WIDE_INT estimated_stmt_executions_int (struct loop *);
 extern bool max_stmt_executions (struct loop *, widest_int *);
 extern bool estimated_stmt_executions (struct loop *, widest_int *);
 extern void estimate_numbers_of_iterations (void);
-extern bool stmt_dominates_stmt_p (gimple, gimple);
+extern bool stmt_dominates_stmt_p (gimple *, gimple *);
 extern bool nowrap_type_p (tree);
-extern bool scev_probably_wraps_p (tree, tree, gimple, struct loop *, bool);
+extern bool scev_probably_wraps_p (tree, tree, gimple *, struct loop *, bool);
 extern void free_numbers_of_iterations_estimates_loop (struct loop *);
 extern void free_numbers_of_iterations_estimates (void);
 extern void substitute_in_loop_info (struct loop *, tree, tree);
diff --git a/gcc/tree-ssa-loop-prefetch.c b/gcc/tree-ssa-loop-prefetch.c
index 1cf650a..ce77dc5 100644
--- a/gcc/tree-ssa-loop-prefetch.c
+++ b/gcc/tree-ssa-loop-prefetch.c
@@ -270,7 +270,7 @@ struct mem_ref_group
 
 struct mem_ref
 {
-  gimple stmt;			/* Statement in that the reference appears.  */
+  gimple *stmt;			/* Statement in that the reference appears.  */
   tree mem;			/* The reference.  */
   HOST_WIDE_INT delta;		/* Constant offset of the reference.  */
   struct mem_ref_group *group;	/* The group of references it belongs to.  */
@@ -359,7 +359,7 @@ find_or_create_group (struct mem_ref_group **groups, tree base, tree step)
    WRITE_P.  The reference occurs in statement STMT.  */
 
 static void
-record_ref (struct mem_ref_group *group, gimple stmt, tree mem,
+record_ref (struct mem_ref_group *group, gimple *stmt, tree mem,
 	    HOST_WIDE_INT delta, bool write_p)
 {
   struct mem_ref **aref;
@@ -425,7 +425,7 @@ release_mem_refs (struct mem_ref_group *groups)
 struct ar_data
 {
   struct loop *loop;			/* Loop of the reference.  */
-  gimple stmt;				/* Statement of the reference.  */
+  gimple *stmt;				/* Statement of the reference.  */
   tree *step;				/* Step of the memory reference.  */
   HOST_WIDE_INT *delta;			/* Offset of the memory reference.  */
 };
@@ -491,7 +491,7 @@ idx_analyze_ref (tree base, tree *index, void *data)
 static bool
 analyze_ref (struct loop *loop, tree *ref_p, tree *base,
 	     tree *step, HOST_WIDE_INT *delta,
-	     gimple stmt)
+	     gimple *stmt)
 {
   struct ar_data ar_data;
   tree off;
@@ -539,7 +539,7 @@ analyze_ref (struct loop *loop, tree *ref_p, tree *base,
 
 static bool
 gather_memory_references_ref (struct loop *loop, struct mem_ref_group **refs,
-			      tree ref, bool write_p, gimple stmt)
+			      tree ref, bool write_p, gimple *stmt)
 {
   tree base, step;
   HOST_WIDE_INT delta;
@@ -615,7 +615,7 @@ gather_memory_references (struct loop *loop, bool *no_other_refs, unsigned *ref_
   basic_block bb;
   unsigned i;
   gimple_stmt_iterator bsi;
-  gimple stmt;
+  gimple *stmt;
   tree lhs, rhs;
   struct mem_ref_group *refs = NULL;
 
@@ -1127,7 +1127,7 @@ issue_prefetch_ref (struct mem_ref *ref, unsigned unroll_factor, unsigned ahead)
 {
   HOST_WIDE_INT delta;
   tree addr, addr_base, write_p, local, forward;
-  gimple prefetch;
+  gimple *prefetch;
   gimple_stmt_iterator bsi;
   unsigned n_prefetches, ap;
   bool nontemporal = ref->reuse_distance >= L2_CACHE_SIZE_BYTES;
@@ -1244,7 +1244,7 @@ emit_mfence_after_loop (struct loop *loop)
 {
   vec<edge> exits = get_loop_exit_edges (loop);
   edge exit;
-  gimple call;
+  gimple *call;
   gimple_stmt_iterator bsi;
   unsigned i;
 
diff --git a/gcc/tree-ssa-loop-unswitch.c b/gcc/tree-ssa-loop-unswitch.c
index a9a27d7..7fed691 100644
--- a/gcc/tree-ssa-loop-unswitch.c
+++ b/gcc/tree-ssa-loop-unswitch.c
@@ -138,7 +138,7 @@ tree_ssa_unswitch_loops (void)
 static tree
 tree_may_unswitch_on (basic_block bb, struct loop *loop)
 {
-  gimple stmt, def;
+  gimple *stmt, *def;
   tree cond, use;
   basic_block def_bb;
   ssa_op_iter iter;
@@ -178,7 +178,7 @@ static tree
 simplify_using_entry_checks (struct loop *loop, tree cond)
 {
   edge e = loop_preheader_edge (loop);
-  gimple stmt;
+  gimple *stmt;
 
   while (1)
     {
@@ -214,7 +214,7 @@ tree_unswitch_single_loop (struct loop *loop, int num)
   struct loop *nloop;
   unsigned i, found;
   tree cond = NULL_TREE;
-  gimple stmt;
+  gimple *stmt;
   bool changed = false;
 
   i = 0;
@@ -312,7 +312,7 @@ tree_unswitch_single_loop (struct loop *loop, int num)
 
 	  if (EDGE_COUNT (b->succs) == 2)
 	    {
-	      gimple stmt = last_stmt (b);
+	      gimple *stmt = last_stmt (b);
 	      if (stmt
 		  && gimple_code (stmt) == GIMPLE_COND)
 		{
diff --git a/gcc/tree-ssa-loop.h b/gcc/tree-ssa-loop.h
index 95857f1..42554a4 100644
--- a/gcc/tree-ssa-loop.h
+++ b/gcc/tree-ssa-loop.h
@@ -71,7 +71,7 @@ extern unsigned tree_num_loop_insns (struct loop *, struct eni_weights_d *);
 /* Returns the loop of the statement STMT.  */
 
 static inline struct loop *
-loop_containing_stmt (gimple stmt)
+loop_containing_stmt (gimple *stmt)
 {
   basic_block bb = gimple_bb (stmt);
   if (!bb)
diff --git a/gcc/tree-ssa-math-opts.c b/gcc/tree-ssa-math-opts.c
index 336626d..1d4c523 100644
--- a/gcc/tree-ssa-math-opts.c
+++ b/gcc/tree-ssa-math-opts.c
@@ -132,7 +132,7 @@ struct occurrence {
 
   /* If non-NULL, the GIMPLE_ASSIGN for a reciprocal computation that
      was inserted in BB.  */
-  gimple recip_def_stmt;
+  gimple *recip_def_stmt;
 
   /* Pointer to a list of "struct occurrence"s for blocks dominated
      by BB.  */
@@ -329,7 +329,7 @@ compute_merit (struct occurrence *occ)
 
 /* Return whether USE_STMT is a floating-point division by DEF.  */
 static inline bool
-is_division_by (gimple use_stmt, tree def)
+is_division_by (gimple *use_stmt, tree def)
 {
   return is_gimple_assign (use_stmt)
 	 && gimple_assign_rhs_code (use_stmt) == RDIV_EXPR
@@ -354,7 +354,7 @@ insert_reciprocals (gimple_stmt_iterator *def_gsi, struct occurrence *occ,
 		    tree def, tree recip_def, int threshold)
 {
   tree type;
-  gimple new_stmt;
+  gimple *new_stmt;
   gimple_stmt_iterator gsi;
   struct occurrence *occ_child;
 
@@ -409,7 +409,7 @@ insert_reciprocals (gimple_stmt_iterator *def_gsi, struct occurrence *occ,
 static inline void
 replace_reciprocal (use_operand_p use_p)
 {
-  gimple use_stmt = USE_STMT (use_p);
+  gimple *use_stmt = USE_STMT (use_p);
   basic_block bb = gimple_bb (use_stmt);
   struct occurrence *occ = (struct occurrence *) bb->aux;
 
@@ -469,7 +469,7 @@ execute_cse_reciprocals_1 (gimple_stmt_iterator *def_gsi, tree def)
 
   FOR_EACH_IMM_USE_FAST (use_p, use_iter, def)
     {
-      gimple use_stmt = USE_STMT (use_p);
+      gimple *use_stmt = USE_STMT (use_p);
       if (is_division_by (use_stmt, def))
 	{
 	  register_division_in (gimple_bb (use_stmt));
@@ -481,7 +481,7 @@ execute_cse_reciprocals_1 (gimple_stmt_iterator *def_gsi, tree def)
   threshold = targetm.min_divisions_for_recip_mul (TYPE_MODE (TREE_TYPE (def)));
   if (count >= threshold)
     {
-      gimple use_stmt;
+      gimple *use_stmt;
       for (occ = occ_head; occ; occ = occ->next)
 	{
 	  compute_merit (occ);
@@ -566,7 +566,7 @@ pass_cse_reciprocals::execute (function *fun)
   FOR_EACH_BB_FN (bb, fun)
     {
       gimple_stmt_iterator gsi;
-      gimple phi;
+      gimple *phi;
       tree def;
 
       for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
@@ -580,7 +580,7 @@ pass_cse_reciprocals::execute (function *fun)
 
       for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi); gsi_next (&gsi))
         {
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 
 	  if (gimple_has_lhs (stmt)
 	      && (def = SINGLE_SSA_TREE_OPERAND (stmt, SSA_OP_DEF)) != NULL
@@ -595,14 +595,14 @@ pass_cse_reciprocals::execute (function *fun)
       /* Scan for a/func(b) and convert it to reciprocal a*rfunc(b).  */
       for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi); gsi_next (&gsi))
         {
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  tree fndecl;
 
 	  if (is_gimple_assign (stmt)
 	      && gimple_assign_rhs_code (stmt) == RDIV_EXPR)
 	    {
 	      tree arg1 = gimple_assign_rhs2 (stmt);
-	      gimple stmt1;
+	      gimple *stmt1;
 
 	      if (TREE_CODE (arg1) != SSA_NAME)
 		continue;
@@ -633,7 +633,7 @@ pass_cse_reciprocals::execute (function *fun)
 		  fail = false;
 		  FOR_EACH_IMM_USE_FAST (use_p, ui, arg1)
 		    {
-		      gimple stmt2 = USE_STMT (use_p);
+		      gimple *stmt2 = USE_STMT (use_p);
 		      if (is_gimple_debug (stmt2))
 			continue;
 		      if (!is_gimple_assign (stmt2)
@@ -691,8 +691,8 @@ make_pass_cse_reciprocals (gcc::context *ctxt)
    statements in the vector.  */
 
 static bool
-maybe_record_sincos (vec<gimple> *stmts,
-		     basic_block *top_bb, gimple use_stmt)
+maybe_record_sincos (vec<gimple *> *stmts,
+		     basic_block *top_bb, gimple *use_stmt)
 {
   basic_block use_bb = gimple_bb (use_stmt);
   if (*top_bb
@@ -725,9 +725,9 @@ execute_cse_sincos_1 (tree name)
   gimple_stmt_iterator gsi;
   imm_use_iterator use_iter;
   tree fndecl, res, type;
-  gimple def_stmt, use_stmt, stmt;
+  gimple *def_stmt, *use_stmt, *stmt;
   int seen_cos = 0, seen_sin = 0, seen_cexpi = 0;
-  vec<gimple> stmts = vNULL;
+  vec<gimple *> stmts = vNULL;
   basic_block top_bb = NULL;
   int i;
   bool cfg_changed = false;
@@ -971,7 +971,7 @@ powi_as_mults_1 (gimple_stmt_iterator *gsi, location_t loc, tree type,
 {
   tree op0, op1, ssa_target;
   unsigned HOST_WIDE_INT digit;
-  gimple mult_stmt;
+  gimple *mult_stmt;
 
   if (n < POWI_TABLE_SIZE && cache[n])
     return cache[n];
@@ -1011,7 +1011,7 @@ powi_as_mults (gimple_stmt_iterator *gsi, location_t loc,
 	       tree arg0, HOST_WIDE_INT n)
 {
   tree cache[POWI_TABLE_SIZE], result, type = TREE_TYPE (arg0);
-  gimple div_stmt;
+  gimple *div_stmt;
   tree target;
 
   if (n == 0)
@@ -1064,7 +1064,7 @@ static tree
 build_and_insert_call (gimple_stmt_iterator *gsi, location_t loc,
 		       tree fn, tree arg)
 {
-  gimple call_stmt;
+  gimple *call_stmt;
   tree ssa_target;
 
   call_stmt = gimple_build_call (fn, 1, arg);
@@ -1087,7 +1087,7 @@ build_and_insert_binop (gimple_stmt_iterator *gsi, location_t loc,
 			tree arg0, tree arg1)
 {
   tree result = make_temp_ssa_name (TREE_TYPE (arg0), NULL, name);
-  gimple stmt = gimple_build_assign_with_ops (code, result, arg0, arg1);
+  gimple *stmt = gimple_build_assign_with_ops (code, result, arg0, arg1);
   gimple_set_location (stmt, loc);
   gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
   return result;
@@ -1103,7 +1103,7 @@ build_and_insert_ref (gimple_stmt_iterator *gsi, location_t loc, tree type,
 		      const char *name, enum tree_code code, tree arg0)
 {
   tree result = make_temp_ssa_name (type, NULL, name);
-  gimple stmt = gimple_build_assign (result, build1 (code, type, arg0));
+  gimple *stmt = gimple_build_assign (result, build1 (code, type, arg0));
   gimple_set_location (stmt, loc);
   gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
   return result;
@@ -1117,7 +1117,7 @@ build_and_insert_cast (gimple_stmt_iterator *gsi, location_t loc,
 		       tree type, tree val)
 {
   tree result = make_ssa_name (type, NULL);
-  gimple stmt = gimple_build_assign_with_ops (NOP_EXPR, result, val, NULL_TREE);
+  gimple *stmt = gimple_build_assign_with_ops (NOP_EXPR, result, val, NULL_TREE);
   gimple_set_location (stmt, loc);
   gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
   return result;
@@ -1453,7 +1453,7 @@ pass_cse_sincos::execute (function *fun)
 
       for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi); gsi_next (&gsi))
         {
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  tree fndecl;
 
 	  /* Only the last stmt in a bb could throw, no need to call
@@ -1495,7 +1495,7 @@ pass_cse_sincos::execute (function *fun)
 		  if (result)
 		    {
 		      tree lhs = gimple_get_lhs (stmt);
-		      gimple new_stmt = gimple_build_assign (lhs, result);
+		      gimple *new_stmt = gimple_build_assign (lhs, result);
 		      gimple_set_location (new_stmt, loc);
 		      unlink_stmt_vdef (stmt);
 		      gsi_replace (&gsi, new_stmt, true);
@@ -1513,7 +1513,7 @@ pass_cse_sincos::execute (function *fun)
 		  if (real_minus_onep (arg0))
 		    {
                       tree t0, t1, cond, one, minus_one;
-		      gimple stmt;
+		      gimple *stmt;
 
 		      t0 = TREE_TYPE (arg0);
 		      t1 = TREE_TYPE (arg1);
@@ -1547,7 +1547,7 @@ pass_cse_sincos::execute (function *fun)
 		  if (result)
 		    {
 		      tree lhs = gimple_get_lhs (stmt);
-		      gimple new_stmt = gimple_build_assign (lhs, result);
+		      gimple *new_stmt = gimple_build_assign (lhs, result);
 		      gimple_set_location (new_stmt, loc);
 		      unlink_stmt_vdef (stmt);
 		      gsi_replace (&gsi, new_stmt, true);
@@ -1565,7 +1565,7 @@ pass_cse_sincos::execute (function *fun)
 		  if (result)
 		    {
 		      tree lhs = gimple_get_lhs (stmt);
-		      gimple new_stmt = gimple_build_assign (lhs, result);
+		      gimple *new_stmt = gimple_build_assign (lhs, result);
 		      gimple_set_location (new_stmt, loc);
 		      unlink_stmt_vdef (stmt);
 		      gsi_replace (&gsi, new_stmt, true);
@@ -1655,7 +1655,7 @@ do_shift_rotate (enum tree_code code,
    statement STMT.  */
 
 static inline bool
-verify_symbolic_number_p (struct symbolic_number *n, gimple stmt)
+verify_symbolic_number_p (struct symbolic_number *n, gimple *stmt)
 {
   tree lhs_type;
 
@@ -1676,11 +1676,11 @@ verify_symbolic_number_p (struct symbolic_number *n, gimple stmt)
    tree expression of the source operand and NULL otherwise.  */
 
 static tree
-find_bswap_1 (gimple stmt, struct symbolic_number *n, int limit)
+find_bswap_1 (gimple *stmt, struct symbolic_number *n, int limit)
 {
   enum tree_code code;
   tree rhs1, rhs2 = NULL;
-  gimple rhs1_stmt, rhs2_stmt;
+  gimple *rhs1_stmt, *rhs2_stmt;
   tree source_expr1;
   enum gimple_rhs_class rhs_class;
 
@@ -1845,7 +1845,7 @@ find_bswap_1 (gimple stmt, struct symbolic_number *n, int limit)
    byte swap is performed and NULL if no bswap was found.  */
 
 static tree
-find_bswap (gimple stmt)
+find_bswap (gimple *stmt)
 {
 /* The number which the find_bswap result should match in order to
    have a full byte swap.  The number is shifted to the left according
@@ -1981,12 +1981,12 @@ pass_optimize_bswap::execute (function *fun)
 	 patterns, the wider variant wouldn't be detected.  */
       for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi_prev (&gsi))
         {
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  tree bswap_src, bswap_type;
 	  tree bswap_tmp;
 	  tree fndecl = NULL_TREE;
 	  int type_size;
-	  gimple call;
+	  gimple *call;
 
 	  if (!is_gimple_assign (stmt)
 	      || gimple_assign_rhs_code (stmt) != BIT_IOR_EXPR)
@@ -2042,7 +2042,7 @@ pass_optimize_bswap::execute (function *fun)
 	  /* Convert the src expression if necessary.  */
 	  if (!useless_type_conversion_p (TREE_TYPE (bswap_tmp), bswap_type))
 	    {
-	      gimple convert_stmt;
+	      gimple *convert_stmt;
 	      bswap_tmp = make_temp_ssa_name (bswap_type, NULL, "bswapsrc");
 	      convert_stmt = gimple_build_assign_with_ops
 		  		(NOP_EXPR, bswap_tmp, bswap_src, NULL);
@@ -2056,7 +2056,7 @@ pass_optimize_bswap::execute (function *fun)
 	  /* Convert the result if necessary.  */
 	  if (!useless_type_conversion_p (TREE_TYPE (bswap_tmp), bswap_type))
 	    {
-	      gimple convert_stmt;
+	      gimple *convert_stmt;
 	      bswap_tmp = make_temp_ssa_name (bswap_type, NULL, "bswapdst");
 	      convert_stmt = gimple_build_assign_with_ops
 			(NOP_EXPR, gimple_assign_lhs (stmt), bswap_tmp, NULL);
@@ -2098,7 +2098,7 @@ make_pass_optimize_bswap (gcc::context *ctxt)
 /* Return true if stmt is a type conversion operation that can be stripped
    when used in a widening multiply operation.  */
 static bool
-widening_mult_conversion_strippable_p (tree result_type, gimple stmt)
+widening_mult_conversion_strippable_p (tree result_type, gimple *stmt)
 {
   enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
 
@@ -2150,7 +2150,7 @@ static bool
 is_widening_mult_rhs_p (tree type, tree rhs, tree *type_out,
 			tree *new_rhs_out)
 {
-  gimple stmt;
+  gimple *stmt;
   tree type1, rhs1;
 
   if (TREE_CODE (rhs) == SSA_NAME)
@@ -2203,7 +2203,7 @@ is_widening_mult_rhs_p (tree type, tree rhs, tree *type_out,
    and *TYPE2_OUT would give the operands of the multiplication.  */
 
 static bool
-is_widening_mult_p (gimple stmt,
+is_widening_mult_p (gimple *stmt,
 		    tree *type1_out, tree *rhs1_out,
 		    tree *type2_out, tree *rhs2_out)
 {
@@ -2255,7 +2255,7 @@ is_widening_mult_p (gimple stmt,
    value is true iff we converted the statement.  */
 
 static bool
-convert_mult_to_widen (gimple stmt, gimple_stmt_iterator *gsi)
+convert_mult_to_widen (gimple *stmt, gimple_stmt_iterator *gsi)
 {
   tree lhs, rhs1, rhs2, type, type1, type2;
   enum insn_code handler;
@@ -2356,11 +2356,11 @@ convert_mult_to_widen (gimple stmt, gimple_stmt_iterator *gsi)
    is true iff we converted the statement.  */
 
 static bool
-convert_plusminus_to_widen (gimple_stmt_iterator *gsi, gimple stmt,
+convert_plusminus_to_widen (gimple_stmt_iterator *gsi, gimple *stmt,
 			    enum tree_code code)
 {
-  gimple rhs1_stmt = NULL, rhs2_stmt = NULL;
-  gimple conv1_stmt = NULL, conv2_stmt = NULL, conv_stmt;
+  gimple *rhs1_stmt = NULL, *rhs2_stmt = NULL;
+  gimple *conv1_stmt = NULL, *conv2_stmt = NULL, *conv_stmt;
   tree type, type1, type2, optype;
   tree lhs, rhs1, rhs2, mult_rhs1, mult_rhs2, add_rhs;
   enum tree_code rhs1_code = ERROR_MARK, rhs2_code = ERROR_MARK;
@@ -2567,11 +2567,11 @@ convert_plusminus_to_widen (gimple_stmt_iterator *gsi, gimple stmt,
    operations.  Returns true if successful and MUL_STMT should be removed.  */
 
 static bool
-convert_mult_to_fma (gimple mul_stmt, tree op1, tree op2)
+convert_mult_to_fma (gimple *mul_stmt, tree op1, tree op2)
 {
   tree mul_result = gimple_get_lhs (mul_stmt);
   tree type = TREE_TYPE (mul_result);
-  gimple use_stmt, neguse_stmt, fma_stmt;
+  gimple *use_stmt, *neguse_stmt, *fma_stmt;
   use_operand_p use_p;
   imm_use_iterator imm_iter;
 
@@ -2685,7 +2685,7 @@ convert_mult_to_fma (gimple mul_stmt, tree op1, tree op2)
 
 	  if (TREE_CODE (rhs2) == SSA_NAME)
 	    {
-	      gimple stmt2 = SSA_NAME_DEF_STMT (rhs2);
+	      gimple *stmt2 = SSA_NAME_DEF_STMT (rhs2);
 	      if (has_single_use (rhs2)
 		  && is_gimple_assign (stmt2)
 		  && gimple_assign_rhs_code (stmt2) == MULT_EXPR)
@@ -2819,7 +2819,7 @@ pass_optimize_widening_mul::execute (function *fun)
 
       for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi);)
         {
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  enum tree_code code;
 
 	  if (is_gimple_assign (stmt))
diff --git a/gcc/tree-ssa-operands.c b/gcc/tree-ssa-operands.c
index 03d3e4d..fb90ce4 100644
--- a/gcc/tree-ssa-operands.c
+++ b/gcc/tree-ssa-operands.c
@@ -127,7 +127,7 @@ static tree build_vuse;
    compilations of multiple functions.  */
 static bitmap_obstack operands_bitmap_obstack;
 
-static void get_expr_operands (struct function *, gimple, tree *, int);
+static void get_expr_operands (struct function *, gimple *, tree *, int);
 
 /* Number of functions with initialized ssa_operands.  */
 static int n_initialized = 0;
@@ -313,7 +313,7 @@ alloc_use (struct function *fn)
 /* Adds OP to the list of uses of statement STMT after LAST.  */
 
 static inline use_optype_p
-add_use_op (struct function *fn, gimple stmt, tree *op, use_optype_p last)
+add_use_op (struct function *fn, gimple *stmt, tree *op, use_optype_p last)
 {
   use_optype_p new_use;
 
@@ -331,7 +331,7 @@ add_use_op (struct function *fn, gimple stmt, tree *op, use_optype_p last)
    TODO -- Make build_defs vec of tree *.  */
 
 static inline void
-finalize_ssa_defs (struct function *fn, gimple stmt)
+finalize_ssa_defs (struct function *fn, gimple *stmt)
 {
   /* Pre-pend the vdef we may have built.  */
   if (build_vdef != NULL_TREE)
@@ -370,7 +370,7 @@ finalize_ssa_defs (struct function *fn, gimple stmt)
    TODO -- Make build_uses vec of tree *.  */
 
 static inline void
-finalize_ssa_uses (struct function *fn, gimple stmt)
+finalize_ssa_uses (struct function *fn, gimple *stmt)
 {
   unsigned new_i;
   struct use_optype_d new_list;
@@ -445,7 +445,7 @@ cleanup_build_arrays (void)
 /* Finalize all the build vectors, fill the new ones into INFO.  */
 
 static inline void
-finalize_ssa_stmt_operands (struct function *fn, gimple stmt)
+finalize_ssa_stmt_operands (struct function *fn, gimple *stmt)
 {
   finalize_ssa_defs (fn, stmt);
   finalize_ssa_uses (fn, stmt);
@@ -503,7 +503,7 @@ append_vuse (tree var)
 
 static void
 add_virtual_operand (struct function *fn,
-		     gimple stmt ATTRIBUTE_UNUSED, int flags)
+		     gimple *stmt ATTRIBUTE_UNUSED, int flags)
 {
   /* Add virtual operands to the stmt, unless the caller has specifically
      requested not to do that (used when adding operands inside an
@@ -526,7 +526,7 @@ add_virtual_operand (struct function *fn,
    added to virtual operands.  */
 
 static void
-add_stmt_operand (struct function *fn, tree *var_p, gimple stmt, int flags)
+add_stmt_operand (struct function *fn, tree *var_p, gimple *stmt, int flags)
 {
   tree var = *var_p;
 
@@ -591,7 +591,7 @@ mark_address_taken (tree ref)
 
 static void
 get_mem_ref_operands (struct function *fn,
-		      gimple stmt, tree expr, int flags)
+		      gimple *stmt, tree expr, int flags)
 {
   tree *pptr = &TREE_OPERAND (expr, 0);
 
@@ -612,7 +612,7 @@ get_mem_ref_operands (struct function *fn,
 /* A subroutine of get_expr_operands to handle TARGET_MEM_REF.  */
 
 static void
-get_tmr_operands (struct function *fn, gimple stmt, tree expr, int flags)
+get_tmr_operands (struct function *fn, gimple *stmt, tree expr, int flags)
 {
   if (!(flags & opf_no_vops)
       && TREE_THIS_VOLATILE (expr))
@@ -634,7 +634,7 @@ get_tmr_operands (struct function *fn, gimple stmt, tree expr, int flags)
    escape, add them to the VDEF/VUSE lists for it.  */
 
 static void
-maybe_add_call_vops (struct function *fn, gimple stmt)
+maybe_add_call_vops (struct function *fn, gimple *stmt)
 {
   int call_flags = gimple_call_flags (stmt);
 
@@ -655,7 +655,7 @@ maybe_add_call_vops (struct function *fn, gimple stmt)
 /* Scan operands in the ASM_EXPR stmt referred to in INFO.  */
 
 static void
-get_asm_stmt_operands (struct function *fn, gimple stmt)
+get_asm_stmt_operands (struct function *fn, gimple *stmt)
 {
   size_t i, noutputs;
   const char **oconstraints;
@@ -713,7 +713,7 @@ get_asm_stmt_operands (struct function *fn, gimple stmt)
    interpret the operands found.  */
 
 static void
-get_expr_operands (struct function *fn, gimple stmt, tree *expr_p, int flags)
+get_expr_operands (struct function *fn, gimple *stmt, tree *expr_p, int flags)
 {
   enum tree_code code;
   enum tree_code_class codeclass;
@@ -900,7 +900,7 @@ get_expr_operands (struct function *fn, gimple stmt, tree *expr_p, int flags)
    build_* operand vectors will have potential operands in them.  */
 
 static void
-parse_ssa_operands (struct function *fn, gimple stmt)
+parse_ssa_operands (struct function *fn, gimple *stmt)
 {
   enum gimple_code code = gimple_code (stmt);
   size_t i, n, start = 0;
@@ -950,7 +950,7 @@ parse_ssa_operands (struct function *fn, gimple stmt)
 /* Create an operands cache for STMT.  */
 
 static void
-build_ssa_operands (struct function *fn, gimple stmt)
+build_ssa_operands (struct function *fn, gimple *stmt)
 {
   /* Initially assume that the statement has no volatile operands.  */
   gimple_set_has_volatile_ops (stmt, false);
@@ -963,7 +963,7 @@ build_ssa_operands (struct function *fn, gimple stmt)
 /* Verifies SSA statement operands.  */
 
 DEBUG_FUNCTION bool
-verify_ssa_operands (struct function *fn, gimple stmt)
+verify_ssa_operands (struct function *fn, gimple *stmt)
 {
   use_operand_p use_p;
   def_operand_p def_p;
@@ -1052,7 +1052,7 @@ verify_ssa_operands (struct function *fn, gimple stmt)
    the stmt operand lists.  */
 
 void
-free_stmt_operands (struct function *fn, gimple stmt)
+free_stmt_operands (struct function *fn, gimple *stmt)
 {
   use_optype_p uses = gimple_use_ops (stmt), last_use;
 
@@ -1077,7 +1077,7 @@ free_stmt_operands (struct function *fn, gimple stmt)
 /* Get the operands of statement STMT.  */
 
 void
-update_stmt_operands (struct function *fn, gimple stmt)
+update_stmt_operands (struct function *fn, gimple *stmt)
 {
   /* If update_stmt_operands is called before SSA is initialized, do
      nothing.  */
@@ -1104,7 +1104,7 @@ update_stmt_operands (struct function *fn, gimple stmt)
    to test the validity of the swap operation.  */
 
 void
-swap_ssa_operands (gimple stmt, tree *exp0, tree *exp1)
+swap_ssa_operands (gimple *stmt, tree *exp0, tree *exp1)
 {
   tree op0, op1;
   op0 = *exp0;
@@ -1293,11 +1293,11 @@ debug_immediate_uses_for (tree var)
 /* Unlink STMTs virtual definition from the IL by propagating its use.  */
 
 void
-unlink_stmt_vdef (gimple stmt)
+unlink_stmt_vdef (gimple *stmt)
 {
   use_operand_p use_p;
   imm_use_iterator iter;
-  gimple use_stmt;
+  gimple *use_stmt;
   tree vdef = gimple_vdef (stmt);
   tree vuse = gimple_vuse (stmt);
 
@@ -1336,7 +1336,7 @@ has_zero_uses_1 (const ssa_use_operand_t *head)
    use, if so, or to NULL otherwise.  */
 bool
 single_imm_use_1 (const ssa_use_operand_t *head,
-		  use_operand_p *use_p, gimple *stmt)
+		  use_operand_p *use_p, gimple **stmt)
 {
   ssa_use_operand_t *ptr, *single_use = 0;
 
diff --git a/gcc/tree-ssa-operands.h b/gcc/tree-ssa-operands.h
index 5f9edd4..829e863 100644
--- a/gcc/tree-ssa-operands.h
+++ b/gcc/tree-ssa-operands.h
@@ -92,10 +92,10 @@ struct GTY(()) ssa_operands {
 extern bool ssa_operands_active (struct function *);
 extern void init_ssa_operands (struct function *fn);
 extern void fini_ssa_operands (struct function *);
-extern bool verify_ssa_operands (struct function *, gimple stmt);
-extern void free_stmt_operands (struct function *, gimple);
-extern void update_stmt_operands (struct function *, gimple);
-extern void swap_ssa_operands (gimple, tree *, tree *);
+extern bool verify_ssa_operands (struct function *, gimple *stmt);
+extern void free_stmt_operands (struct function *, gimple *);
+extern void update_stmt_operands (struct function *, gimple *);
+extern void swap_ssa_operands (gimple *, tree *, tree *);
 extern bool verify_imm_links (FILE *f, tree var);
 
 extern void dump_immediate_uses_for (FILE *file, tree var);
@@ -103,7 +103,7 @@ extern void dump_immediate_uses (FILE *file);
 extern void debug_immediate_uses (void);
 extern void debug_immediate_uses_for (tree var);
 
-extern void unlink_stmt_vdef (gimple);
+extern void unlink_stmt_vdef (gimple *);
 
 /* Return the tree pointed-to by USE.  */
 static inline tree
diff --git a/gcc/tree-ssa-phiopt.c b/gcc/tree-ssa-phiopt.c
index d4aaf42..6e7e4a7 100644
--- a/gcc/tree-ssa-phiopt.c
+++ b/gcc/tree-ssa-phiopt.c
@@ -62,20 +62,20 @@ along with GCC; see the file COPYING3.  If not see
 
 static unsigned int tree_ssa_phiopt_worker (bool, bool);
 static bool conditional_replacement (basic_block, basic_block,
-				     edge, edge, gimple, tree, tree);
+				     edge, edge, gimple *, tree, tree);
 static int value_replacement (basic_block, basic_block,
-			      edge, edge, gimple, tree, tree);
+			      edge, edge, gimple *, tree, tree);
 static bool minmax_replacement (basic_block, basic_block,
-				edge, edge, gimple, tree, tree);
+				edge, edge, gimple *, tree, tree);
 static bool abs_replacement (basic_block, basic_block,
-			     edge, edge, gimple, tree, tree);
+			     edge, edge, gimple *, tree, tree);
 static bool neg_replacement (basic_block, basic_block,
-			     edge, edge, gimple, tree, tree);
+			     edge, edge, gimple *, tree, tree);
 static bool cond_store_replacement (basic_block, basic_block, edge, edge,
 				    struct pointer_set_t *);
 static bool cond_if_else_store_replacement (basic_block, basic_block, basic_block);
 static struct pointer_set_t * get_non_trapping (void);
-static void replace_phi_edge_with_variable (basic_block, edge, gimple, tree);
+static void replace_phi_edge_with_variable (basic_block, edge, gimple *, tree);
 static void hoist_adjacent_loads (basic_block, basic_block,
 				  basic_block, basic_block);
 static bool gate_hoist_loads (void);
@@ -138,16 +138,16 @@ tree_ssa_cs_elim (void)
 
 /* Return the singleton PHI in the SEQ of PHIs for edges E0 and E1. */
 
-static gimple
+static gimple *
 single_non_singleton_phi_for_edges (gimple_seq seq, edge e0, edge e1)
 {
   gimple_stmt_iterator i;
-  gimple phi = NULL;
+  gimple *phi = NULL;
   if (gimple_seq_singleton_p (seq))
     return gsi_stmt (gsi_start (seq));
   for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
     {
-      gimple p = gsi_stmt (i);
+      gimple *p = gsi_stmt (i);
       /* If the PHI arguments are equal then we can skip this PHI. */
       if (operand_equal_for_phi_arg_p (gimple_phi_arg_def (p, e0->dest_idx),
 				       gimple_phi_arg_def (p, e1->dest_idx)))
@@ -211,7 +211,7 @@ tree_ssa_phiopt_worker (bool do_store_elim, bool do_hoist_loads)
 
   for (i = 0; i < n; i++)
     {
-      gimple cond_stmt, phi;
+      gimple *cond_stmt, *phi;
       basic_block bb1, bb2;
       edge e1, e2;
       tree arg0, arg1;
@@ -383,7 +383,7 @@ tree_ssa_phiopt_worker (bool do_store_elim, bool do_hoist_loads)
 
 static void
 replace_phi_edge_with_variable (basic_block cond_block,
-				edge e, gimple phi, tree new_tree)
+				edge e, gimple *phi, tree new_tree)
 {
   basic_block bb = gimple_bb (phi);
   basic_block block_to_remove;
@@ -433,11 +433,11 @@ replace_phi_edge_with_variable (basic_block cond_block,
 
 static bool
 conditional_replacement (basic_block cond_bb, basic_block middle_bb,
-			 edge e0, edge e1, gimple phi,
+			 edge e0, edge e1, gimple *phi,
 			 tree arg0, tree arg1)
 {
   tree result;
-  gimple stmt, new_stmt;
+  gimple *stmt, *new_stmt;
   tree cond;
   gimple_stmt_iterator gsi;
   edge true_edge, false_edge;
@@ -548,7 +548,7 @@ conditional_replacement (basic_block cond_bb, basic_block middle_bb,
    statement is made dead by that rewriting.  */
 
 static bool
-jump_function_from_stmt (tree *arg, gimple stmt)
+jump_function_from_stmt (tree *arg, gimple *stmt)
 {
   enum tree_code code = gimple_assign_rhs_code (stmt);
   if (code == ADDR_EXPR)
@@ -589,7 +589,7 @@ rhs_is_fed_for_value_replacement (const_tree arg0, const_tree arg1,
      statement.  */
   if (TREE_CODE (rhs) == SSA_NAME)
     {
-      gimple def1 = SSA_NAME_DEF_STMT (rhs);
+      gimple *def1 = SSA_NAME_DEF_STMT (rhs);
 
       /* Verify the defining statement has an EQ_EXPR on the RHS.  */
       if (is_gimple_assign (def1) && gimple_assign_rhs_code (def1) == EQ_EXPR)
@@ -621,9 +621,9 @@ rhs_is_fed_for_value_replacement (const_tree arg0, const_tree arg1,
 
 static bool
 operand_equal_for_value_replacement (const_tree arg0, const_tree arg1,
-				     enum tree_code *code, gimple cond)
+				     enum tree_code *code, gimple *cond)
 {
-  gimple def;
+  gimple *def;
   tree lhs = gimple_cond_lhs (cond);
   tree rhs = gimple_cond_rhs (cond);
 
@@ -726,11 +726,11 @@ absorbing_element_p (tree_code code, tree arg)
 
 static int
 value_replacement (basic_block cond_bb, basic_block middle_bb,
-		   edge e0, edge e1, gimple phi,
+		   edge e0, edge e1, gimple *phi,
 		   tree arg0, tree arg1)
 {
   gimple_stmt_iterator gsi;
-  gimple cond;
+  gimple *cond;
   edge true_edge, false_edge;
   enum tree_code code;
   bool emtpy_or_with_defined_p = true;
@@ -745,7 +745,7 @@ value_replacement (basic_block cond_bb, basic_block middle_bb,
   gsi = gsi_start_nondebug_after_labels_bb (middle_bb);
   while (!gsi_end_p (gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       tree lhs;
       gsi_next_nondebug (&gsi);
       if (!is_gimple_assign (stmt))
@@ -842,7 +842,7 @@ value_replacement (basic_block cond_bb, basic_block middle_bb,
   /* Now optimize (x != 0) ? x + y : y to just y.
      The following condition is too restrictive, there can easily be another
      stmt in middle_bb, for instance a CONVERT_EXPR for the second argument.  */
-  gimple assign = last_and_only_stmt (middle_bb);
+  gimple *assign = last_and_only_stmt (middle_bb);
   if (!assign || gimple_code (assign) != GIMPLE_ASSIGN
       || gimple_assign_rhs_class (assign) != GIMPLE_BINARY_RHS
       || (!INTEGRAL_TYPE_P (TREE_TYPE (arg0))
@@ -898,11 +898,11 @@ value_replacement (basic_block cond_bb, basic_block middle_bb,
 
 static bool
 minmax_replacement (basic_block cond_bb, basic_block middle_bb,
-		    edge e0, edge e1, gimple phi,
+		    edge e0, edge e1, gimple *phi,
 		    tree arg0, tree arg1)
 {
   tree result, type;
-  gimple cond, new_stmt;
+  gimple *cond, *new_stmt;
   edge true_edge, false_edge;
   enum tree_code cmp, minmax, ass_code;
   tree smaller, larger, arg_true, arg_false;
@@ -988,7 +988,7 @@ minmax_replacement (basic_block cond_bb, basic_block middle_bb,
 	 b = MAX (a, d);
 	 x = MIN (b, u);  */
 
-      gimple assign = last_and_only_stmt (middle_bb);
+      gimple *assign = last_and_only_stmt (middle_bb);
       tree lhs, op0, op1, bound;
 
       if (!assign
@@ -1146,13 +1146,13 @@ minmax_replacement (basic_block cond_bb, basic_block middle_bb,
 static bool
 abs_replacement (basic_block cond_bb, basic_block middle_bb,
 		 edge e0 ATTRIBUTE_UNUSED, edge e1,
-		 gimple phi, tree arg0, tree arg1)
+		 gimple *phi, tree arg0, tree arg1)
 {
   tree result;
-  gimple new_stmt, cond;
+  gimple *new_stmt, *cond;
   gimple_stmt_iterator gsi;
   edge true_edge, false_edge;
-  gimple assign;
+  gimple *assign;
   edge e;
   tree rhs, lhs;
   bool negate;
@@ -1277,11 +1277,11 @@ abs_replacement (basic_block cond_bb, basic_block middle_bb,
 static bool
 neg_replacement (basic_block cond_bb, basic_block middle_bb,
 		 edge e0 ATTRIBUTE_UNUSED, edge e1,
-		 gimple phi, tree arg0, tree arg1)
+		 gimple *phi, tree arg0, tree arg1)
 {
-  gimple new_stmt, cond;
+  gimple *new_stmt, *cond;
   gimple_stmt_iterator gsi;
-  gimple assign;
+  gimple *assign;
   edge true_edge, false_edge;
   tree rhs, lhs;
   enum tree_code cond_code;
@@ -1562,7 +1562,7 @@ nontrapping_dom_walker::before_dom_children (basic_block bb)
   /* And walk the statements in order.  */
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
 
       if (is_gimple_call (stmt) && !nonfreeing_call_p (stmt))
 	nt_call_phase++;
@@ -1624,9 +1624,9 @@ static bool
 cond_store_replacement (basic_block middle_bb, basic_block join_bb,
 			edge e0, edge e1, struct pointer_set_t *nontrap)
 {
-  gimple assign = last_and_only_stmt (middle_bb);
+  gimple *assign = last_and_only_stmt (middle_bb);
   tree lhs, rhs, name, name2;
-  gimple newphi, new_stmt;
+  gimple *newphi, *new_stmt;
   gimple_stmt_iterator gsi;
   source_location locus;
 
@@ -1693,13 +1693,13 @@ cond_store_replacement (basic_block middle_bb, basic_block join_bb,
 
 static bool
 cond_if_else_store_replacement_1 (basic_block then_bb, basic_block else_bb,
-				  basic_block join_bb, gimple then_assign,
-				  gimple else_assign)
+				  basic_block join_bb, gimple *then_assign,
+				  gimple *else_assign)
 {
   tree lhs_base, lhs, then_rhs, else_rhs, name;
   source_location then_locus, else_locus;
   gimple_stmt_iterator gsi;
-  gimple newphi, new_stmt;
+  gimple *newphi, *new_stmt;
 
   if (then_assign == NULL
       || !gimple_assign_single_p (then_assign)
@@ -1787,11 +1787,11 @@ static bool
 cond_if_else_store_replacement (basic_block then_bb, basic_block else_bb,
                                 basic_block join_bb)
 {
-  gimple then_assign = last_and_only_stmt (then_bb);
-  gimple else_assign = last_and_only_stmt (else_bb);
+  gimple *then_assign = last_and_only_stmt (then_bb);
+  gimple *else_assign = last_and_only_stmt (else_bb);
   vec<data_reference_p> then_datarefs, else_datarefs;
   vec<ddr_p> then_ddrs, else_ddrs;
-  gimple then_store, else_store;
+  gimple *then_store, *else_store;
   bool found, ok = false, res;
   struct data_dependence_relation *ddr;
   data_reference_p then_dr, else_dr;
@@ -1823,7 +1823,7 @@ cond_if_else_store_replacement (basic_block then_bb, basic_block else_bb,
     }
 
   /* Find pairs of stores with equal LHS.  */
-  auto_vec<gimple, 1> then_stores, else_stores;
+  auto_vec<gimple *, 1> then_stores, else_stores;
   FOR_EACH_VEC_ELT (then_datarefs, i, then_dr)
     {
       if (DR_IS_READ (then_dr))
@@ -1951,10 +1951,10 @@ cond_if_else_store_replacement (basic_block then_bb, basic_block else_bb,
 /* Return TRUE if STMT has a VUSE whose corresponding VDEF is in BB.  */
 
 static bool
-local_mem_dependence (gimple stmt, basic_block bb)
+local_mem_dependence (gimple *stmt, basic_block bb)
 {
   tree vuse = gimple_vuse (stmt);
-  gimple def;
+  gimple *def;
 
   if (!vuse)
     return false;
@@ -2000,8 +2000,8 @@ hoist_adjacent_loads (basic_block bb0, basic_block bb1,
      bb2.  */
   for (gsi = gsi_start_phis (bb3); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple phi_stmt = gsi_stmt (gsi);
-      gimple def1, def2, defswap;
+      gimple *phi_stmt = gsi_stmt (gsi);
+      gimple *def1, *def2, *defswap;
       tree arg1, arg2, ref1, ref2, field1, field2, fieldswap;
       tree tree_offset1, tree_offset2, tree_size2, next;
       int offset1, offset2, size2;
diff --git a/gcc/tree-ssa-phiprop.c b/gcc/tree-ssa-phiprop.c
index 8a66863..16e0d22 100644
--- a/gcc/tree-ssa-phiprop.c
+++ b/gcc/tree-ssa-phiprop.c
@@ -113,7 +113,7 @@ static bool
 phivn_valid_p (struct phiprop_d *phivn, tree name, basic_block bb)
 {
   tree vuse = phivn[SSA_NAME_VERSION (name)].vuse;
-  gimple use_stmt;
+  gimple *use_stmt;
   imm_use_iterator ui2;
   bool ok = true;
 
@@ -139,11 +139,11 @@ phivn_valid_p (struct phiprop_d *phivn, tree name, basic_block bb)
    BB with the virtual operands from USE_STMT.  */
 
 static tree
-phiprop_insert_phi (basic_block bb, gimple phi, gimple use_stmt,
+phiprop_insert_phi (basic_block bb, gimple *phi, gimple *use_stmt,
 		    struct phiprop_d *phivn, size_t n)
 {
   tree res;
-  gimple new_phi;
+  gimple *new_phi;
   edge_iterator ei;
   edge e;
 
@@ -166,7 +166,7 @@ phiprop_insert_phi (basic_block bb, gimple phi, gimple use_stmt,
   FOR_EACH_EDGE (e, ei, bb->preds)
     {
       tree old_arg, new_var;
-      gimple tmp;
+      gimple *tmp;
       source_location locus;
 
       old_arg = PHI_ARG_DEF_FROM_EDGE (phi, e);
@@ -175,7 +175,7 @@ phiprop_insert_phi (basic_block bb, gimple phi, gimple use_stmt,
 	     && (SSA_NAME_VERSION (old_arg) >= n
 	         || phivn[SSA_NAME_VERSION (old_arg)].value == NULL_TREE))
 	{
-	  gimple def_stmt = SSA_NAME_DEF_STMT (old_arg);
+	  gimple *def_stmt = SSA_NAME_DEF_STMT (old_arg);
 	  old_arg = gimple_assign_rhs1 (def_stmt);
 	  locus = gimple_location (def_stmt);
 	}
@@ -247,11 +247,11 @@ phiprop_insert_phi (basic_block bb, gimple phi, gimple use_stmt,
    with aliasing issues as we are moving memory reads.  */
 
 static bool
-propagate_with_phi (basic_block bb, gimple phi, struct phiprop_d *phivn,
+propagate_with_phi (basic_block bb, gimple *phi, struct phiprop_d *phivn,
 		    size_t n)
 {
   tree ptr = PHI_RESULT (phi);
-  gimple use_stmt;
+  gimple *use_stmt;
   tree res = NULL_TREE;
   gimple_stmt_iterator gsi;
   imm_use_iterator ui;
@@ -276,7 +276,7 @@ propagate_with_phi (basic_block bb, gimple phi, struct phiprop_d *phivn,
 	     && (SSA_NAME_VERSION (arg) >= n
 	         || phivn[SSA_NAME_VERSION (arg)].value == NULL_TREE))
 	{
-	  gimple def_stmt = SSA_NAME_DEF_STMT (arg);
+	  gimple *def_stmt = SSA_NAME_DEF_STMT (arg);
 	  if (!gimple_assign_single_p (def_stmt))
 	    return false;
 	  arg = gimple_assign_rhs1 (def_stmt);
@@ -306,7 +306,7 @@ propagate_with_phi (basic_block bb, gimple phi, struct phiprop_d *phivn,
   phi_inserted = false;
   FOR_EACH_IMM_USE_STMT (use_stmt, ui, ptr)
     {
-      gimple def_stmt;
+      gimple *def_stmt;
       tree vuse;
 
       /* Only replace loads in blocks that post-dominate the PHI node.  That
diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c
index f634f5e..9b8602f 100644
--- a/gcc/tree-ssa-pre.c
+++ b/gcc/tree-ssa-pre.c
@@ -1267,7 +1267,7 @@ translate_vuse_through_block (vec<vn_reference_op_s> operands,
 			      basic_block phiblock,
 			      basic_block block, bool *same_valid)
 {
-  gimple phi = SSA_NAME_DEF_STMT (vuse);
+  gimple *phi = SSA_NAME_DEF_STMT (vuse);
   ao_ref ref;
   edge e = NULL;
   bool use_oracle;
@@ -1719,7 +1719,7 @@ phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2,
     case NAME:
       {
 	tree name = PRE_EXPR_NAME (expr);
-	gimple def_stmt = SSA_NAME_DEF_STMT (name);
+	gimple *def_stmt = SSA_NAME_DEF_STMT (name);
 	/* If the SSA name is defined by a PHI node in this block,
 	   translate it.  */
 	if (gimple_code (def_stmt) == GIMPLE_PHI
@@ -1883,7 +1883,7 @@ value_dies_in_block_x (pre_expr expr, basic_block block)
 {
   tree vuse = PRE_EXPR_REFERENCE (expr)->vuse;
   vn_reference_t refx = PRE_EXPR_REFERENCE (expr);
-  gimple def;
+  gimple *def;
   gimple_stmt_iterator gsi;
   unsigned id = get_expression_id (expr);
   bool res = false;
@@ -2069,7 +2069,7 @@ prune_clobbered_mems (bitmap_set_t set, basic_block block)
 	  vn_reference_t ref = PRE_EXPR_REFERENCE (expr);
 	  if (ref->vuse)
 	    {
-	      gimple def_stmt = SSA_NAME_DEF_STMT (ref->vuse);
+	      gimple *def_stmt = SSA_NAME_DEF_STMT (ref->vuse);
 	      if (!gimple_nop_p (def_stmt)
 		  && ((gimple_bb (def_stmt) != block
 		       && !dominated_by_p (CDI_DOMINATORS,
@@ -2862,7 +2862,7 @@ create_expression_by_pieces (basic_block block, pre_expr expr,
   gimple_stmt_iterator gsi;
   tree exprtype = type ? type : get_expr_type (expr);
   pre_expr nameexpr;
-  gimple newstmt;
+  gimple *newstmt;
 
   switch (expr->kind)
     {
@@ -2954,7 +2954,7 @@ create_expression_by_pieces (basic_block block, pre_expr expr,
       gsi = gsi_start (forced_stmts);
       for (; !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  tree forcedname = gimple_get_lhs (stmt);
 	  pre_expr nameexpr;
 
@@ -3034,7 +3034,7 @@ insert_into_preds_of_block (basic_block block, unsigned int exprnum,
   edge_iterator ei;
   tree type = get_expr_type (expr);
   tree temp;
-  gimple phi;
+  gimple *phi;
 
   /* Make sure we aren't creating an induction variable.  */
   if (bb_loop_depth (block) > 0 && EDGE_COUNT (block->preds) == 2)
@@ -3105,7 +3105,7 @@ insert_into_preds_of_block (basic_block block, unsigned int exprnum,
 			  gsi = gsi_start (stmts);
 			  for (; !gsi_end_p (gsi); gsi_next (&gsi))
 			    {
-			      gimple stmt = gsi_stmt (gsi);
+			      gimple *stmt = gsi_stmt (gsi);
 			      tree lhs = gimple_get_lhs (stmt);
 			      if (TREE_CODE (lhs) == SSA_NAME)
 				bitmap_set_bit (inserted_exprs,
@@ -3151,7 +3151,7 @@ insert_into_preds_of_block (basic_block block, unsigned int exprnum,
 		  gsi = gsi_start (stmts);
 		  for (; !gsi_end_p (gsi); gsi_next (&gsi))
 		    {
-		      gimple stmt = gsi_stmt (gsi);
+		      gimple *stmt = gsi_stmt (gsi);
 		      tree lhs = gimple_get_lhs (stmt);
 		      if (TREE_CODE (lhs) == SSA_NAME)
 			bitmap_set_bit (inserted_exprs, SSA_NAME_VERSION (lhs));
@@ -3383,7 +3383,7 @@ do_regular_insertion (basic_block block, basic_block dom)
 
 	      tree temp = make_temp_ssa_name (get_expr_type (expr),
 					      NULL, "pretmp");
-	      gimple assign = gimple_build_assign (temp,
+	      gimple *assign = gimple_build_assign (temp,
 						   edoubleprime->kind == CONSTANT ? PRE_EXPR_CONSTANT (edoubleprime) : PRE_EXPR_NAME (edoubleprime));
 	      gimple_stmt_iterator gsi = gsi_after_labels (block);
 	      gsi_insert_before (&gsi, assign, GSI_NEW_STMT);
@@ -3679,7 +3679,7 @@ compute_avail (void)
   while (sp)
     {
       gimple_stmt_iterator gsi;
-      gimple stmt;
+      gimple *stmt;
       basic_block dom;
 
       /* Pick a block from the worklist.  */
@@ -3848,7 +3848,7 @@ compute_avail (void)
 			 to EXP_GEN.  */
 		      if (gimple_vuse (stmt))
 			{
-			  gimple def_stmt;
+			  gimple *def_stmt;
 			  bool ok = true;
 			  def_stmt = SSA_NAME_DEF_STMT (gimple_vuse (stmt));
 			  while (!gimple_nop_p (def_stmt)
@@ -3914,8 +3914,8 @@ compute_avail (void)
 
 
 /* Local state for the eliminate domwalk.  */
-static vec<gimple> el_to_remove;
-static vec<gimple> el_to_update;
+static vec<gimple *> el_to_remove;
+static vec<gimple *> el_to_update;
 static unsigned int el_todo;
 static vec<tree> el_avail;
 static vec<tree> el_avail_stack;
@@ -3971,7 +3971,7 @@ eliminate_insert (gimple_stmt_iterator *gsi, tree val)
     return NULL_TREE;
 
   tree res = make_temp_ssa_name (TREE_TYPE (val), NULL, "pretmp");
-  gimple tem = gimple_build_assign (res,
+  gimple *tem = gimple_build_assign (res,
 				    fold_build1 (TREE_CODE (expr),
 						 TREE_TYPE (expr), leader));
   gsi_insert_before (gsi, tem, GSI_SAME_STMT);
@@ -4005,14 +4005,14 @@ void
 eliminate_dom_walker::before_dom_children (basic_block b)
 {
   gimple_stmt_iterator gsi;
-  gimple stmt;
+  gimple *stmt;
 
   /* Mark new bb.  */
   el_avail_stack.safe_push (NULL_TREE);
 
   for (gsi = gsi_start_phis (b); !gsi_end_p (gsi);)
     {
-      gimple stmt, phi = gsi_stmt (gsi);
+      gimple *stmt, *phi = gsi_stmt (gsi);
       tree sprime = NULL_TREE, res = PHI_RESULT (phi);
       gimple_stmt_iterator gsi2;
 
@@ -4095,7 +4095,7 @@ eliminate_dom_walker::before_dom_children (basic_block b)
 	  && !gimple_has_volatile_ops  (stmt))
 	{
 	  tree sprime;
-	  gimple orig_stmt = stmt;
+	  gimple *orig_stmt = stmt;
 
 	  sprime = eliminate_avail (lhs);
 	  /* If there is no usable leader mark lhs as leader for its value.  */
@@ -4184,7 +4184,7 @@ eliminate_dom_walker::before_dom_children (basic_block b)
 		  && TREE_CODE (sprime) == SSA_NAME
 		  && loop_outer (b->loop_father))
 		{
-		  gimple def_stmt = SSA_NAME_DEF_STMT (sprime);
+		  gimple *def_stmt = SSA_NAME_DEF_STMT (sprime);
 		  basic_block def_bb = gimple_bb (def_stmt);
 		  if (gimple_code (def_stmt) == GIMPLE_PHI
 		      && b->loop_father->header == def_bb
@@ -4414,7 +4414,7 @@ static unsigned int
 eliminate (void)
 {
   gimple_stmt_iterator gsi;
-  gimple stmt;
+  gimple *stmt;
   unsigned i;
 
   need_eh_cleanup = BITMAP_ALLOC (NULL);
@@ -4439,7 +4439,7 @@ eliminate (void)
       tree lhs = gimple_assign_lhs (stmt);
       tree rhs = gimple_assign_rhs1 (stmt);
       use_operand_p use_p;
-      gimple use_stmt;
+      gimple *use_stmt;
 
       /* If there is a single use only, propagate the equivalency
 	 instead of keeping the copy.  */
@@ -4513,10 +4513,10 @@ fini_eliminate (void)
    mark that statement necessary. Return the stmt, if it is newly
    necessary.  */
 
-static inline gimple
+static inline gimple *
 mark_operand_necessary (tree op)
 {
-  gimple stmt;
+  gimple *stmt;
 
   gcc_assert (op);
 
@@ -4545,7 +4545,7 @@ remove_dead_inserted_code (void)
   bitmap worklist;
   unsigned i;
   bitmap_iterator bi;
-  gimple t;
+  gimple *t;
 
   worklist = BITMAP_ALLOC (NULL);
   EXECUTE_IF_SET_IN_BITMAP (inserted_exprs, 0, i, bi)
@@ -4572,7 +4572,7 @@ remove_dead_inserted_code (void)
 	      tree arg = PHI_ARG_DEF (t, k);
 	      if (TREE_CODE (arg) == SSA_NAME)
 		{
-		  gimple n = mark_operand_necessary (arg);
+		  gimple *n = mark_operand_necessary (arg);
 		  if (n)
 		    bitmap_set_bit (worklist, SSA_NAME_VERSION (arg));
 		}
@@ -4593,7 +4593,7 @@ remove_dead_inserted_code (void)
 
 	  FOR_EACH_SSA_TREE_OPERAND (use, t, iter, SSA_OP_ALL_USES)
 	    {
-	      gimple n = mark_operand_necessary (use);
+	      gimple *n = mark_operand_necessary (use);
 	      if (n)
 		bitmap_set_bit (worklist, SSA_NAME_VERSION (use));
 	    }
diff --git a/gcc/tree-ssa-propagate.c b/gcc/tree-ssa-propagate.c
index 4e76d97..dcb064f 100644
--- a/gcc/tree-ssa-propagate.c
+++ b/gcc/tree-ssa-propagate.c
@@ -153,7 +153,7 @@ static sbitmap bb_in_list;
    definition has changed.  SSA edges are def-use edges in the SSA
    web.  For each D-U edge, we store the target statement or PHI node
    U.  */
-static vec<gimple> interesting_ssa_edges;
+static vec<gimple *> interesting_ssa_edges;
 
 /* Identical to INTERESTING_SSA_EDGES.  For performance reasons, the
    list of SSA edges is split into two.  One contains all SSA edges
@@ -169,7 +169,7 @@ static vec<gimple> interesting_ssa_edges;
    don't use a separate worklist for VARYING edges, we end up with
    situations where lattice values move from
    UNDEFINED->INTERESTING->VARYING instead of UNDEFINED->VARYING.  */
-static vec<gimple> varying_ssa_edges;
+static vec<gimple *> varying_ssa_edges;
 
 
 /* Return true if the block worklist empty.  */
@@ -264,7 +264,7 @@ add_ssa_edge (tree var, bool is_varying)
 
   FOR_EACH_IMM_USE_FAST (use_p, iter, var)
     {
-      gimple use_stmt = USE_STMT (use_p);
+      gimple *use_stmt = USE_STMT (use_p);
 
       if (prop_simulate_again_p (use_stmt)
 	  && !gimple_plf (use_stmt, STMT_IN_SSA_EDGE_WORKLIST))
@@ -309,7 +309,7 @@ add_control_edge (edge e)
 /* Simulate the execution of STMT and update the work lists accordingly.  */
 
 static void
-simulate_stmt (gimple stmt)
+simulate_stmt (gimple *stmt)
 {
   enum ssa_prop_result val = SSA_PROP_NOT_INTERESTING;
   edge taken_edge = NULL;
@@ -369,7 +369,7 @@ simulate_stmt (gimple stmt)
    SSA edge is added to it in simulate_stmt.  */
 
 static void
-process_ssa_edge_worklist (vec<gimple> *worklist)
+process_ssa_edge_worklist (vec<gimple *> *worklist)
 {
   /* Drain the entire worklist.  */
   while (worklist->length () > 0)
@@ -377,7 +377,7 @@ process_ssa_edge_worklist (vec<gimple> *worklist)
       basic_block bb;
 
       /* Pull the statement to simulate off the worklist.  */
-      gimple stmt = worklist->pop ();
+      gimple *stmt = worklist->pop ();
 
       /* If this statement was already visited by simulate_block, then
 	 we don't need to visit it again here.  */
@@ -439,7 +439,7 @@ simulate_block (basic_block block)
 
       for (j = gsi_start_bb (block); !gsi_end_p (j); gsi_next (&j))
 	{
-	  gimple stmt = gsi_stmt (j);
+	  gimple *stmt = gsi_stmt (j);
 
 	  /* If this statement is already in the worklist then
 	     "cancel" it.  The reevaluation implied by the worklist
@@ -695,7 +695,7 @@ valid_gimple_call_p (tree expr)
    as their defining statement.  */
 
 void
-move_ssa_defining_stmt_for_defs (gimple new_stmt, gimple old_stmt)
+move_ssa_defining_stmt_for_defs (gimple *new_stmt, gimple *old_stmt)
 {
   tree var;
   ssa_op_iter iter;
@@ -716,8 +716,8 @@ move_ssa_defining_stmt_for_defs (gimple new_stmt, gimple old_stmt)
    A GIMPLE_CALL STMT is being replaced with GIMPLE_CALL NEW_STMT.  */
 
 static void
-finish_update_gimple_call (gimple_stmt_iterator *si_p, gimple new_stmt,
-			   gimple stmt)
+finish_update_gimple_call (gimple_stmt_iterator *si_p, gimple *new_stmt,
+			   gimple *stmt)
 {
   gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
   move_ssa_defining_stmt_for_defs (new_stmt, stmt);
@@ -737,7 +737,7 @@ bool
 update_gimple_call (gimple_stmt_iterator *si_p, tree fn, int nargs, ...)
 {
   va_list ap;
-  gimple new_stmt, stmt = gsi_stmt (*si_p);
+  gimple *new_stmt, *stmt = gsi_stmt (*si_p);
 
   gcc_assert (is_gimple_call (stmt));
   va_start (ap, nargs);
@@ -762,7 +762,7 @@ update_gimple_call (gimple_stmt_iterator *si_p, tree fn, int nargs, ...)
 bool
 update_call_from_tree (gimple_stmt_iterator *si_p, tree expr)
 {
-  gimple stmt = gsi_stmt (*si_p);
+  gimple *stmt = gsi_stmt (*si_p);
 
   if (valid_gimple_call_p (expr))
     {
@@ -771,7 +771,7 @@ update_call_from_tree (gimple_stmt_iterator *si_p, tree expr)
       unsigned i;
       unsigned nargs = call_expr_nargs (expr);
       vec<tree> args = vNULL;
-      gimple new_stmt;
+      gimple *new_stmt;
 
       if (nargs > 0)
         {
@@ -791,7 +791,7 @@ update_call_from_tree (gimple_stmt_iterator *si_p, tree expr)
   else if (valid_gimple_rhs_p (expr))
     {
       tree lhs = gimple_call_lhs (stmt);
-      gimple new_stmt;
+      gimple *new_stmt;
 
       /* The call has simplified to an expression
          that cannot be represented as a GIMPLE_CALL. */
@@ -887,7 +887,7 @@ ssa_propagate (ssa_prop_visit_stmt_fn visit_stmt,
    because they are not interesting for the optimizers.  */
 
 bool
-stmt_makes_single_store (gimple stmt)
+stmt_makes_single_store (gimple *stmt)
 {
   tree lhs;
 
@@ -925,7 +925,7 @@ static struct prop_stats_d prop_stats;
    PROP_VALUE. Return true if at least one reference was replaced.  */
 
 static bool
-replace_uses_in (gimple stmt, ssa_prop_get_value_fn get_value)
+replace_uses_in (gimple *stmt, ssa_prop_get_value_fn get_value)
 {
   bool replaced = false;
   use_operand_p use;
@@ -964,7 +964,7 @@ replace_uses_in (gimple stmt, ssa_prop_get_value_fn get_value)
    values from PROP_VALUE.  */
 
 static void
-replace_phi_args_in (gimple phi, ssa_prop_get_value_fn get_value)
+replace_phi_args_in (gimple *phi, ssa_prop_get_value_fn get_value)
 {
   size_t i;
   bool replaced = false;
@@ -1056,7 +1056,7 @@ substitute_and_fold (ssa_prop_get_value_fn get_value_fn,
       {
 	tree name = ssa_name (i);
 	tree val;
-	gimple def_stmt;
+	gimple *def_stmt;
 	gimple_stmt_iterator gsi;
 
 	if (!name
@@ -1096,7 +1096,7 @@ substitute_and_fold (ssa_prop_get_value_fn get_value_fn,
 	  }
 	else if (gimple_code (def_stmt) == GIMPLE_PHI)
 	  {
-	    gimple new_stmt = gimple_build_assign (name, val);
+	    gimple *new_stmt = gimple_build_assign (name, val);
 	    gimple_stmt_iterator gsi2;
 	    gsi2 = gsi_after_labels (gimple_bb (def_stmt));
 	    gsi_insert_before (&gsi2, new_stmt, GSI_SAME_STMT);
@@ -1122,8 +1122,8 @@ substitute_and_fold (ssa_prop_get_value_fn get_value_fn,
       for (i = (do_dce ? gsi_last_bb (bb) : gsi_start_bb (bb)); !gsi_end_p (i);)
 	{
           bool did_replace;
-	  gimple stmt = gsi_stmt (i);
-	  gimple old_stmt;
+	  gimple *stmt = gsi_stmt (i);
+	  gimple *old_stmt;
 	  enum gimple_code code = gimple_code (stmt);
 	  gimple_stmt_iterator oldi;
 
@@ -1295,7 +1295,7 @@ may_propagate_copy (tree dest, tree orig)
    gimple tuples representation.  */
 
 bool
-may_propagate_copy_into_stmt (gimple dest, tree orig)
+may_propagate_copy_into_stmt (gimple *dest, tree orig)
 {
   tree type_d;
   tree type_o;
@@ -1431,7 +1431,7 @@ propagate_tree_value (tree *op_p, tree val)
 void
 propagate_tree_value_into_stmt (gimple_stmt_iterator *gsi, tree val)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
 
   if (is_gimple_assign (stmt))
     {
diff --git a/gcc/tree-ssa-propagate.h b/gcc/tree-ssa-propagate.h
index 2d8d876..bee4022 100644
--- a/gcc/tree-ssa-propagate.h
+++ b/gcc/tree-ssa-propagate.h
@@ -25,7 +25,7 @@ along with GCC; see the file COPYING3.  If not see
 /* If SIM_P is true, statement S will be simulated again.  */
 
 static inline void
-prop_set_simulate_again (gimple s, bool visit_p)
+prop_set_simulate_again (gimple *s, bool visit_p)
 {
   gimple_set_visited (s, visit_p);
 }
@@ -33,7 +33,7 @@ prop_set_simulate_again (gimple s, bool visit_p)
 /* Return true if statement T should be simulated again.  */
 
 static inline bool
-prop_simulate_again_p (gimple s)
+prop_simulate_again_p (gimple *s)
 {
   return gimple_visited_p (s);
 }
@@ -62,22 +62,22 @@ enum ssa_prop_result {
 
 
 /* Call-back functions used by the value propagation engine.  */
-typedef enum ssa_prop_result (*ssa_prop_visit_stmt_fn) (gimple, edge *, tree *);
-typedef enum ssa_prop_result (*ssa_prop_visit_phi_fn) (gimple);
+typedef enum ssa_prop_result (*ssa_prop_visit_stmt_fn) (gimple *, edge *, tree *);
+typedef enum ssa_prop_result (*ssa_prop_visit_phi_fn) (gimple *);
 typedef bool (*ssa_prop_fold_stmt_fn) (gimple_stmt_iterator *gsi);
 typedef tree (*ssa_prop_get_value_fn) (tree);
 
 
 extern bool valid_gimple_rhs_p (tree);
-extern void move_ssa_defining_stmt_for_defs (gimple, gimple);
+extern void move_ssa_defining_stmt_for_defs (gimple *, gimple *);
 extern bool update_gimple_call (gimple_stmt_iterator *, tree, int, ...);
 extern bool update_call_from_tree (gimple_stmt_iterator *, tree);
 extern void ssa_propagate (ssa_prop_visit_stmt_fn, ssa_prop_visit_phi_fn);
-extern bool stmt_makes_single_store (gimple);
+extern bool stmt_makes_single_store (gimple *);
 extern bool substitute_and_fold (ssa_prop_get_value_fn, ssa_prop_fold_stmt_fn,
 				 bool);
 extern bool may_propagate_copy (tree, tree);
-extern bool may_propagate_copy_into_stmt (gimple, tree);
+extern bool may_propagate_copy_into_stmt (gimple *, tree);
 extern bool may_propagate_copy_into_asm (tree);
 extern void propagate_value (use_operand_p, tree);
 extern void replace_exp (use_operand_p, tree);
diff --git a/gcc/tree-ssa-reassoc.c b/gcc/tree-ssa-reassoc.c
index 357ac08..94a4196 100644
--- a/gcc/tree-ssa-reassoc.c
+++ b/gcc/tree-ssa-reassoc.c
@@ -219,7 +219,7 @@ static struct pointer_map_t *operand_rank;
 
 /* Forward decls.  */
 static long get_rank (tree);
-static bool reassoc_stmt_dominates_stmt_p (gimple, gimple);
+static bool reassoc_stmt_dominates_stmt_p (gimple *, gimple *);
 
 /* Wrapper around gsi_remove, which adjusts gimple_uid of debug stmts
    possibly added by gsi_remove.  */
@@ -227,7 +227,7 @@ static bool reassoc_stmt_dominates_stmt_p (gimple, gimple);
 bool
 reassoc_remove_stmt (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
 
   if (!MAY_HAVE_DEBUG_STMTS || gimple_code (stmt) == GIMPLE_PHI)
     return gsi_remove (gsi, true);
@@ -241,7 +241,7 @@ reassoc_remove_stmt (gimple_stmt_iterator *gsi)
     gsi_next (&prev);
   else
     prev = gsi_start_bb (bb);
-  gimple end_stmt = gsi_stmt (*gsi);
+  gimple *end_stmt = gsi_stmt (*gsi);
   while ((stmt = gsi_stmt (prev)) != end_stmt)
     {
       gcc_assert (stmt && is_gimple_debug (stmt) && gimple_uid (stmt) == 0);
@@ -264,14 +264,14 @@ reassoc_remove_stmt (gimple_stmt_iterator *gsi)
    iteration of the loop.  If STMT is some other phi, the rank is the
    block rank of its containing block.  */
 static long
-phi_rank (gimple stmt)
+phi_rank (gimple *stmt)
 {
   basic_block bb = gimple_bb (stmt);
   struct loop *father = bb->loop_father;
   tree res;
   unsigned i;
   use_operand_p use;
-  gimple use_stmt;
+  gimple *use_stmt;
 
   /* We only care about real loops (those with a latch).  */
   if (!father->latch)
@@ -300,7 +300,7 @@ phi_rank (gimple stmt)
       if (TREE_CODE (arg) == SSA_NAME
 	  && !SSA_NAME_IS_DEFAULT_DEF (arg))
 	{
-	  gimple def_stmt = SSA_NAME_DEF_STMT (arg);
+	  gimple *def_stmt = SSA_NAME_DEF_STMT (arg);
 	  if (gimple_bb (def_stmt)->loop_father == father)
 	    return bb_rank[father->latch->index] + PHI_LOOP_BIAS;
 	}
@@ -316,7 +316,7 @@ phi_rank (gimple stmt)
 static bool
 loop_carried_phi (tree exp)
 {
-  gimple phi_stmt;
+  gimple *phi_stmt;
   long block_rank;
 
   if (TREE_CODE (exp) != SSA_NAME
@@ -425,7 +425,7 @@ get_rank (tree e)
 
   if (TREE_CODE (e) == SSA_NAME)
     {
-      gimple stmt;
+      gimple *stmt;
       long rank;
       int i, n;
       tree op;
@@ -549,8 +549,8 @@ sort_by_operand_rank (const void *pa, const void *pb)
 	  && !SSA_NAME_IS_DEFAULT_DEF (oeb->op)
 	  && SSA_NAME_VERSION (oeb->op) != SSA_NAME_VERSION (oea->op))
 	{
-	  gimple stmta = SSA_NAME_DEF_STMT (oea->op);
-	  gimple stmtb = SSA_NAME_DEF_STMT (oeb->op);
+	  gimple *stmta = SSA_NAME_DEF_STMT (oea->op);
+	  gimple *stmtb = SSA_NAME_DEF_STMT (oeb->op);
 	  basic_block bba = gimple_bb (stmta);
 	  basic_block bbb = gimple_bb (stmtb);
 	  if (bbb != bba)
@@ -615,7 +615,7 @@ add_repeat_to_ops_vec (vec<operand_entry_t> *ops, tree op,
    operation with tree code CODE, and is inside LOOP.  */
 
 static bool
-is_reassociable_op (gimple stmt, enum tree_code code, struct loop *loop)
+is_reassociable_op (gimple *stmt, enum tree_code code, struct loop *loop)
 {
   basic_block bb = gimple_bb (stmt);
 
@@ -640,7 +640,7 @@ is_reassociable_op (gimple stmt, enum tree_code code, struct loop *loop)
 static tree
 get_unary_op (tree name, enum tree_code opcode)
 {
-  gimple stmt = SSA_NAME_DEF_STMT (name);
+  gimple *stmt = SSA_NAME_DEF_STMT (name);
 
   if (!is_gimple_assign (stmt))
     return NULL_TREE;
@@ -1004,7 +1004,7 @@ eliminate_using_constants (enum tree_code opcode,
 }
 
 
-static void linearize_expr_tree (vec<operand_entry_t> *, gimple,
+static void linearize_expr_tree (vec<operand_entry_t> *, gimple *,
 				 bool, bool);
 
 /* Structure for tracking and counting operands.  */
@@ -1070,7 +1070,7 @@ oecount_cmp (const void *p1, const void *p2)
    to some exponent.  */
 
 static bool
-stmt_is_power_of_op (gimple stmt, tree op)
+stmt_is_power_of_op (gimple *stmt, tree op)
 {
   tree fndecl;
 
@@ -1099,7 +1099,7 @@ stmt_is_power_of_op (gimple stmt, tree op)
    was previously called for STMT and returned TRUE.  */
 
 static HOST_WIDE_INT
-decrement_power (gimple stmt)
+decrement_power (gimple *stmt)
 {
   REAL_VALUE_TYPE c, cint;
   HOST_WIDE_INT power;
@@ -1131,10 +1131,10 @@ decrement_power (gimple stmt)
    replace *DEF with OP as well.  */
 
 static void
-propagate_op_to_single_use (tree op, gimple stmt, tree *def)
+propagate_op_to_single_use (tree op, gimple *stmt, tree *def)
 {
   tree lhs;
-  gimple use_stmt;
+  gimple *use_stmt;
   use_operand_p use;
   gimple_stmt_iterator gsi;
 
@@ -1163,7 +1163,7 @@ propagate_op_to_single_use (tree op, gimple stmt, tree *def)
 static void
 zero_one_operation (tree *def, enum tree_code opcode, tree op)
 {
-  gimple stmt = SSA_NAME_DEF_STMT (*def);
+  gimple *stmt = SSA_NAME_DEF_STMT (*def);
 
   do
     {
@@ -1199,7 +1199,7 @@ zero_one_operation (tree *def, enum tree_code opcode, tree op)
 	  && TREE_CODE (gimple_assign_rhs2 (stmt)) == SSA_NAME
 	  && has_single_use (gimple_assign_rhs2 (stmt)))
 	{
-	  gimple stmt2 = SSA_NAME_DEF_STMT (gimple_assign_rhs2 (stmt));
+	  gimple *stmt2 = SSA_NAME_DEF_STMT (gimple_assign_rhs2 (stmt));
 	  if (stmt_is_power_of_op (stmt2, op))
 	    {
 	      if (decrement_power (stmt2) == 1)
@@ -1220,7 +1220,7 @@ zero_one_operation (tree *def, enum tree_code opcode, tree op)
    stmt_dominates_stmt_p, but uses stmt UIDs to optimize.  */
 
 static bool
-reassoc_stmt_dominates_stmt_p (gimple s1, gimple s2)
+reassoc_stmt_dominates_stmt_p (gimple *s1, gimple *s2)
 {
   basic_block bb1 = gimple_bb (s1), bb2 = gimple_bb (s2);
 
@@ -1257,7 +1257,7 @@ reassoc_stmt_dominates_stmt_p (gimple s1, gimple s2)
       unsigned int uid = gimple_uid (s1);
       for (gsi_next (&gsi); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple s = gsi_stmt (gsi);
+	  gimple *s = gsi_stmt (gsi);
 	  if (gimple_uid (s) != uid)
 	    break;
 	  if (s == s2)
@@ -1273,7 +1273,7 @@ reassoc_stmt_dominates_stmt_p (gimple s1, gimple s2)
 /* Insert STMT after INSERT_POINT.  */
 
 static void
-insert_stmt_after (gimple stmt, gimple insert_point)
+insert_stmt_after (gimple *stmt, gimple *insert_point)
 {
   gimple_stmt_iterator gsi;
   basic_block bb;
@@ -1310,13 +1310,13 @@ insert_stmt_after (gimple stmt, gimple insert_point)
    the result.  Places the statement after the definition of either
    OP1 or OP2.  Returns the new statement.  */
 
-static gimple
+static gimple *
 build_and_add_sum (tree type, tree op1, tree op2, enum tree_code opcode)
 {
-  gimple op1def = NULL, op2def = NULL;
+  gimple *op1def = NULL, *op2def = NULL;
   gimple_stmt_iterator gsi;
   tree op;
-  gimple sum;
+  gimple *sum;
 
   /* Create the addition statement.  */
   op = make_ssa_name (type, NULL);
@@ -1344,7 +1344,7 @@ build_and_add_sum (tree type, tree op1, tree op2, enum tree_code opcode)
     }
   else
     {
-      gimple insert_point;
+      gimple *insert_point;
       if ((!op1def || gimple_nop_p (op1def))
 	   || (op2def && !gimple_nop_p (op2def)
 	       && reassoc_stmt_dominates_stmt_p (op1def, op2def)))
@@ -1419,7 +1419,7 @@ undistribute_ops_list (enum tree_code opcode,
   FOR_EACH_VEC_ELT (*ops, i, oe1)
     {
       enum tree_code dcode;
-      gimple oe1def;
+      gimple *oe1def;
 
       if (TREE_CODE (oe1->op) != SSA_NAME)
 	continue;
@@ -1459,7 +1459,7 @@ undistribute_ops_list (enum tree_code opcode,
   subops = XCNEWVEC (vec_operand_entry_t_heap, ops->length ());
   EXECUTE_IF_SET_IN_BITMAP (candidates, 0, i, sbi0)
     {
-      gimple oedef;
+      gimple *oedef;
       enum tree_code oecode;
       unsigned j;
 
@@ -1524,7 +1524,7 @@ undistribute_ops_list (enum tree_code opcode,
       nr_candidates2 = 0;
       EXECUTE_IF_SET_IN_BITMAP (candidates, 0, i, sbi0)
 	{
-	  gimple oedef;
+	  gimple *oedef;
 	  enum tree_code oecode;
 	  unsigned j;
 	  tree op = (*ops)[i]->op;
@@ -1553,7 +1553,7 @@ undistribute_ops_list (enum tree_code opcode,
       if (nr_candidates2 >= 2)
 	{
 	  operand_entry_t oe1, oe2;
-	  gimple prod;
+	  gimple *prod;
 	  int first = bitmap_first_set_bit (candidates2);
 
 	  /* Build the new addition chain.  */
@@ -1566,7 +1566,7 @@ undistribute_ops_list (enum tree_code opcode,
 	  zero_one_operation (&oe1->op, c->oecode, c->op);
 	  EXECUTE_IF_SET_IN_BITMAP (candidates2, first+1, i, sbi0)
 	    {
-	      gimple sum;
+	      gimple *sum;
 	      oe2 = (*ops)[i];
 	      if (dump_file && (dump_flags & TDF_DETAILS))
 		{
@@ -1626,7 +1626,7 @@ eliminate_redundant_comparison (enum tree_code opcode,
 {
   tree op1, op2;
   enum tree_code lcode, rcode;
-  gimple def1, def2;
+  gimple *def1, *def2;
   int i;
   operand_entry_t oe;
 
@@ -1720,7 +1720,7 @@ eliminate_redundant_comparison (enum tree_code opcode,
 	}
       else if (!operand_equal_p (t, curr->op, 0))
 	{
-	  gimple sum;
+	  gimple *sum;
 	  enum tree_code subcode;
 	  tree newop1;
 	  tree newop2;
@@ -1849,7 +1849,7 @@ struct range_entry
    argument should be a GIMPLE_COND.  */
 
 static void
-init_range_entry (struct range_entry *r, tree exp, gimple stmt)
+init_range_entry (struct range_entry *r, tree exp, gimple *stmt)
 {
   int in_p;
   tree low, high;
@@ -2084,7 +2084,7 @@ update_range_test (struct range_entry *range, struct range_entry *otherrange,
 {
   operand_entry_t oe = (*ops)[range->idx];
   tree op = oe->op;
-  gimple stmt = op ? SSA_NAME_DEF_STMT (op) :
+  gimple *stmt = op ? SSA_NAME_DEF_STMT (op) :
     last_stmt (BASIC_BLOCK_FOR_FN (cfun, oe->id));
   location_t loc = gimple_location (stmt);
   tree optype = op ? TREE_TYPE (op) : boolean_type_node;
@@ -2436,13 +2436,13 @@ optimize_range_tests (enum tree_code opcode,
    the last block of a range test.  */
 
 static bool
-final_range_test_p (gimple stmt)
+final_range_test_p (gimple *stmt)
 {
   basic_block bb, rhs_bb;
   edge e;
   tree lhs, rhs;
   use_operand_p use_p;
-  gimple use_stmt;
+  gimple *use_stmt;
 
   if (!gimple_assign_cast_p (stmt))
     return false;
@@ -2490,7 +2490,7 @@ suitable_cond_bb (basic_block bb, basic_block test_bb, basic_block *other_bb,
 {
   edge_iterator ei, ei2;
   edge e, e2;
-  gimple stmt;
+  gimple *stmt;
   gimple_stmt_iterator gsi;
   bool other_edge_seen = false;
   bool is_cond;
@@ -2553,7 +2553,7 @@ suitable_cond_bb (basic_block bb, basic_block test_bb, basic_block *other_bb,
   e2 = find_edge (test_bb, *other_bb);
   for (gsi = gsi_start_phis (e->dest); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple phi = gsi_stmt (gsi);
+      gimple *phi = gsi_stmt (gsi);
       /* If both BB and TEST_BB end with GIMPLE_COND, all PHI arguments
 	 corresponding to BB and TEST_BB predecessor must be the same.  */
       if (!operand_equal_p (gimple_phi_arg_def (phi, e->dest_idx),
@@ -2575,7 +2575,7 @@ suitable_cond_bb (basic_block bb, basic_block test_bb, basic_block *other_bb,
 	    }
 	  else
 	    {
-	      gimple test_last = last_stmt (test_bb);
+	      gimple *test_last = last_stmt (test_bb);
 	      if (gimple_code (test_last) != GIMPLE_COND
 		  && gimple_phi_arg_def (phi, e2->dest_idx)
 		     == gimple_assign_lhs (test_last)
@@ -2598,14 +2598,14 @@ static bool
 no_side_effect_bb (basic_block bb)
 {
   gimple_stmt_iterator gsi;
-  gimple last;
+  gimple *last;
 
   if (!gimple_seq_empty_p (phi_nodes (bb)))
     return false;
   last = last_stmt (bb);
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       tree lhs;
       imm_use_iterator imm_iter;
       use_operand_p use_p;
@@ -2625,7 +2625,7 @@ no_side_effect_bb (basic_block bb)
 	return false;
       FOR_EACH_IMM_USE_FAST (use_p, imm_iter, lhs)
 	{
-	  gimple use_stmt = USE_STMT (use_p);
+	  gimple *use_stmt = USE_STMT (use_p);
 	  if (is_gimple_debug (use_stmt))
 	    continue;
 	  if (gimple_bb (use_stmt) != bb)
@@ -2642,7 +2642,7 @@ static bool
 get_ops (tree var, enum tree_code code, vec<operand_entry_t> *ops,
 	 struct loop *loop)
 {
-  gimple stmt = SSA_NAME_DEF_STMT (var);
+  gimple *stmt = SSA_NAME_DEF_STMT (var);
   tree rhs[2];
   int i;
 
@@ -2676,7 +2676,7 @@ static tree
 update_ops (tree var, enum tree_code code, vec<operand_entry_t> ops,
 	    unsigned int *pidx, struct loop *loop)
 {
-  gimple stmt = SSA_NAME_DEF_STMT (var);
+  gimple *stmt = SSA_NAME_DEF_STMT (var);
   tree rhs[4];
   int i;
 
@@ -2704,7 +2704,7 @@ update_ops (tree var, enum tree_code code, vec<operand_entry_t> ops,
     {
       gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
       var = make_ssa_name (TREE_TYPE (var), NULL);
-      gimple g = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt),
+      gimple *g = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt),
 					       var, rhs[2], rhs[3]);
       gimple_set_uid (g, gimple_uid (stmt));
       gimple_set_visited (g, true);
@@ -2725,7 +2725,7 @@ struct inter_bb_range_test_entry
 /* Inter-bb range test optimization.  */
 
 static void
-maybe_optimize_range_tests (gimple stmt)
+maybe_optimize_range_tests (gimple *stmt)
 {
   basic_block first_bb = gimple_bb (stmt);
   basic_block last_bb = first_bb;
@@ -2848,7 +2848,7 @@ maybe_optimize_range_tests (gimple stmt)
       if (gimple_code (stmt) != GIMPLE_COND)
 	{
 	  use_operand_p use_p;
-	  gimple phi;
+	  gimple *phi;
 	  edge e2;
 	  unsigned int d;
 
@@ -2983,7 +2983,7 @@ maybe_optimize_range_tests (gimple stmt)
 		{
 		  imm_use_iterator iter;
 		  use_operand_p use_p;
-		  gimple use_stmt, cast_stmt = NULL;
+		  gimple *use_stmt, *cast_stmt = NULL;
 
 		  FOR_EACH_IMM_USE_STMT (use_stmt, iter, bbinfo[idx].op)
 		    if (is_gimple_debug (use_stmt))
@@ -3003,7 +3003,7 @@ maybe_optimize_range_tests (gimple stmt)
 		      tree new_lhs = make_ssa_name (TREE_TYPE (lhs), NULL);
 		      enum tree_code rhs_code
 			= gimple_assign_rhs_code (cast_stmt);
-		      gimple g;
+		      gimple *g;
 		      if (is_gimple_min_invariant (new_op))
 			{
 			  new_op = fold_convert (TREE_TYPE (lhs), new_op);
@@ -3061,9 +3061,9 @@ maybe_optimize_range_tests (gimple stmt)
    update" operation.  */
 
 static bool
-is_phi_for_stmt (gimple stmt, tree operand)
+is_phi_for_stmt (gimple *stmt, tree operand)
 {
-  gimple def_stmt;
+  gimple *def_stmt;
   tree lhs;
   use_operand_p arg_p;
   ssa_op_iter i;
@@ -3089,7 +3089,7 @@ is_phi_for_stmt (gimple stmt, tree operand)
 static void
 remove_visited_stmt_chain (tree var)
 {
-  gimple stmt;
+  gimple *stmt;
   gimple_stmt_iterator gsi;
 
   while (1)
@@ -3131,7 +3131,7 @@ remove_visited_stmt_chain (tree var)
 
 static void
 swap_ops_for_binary_stmt (vec<operand_entry_t> ops,
-			  unsigned int opindex, gimple stmt)
+			  unsigned int opindex, gimple *stmt)
 {
   operand_entry_t oe1, oe2, oe3;
 
@@ -3168,8 +3168,8 @@ swap_ops_for_binary_stmt (vec<operand_entry_t> ops,
 /* If definition of RHS1 or RHS2 dominates STMT, return the later of those
    two definitions, otherwise return STMT.  */
 
-static inline gimple
-find_insert_point (gimple stmt, tree rhs1, tree rhs2)
+static inline gimple *
+find_insert_point (gimple *stmt, tree rhs1, tree rhs2)
 {
   if (TREE_CODE (rhs1) == SSA_NAME
       && reassoc_stmt_dominates_stmt_p (stmt, SSA_NAME_DEF_STMT (rhs1)))
@@ -3185,7 +3185,7 @@ find_insert_point (gimple stmt, tree rhs1, tree rhs2)
    order.  Return new lhs.  */
 
 static tree
-rewrite_expr_tree (gimple stmt, unsigned int opindex,
+rewrite_expr_tree (gimple *stmt, unsigned int opindex,
 		   vec<operand_entry_t> ops, bool changed)
 {
   tree rhs1 = gimple_assign_rhs1 (stmt);
@@ -3218,7 +3218,7 @@ rewrite_expr_tree (gimple stmt, unsigned int opindex,
 
 	  if (changed)
 	    {
-	      gimple insert_point = find_insert_point (stmt, oe1->op, oe2->op);
+	      gimple *insert_point = find_insert_point (stmt, oe1->op, oe2->op);
 	      lhs = make_ssa_name (TREE_TYPE (lhs), NULL);
 	      stmt
 		= gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt),
@@ -3282,7 +3282,7 @@ rewrite_expr_tree (gimple stmt, unsigned int opindex,
 	{
 	  gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
 	  unsigned int uid = gimple_uid (stmt);
-	  gimple insert_point = find_insert_point (stmt, new_rhs1, oe->op);
+	  gimple *insert_point = find_insert_point (stmt, new_rhs1, oe->op);
 
 	  lhs = make_ssa_name (TREE_TYPE (lhs), NULL);
 	  stmt = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt),
@@ -3390,13 +3390,13 @@ get_reassociation_width (int ops_num, enum tree_code opc,
    parallel.  */
 
 static void
-rewrite_expr_tree_parallel (gimple stmt, int width,
+rewrite_expr_tree_parallel (gimple *stmt, int width,
 			    vec<operand_entry_t> ops)
 {
   enum tree_code opcode = gimple_assign_rhs_code (stmt);
   int op_num = ops.length ();
   int stmt_num = op_num - 1;
-  gimple *stmts = XALLOCAVEC (gimple, stmt_num);
+  gimple **stmts = XALLOCAVEC (gimple *, stmt_num);
   int op_index = op_num - 1;
   int stmt_index = 0;
   int ready_stmts_end = 0;
@@ -3485,14 +3485,14 @@ rewrite_expr_tree_parallel (gimple stmt, int width,
    Recurse on D if necessary.  */
 
 static void
-linearize_expr (gimple stmt)
+linearize_expr (gimple *stmt)
 {
   gimple_stmt_iterator gsi;
-  gimple binlhs = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (stmt));
-  gimple binrhs = SSA_NAME_DEF_STMT (gimple_assign_rhs2 (stmt));
-  gimple oldbinrhs = binrhs;
+  gimple *binlhs = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (stmt));
+  gimple *binrhs = SSA_NAME_DEF_STMT (gimple_assign_rhs2 (stmt));
+  gimple *oldbinrhs = binrhs;
   enum tree_code rhscode = gimple_assign_rhs_code (stmt);
-  gimple newbinrhs = NULL;
+  gimple *newbinrhs = NULL;
   struct loop *loop = loop_containing_stmt (stmt);
   tree lhs = gimple_assign_lhs (stmt);
 
@@ -3540,11 +3540,11 @@ linearize_expr (gimple stmt)
 /* If LHS has a single immediate use that is a GIMPLE_ASSIGN statement, return
    it.  Otherwise, return NULL.  */
 
-static gimple
+static gimple *
 get_single_immediate_use (tree lhs)
 {
   use_operand_p immuse;
-  gimple immusestmt;
+  gimple *immusestmt;
 
   if (TREE_CODE (lhs) == SSA_NAME
       && single_imm_use (lhs, &immuse, &immusestmt)
@@ -3564,7 +3564,7 @@ get_single_immediate_use (tree lhs)
 static tree
 negate_value (tree tonegate, gimple_stmt_iterator *gsip)
 {
-  gimple negatedefstmt = NULL;
+  gimple *negatedefstmt = NULL;
   tree resultofnegate;
   gimple_stmt_iterator gsi;
   unsigned int uid;
@@ -3582,7 +3582,7 @@ negate_value (tree tonegate, gimple_stmt_iterator *gsip)
       tree rhs1 = gimple_assign_rhs1 (negatedefstmt);
       tree rhs2 = gimple_assign_rhs2 (negatedefstmt);
       tree lhs = gimple_assign_lhs (negatedefstmt);
-      gimple g;
+      gimple *g;
 
       gsi = gsi_for_stmt (negatedefstmt);
       rhs1 = negate_value (rhs1, &gsi);
@@ -3606,7 +3606,7 @@ negate_value (tree tonegate, gimple_stmt_iterator *gsip)
   uid = gimple_uid (gsi_stmt (gsi));
   for (gsi_prev (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       if (gimple_uid (stmt) != 0)
 	break;
       gimple_set_uid (stmt, uid);
@@ -3621,12 +3621,12 @@ negate_value (tree tonegate, gimple_stmt_iterator *gsip)
    exposes the adds to reassociation.  */
 
 static bool
-should_break_up_subtract (gimple stmt)
+should_break_up_subtract (gimple *stmt)
 {
   tree lhs = gimple_assign_lhs (stmt);
   tree binlhs = gimple_assign_rhs1 (stmt);
   tree binrhs = gimple_assign_rhs2 (stmt);
-  gimple immusestmt;
+  gimple *immusestmt;
   struct loop *loop = loop_containing_stmt (stmt);
 
   if (TREE_CODE (binlhs) == SSA_NAME
@@ -3649,7 +3649,7 @@ should_break_up_subtract (gimple stmt)
 /* Transform STMT from A - B into A + -B.  */
 
 static void
-break_up_subtract (gimple stmt, gimple_stmt_iterator *gsip)
+break_up_subtract (gimple *stmt, gimple_stmt_iterator *gsip)
 {
   tree rhs1 = gimple_assign_rhs1 (stmt);
   tree rhs2 = gimple_assign_rhs2 (stmt);
@@ -3672,7 +3672,7 @@ break_up_subtract (gimple stmt, gimple_stmt_iterator *gsip)
    If any of these conditions does not hold, return FALSE.  */
 
 static bool
-acceptable_pow_call (gimple stmt, tree *base, HOST_WIDE_INT *exponent)
+acceptable_pow_call (gimple *stmt, tree *base, HOST_WIDE_INT *exponent)
 {
   tree fndecl, arg1;
   REAL_VALUE_TYPE c, cint;
@@ -3737,12 +3737,12 @@ acceptable_pow_call (gimple stmt, tree *base, HOST_WIDE_INT *exponent)
    Place the operands of the expression tree in the vector named OPS.  */
 
 static void
-linearize_expr_tree (vec<operand_entry_t> *ops, gimple stmt,
+linearize_expr_tree (vec<operand_entry_t> *ops, gimple *stmt,
 		     bool is_associative, bool set_visited)
 {
   tree binlhs = gimple_assign_rhs1 (stmt);
   tree binrhs = gimple_assign_rhs2 (stmt);
-  gimple binlhsdef = NULL, binrhsdef = NULL;
+  gimple *binlhsdef = NULL, *binrhsdef = NULL;
   bool binlhsisreassoc = false;
   bool binrhsisreassoc = false;
   enum tree_code rhscode = gimple_assign_rhs_code (stmt);
@@ -3867,7 +3867,7 @@ repropagate_negates (void)
 
   FOR_EACH_VEC_ELT (plus_negates, i, negate)
     {
-      gimple user = get_single_immediate_use (negate);
+      gimple *user = get_single_immediate_use (negate);
 
       if (!user || !is_gimple_assign (user))
 	continue;
@@ -3913,13 +3913,13 @@ repropagate_negates (void)
 		 This pushes down the negate which we possibly can merge
 		 into some other operation, hence insert it into the
 		 plus_negates vector.  */
-	      gimple feed = SSA_NAME_DEF_STMT (negate);
+	      gimple *feed = SSA_NAME_DEF_STMT (negate);
 	      tree a = gimple_assign_rhs1 (feed);
 	      tree b = gimple_assign_rhs2 (user);
 	      gimple_stmt_iterator gsi = gsi_for_stmt (feed);
 	      gimple_stmt_iterator gsi2 = gsi_for_stmt (user);
 	      tree x = make_ssa_name (TREE_TYPE (gimple_assign_lhs (feed)), NULL);
-	      gimple g = gimple_build_assign_with_ops (PLUS_EXPR, x, a, b);
+	      gimple *g = gimple_build_assign_with_ops (PLUS_EXPR, x, a, b);
 	      gsi_insert_before (&gsi2, g, GSI_SAME_STMT);
 	      gimple_assign_set_rhs_with_ops (&gsi2, NEGATE_EXPR, x, NULL);
 	      user = gsi_stmt (gsi2);
@@ -3932,7 +3932,7 @@ repropagate_negates (void)
 	    {
 	      /* Transform "x = -a; y = b - x" into "y = b + a", getting
 	         rid of one operation.  */
-	      gimple feed = SSA_NAME_DEF_STMT (negate);
+	      gimple *feed = SSA_NAME_DEF_STMT (negate);
 	      tree a = gimple_assign_rhs1 (feed);
 	      tree rhs1 = gimple_assign_rhs1 (user);
 	      gimple_stmt_iterator gsi = gsi_for_stmt (user);
@@ -3985,7 +3985,7 @@ break_up_subtract_bb (basic_block bb)
 
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       gimple_set_visited (stmt, false);
       gimple_set_uid (stmt, uid++);
 
@@ -4061,7 +4061,7 @@ compare_repeat_factors (const void *x1, const void *x2)
    SSA name representing the value of the replacement sequence.  */
 
 static tree
-attempt_builtin_powi (gimple stmt, vec<operand_entry_t> *ops)
+attempt_builtin_powi (gimple *stmt, vec<operand_entry_t> *ops)
 {
   unsigned i, j, vec_len;
   int ii;
@@ -4073,7 +4073,7 @@ attempt_builtin_powi (gimple stmt, vec<operand_entry_t> *ops)
   tree type = TREE_TYPE (gimple_get_lhs (stmt));
   tree powi_fndecl = mathfn_built_in (type, BUILT_IN_POWI);
   gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
-  gimple mul_stmt, pow_stmt;
+  gimple *mul_stmt, *pow_stmt;
 
   /* Nothing to do if BUILT_IN_POWI doesn't exist for this type and
      target.  */
@@ -4360,7 +4360,7 @@ attempt_builtin_powi (gimple stmt, vec<operand_entry_t> *ops)
 /* Transform STMT at *GSI into a copy by replacing its rhs with NEW_RHS.  */
 
 static void
-transform_stmt_to_copy (gimple_stmt_iterator *gsi, gimple stmt, tree new_rhs)
+transform_stmt_to_copy (gimple_stmt_iterator *gsi, gimple *stmt, tree new_rhs)
 {
   tree rhs1;
 
@@ -4385,7 +4385,7 @@ transform_stmt_to_copy (gimple_stmt_iterator *gsi, gimple stmt, tree new_rhs)
 /* Transform STMT at *GSI into a multiply of RHS1 and RHS2.  */
 
 static void
-transform_stmt_to_multiply (gimple_stmt_iterator *gsi, gimple stmt,
+transform_stmt_to_multiply (gimple_stmt_iterator *gsi, gimple *stmt,
 			    tree rhs1, tree rhs2)
 {
   if (dump_file && (dump_flags & TDF_DETAILS))
@@ -4413,7 +4413,7 @@ reassociate_bb (basic_block bb)
 {
   gimple_stmt_iterator gsi;
   basic_block son;
-  gimple stmt = last_stmt (bb);
+  gimple *stmt = last_stmt (bb);
 
   if (stmt && !gimple_visited_p (stmt))
     maybe_optimize_range_tests (stmt);
@@ -4550,7 +4550,7 @@ reassociate_bb (basic_block bb)
 		     reassociated operands.  */
 		  if (powi_result)
 		    {
-		      gimple mul_stmt, lhs_stmt = SSA_NAME_DEF_STMT (lhs);
+		      gimple *mul_stmt, *lhs_stmt = SSA_NAME_DEF_STMT (lhs);
 		      tree type = TREE_TYPE (lhs);
 		      tree target_ssa = make_temp_ssa_name (type, NULL,
 							    "reassocpow");
diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c
index 07b9bd2..7a7fce4 100644
--- a/gcc/tree-ssa-sccvn.c
+++ b/gcc/tree-ssa-sccvn.c
@@ -383,7 +383,7 @@ tree
 vn_get_expr_for (tree name)
 {
   vn_ssa_aux_t vn = VN_INFO (name);
-  gimple def_stmt;
+  gimple *def_stmt;
   tree expr = NULL_TREE;
   enum tree_code code;
 
@@ -466,7 +466,7 @@ vn_get_expr_for (tree name)
    associated with.  */
 
 enum vn_kind
-vn_get_stmt_kind (gimple stmt)
+vn_get_stmt_kind (gimple *stmt)
 {
   switch (gimple_code (stmt))
     {
@@ -1098,7 +1098,7 @@ ao_ref_init_from_vn_reference (ao_ref *ref,
    vn_reference_op_s's.  */
 
 void
-copy_reference_ops_from_call (gimple call,
+copy_reference_ops_from_call (gimple *call,
 			      vec<vn_reference_op_s> *result)
 {
   vn_reference_op_s temp;
@@ -1140,7 +1140,7 @@ copy_reference_ops_from_call (gimple call,
    call statement.  The vector is not shared.  */
 
 static vec<vn_reference_op_s> 
-create_reference_ops_from_call (gimple call)
+create_reference_ops_from_call (gimple *call)
 {
   vec<vn_reference_op_s> result = vNULL;
 
@@ -1188,7 +1188,7 @@ vn_reference_maybe_forwprop_address (vec<vn_reference_op_s> *ops,
   unsigned int i = *i_p;
   vn_reference_op_t op = &(*ops)[i];
   vn_reference_op_t mem_op = &(*ops)[i - 1];
-  gimple def_stmt;
+  gimple *def_stmt;
   enum tree_code code;
   offset_int off;
 
@@ -1431,7 +1431,7 @@ valueize_shared_reference_ops_from_ref (tree ref, bool *valueized_anything)
    this function.  */
 
 static vec<vn_reference_op_s> 
-valueize_shared_reference_ops_from_call (gimple call)
+valueize_shared_reference_ops_from_call (gimple *call)
 {
   if (!call)
     return vNULL;
@@ -1547,7 +1547,7 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *vr_,
 		       bool disambiguate_only)
 {
   vn_reference_t vr = (vn_reference_t)vr_;
-  gimple def_stmt = SSA_NAME_DEF_STMT (vuse);
+  gimple *def_stmt = SSA_NAME_DEF_STMT (vuse);
   tree base;
   HOST_WIDE_INT offset, maxsize;
   static vec<vn_reference_op_s>
@@ -1728,7 +1728,7 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *vr_,
 	   && TREE_CODE (gimple_assign_rhs1 (def_stmt)) == SSA_NAME)
     {
       tree rhs1 = gimple_assign_rhs1 (def_stmt);
-      gimple def_stmt2 = SSA_NAME_DEF_STMT (rhs1);
+      gimple *def_stmt2 = SSA_NAME_DEF_STMT (rhs1);
       if (is_gimple_assign (def_stmt2)
 	  && (gimple_assign_rhs_code (def_stmt2) == COMPLEX_EXPR
 	      || gimple_assign_rhs_code (def_stmt2) == CONSTRUCTOR)
@@ -2291,7 +2291,7 @@ init_vn_nary_op_from_op (vn_nary_op_t vno, tree op)
 /* Return the number of operands for a vn_nary ops structure from STMT.  */
 
 static unsigned int
-vn_nary_length_from_stmt (gimple stmt)
+vn_nary_length_from_stmt (gimple *stmt)
 {
   switch (gimple_assign_rhs_code (stmt))
     {
@@ -2314,7 +2314,7 @@ vn_nary_length_from_stmt (gimple stmt)
 /* Initialize VNO from STMT.  */
 
 static void
-init_vn_nary_op_from_stmt (vn_nary_op_t vno, gimple stmt)
+init_vn_nary_op_from_stmt (vn_nary_op_t vno, gimple *stmt)
 {
   unsigned i;
 
@@ -2413,7 +2413,7 @@ vn_nary_op_lookup (tree op, vn_nary_op_t *vnresult)
    vn_nary_op_t from the hashtable if it exists.  */
 
 tree
-vn_nary_op_lookup_stmt (gimple stmt, vn_nary_op_t *vnresult)
+vn_nary_op_lookup_stmt (gimple *stmt, vn_nary_op_t *vnresult)
 {
   vn_nary_op_t vno1
     = XALLOCAVAR (struct vn_nary_op_s,
@@ -2498,7 +2498,7 @@ vn_nary_op_insert (tree op, tree result)
    RESULT.  */
 
 vn_nary_op_t
-vn_nary_op_insert_stmt (gimple stmt, tree result)
+vn_nary_op_insert_stmt (gimple *stmt, tree result)
 {
   vn_nary_op_t vno1
     = alloc_vn_nary_op (vn_nary_length_from_stmt (stmt),
@@ -2574,7 +2574,7 @@ static vec<tree> shared_lookup_phiargs;
    it does not exist in the hash table. */
 
 static tree
-vn_phi_lookup (gimple phi)
+vn_phi_lookup (gimple *phi)
 {
   vn_phi_s **slot;
   struct vn_phi_s vp1;
@@ -2605,7 +2605,7 @@ vn_phi_lookup (gimple phi)
    RESULT.  */
 
 static vn_phi_t
-vn_phi_insert (gimple phi, tree result)
+vn_phi_insert (gimple *phi, tree result)
 {
   vn_phi_s **slot;
   vn_phi_t vp1 = (vn_phi_t) pool_alloc (current_info->phis_pool);
@@ -2725,7 +2725,7 @@ mark_use_processed (tree use)
 {
   ssa_op_iter iter;
   def_operand_p defp;
-  gimple stmt = SSA_NAME_DEF_STMT (use);
+  gimple *stmt = SSA_NAME_DEF_STMT (use);
 
   if (SSA_NAME_IS_DEFAULT_DEF (use) || gimple_code (stmt) == GIMPLE_PHI)
     {
@@ -2745,7 +2745,7 @@ mark_use_processed (tree use)
    Return true if a value number changed. */
 
 static bool
-defs_to_varying (gimple stmt)
+defs_to_varying (gimple *stmt)
 {
   bool changed = false;
   ssa_op_iter iter;
@@ -2782,7 +2782,7 @@ visit_copy (tree lhs, tree rhs)
    value number of LHS has changed as a result.  */
 
 static bool
-visit_nary_op (tree lhs, gimple stmt)
+visit_nary_op (tree lhs, gimple *stmt)
 {
   bool changed = false;
   tree result = vn_nary_op_lookup_stmt (stmt, NULL);
@@ -2802,7 +2802,7 @@ visit_nary_op (tree lhs, gimple stmt)
    of the LHS has changed as a result.  */
 
 static bool
-visit_reference_op_call (tree lhs, gimple stmt)
+visit_reference_op_call (tree lhs, gimple *stmt)
 {
   bool changed = false;
   struct vn_reference_s vr1;
@@ -2867,7 +2867,7 @@ visit_reference_op_call (tree lhs, gimple stmt)
    and return true if the value number of the LHS has changed as a result.  */
 
 static bool
-visit_reference_op_load (tree lhs, tree op, gimple stmt)
+visit_reference_op_load (tree lhs, tree op, gimple *stmt)
 {
   bool changed = false;
   tree last_vuse;
@@ -2973,7 +2973,7 @@ visit_reference_op_load (tree lhs, tree op, gimple stmt)
    and return true if the value number of the LHS has changed as a result.  */
 
 static bool
-visit_reference_op_store (tree lhs, tree op, gimple stmt)
+visit_reference_op_store (tree lhs, tree op, gimple *stmt)
 {
   bool changed = false;
   vn_reference_t vnresult = NULL;
@@ -3065,7 +3065,7 @@ visit_reference_op_store (tree lhs, tree op, gimple stmt)
    changed.  */
 
 static bool
-visit_phi (gimple phi)
+visit_phi (gimple *phi)
 {
   bool changed = false;
   tree result;
@@ -3170,7 +3170,7 @@ expr_has_constants (tree expr)
 /* Return true if STMT contains constants.  */
 
 static bool
-stmt_has_constants (gimple stmt)
+stmt_has_constants (gimple *stmt)
 {
   tree tem;
 
@@ -3214,7 +3214,7 @@ stmt_has_constants (gimple stmt)
    simplified. */
 
 static tree
-simplify_binary_expression (gimple stmt)
+simplify_binary_expression (gimple *stmt)
 {
   tree result = NULL_TREE;
   tree op0 = gimple_assign_rhs1 (stmt);
@@ -3282,7 +3282,7 @@ simplify_binary_expression (gimple stmt)
    simplified. */
 
 static tree
-simplify_unary_expression (gimple stmt)
+simplify_unary_expression (gimple *stmt)
 {
   tree result = NULL_TREE;
   tree orig_op0, op0 = gimple_assign_rhs1 (stmt);
@@ -3345,7 +3345,7 @@ simplify_unary_expression (gimple stmt)
 /* Try to simplify RHS using equivalences and constant folding.  */
 
 static tree
-try_to_simplify (gimple stmt)
+try_to_simplify (gimple *stmt)
 {
   enum tree_code code = gimple_assign_rhs_code (stmt);
   tree tem;
@@ -3395,7 +3395,7 @@ static bool
 visit_use (tree use)
 {
   bool changed = false;
-  gimple stmt = SSA_NAME_DEF_STMT (use);
+  gimple *stmt = SSA_NAME_DEF_STMT (use);
 
   mark_use_processed (use);
 
@@ -3626,8 +3626,8 @@ compare_ops (const void *pa, const void *pb)
 {
   const tree opa = *((const tree *)pa);
   const tree opb = *((const tree *)pb);
-  gimple opstmta = SSA_NAME_DEF_STMT (opa);
-  gimple opstmtb = SSA_NAME_DEF_STMT (opb);
+  gimple *opstmta = SSA_NAME_DEF_STMT (opa);
+  gimple *opstmtb = SSA_NAME_DEF_STMT (opb);
   basic_block bba;
   basic_block bbb;
 
@@ -3851,7 +3851,7 @@ DFS (tree name)
   vec<ssa_op_iter> itervec = vNULL;
   vec<tree> namevec = vNULL;
   use_operand_p usep = NULL;
-  gimple defstmt;
+  gimple *defstmt;
   tree use;
   ssa_op_iter iter;
 
diff --git a/gcc/tree-ssa-sccvn.h b/gcc/tree-ssa-sccvn.h
index f52783a..0608052 100644
--- a/gcc/tree-ssa-sccvn.h
+++ b/gcc/tree-ssa-sccvn.h
@@ -121,7 +121,7 @@ typedef struct vn_constant_s
 } *vn_constant_t;
 
 enum vn_kind { VN_NONE, VN_CONSTANT, VN_NARY, VN_REFERENCE, VN_PHI };
-enum vn_kind vn_get_stmt_kind (gimple);
+enum vn_kind vn_get_stmt_kind (gimple *);
 
 /* Hash the type TYPE using bits that distinguishes it in the
    types_compatible_p sense.  */
@@ -193,17 +193,17 @@ tree vn_get_expr_for (tree);
 bool run_scc_vn (vn_lookup_kind);
 void free_scc_vn (void);
 tree vn_nary_op_lookup (tree, vn_nary_op_t *);
-tree vn_nary_op_lookup_stmt (gimple, vn_nary_op_t *);
+tree vn_nary_op_lookup_stmt (gimple *, vn_nary_op_t *);
 tree vn_nary_op_lookup_pieces (unsigned int, enum tree_code,
 			       tree, tree *, vn_nary_op_t *);
 vn_nary_op_t vn_nary_op_insert (tree, tree);
-vn_nary_op_t vn_nary_op_insert_stmt (gimple, tree);
+vn_nary_op_t vn_nary_op_insert_stmt (gimple *, tree);
 vn_nary_op_t vn_nary_op_insert_pieces (unsigned int, enum tree_code,
 				       tree, tree *, tree, unsigned int);
 void vn_reference_fold_indirect (vec<vn_reference_op_s> *,
 				 unsigned int *);
 void copy_reference_ops_from_ref (tree, vec<vn_reference_op_s> *);
-void copy_reference_ops_from_call (gimple, vec<vn_reference_op_s> *);
+void copy_reference_ops_from_call (gimple *, vec<vn_reference_op_s> *);
 bool ao_ref_init_from_vn_reference (ao_ref *, alias_set_type, tree,
 				    vec<vn_reference_op_s> );
 tree vn_reference_lookup_pieces (tree, alias_set_type, tree,
diff --git a/gcc/tree-ssa-sink.c b/gcc/tree-ssa-sink.c
index 1d4924f..ae80322 100644
--- a/gcc/tree-ssa-sink.c
+++ b/gcc/tree-ssa-sink.c
@@ -85,7 +85,7 @@ static struct
    we return NULL.  */
 
 static basic_block
-find_bb_for_arg (gimple phi, tree def)
+find_bb_for_arg (gimple *phi, tree def)
 {
   size_t i;
   bool foundone = false;
@@ -110,9 +110,9 @@ find_bb_for_arg (gimple phi, tree def)
    used in, so that you only have one place you can sink it to.  */
 
 static bool
-all_immediate_uses_same_place (gimple stmt)
+all_immediate_uses_same_place (gimple *stmt)
 {
-  gimple firstuse = NULL;
+  gimple *firstuse = NULL;
   ssa_op_iter op_iter;
   imm_use_iterator imm_iter;
   use_operand_p use_p;
@@ -138,7 +138,7 @@ all_immediate_uses_same_place (gimple stmt)
 /* Find the nearest common dominator of all of the immediate uses in IMM.  */
 
 static basic_block
-nearest_common_dominator_of_uses (gimple stmt, bool *debug_stmts)
+nearest_common_dominator_of_uses (gimple *stmt, bool *debug_stmts)
 {
   bitmap blocks = BITMAP_ALLOC (NULL);
   basic_block commondom;
@@ -154,7 +154,7 @@ nearest_common_dominator_of_uses (gimple stmt, bool *debug_stmts)
     {
       FOR_EACH_IMM_USE_FAST (use_p, imm_iter, var)
         {
-	  gimple usestmt = USE_STMT (use_p);
+	  gimple *usestmt = USE_STMT (use_p);
 	  basic_block useblock;
 
 	  if (gimple_code (usestmt) == GIMPLE_PHI)
@@ -209,7 +209,7 @@ nearest_common_dominator_of_uses (gimple stmt, bool *debug_stmts)
 static basic_block
 select_best_block (basic_block early_bb,
 		   basic_block late_bb,
-		   gimple stmt)
+		   gimple *stmt)
 {
   basic_block best_bb = late_bb;
   basic_block temp_bb = late_bb;
@@ -261,10 +261,10 @@ select_best_block (basic_block early_bb,
    statement before that STMT should be moved.  */
 
 static bool
-statement_sink_location (gimple stmt, basic_block frombb,
+statement_sink_location (gimple *stmt, basic_block frombb,
 			 gimple_stmt_iterator *togsi)
 {
-  gimple use;
+  gimple *use;
   use_operand_p one_use = NULL_USE_OPERAND_P;
   basic_block sinkbb;
   use_operand_p use_p;
@@ -336,7 +336,7 @@ statement_sink_location (gimple stmt, basic_block frombb,
     {
       FOR_EACH_IMM_USE_FAST (use_p, imm_iter, DEF_FROM_PTR (def_p))
 	{
-	  gimple use_stmt = USE_STMT (use_p);
+	  gimple *use_stmt = USE_STMT (use_p);
 
 	  /* A killing definition is not a use.  */
 	  if ((gimple_has_lhs (use_stmt)
@@ -461,7 +461,7 @@ sink_code_in_bb (basic_block bb)
 
   for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi);)
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       gimple_stmt_iterator togsi;
 
       if (!statement_sink_location (stmt, bb, &togsi))
@@ -485,7 +485,7 @@ sink_code_in_bb (basic_block bb)
 	{
 	  imm_use_iterator iter;
 	  use_operand_p use_p;
-	  gimple vuse_stmt;
+	  gimple *vuse_stmt;
 
 	  FOR_EACH_IMM_USE_STMT (vuse_stmt, iter, gimple_vdef (stmt))
 	    if (gimple_code (vuse_stmt) != GIMPLE_PHI)
diff --git a/gcc/tree-ssa-strlen.c b/gcc/tree-ssa-strlen.c
index bc3d712..acb8c27 100644
--- a/gcc/tree-ssa-strlen.c
+++ b/gcc/tree-ssa-strlen.c
@@ -67,7 +67,7 @@ typedef struct strinfo_struct
   /* Any of the corresponding pointers for querying alias oracle.  */
   tree ptr;
   /* Statement for delayed length computation.  */
-  gimple stmt;
+  gimple *stmt;
   /* Pointer to '\0' if known, if NULL, it can be computed as
      ptr + length.  */
   tree endptr;
@@ -168,7 +168,7 @@ static struct obstack stridx_obstack;
    *x = '\0' store that could be removed if it is immediately overwritten.  */
 struct laststmt_struct
 {
-  gimple stmt;
+  gimple *stmt;
   tree len;
   int stridx;
 } laststmt;
@@ -425,7 +425,7 @@ get_string_length (strinfo si)
 
   if (si->stmt)
     {
-      gimple stmt = si->stmt, lenstmt;
+      gimple *stmt = si->stmt, *lenstmt;
       tree callee, lhs, fn, tem;
       location_t loc;
       gimple_stmt_iterator gsi;
@@ -516,7 +516,7 @@ get_string_length (strinfo si)
    might change due to stores in stmt.  */
 
 static bool
-maybe_invalidate (gimple stmt)
+maybe_invalidate (gimple *stmt)
 {
   strinfo si;
   unsigned int i;
@@ -730,7 +730,7 @@ find_equal_ptrs (tree ptr, int idx)
     return;
   while (1)
     {
-      gimple stmt = SSA_NAME_DEF_STMT (ptr);
+      gimple *stmt = SSA_NAME_DEF_STMT (ptr);
       if (!is_gimple_assign (stmt))
 	return;
       ptr = gimple_assign_rhs1 (stmt);
@@ -775,7 +775,7 @@ find_equal_ptrs (tree ptr, int idx)
    strinfo.  */
 
 static void
-adjust_last_stmt (strinfo si, gimple stmt, bool is_strcat)
+adjust_last_stmt (strinfo si, gimple *stmt, bool is_strcat)
 {
   tree vuse, callee, len;
   struct laststmt_struct last = laststmt;
@@ -869,7 +869,7 @@ adjust_last_stmt (strinfo si, gimple stmt, bool is_strcat)
     }
   else if (TREE_CODE (len) == SSA_NAME)
     {
-      gimple def_stmt = SSA_NAME_DEF_STMT (len);
+      gimple *def_stmt = SSA_NAME_DEF_STMT (len);
       if (!is_gimple_assign (def_stmt)
 	  || gimple_assign_rhs_code (def_stmt) != PLUS_EXPR
 	  || gimple_assign_rhs1 (def_stmt) != last.len
@@ -892,7 +892,7 @@ handle_builtin_strlen (gimple_stmt_iterator *gsi)
 {
   int idx;
   tree src;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   tree lhs = gimple_call_lhs (stmt);
 
   if (lhs == NULL_TREE)
@@ -968,7 +968,7 @@ handle_builtin_strchr (gimple_stmt_iterator *gsi)
 {
   int idx;
   tree src;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   tree lhs = gimple_call_lhs (stmt);
 
   if (lhs == NULL_TREE)
@@ -1078,7 +1078,7 @@ handle_builtin_strcpy (enum built_in_function bcode, gimple_stmt_iterator *gsi)
   int idx, didx;
   tree src, dst, srclen, len, lhs, args, type, fn, oldlen;
   bool success;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   strinfo si, dsi, olddsi, zsi;
   location_t loc;
 
@@ -1301,7 +1301,7 @@ handle_builtin_memcpy (enum built_in_function bcode, gimple_stmt_iterator *gsi)
 {
   int idx, didx;
   tree src, dst, len, lhs, oldlen, newlen;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   strinfo si, dsi, olddsi;
 
   len = gimple_call_arg (stmt, 2);
@@ -1325,7 +1325,7 @@ handle_builtin_memcpy (enum built_in_function bcode, gimple_stmt_iterator *gsi)
 
   if (idx > 0)
     {
-      gimple def_stmt;
+      gimple *def_stmt;
 
       /* Handle memcpy (x, y, l) where l is strlen (y) + 1.  */
       si = get_strinfo (idx);
@@ -1439,7 +1439,7 @@ handle_builtin_strcat (enum built_in_function bcode, gimple_stmt_iterator *gsi)
   int idx, didx;
   tree src, dst, srclen, dstlen, len, lhs, args, type, fn, objsz, endptr;
   bool success;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   strinfo si, dsi;
   location_t loc;
 
@@ -1623,7 +1623,7 @@ handle_builtin_strcat (enum built_in_function bcode, gimple_stmt_iterator *gsi)
 static void
 handle_pointer_plus (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   tree lhs = gimple_assign_lhs (stmt), off;
   int idx = get_stridx (gimple_assign_rhs1 (stmt));
   strinfo si, zsi;
@@ -1651,7 +1651,7 @@ handle_pointer_plus (gimple_stmt_iterator *gsi)
     zsi = zero_length_string (lhs, si);
   else if (TREE_CODE (off) == SSA_NAME)
     {
-      gimple def_stmt = SSA_NAME_DEF_STMT (off);
+      gimple *def_stmt = SSA_NAME_DEF_STMT (off);
       if (gimple_assign_single_p (def_stmt)
 	  && operand_equal_p (si->length, gimple_assign_rhs1 (def_stmt), 0))
 	zsi = zero_length_string (lhs, si);
@@ -1677,7 +1677,7 @@ handle_char_store (gimple_stmt_iterator *gsi)
 {
   int idx = -1;
   strinfo si = NULL;
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   tree ssaname = NULL_TREE, lhs = gimple_assign_lhs (stmt);
 
   if (TREE_CODE (lhs) == MEM_REF
@@ -1822,7 +1822,7 @@ handle_char_store (gimple_stmt_iterator *gsi)
 static bool
 strlen_optimize_stmt (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
 
   if (is_gimple_call (stmt))
     {
@@ -1898,14 +1898,14 @@ strlen_optimize_stmt (gimple_stmt_iterator *gsi)
    been invalidated.  */
 
 static void
-do_invalidate (basic_block dombb, gimple phi, bitmap visited, int *count)
+do_invalidate (basic_block dombb, gimple *phi, bitmap visited, int *count)
 {
   unsigned int i, n = gimple_phi_num_args (phi);
 
   for (i = 0; i < n; i++)
     {
       tree vuse = gimple_phi_arg_def (phi, i);
-      gimple stmt = SSA_NAME_DEF_STMT (vuse);
+      gimple *stmt = SSA_NAME_DEF_STMT (vuse);
       basic_block bb = gimple_bb (stmt);
       if (bb == NULL
 	  || bb == dombb
@@ -1970,7 +1970,7 @@ strlen_dom_walker::before_dom_children (basic_block bb)
 	{
 	  for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	    {
-	      gimple phi = gsi_stmt (gsi);
+	      gimple *phi = gsi_stmt (gsi);
 	      if (virtual_operand_p (gimple_phi_result (phi)))
 		{
 		  bitmap visited = BITMAP_ALLOC (NULL);
@@ -2009,7 +2009,7 @@ strlen_dom_walker::before_dom_children (basic_block bb)
      has it as well.  */
   for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple phi = gsi_stmt (gsi);
+      gimple *phi = gsi_stmt (gsi);
       tree result = gimple_phi_result (phi);
       if (!virtual_operand_p (result) && POINTER_TYPE_P (TREE_TYPE (result)))
 	{
diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c
index 5d3a323..9d07fdd 100644
--- a/gcc/tree-ssa-structalias.c
+++ b/gcc/tree-ssa-structalias.c
@@ -398,7 +398,7 @@ static struct pointer_map_t *call_stmt_vars;
 /* Lookup or create the variable for the call statement CALL.  */
 
 static varinfo_t
-get_call_vi (gimple call)
+get_call_vi (gimple *call)
 {
   void **slot_p;
   varinfo_t vi, vi2;
@@ -429,7 +429,7 @@ get_call_vi (gimple call)
    the uses.  Returns NULL if there is nothing special about this call.  */
 
 static varinfo_t
-lookup_call_use_vi (gimple call)
+lookup_call_use_vi (gimple *call)
 {
   void **slot_p;
 
@@ -444,7 +444,7 @@ lookup_call_use_vi (gimple call)
    the clobbers.  Returns NULL if there is nothing special about this call.  */
 
 static varinfo_t
-lookup_call_clobber_vi (gimple call)
+lookup_call_clobber_vi (gimple *call)
 {
   varinfo_t uses = lookup_call_use_vi (call);
   if (!uses)
@@ -457,7 +457,7 @@ lookup_call_clobber_vi (gimple call)
    the uses.  */
 
 static varinfo_t
-get_call_use_vi (gimple call)
+get_call_use_vi (gimple *call)
 {
   return get_call_vi (call);
 }
@@ -466,7 +466,7 @@ get_call_use_vi (gimple call)
    the clobbers.  */
 
 static varinfo_t ATTRIBUTE_UNUSED
-get_call_clobber_vi (gimple call)
+get_call_clobber_vi (gimple *call)
 {
   return vi_next (get_call_vi (call));
 }
@@ -3850,7 +3850,7 @@ get_function_part_constraint (varinfo_t fi, unsigned part)
    RHS.  */
 
 static void
-handle_rhs_call (gimple stmt, vec<ce_s> *results)
+handle_rhs_call (gimple *stmt, vec<ce_s> *results)
 {
   struct constraint_expr rhsc;
   unsigned i;
@@ -3952,7 +3952,7 @@ handle_rhs_call (gimple stmt, vec<ce_s> *results)
    the LHS point to global and escaped variables.  */
 
 static void
-handle_lhs_call (gimple stmt, tree lhs, int flags, vec<ce_s> rhsc,
+handle_lhs_call (gimple *stmt, tree lhs, int flags, vec<ce_s> rhsc,
 		 tree fndecl)
 {
   auto_vec<ce_s> lhsc;
@@ -4016,7 +4016,7 @@ handle_lhs_call (gimple stmt, tree lhs, int flags, vec<ce_s> rhsc,
    const function that returns a pointer in the statement STMT.  */
 
 static void
-handle_const_call (gimple stmt, vec<ce_s> *results)
+handle_const_call (gimple *stmt, vec<ce_s> *results)
 {
   struct constraint_expr rhsc;
   unsigned int k;
@@ -4057,7 +4057,7 @@ handle_const_call (gimple stmt, vec<ce_s> *results)
    pure function in statement STMT.  */
 
 static void
-handle_pure_call (gimple stmt, vec<ce_s> *results)
+handle_pure_call (gimple *stmt, vec<ce_s> *results)
 {
   struct constraint_expr rhsc;
   unsigned i;
@@ -4104,7 +4104,7 @@ handle_pure_call (gimple stmt, vec<ce_s> *results)
 /* Return the varinfo for the callee of CALL.  */
 
 static varinfo_t
-get_fi_for_callee (gimple call)
+get_fi_for_callee (gimple *call)
 {
   tree decl, fn = gimple_call_fn (call);
 
@@ -4135,7 +4135,7 @@ get_fi_for_callee (gimple call)
    was handled, otherwise false.  */
 
 static bool
-find_func_aliases_for_builtin_call (struct function *fn, gimple t)
+find_func_aliases_for_builtin_call (struct function *fn, gimple *t)
 {
   tree fndecl = gimple_call_fndecl (t);
   vec<ce_s> lhsc = vNULL;
@@ -4501,7 +4501,7 @@ find_func_aliases_for_builtin_call (struct function *fn, gimple t)
 /* Create constraints for the call T.  */
 
 static void
-find_func_aliases_for_call (struct function *fn, gimple t)
+find_func_aliases_for_call (struct function *fn, gimple *t)
 {
   tree fndecl = gimple_call_fndecl (t);
   vec<ce_s> lhsc = vNULL;
@@ -4620,9 +4620,9 @@ find_func_aliases_for_call (struct function *fn, gimple t)
    when building alias sets and computing alias grouping heuristics.  */
 
 static void
-find_func_aliases (struct function *fn, gimple origt)
+find_func_aliases (struct function *fn, gimple *origt)
 {
-  gimple t = origt;
+  gimple *t = origt;
   vec<ce_s> lhsc = vNULL;
   vec<ce_s> rhsc = vNULL;
   struct constraint_expr *c;
@@ -4858,9 +4858,9 @@ process_ipa_clobber (varinfo_t fi, tree ptr)
    IPA constraint builder.  */
 
 static void
-find_func_clobbers (struct function *fn, gimple origt)
+find_func_clobbers (struct function *fn, gimple *origt)
 {
-  gimple t = origt;
+  gimple *t = origt;
   vec<ce_s> lhsc = vNULL;
   auto_vec<ce_s> rhsc;
   varinfo_t fi;
@@ -6810,7 +6810,7 @@ compute_points_to_sets (void)
 
       for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple phi = gsi_stmt (gsi);
+	  gimple *phi = gsi_stmt (gsi);
 
 	  if (! virtual_operand_p (gimple_phi_result (phi)))
 	    find_func_aliases (cfun, phi);
@@ -6818,7 +6818,7 @@ compute_points_to_sets (void)
 
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 
 	  find_func_aliases (cfun, stmt);
 	}
@@ -6857,7 +6857,7 @@ compute_points_to_sets (void)
 
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  struct pt_solution *pt;
 	  if (!is_gimple_call (stmt))
 	    continue;
@@ -7199,7 +7199,7 @@ ipa_pta_execute (void)
 	  for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
 	       gsi_next (&gsi))
 	    {
-	      gimple phi = gsi_stmt (gsi);
+	      gimple *phi = gsi_stmt (gsi);
 
 	      if (! virtual_operand_p (gimple_phi_result (phi)))
 		find_func_aliases (func, phi);
@@ -7207,7 +7207,7 @@ ipa_pta_execute (void)
 
 	  for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	    {
-	      gimple stmt = gsi_stmt (gsi);
+	      gimple *stmt = gsi_stmt (gsi);
 
 	      find_func_aliases (func, stmt);
 	      find_func_clobbers (func, stmt);
@@ -7267,7 +7267,7 @@ ipa_pta_execute (void)
 
 	  for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	    {
-	      gimple stmt = gsi_stmt (gsi);
+	      gimple *stmt = gsi_stmt (gsi);
 	      struct pt_solution *pt;
 	      varinfo_t vi, fi;
 	      tree decl;
diff --git a/gcc/tree-ssa-tail-merge.c b/gcc/tree-ssa-tail-merge.c
index f879871..efc804f 100644
--- a/gcc/tree-ssa-tail-merge.c
+++ b/gcc/tree-ssa-tail-merge.c
@@ -304,7 +304,7 @@ struct aux_bb_info
    used SSA_NAMEs.  */
 
 static bool
-stmt_local_def (gimple stmt)
+stmt_local_def (gimple *stmt)
 {
   basic_block bb, def_bb;
   imm_use_iterator iter;
@@ -350,7 +350,7 @@ stmt_local_def (gimple stmt)
 static void
 gsi_advance_fw_nondebug_nonlocal (gimple_stmt_iterator *gsi)
 {
-  gimple stmt;
+  gimple *stmt;
 
   while (true)
     {
@@ -436,7 +436,7 @@ update_dep_bb (basic_block use_bb, tree val)
 /* Update BB_DEP_BB, given the dependencies in STMT.  */
 
 static void
-stmt_update_dep_bb (gimple stmt)
+stmt_update_dep_bb (gimple *stmt)
 {
   ssa_op_iter iter;
   use_operand_p use;
@@ -457,7 +457,7 @@ same_succ_hash (const_same_succ e)
   basic_block bb = BASIC_BLOCK_FOR_FN (cfun, first);
   int size = 0;
   gimple_stmt_iterator gsi;
-  gimple stmt;
+  gimple *stmt;
   tree arg;
   unsigned int s;
   bitmap_iterator bs;
@@ -506,7 +506,7 @@ same_succ_hash (const_same_succ e)
       for (gsi = gsi_start_phis (BASIC_BLOCK_FOR_FN (cfun, s)); !gsi_end_p (gsi);
 	   gsi_next (&gsi))
 	{
-	  gimple phi = gsi_stmt (gsi);
+	  gimple *phi = gsi_stmt (gsi);
 	  tree lhs = gimple_phi_result (phi);
 	  tree val = gimple_phi_arg_def (phi, n);
 
@@ -550,7 +550,7 @@ same_succ_def::equal (const value_type *e1, const compare_type *e2)
 {
   unsigned int i, first1, first2;
   gimple_stmt_iterator gsi1, gsi2;
-  gimple s1, s2;
+  gimple *s1, *s2;
   basic_block bb1, bb2;
 
   if (e1->hashval != e2->hashval)
@@ -846,7 +846,7 @@ release_last_vdef (basic_block bb)
 
   for (i = gsi_last_bb (bb); !gsi_end_p (i); gsi_prev_nondebug (&i))
     {
-      gimple stmt = gsi_stmt (i);
+      gimple *stmt = gsi_stmt (i);
       if (gimple_vdef (stmt) == NULL_TREE)
 	continue;
 
@@ -856,7 +856,7 @@ release_last_vdef (basic_block bb)
 
   for (i = gsi_start_phis (bb); !gsi_end_p (i); gsi_next (&i))
     {
-      gimple phi = gsi_stmt (i);
+      gimple *phi = gsi_stmt (i);
       tree res = gimple_phi_result (phi);
 
       if (!virtual_operand_p (res))
@@ -1106,7 +1106,7 @@ gimple_operand_equal_value_p (tree t1, tree t2)
    gimple_bb (s2) are members of SAME_SUCC.  */
 
 static bool
-gimple_equal_p (same_succ same_succ, gimple s1, gimple s2)
+gimple_equal_p (same_succ same_succ, gimple *s1, gimple *s2)
 {
   unsigned int i;
   tree lhs1, lhs2;
@@ -1202,7 +1202,7 @@ static void
 gsi_advance_bw_nondebug_nonlocal (gimple_stmt_iterator *gsi, tree *vuse,
 				  bool *vuse_escaped)
 {
-  gimple stmt;
+  gimple *stmt;
   tree lvuse;
 
   while (true)
@@ -1241,8 +1241,8 @@ find_duplicate (same_succ same_succ, basic_block bb1, basic_block bb2)
 
   while (!gsi_end_p (gsi1) && !gsi_end_p (gsi2))
     {
-      gimple stmt1 = gsi_stmt (gsi1);
-      gimple stmt2 = gsi_stmt (gsi2);
+      gimple *stmt1 = gsi_stmt (gsi1);
+      gimple *stmt2 = gsi_stmt (gsi2);
 
       /* What could be better than to this this here is to blacklist the bb
 	 containing the stmt, when encountering the stmt f.i. in
@@ -1288,7 +1288,7 @@ same_phi_alternatives_1 (basic_block dest, edge e1, edge e2)
 
   for (gsi = gsi_start_phis (dest); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple phi = gsi_stmt (gsi);
+      gimple *phi = gsi_stmt (gsi);
       tree lhs = gimple_phi_result (phi);
       tree val1 = gimple_phi_arg_def (phi, n1);
       tree val2 = gimple_phi_arg_def (phi, n2);
@@ -1342,7 +1342,7 @@ static bool
 bb_has_non_vop_phi (basic_block bb)
 {
   gimple_seq phis = phi_nodes (bb);
-  gimple phi;
+  gimple *phi;
 
   if (phis == NULL)
     return false;
@@ -1465,10 +1465,10 @@ find_clusters (void)
 
 /* Returns the vop phi of BB, if any.  */
 
-static gimple
+static gimple *
 vop_phi (basic_block bb)
 {
-  gimple stmt;
+  gimple *stmt;
   gimple_stmt_iterator gsi;
   for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
@@ -1489,7 +1489,7 @@ replace_block_by (basic_block bb1, basic_block bb2)
   edge e1, e2;
   edge_iterator ei;
   unsigned int i;
-  gimple bb2_phi;
+  gimple *bb2_phi;
 
   bb2_phi = vop_phi (bb2);
 
@@ -1588,12 +1588,12 @@ apply_clusters (void)
    defs.  */
 
 static void
-update_debug_stmt (gimple stmt)
+update_debug_stmt (gimple *stmt)
 {
   use_operand_p use_p;
   ssa_op_iter oi;
   basic_block bbdef, bbuse;
-  gimple def_stmt;
+  gimple *def_stmt;
   tree name;
 
   if (!gimple_debug_bind_p (stmt))
@@ -1630,7 +1630,7 @@ update_debug_stmts (void)
 
   EXECUTE_IF_SET_IN_BITMAP (update_bbs, 0, i, bi)
     {
-      gimple stmt;
+      gimple *stmt;
       gimple_stmt_iterator gsi;
 
       bb = BASIC_BLOCK_FOR_FN (cfun, i);
diff --git a/gcc/tree-ssa-ter.c b/gcc/tree-ssa-ter.c
index 78bedfc..f78b543 100644
--- a/gcc/tree-ssa-ter.c
+++ b/gcc/tree-ssa-ter.c
@@ -402,14 +402,14 @@ finished_with_expr (temp_expr_table_p tab, int version, bool free_expr)
    is available.  */
 
 static inline bool
-ter_is_replaceable_p (gimple stmt)
+ter_is_replaceable_p (gimple *stmt)
 {
 
   if (ssa_is_replaceable_p (stmt))
     {
       use_operand_p use_p;
       tree def;
-      gimple use_stmt;
+      gimple *use_stmt;
       location_t locus1, locus2;
       tree block1, block2;
 
@@ -450,7 +450,7 @@ ter_is_replaceable_p (gimple stmt)
 /* Create an expression entry for a replaceable expression.  */
 
 static void
-process_replaceable (temp_expr_table_p tab, gimple stmt, int call_cnt)
+process_replaceable (temp_expr_table_p tab, gimple *stmt, int call_cnt)
 {
   tree var, def, basevar;
   int version;
@@ -569,7 +569,7 @@ find_ssaname (tree *tp, int *walk_subtrees, void *data)
    walk_stmt_load_store_addr_ops.  */
 
 static bool
-find_ssaname_in_store (gimple, tree, tree t, void *data)
+find_ssaname_in_store (gimple *, tree, tree t, void *data)
 {
   return walk_tree (&t, find_ssaname, data, NULL) != NULL_TREE;
 }
@@ -581,7 +581,7 @@ static void
 find_replaceable_in_bb (temp_expr_table_p tab, basic_block bb)
 {
   gimple_stmt_iterator bsi;
-  gimple stmt;
+  gimple *stmt;
   tree def, use, fndecl;
   int partition;
   var_map map = tab->map;
@@ -629,7 +629,7 @@ find_replaceable_in_bb (temp_expr_table_p tab, basic_block bb)
 		 assignments which we cannot expand correctly.  */
 	      if (gimple_vdef (stmt))
 		{
-		  gimple def_stmt = SSA_NAME_DEF_STMT (use);
+		  gimple *def_stmt = SSA_NAME_DEF_STMT (use);
 		  while (is_gimple_assign (def_stmt)
 			 && gimple_assign_rhs_code (def_stmt) == SSA_NAME)
 		    def_stmt
diff --git a/gcc/tree-ssa-threadedge.c b/gcc/tree-ssa-threadedge.c
index 8e628d5..0bcc7ac 100644
--- a/gcc/tree-ssa-threadedge.c
+++ b/gcc/tree-ssa-threadedge.c
@@ -116,10 +116,10 @@ potentially_threadable_block (basic_block bb)
    BB.  If no such ASSERT_EXPR is found, return OP.  */
 
 static tree
-lhs_of_dominating_assert (tree op, basic_block bb, gimple stmt)
+lhs_of_dominating_assert (tree op, basic_block bb, gimple *stmt)
 {
   imm_use_iterator imm_iter;
-  gimple use_stmt;
+  gimple *use_stmt;
   use_operand_p use_p;
 
   FOR_EACH_IMM_USE_FAST (use_p, imm_iter, op)
@@ -210,7 +210,7 @@ record_temporary_equivalences_from_phis (edge e, vec<tree> *stack,
      later.  */
   for (gsi = gsi_start_phis (e->dest); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple phi = gsi_stmt (gsi);
+      gimple *phi = gsi_stmt (gsi);
       tree src = PHI_ARG_DEF_FROM_EDGE (phi, e);
       tree dst = gimple_phi_result (phi);
 
@@ -245,7 +245,7 @@ record_temporary_equivalences_from_phis (edge e, vec<tree> *stack,
    May return NULL_TREE if no simplification is possible.  */
 
 static tree
-fold_assignment_stmt (gimple stmt)
+fold_assignment_stmt (gimple *stmt)
 {
   enum tree_code subcode = gimple_assign_rhs_code (stmt);
 
@@ -336,16 +336,16 @@ invalidate_equivalences (tree lhs, vec<tree> *stack,
    a context sensitive equivalence which may help us simplify
    later statements in E->dest.  */
 
-static gimple
+static gimple *
 record_temporary_equivalences_from_stmts_at_dest (edge e,
 						  vec<tree> *stack,
-						  tree (*simplify) (gimple,
-								    gimple),
+						  tree (*simplify) (gimple *,
+								    gimple *),
 						  bool backedge_seen,
 						  bitmap src_map,
 						  bitmap dst_map)
 {
-  gimple stmt = NULL;
+  gimple *stmt = NULL;
   gimple_stmt_iterator gsi;
   int max_stmt_count;
 
@@ -544,7 +544,7 @@ record_temporary_equivalences_from_stmts_at_dest (edge e,
    necessarily valid.  We use this callback rather than the ones provided by
    DOM/VRP to achieve that effect.  */
 static tree
-dummy_simplify (gimple stmt1 ATTRIBUTE_UNUSED, gimple stmt2 ATTRIBUTE_UNUSED)
+dummy_simplify (gimple *stmt1 ATTRIBUTE_UNUSED, gimple *stmt2 ATTRIBUTE_UNUSED)
 {
   return NULL_TREE;
 }
@@ -562,9 +562,9 @@ dummy_simplify (gimple stmt1 ATTRIBUTE_UNUSED, gimple stmt2 ATTRIBUTE_UNUSED)
 
 static tree
 simplify_control_stmt_condition (edge e,
-				 gimple stmt,
-				 gimple dummy_cond,
-				 tree (*simplify) (gimple, gimple),
+				 gimple *stmt,
+				 gimple *dummy_cond,
+				 tree (*simplify) (gimple *, gimple *),
 				 bool handle_dominating_asserts)
 {
   tree cond, cached_lhs;
@@ -711,7 +711,7 @@ propagate_threaded_block_debug_into (basic_block dest, basic_block src)
   for (gimple_stmt_iterator si = gsi;
        i * 4 <= alloc_count * 3 && !gsi_end_p (si); gsi_next (&si))
     {
-      gimple stmt = gsi_stmt (si);
+      gimple *stmt = gsi_stmt (si);
       if (!is_gimple_debug (stmt))
 	break;
       i++;
@@ -731,7 +731,7 @@ propagate_threaded_block_debug_into (basic_block dest, basic_block src)
      duplicates in FEWVARS.  */
   for (gimple_stmt_iterator si = gsi; !gsi_end_p (si); gsi_next (&si))
     {
-      gimple stmt = gsi_stmt (si);
+      gimple *stmt = gsi_stmt (si);
       if (!is_gimple_debug (stmt))
 	break;
 
@@ -758,7 +758,7 @@ propagate_threaded_block_debug_into (basic_block dest, basic_block src)
       for (gimple_stmt_iterator si = gsi_last_bb (bb);
 	   !gsi_end_p (si); gsi_prev (&si))
 	{
-	  gimple stmt = gsi_stmt (si);
+	  gimple *stmt = gsi_stmt (si);
 	  if (!is_gimple_debug (stmt))
 	    continue;
 
@@ -827,16 +827,16 @@ propagate_threaded_block_debug_into (basic_block dest, basic_block src)
    try and simplify the condition at the end of TAKEN_EDGE->dest.  */
 static bool
 thread_around_empty_blocks (edge taken_edge,
-			    gimple dummy_cond,
+			    gimple *dummy_cond,
 			    bool handle_dominating_asserts,
-			    tree (*simplify) (gimple, gimple),
+			    tree (*simplify) (gimple *, gimple *),
 			    bitmap visited,
 			    vec<jump_thread_edge *> *path,
 			    bool *backedge_seen_p)
 {
   basic_block bb = taken_edge->dest;
   gimple_stmt_iterator gsi;
-  gimple stmt;
+  gimple *stmt;
   tree cond;
 
   /* The key property of these blocks is that they need not be duplicated
@@ -975,10 +975,10 @@ thread_around_empty_blocks (edge taken_edge,
 
 static int
 thread_through_normal_block (edge e,
-			     gimple dummy_cond,
+			     gimple *dummy_cond,
 			     bool handle_dominating_asserts,
 			     vec<tree> *stack,
-			     tree (*simplify) (gimple, gimple),
+			     tree (*simplify) (gimple *, gimple *),
 			     vec<jump_thread_edge *> *path,
 			     bitmap visited,
 			     bool *backedge_seen_p,
@@ -999,7 +999,7 @@ thread_through_normal_block (edge e,
 
   /* Now walk each statement recording any context sensitive
      temporary equivalences we can detect.  */
-  gimple stmt
+  gimple *stmt
     = record_temporary_equivalences_from_stmts_at_dest (e, stack, simplify,
 							*backedge_seen_p,
 							src_map, dst_map);
@@ -1104,11 +1104,11 @@ thread_through_normal_block (edge e,
    SIMPLIFY is a pass-specific function used to simplify statements.  */
 
 void
-thread_across_edge (gimple dummy_cond,
+thread_across_edge (gimple *dummy_cond,
 		    edge e,
 		    bool handle_dominating_asserts,
 		    vec<tree> *stack,
-		    tree (*simplify) (gimple, gimple))
+		    tree (*simplify) (gimple *, gimple *))
 {
   bitmap visited = BITMAP_ALLOC (NULL);
   bitmap src_map = BITMAP_ALLOC (NULL);
diff --git a/gcc/tree-ssa-threadedge.h b/gcc/tree-ssa-threadedge.h
index f005607..d4ae281 100644
--- a/gcc/tree-ssa-threadedge.h
+++ b/gcc/tree-ssa-threadedge.h
@@ -30,7 +30,7 @@ extern void threadedge_initialize_values (void);
 extern void threadedge_finalize_values (void);
 extern bool potentially_threadable_block (basic_block);
 extern void propagate_threaded_block_debug_into (basic_block, basic_block);
-extern void thread_across_edge (gimple, edge, bool,
-				vec<tree> *, tree (*) (gimple, gimple));
+extern void thread_across_edge (gimple *, edge, bool,
+				vec<tree> *, tree (*) (gimple *, gimple *));
 
 #endif /* GCC_TREE_SSA_THREADEDGE_H */
diff --git a/gcc/tree-ssa-threadupdate.c b/gcc/tree-ssa-threadupdate.c
index 0a24a5c..5e28965 100644
--- a/gcc/tree-ssa-threadupdate.c
+++ b/gcc/tree-ssa-threadupdate.c
@@ -393,8 +393,8 @@ copy_phi_arg_into_existing_phi (edge src_e, edge tgt_e)
        !gsi_end_p (gsi);
        gsi_next (&gsi), gsi_next (&gsi2))
     {
-      gimple src_phi = gsi_stmt (gsi);
-      gimple dest_phi = gsi_stmt (gsi2);
+      gimple *src_phi = gsi_stmt (gsi);
+      gimple *dest_phi = gsi_stmt (gsi2);
       tree val = gimple_phi_arg_def (src_phi, src_idx);
       source_location locus = gimple_phi_arg_location (src_phi, src_idx);
 
@@ -413,7 +413,7 @@ get_value_locus_in_path (tree def, vec<jump_thread_edge *> *path,
 			 basic_block bb, int idx, source_location *locus)
 {
   tree arg;
-  gimple def_phi;
+  gimple *def_phi;
   basic_block def_bb;
 
   if (path == NULL || idx == 0)
@@ -462,7 +462,7 @@ copy_phi_args (basic_block bb, edge src_e, edge tgt_e,
 
   for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple phi = gsi_stmt (gsi);
+      gimple *phi = gsi_stmt (gsi);
       tree def = gimple_phi_arg_def (phi, src_indx);
       source_location locus = gimple_phi_arg_location (phi, src_indx);
 
@@ -1461,7 +1461,7 @@ phi_args_equal_on_edges (edge e1, edge e2)
 
   for (gsi = gsi_start_phis (e1->dest); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple phi = gsi_stmt (gsi);
+      gimple *phi = gsi_stmt (gsi);
 
       if (!operand_equal_p (gimple_phi_arg_def (phi, indx1),
 			    gimple_phi_arg_def (phi, indx2), 0))
@@ -1678,7 +1678,7 @@ mark_threaded_blocks (bitmap threaded_blocks)
 static bool
 bb_ends_with_multiway_branch (basic_block bb ATTRIBUTE_UNUSED)
 {
-  gimple stmt = last_stmt (bb);
+  gimple *stmt = last_stmt (bb);
   if (stmt && gimple_code (stmt) == GIMPLE_SWITCH)
     return true;
   if (stmt && gimple_code (stmt) == GIMPLE_GOTO
diff --git a/gcc/tree-ssa-uncprop.c b/gcc/tree-ssa-uncprop.c
index 7342c9d..4c196e1 100644
--- a/gcc/tree-ssa-uncprop.c
+++ b/gcc/tree-ssa-uncprop.c
@@ -68,7 +68,7 @@ associate_equivalences_with_edges (void)
   FOR_EACH_BB_FN (bb, cfun)
     {
       gimple_stmt_iterator gsi = gsi_last_bb (bb);
-      gimple stmt;
+      gimple *stmt;
 
       /* If the block does not end with a COND_EXPR or SWITCH_EXPR
 	 then there is nothing to do.  */
@@ -430,7 +430,7 @@ uncprop_into_successor_phis (basic_block bb)
       /* Walk over the PHI nodes, unpropagating values.  */
       for (gsi = gsi_start (phis) ; !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple phi = gsi_stmt (gsi);
+	  gimple *phi = gsi_stmt (gsi);
 	  tree arg = PHI_ARG_DEF (phi, e->dest_idx);
 	  tree res = PHI_RESULT (phi);
 	  equiv_hash_elt an_equiv_elt;
diff --git a/gcc/tree-ssa-uninit.c b/gcc/tree-ssa-uninit.c
index 8b298fa..8ae8d78 100644
--- a/gcc/tree-ssa-uninit.c
+++ b/gcc/tree-ssa-uninit.c
@@ -132,7 +132,7 @@ static void
 warn_uninit (enum opt_code wc, tree t, tree expr, tree var,
 	     const char *gmsgid, void *data, location_t phiarg_loc)
 {
-  gimple context = (gimple) data;
+  gimple *context = (gimple *) data;
   location_t location, cfun_loc;
   expanded_location xloc, floc;
 
@@ -194,7 +194,7 @@ warn_uninitialized_vars (bool warn_possibly_uninitialized)
 					     single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun)), bb);
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  use_operand_p use_p;
 	  ssa_op_iter op_iter;
 	  tree use;
@@ -267,9 +267,9 @@ warn_uninitialized_vars (bool warn_possibly_uninitialized)
    redundant. Can be enhanced to be more general.  */
 
 static bool
-can_skip_redundant_opnd (tree opnd, gimple phi)
+can_skip_redundant_opnd (tree opnd, gimple *phi)
 {
-  gimple op_def;
+  gimple *op_def;
   tree phi_def;
   int i, n;
 
@@ -294,7 +294,7 @@ can_skip_redundant_opnd (tree opnd, gimple phi)
    that have empty (or possibly empty) definitions.  */
 
 static unsigned
-compute_uninit_opnds_pos (gimple phi)
+compute_uninit_opnds_pos (gimple *phi)
 {
   size_t i, n;
   unsigned uninit_opnds = 0;
@@ -539,7 +539,7 @@ convert_control_dep_chain_into_preds (vec<edge> *dep_chains,
       pred_chain t_chain = vNULL;
       for (j = 0; j < one_cd_chain.length (); j++)
         {
-          gimple cond_stmt;
+          gimple *cond_stmt;
           gimple_stmt_iterator gsi;
           basic_block guard_bb;
           pred_info one_pred;
@@ -646,7 +646,7 @@ find_predicates (pred_chain_union *preds,
    VISITED_PHIS is a pointer set for detecting cycles.  */
 
 static void
-collect_phi_def_edges (gimple phi, basic_block cd_root,
+collect_phi_def_edges (gimple *phi, basic_block cd_root,
                        vec<edge> *edges,
                        pointer_set_t *visited_phis)
 {
@@ -674,7 +674,7 @@ collect_phi_def_edges (gimple phi, basic_block cd_root,
         }
       else
         {
-          gimple def = SSA_NAME_DEF_STMT (opnd);
+          gimple *def = SSA_NAME_DEF_STMT (opnd);
 
           if (gimple_code (def) == GIMPLE_PHI
               && dominated_by_p (CDI_DOMINATORS,
@@ -699,7 +699,7 @@ collect_phi_def_edges (gimple phi, basic_block cd_root,
    composite predicates pointed to by PREDS.  */
 
 static bool
-find_def_preds (pred_chain_union *preds, gimple phi)
+find_def_preds (pred_chain_union *preds, gimple *phi)
 {
   size_t num_chains = 0, i, n;
   vec<edge> dep_chains[MAX_NUM_CHAINS];
@@ -756,7 +756,7 @@ find_def_preds (pred_chain_union *preds, gimple phi)
 /* Dumps the predicates (PREDS) for USESTMT.  */
 
 static void
-dump_predicates (gimple usestmt, pred_chain_union preds,
+dump_predicates (gimple *usestmt, pred_chain_union preds,
                  const char* msg)
 {
   size_t i, j;
@@ -937,9 +937,9 @@ find_matching_predicate_in_rest_chains (pred_info pred,
 
 /* Forward declaration.  */
 static bool
-is_use_properly_guarded (gimple use_stmt,
+is_use_properly_guarded (gimple *use_stmt,
                          basic_block use_bb,
-                         gimple phi,
+                         gimple *phi,
                          unsigned uninit_opnds,
                          pointer_set_t *visited_phis);
 
@@ -978,9 +978,9 @@ is_use_properly_guarded (gimple use_stmt,
 */
 
 static bool
-prune_uninit_phi_opnds_in_unrealizable_paths (gimple phi,
+prune_uninit_phi_opnds_in_unrealizable_paths (gimple *phi,
 					      unsigned uninit_opnds,
-					      gimple flag_def,
+					      gimple *flag_def,
 					      tree boundary_cst,
 					      enum tree_code cmp_code,
 					      pointer_set_t *visited_phis,
@@ -998,7 +998,7 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gimple phi,
       flag_arg = gimple_phi_arg_def (flag_def, i);
       if (!is_gimple_constant (flag_arg))
         {
-          gimple flag_arg_def, phi_arg_def;
+          gimple *flag_arg_def, *phi_arg_def;
           tree phi_arg;
           unsigned uninit_opnds_arg_phi;
 
@@ -1045,7 +1045,7 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gimple phi,
       if (is_value_included_in (flag_arg, boundary_cst, cmp_code))
         {
           tree opnd;
-          gimple opnd_def;
+          gimple *opnd_def;
 
           /* Now that we know that this undefined edge is not
              pruned. If the operand is defined by another phi,
@@ -1152,11 +1152,11 @@ prune_uninit_phi_opnds_in_unrealizable_paths (gimple phi,
 
 static bool
 use_pred_not_overlap_with_undef_path_pred (pred_chain_union preds,
-				           gimple phi, unsigned uninit_opnds,
+				           gimple *phi, unsigned uninit_opnds,
 					   pointer_set_t *visited_phis)
 {
   unsigned int i, n;
-  gimple flag_def = 0;
+  gimple *flag_def = 0;
   tree  boundary_cst = 0;
   enum tree_code cmp_code;
   bool swap_cond = false;
@@ -1473,7 +1473,7 @@ simplify_pred (pred_chain *one_chain)
       if (!is_neq_zero_form_p (*a_pred))
         continue;
 
-      gimple def_stmt = SSA_NAME_DEF_STMT (a_pred->pred_lhs);
+      gimple *def_stmt = SSA_NAME_DEF_STMT (a_pred->pred_lhs);
       if (gimple_code (def_stmt) != GIMPLE_ASSIGN)
         continue;
       if (gimple_assign_rhs_code (def_stmt) == BIT_IOR_EXPR)
@@ -1662,7 +1662,7 @@ simplify_preds_4 (pred_chain_union *preds)
   size_t i, j, n;
   bool simplified = false;
   pred_chain_union s_preds = vNULL;
-  gimple def_stmt;
+  gimple *def_stmt;
 
   n = preds->length ();
   for (i = 0; i < n; i++)
@@ -1736,7 +1736,7 @@ simplify_preds_4 (pred_chain_union *preds)
 /* This function simplifies predicates in PREDS.  */
 
 static void
-simplify_preds (pred_chain_union *preds, gimple use_or_def, bool is_use)
+simplify_preds (pred_chain_union *preds, gimple *use_or_def, bool is_use)
 {
   size_t i, n;
   bool changed = false;
@@ -1836,7 +1836,7 @@ push_to_worklist (tree op, vec<pred_info, va_heap, vl_ptr> *work_list,
    CMP_ASSIGN with comparison rhs.  */
 
 static pred_info
-get_pred_info_from_cmp (gimple cmp_assign)
+get_pred_info_from_cmp (gimple *cmp_assign)
 {
   pred_info n_pred;
   n_pred.pred_lhs = gimple_assign_rhs1 (cmp_assign);
@@ -1851,11 +1851,11 @@ get_pred_info_from_cmp (gimple cmp_assign)
    will be updated to that value.  */
 
 static bool
-is_degenerated_phi (gimple phi, pred_info *pred_p)
+is_degenerated_phi (gimple *phi, pred_info *pred_p)
 {
   int i, n;
   tree op0;
-  gimple def0;
+  gimple *def0;
   pred_info pred0;
 
   n = gimple_phi_num_args (phi);
@@ -1874,7 +1874,7 @@ is_degenerated_phi (gimple phi, pred_info *pred_p)
 
   for (i = 1; i < n; ++i)
     {
-      gimple def;
+      gimple *def;
       pred_info pred;
       tree op = gimple_phi_arg_def (phi, i);
 
@@ -1918,7 +1918,7 @@ normalize_one_pred_1 (pred_chain_union *norm_preds,
       return;
     }
 
-  gimple def_stmt = SSA_NAME_DEF_STMT (pred.pred_lhs);
+  gimple *def_stmt = SSA_NAME_DEF_STMT (pred.pred_lhs);
  
   if (gimple_code (def_stmt) == GIMPLE_PHI
       && is_degenerated_phi (def_stmt, &pred))
@@ -1997,7 +1997,7 @@ normalize_one_pred (pred_chain_union *norm_preds,
       return;
     }
 
-  gimple def_stmt = SSA_NAME_DEF_STMT (pred.pred_lhs);
+  gimple *def_stmt = SSA_NAME_DEF_STMT (pred.pred_lhs);
   if (gimple_code (def_stmt) == GIMPLE_ASSIGN)
     and_or_code = gimple_assign_rhs_code (def_stmt);
   if (and_or_code != BIT_IOR_EXPR
@@ -2060,7 +2060,7 @@ normalize_one_pred_chain (pred_chain_union *norm_preds,
 /* Normalize predicate chains PREDS and returns the normalized one.  */
 
 static pred_chain_union
-normalize_preds (pred_chain_union preds, gimple use_or_def, bool is_use)
+normalize_preds (pred_chain_union preds, gimple *use_or_def, bool is_use)
 {
   pred_chain_union norm_preds = vNULL;
   size_t n = preds.length ();
@@ -2108,9 +2108,9 @@ normalize_preds (pred_chain_union preds, gimple use_or_def, bool is_use)
    set of phis being visted.  */
 
 static bool
-is_use_properly_guarded (gimple use_stmt,
+is_use_properly_guarded (gimple *use_stmt,
                          basic_block use_bb,
-                         gimple phi,
+                         gimple *phi,
                          unsigned uninit_opnds,
                          pointer_set_t *visited_phis)
 {
@@ -2178,14 +2178,14 @@ is_use_properly_guarded (gimple use_stmt,
    function. ADDED_TO_WORKLIST is the pointer set tracking
    if the new phi is already in the worklist.  */
 
-static gimple
-find_uninit_use (gimple phi, unsigned uninit_opnds,
-                 vec<gimple> *worklist,
+static gimple *
+find_uninit_use (gimple *phi, unsigned uninit_opnds,
+                 vec<gimple *> *worklist,
 		 pointer_set_t *added_to_worklist)
 {
   tree phi_result;
   use_operand_p use_p;
-  gimple use_stmt;
+  gimple *use_stmt;
   imm_use_iterator iter;
 
   phi_result = gimple_phi_result (phi);
@@ -2251,11 +2251,11 @@ find_uninit_use (gimple phi, unsigned uninit_opnds,
    a pointer set tracking if the new phi is added to the worklist or not.  */
 
 static void
-warn_uninitialized_phi (gimple phi, vec<gimple> *worklist,
+warn_uninitialized_phi (gimple *phi, vec<gimple *> *worklist,
                         pointer_set_t *added_to_worklist)
 {
   unsigned uninit_opnds;
-  gimple uninit_use_stmt = 0;
+  gimple *uninit_use_stmt = 0;
   tree uninit_op;
   int phiarg_index;
   location_t loc;
@@ -2339,7 +2339,7 @@ pass_late_warn_uninitialized::execute (function *fun)
 {
   basic_block bb;
   gimple_stmt_iterator gsi;
-  vec<gimple> worklist = vNULL;
+  vec<gimple *> worklist = vNULL;
   pointer_set_t *added_to_worklist;
 
   calculate_dominance_info (CDI_DOMINATORS);
@@ -2358,7 +2358,7 @@ pass_late_warn_uninitialized::execute (function *fun)
   FOR_EACH_BB_FN (bb, fun)
     for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
       {
-	gimple phi = gsi_stmt (gsi);
+	gimple *phi = gsi_stmt (gsi);
 	size_t n, i;
 
 	n = gimple_phi_num_args (phi);
@@ -2387,7 +2387,7 @@ pass_late_warn_uninitialized::execute (function *fun)
 
   while (worklist.length () != 0)
     {
-      gimple cur_phi = 0;
+      gimple *cur_phi = 0;
       cur_phi = worklist.pop ();
       warn_uninitialized_phi (cur_phi, &worklist, added_to_worklist);
     }
diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c
index 42a2783..a4fcb62 100644
--- a/gcc/tree-ssa.c
+++ b/gcc/tree-ssa.c
@@ -190,7 +190,7 @@ edge
 ssa_redirect_edge (edge e, basic_block dest)
 {
   gimple_stmt_iterator gsi;
-  gimple phi;
+  gimple *phi;
 
   redirect_edge_var_map_clear (e);
 
@@ -222,7 +222,7 @@ ssa_redirect_edge (edge e, basic_block dest)
 void
 flush_pending_stmts (edge e)
 {
-  gimple phi;
+  gimple *phi;
   edge_var_map_vector *v;
   edge_var_map *vm;
   int i;
@@ -266,7 +266,7 @@ flush_pending_stmts (edge e)
    copying and removing.  */
 
 void
-gimple_replace_ssa_lhs (gimple stmt, tree nlhs)
+gimple_replace_ssa_lhs (gimple *stmt, tree nlhs)
 {
   if (MAY_HAVE_DEBUG_STMTS)
     {
@@ -351,8 +351,8 @@ insert_debug_temp_for_var_def (gimple_stmt_iterator *gsi, tree var)
 {
   imm_use_iterator imm_iter;
   use_operand_p use_p;
-  gimple stmt;
-  gimple def_stmt = NULL;
+  gimple *stmt;
+  gimple *def_stmt = NULL;
   int usecount = 0;
   tree value = NULL;
 
@@ -477,7 +477,7 @@ insert_debug_temp_for_var_def (gimple_stmt_iterator *gsi, tree var)
 	;
       else
 	{
-	  gimple def_temp;
+	  gimple *def_temp;
 	  tree vexpr = make_node (DEBUG_EXPR_DECL);
 
 	  def_temp = gimple_build_debug_bind (vexpr,
@@ -540,7 +540,7 @@ insert_debug_temp_for_var_def (gimple_stmt_iterator *gsi, tree var)
 void
 insert_debug_temps_for_defs (gimple_stmt_iterator *gsi)
 {
-  gimple stmt;
+  gimple *stmt;
   ssa_op_iter op_iter;
   def_operand_p def_p;
 
@@ -563,12 +563,12 @@ insert_debug_temps_for_defs (gimple_stmt_iterator *gsi)
 /* Reset all debug stmts that use SSA_NAME(s) defined in STMT.  */
 
 void
-reset_debug_uses (gimple stmt)
+reset_debug_uses (gimple *stmt)
 {
   ssa_op_iter op_iter;
   def_operand_p def_p;
   imm_use_iterator imm_iter;
-  gimple use_stmt;
+  gimple *use_stmt;
 
   if (!MAY_HAVE_DEBUG_STMTS)
     return;
@@ -609,7 +609,7 @@ release_defs_bitset (bitmap toremove)
       {
 	bool remove_now = true;
 	tree var = ssa_name (j);
-	gimple stmt;
+	gimple *stmt;
 	imm_use_iterator uit;
 
 	FOR_EACH_IMM_USE_STMT (stmt, uit, var)
@@ -643,7 +643,7 @@ release_defs_bitset (bitmap toremove)
 
 	if (remove_now)
 	  {
-	    gimple def = SSA_NAME_DEF_STMT (var);
+	    gimple *def = SSA_NAME_DEF_STMT (var);
 	    gimple_stmt_iterator gsi = gsi_for_stmt (def);
 
 	    if (gimple_code (def) == GIMPLE_PHI)
@@ -728,7 +728,7 @@ verify_ssa_name (tree ssa_name, bool is_virtual)
 
 static bool
 verify_def (basic_block bb, basic_block *definition_block, tree ssa_name,
-	    gimple stmt, bool is_virtual)
+	    gimple *stmt, bool is_virtual)
 {
   if (verify_ssa_name (ssa_name, is_virtual))
     goto err;
@@ -788,7 +788,7 @@ err:
 
 static bool
 verify_use (basic_block bb, basic_block def_bb, use_operand_p use_p,
-	    gimple stmt, bool check_abnormal, bitmap names_defined_in_bb)
+	    gimple *stmt, bool check_abnormal, bitmap names_defined_in_bb)
 {
   bool err = false;
   tree ssa_name = USE_FROM_PTR (use_p);
@@ -871,7 +871,7 @@ verify_use (basic_block bb, basic_block def_bb, use_operand_p use_p,
       definition of SSA_NAME.  */
 
 static bool
-verify_phi_args (gimple phi, basic_block bb, basic_block *definition_block)
+verify_phi_args (gimple *phi, basic_block bb, basic_block *definition_block)
 {
   edge e;
   bool err = false;
@@ -979,7 +979,7 @@ verify_ssa (bool check_modified_stmt, bool check_ssa_operands)
       tree name = ssa_name (i);
       if (name)
 	{
-	  gimple stmt;
+	  gimple *stmt;
 	  TREE_VISITED (name) = 0;
 
 	  verify_ssa_name (name, virtual_operand_p (name));
@@ -1002,7 +1002,7 @@ verify_ssa (bool check_modified_stmt, bool check_ssa_operands)
   FOR_EACH_BB_FN (bb, cfun)
     {
       edge e;
-      gimple phi;
+      gimple *phi;
       edge_iterator ei;
       gimple_stmt_iterator gsi;
 
@@ -1031,7 +1031,7 @@ verify_ssa (bool check_modified_stmt, bool check_ssa_operands)
       /* Now verify all the uses and vuses in every statement of the block.  */
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  use_operand_p use_p;
 
 	  if (check_modified_stmt && gimple_modified_p (stmt))
@@ -1246,7 +1246,7 @@ tree_ssa_strip_useless_type_conversions (tree exp)
 bool
 ssa_undefined_value_p (tree t)
 {
-  gimple def_stmt;
+  gimple *def_stmt;
   tree var = SSA_NAME_VAR (t);
 
   if (!var)
@@ -1474,7 +1474,7 @@ execute_update_addresses_taken (void)
     {
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  enum gimple_code code = gimple_code (stmt);
 	  tree decl;
 
@@ -1544,7 +1544,7 @@ execute_update_addresses_taken (void)
       for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
 	  size_t i;
-	  gimple phi = gsi_stmt (gsi);
+	  gimple *phi = gsi_stmt (gsi);
 
 	  for (i = 0; i < gimple_phi_num_args (phi); i++)
 	    {
@@ -1575,7 +1575,7 @@ execute_update_addresses_taken (void)
       FOR_EACH_BB_FN (bb, cfun)
 	for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
 	  {
-	    gimple stmt = gsi_stmt (gsi);
+	    gimple *stmt = gsi_stmt (gsi);
 
 	    /* Re-write TARGET_MEM_REFs of symbols we want to
 	       rewrite into SSA form.  */
diff --git a/gcc/tree-ssa.h b/gcc/tree-ssa.h
index c866206..fc591f6 100644
--- a/gcc/tree-ssa.h
+++ b/gcc/tree-ssa.h
@@ -39,11 +39,11 @@ extern edge_var_map_vector *redirect_edge_var_map_vector (edge);
 extern void redirect_edge_var_map_destroy (void);
 extern edge ssa_redirect_edge (edge, basic_block);
 extern void flush_pending_stmts (edge);
-extern void gimple_replace_ssa_lhs (gimple, tree);
+extern void gimple_replace_ssa_lhs (gimple *, tree);
 extern tree target_for_debug_bind (tree);
 extern void insert_debug_temp_for_var_def (gimple_stmt_iterator *, tree);
 extern void insert_debug_temps_for_defs (gimple_stmt_iterator *);
-extern void reset_debug_uses (gimple);
+extern void reset_debug_uses (gimple *);
 extern void release_defs_bitset (bitmap toremove);
 extern void verify_ssa (bool, bool);
 extern void init_tree_ssa (struct function *);
diff --git a/gcc/tree-ssanames.c b/gcc/tree-ssanames.c
index 20a2c3f..90e737e 100644
--- a/gcc/tree-ssanames.c
+++ b/gcc/tree-ssanames.c
@@ -125,7 +125,7 @@ ssanames_print_statistics (void)
    used without a preceding definition).  */
 
 tree
-make_ssa_name_fn (struct function *fn, tree var, gimple stmt)
+make_ssa_name_fn (struct function *fn, tree var, gimple *stmt)
 {
   tree t;
   use_operand_p imm;
@@ -442,7 +442,7 @@ get_ptr_info (tree t)
    statement STMT in function FN.  */
 
 tree
-copy_ssa_name_fn (struct function *fn, tree name, gimple stmt)
+copy_ssa_name_fn (struct function *fn, tree name, gimple *stmt)
 {
   tree new_name;
 
@@ -510,7 +510,7 @@ duplicate_ssa_name_range_info (tree name, enum value_range_type range_type,
    in function FN.  */
 
 tree
-duplicate_ssa_name_fn (struct function *fn, tree name, gimple stmt)
+duplicate_ssa_name_fn (struct function *fn, tree name, gimple *stmt)
 {
   tree new_name = copy_ssa_name_fn (fn, name, stmt);
   if (POINTER_TYPE_P (TREE_TYPE (name)))
@@ -536,7 +536,7 @@ duplicate_ssa_name_fn (struct function *fn, tree name, gimple stmt)
 /* Release all the SSA_NAMEs created by STMT.  */
 
 void
-release_defs (gimple stmt)
+release_defs (gimple *stmt)
 {
   tree def;
   ssa_op_iter iter;
diff --git a/gcc/tree-ssanames.h b/gcc/tree-ssanames.h
index 4fc9f69..3aa0ac6 100644
--- a/gcc/tree-ssanames.h
+++ b/gcc/tree-ssanames.h
@@ -79,7 +79,7 @@ extern wide_int get_nonzero_bits (const_tree);
 extern void init_ssanames (struct function *, int);
 extern void fini_ssanames (void);
 extern void ssanames_print_statistics (void);
-extern tree make_ssa_name_fn (struct function *, tree, gimple);
+extern tree make_ssa_name_fn (struct function *, tree, gimple *);
 extern void release_ssa_name_fn (struct function *, tree);
 extern bool get_ptr_info_alignment (struct ptr_info_def *, unsigned int *,
 				    unsigned int *);
@@ -90,12 +90,12 @@ extern void adjust_ptr_info_misalignment (struct ptr_info_def *,
 					  unsigned int);
 extern struct ptr_info_def *get_ptr_info (tree);
 
-extern tree copy_ssa_name_fn (struct function *, tree, gimple);
+extern tree copy_ssa_name_fn (struct function *, tree, gimple *);
 extern void duplicate_ssa_name_ptr_info (tree, struct ptr_info_def *);
-extern tree duplicate_ssa_name_fn (struct function *, tree, gimple);
+extern tree duplicate_ssa_name_fn (struct function *, tree, gimple *);
 extern void duplicate_ssa_name_range_info (tree, enum value_range_type,
 					   struct range_info_def *);
-extern void release_defs (gimple);
+extern void release_defs (gimple *);
 extern void replace_ssa_name_symbol (tree, tree);
 
 
@@ -103,7 +103,7 @@ extern void replace_ssa_name_symbol (tree, tree);
    in function cfun.  */
 
 static inline tree
-make_ssa_name (tree var, gimple stmt)
+make_ssa_name (tree var, gimple *stmt)
 {
   return make_ssa_name_fn (cfun, var, stmt);
 }
@@ -112,7 +112,7 @@ make_ssa_name (tree var, gimple stmt)
    statement STMT in function cfun.  */
 
 static inline tree
-copy_ssa_name (tree var, gimple stmt)
+copy_ssa_name (tree var, gimple *stmt)
 {
   return copy_ssa_name_fn (cfun, var, stmt);
 }
@@ -121,7 +121,7 @@ copy_ssa_name (tree var, gimple stmt)
     in function cfun.  */
 
 static inline tree
-duplicate_ssa_name (tree var, gimple stmt)
+duplicate_ssa_name (tree var, gimple *stmt)
 {
   return duplicate_ssa_name_fn (cfun, var, stmt);
 }
@@ -138,7 +138,7 @@ release_ssa_name (tree name)
    in function cfun.  Arrange so that it uses NAME in dumps.  */
 
 static inline tree
-make_temp_ssa_name (tree type, gimple stmt, const char *name)
+make_temp_ssa_name (tree type, gimple *stmt, const char *name)
 {
   tree ssa_name;
   gcc_checking_assert (TYPE_P (type));
diff --git a/gcc/tree-stdarg.c b/gcc/tree-stdarg.c
index 1cdf0ed..84b585e 100644
--- a/gcc/tree-stdarg.c
+++ b/gcc/tree-stdarg.c
@@ -127,7 +127,7 @@ va_list_counter_bump (struct stdarg_info *si, tree counter, tree rhs,
 		      bool gpr_p)
 {
   tree lhs, orig_lhs;
-  gimple stmt;
+  gimple *stmt;
   unsigned HOST_WIDE_INT ret = 0, val, counter_val;
   unsigned int max_size;
 
@@ -545,7 +545,7 @@ check_all_va_list_escapes (struct stdarg_info *si)
 	  tree lhs;
 	  use_operand_p uop;
 	  ssa_op_iter soi;
-	  gimple phi = gsi_stmt (i);
+	  gimple *phi = gsi_stmt (i);
 
 	  lhs = PHI_RESULT (phi);
 	  if (virtual_operand_p (lhs)
@@ -573,7 +573,7 @@ check_all_va_list_escapes (struct stdarg_info *si)
 
       for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
 	{
-	  gimple stmt = gsi_stmt (i);
+	  gimple *stmt = gsi_stmt (i);
 	  tree use;
 	  ssa_op_iter iter;
 
@@ -730,7 +730,7 @@ pass_stdarg::execute (function *fun)
 
       for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
 	{
-	  gimple stmt = gsi_stmt (i);
+	  gimple *stmt = gsi_stmt (i);
 	  tree callee, ap;
 
 	  if (!is_gimple_call (stmt))
@@ -853,7 +853,7 @@ pass_stdarg::execute (function *fun)
 
 	  for (i = gsi_start_phis (bb); !gsi_end_p (i); gsi_next (&i))
 	    {
-	      gimple phi = gsi_stmt (i);
+	      gimple *phi = gsi_stmt (i);
 	      lhs = PHI_RESULT (phi);
 
 	      if (virtual_operand_p (lhs))
@@ -887,7 +887,7 @@ pass_stdarg::execute (function *fun)
 	   !gsi_end_p (i) && !va_list_escapes;
 	   gsi_next (&i))
 	{
-	  gimple stmt = gsi_stmt (i);
+	  gimple *stmt = gsi_stmt (i);
 
 	  /* Don't look at __builtin_va_{start,end}, they are ok.  */
 	  if (is_gimple_call (stmt))
diff --git a/gcc/tree-switch-conversion.c b/gcc/tree-switch-conversion.c
index 3651120d..f5de6d9 100644
--- a/gcc/tree-switch-conversion.c
+++ b/gcc/tree-switch-conversion.c
@@ -85,7 +85,7 @@ hoist_edge_and_branch_if_true (gimple_stmt_iterator *gsip,
 			       bool update_dominators)
 {
   tree tmp;
-  gimple cond_stmt;
+  gimple *cond_stmt;
   edge e_false;
   basic_block new_bb, split_bb = gsi_bb (*gsip);
   bool dominated_e_true = false;
@@ -299,7 +299,7 @@ case_bit_test_cmp (const void *p1, const void *p2)
     node targets.  */
 
 static void
-emit_case_bit_tests (gimple swtch, tree index_expr,
+emit_case_bit_tests (gimple *swtch, tree index_expr,
 		     tree minval, tree range)
 {
   struct case_bit_test test[MAX_CASE_BIT_TESTS];
@@ -318,7 +318,7 @@ emit_case_bit_tests (gimple swtch, tree index_expr,
   unsigned int branch_num = gimple_switch_num_labels (swtch);
 
   gimple_stmt_iterator gsi;
-  gimple shift_stmt;
+  gimple *shift_stmt;
 
   tree idx, tmp, csui;
   tree word_type_node = lang_hooks.types.type_for_mode (word_mode, 1);
@@ -597,10 +597,10 @@ struct switch_conv_info
 
   /* The first load statement that loads a temporary from a new static array.
    */
-  gimple arr_ref_first;
+  gimple *arr_ref_first;
 
   /* The last load statement that loads a temporary from a new static array.  */
-  gimple arr_ref_last;
+  gimple *arr_ref_last;
 
   /* String reason why the case wasn't a good candidate that is written to the
      dump file, if there is one.  */
@@ -615,7 +615,7 @@ struct switch_conv_info
 /* Collect information about GIMPLE_SWITCH statement SWTCH into INFO.  */
 
 static void
-collect_switch_conv_info (gimple swtch, struct switch_conv_info *info)
+collect_switch_conv_info (gimple *swtch, struct switch_conv_info *info)
 {
   unsigned int branch_num = gimple_switch_num_labels (swtch);
   tree min_case, max_case;
@@ -757,7 +757,7 @@ check_final_bb (struct switch_conv_info *info)
   info->phi_count = 0;
   for (gsi = gsi_start_phis (info->final_bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple phi = gsi_stmt (gsi);
+      gimple *phi = gsi_stmt (gsi);
       unsigned int i;
 
       info->phi_count++;
@@ -847,7 +847,7 @@ gather_default_values (tree default_case, struct switch_conv_info *info)
 
   for (gsi = gsi_start_phis (info->final_bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple phi = gsi_stmt (gsi);
+      gimple *phi = gsi_stmt (gsi);
       tree val = PHI_ARG_DEF_FROM_EDGE (phi, e);
       gcc_assert (val);
       info->default_values[i++] = val;
@@ -859,7 +859,7 @@ gather_default_values (tree default_case, struct switch_conv_info *info)
    order of phi nodes.  SWTCH is the switch statement being converted.  */
 
 static void
-build_constructors (gimple swtch, struct switch_conv_info *info)
+build_constructors (gimple *swtch, struct switch_conv_info *info)
 {
   unsigned i, branch_num = gimple_switch_num_labels (swtch);
   tree pos = info->range_min;
@@ -905,7 +905,7 @@ build_constructors (gimple swtch, struct switch_conv_info *info)
       for (gsi = gsi_start_phis (info->final_bb);
 	   !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple phi = gsi_stmt (gsi);
+	  gimple *phi = gsi_stmt (gsi);
 	  tree val = PHI_ARG_DEF_FROM_EDGE (phi, e);
 	  tree low = CASE_LOW (cs);
 	  pos = CASE_LOW (cs);
@@ -953,7 +953,7 @@ constructor_contains_same_values_p (vec<constructor_elt, va_gc> *vec)
    all the constants.  */
 
 static tree
-array_value_type (gimple swtch, tree type, int num,
+array_value_type (gimple *swtch, tree type, int num,
 		  struct switch_conv_info *info)
 {
   unsigned int i, len = vec_safe_length (info->constructors[num]);
@@ -1030,11 +1030,11 @@ array_value_type (gimple swtch, tree type, int num,
    new array.  */
 
 static void
-build_one_array (gimple swtch, int num, tree arr_index_type, gimple phi,
+build_one_array (gimple *swtch, int num, tree arr_index_type, gimple *phi,
 		 tree tidx, struct switch_conv_info *info)
 {
   tree name, cst;
-  gimple load;
+  gimple *load;
   gimple_stmt_iterator gsi = gsi_for_stmt (swtch);
   location_t loc = gimple_location (swtch);
 
@@ -1096,11 +1096,11 @@ build_one_array (gimple swtch, int num, tree arr_index_type, gimple phi,
    them.  */
 
 static void
-build_arrays (gimple swtch, struct switch_conv_info *info)
+build_arrays (gimple *swtch, struct switch_conv_info *info)
 {
   tree arr_index_type;
   tree tidx, sub, utype;
-  gimple stmt;
+  gimple *stmt;
   gimple_stmt_iterator gsi;
   int i;
   location_t loc = gimple_location (swtch);
@@ -1135,11 +1135,11 @@ build_arrays (gimple swtch, struct switch_conv_info *info)
 /* Generates and appropriately inserts loads of default values at the position
    given by BSI.  Returns the last inserted statement.  */
 
-static gimple
+static gimple *
 gen_def_assigns (gimple_stmt_iterator *gsi, struct switch_conv_info *info)
 {
   int i;
-  gimple assign = NULL;
+  gimple *assign = NULL;
 
   for (i = 0; i < info->phi_count; i++)
     {
@@ -1189,7 +1189,7 @@ fix_phi_nodes (edge e1f, edge e2f, basic_block bbf,
   for (gsi = gsi_start_phis (bbf), i = 0;
        !gsi_end_p (gsi); gsi_next (&gsi), i++)
     {
-      gimple phi = gsi_stmt (gsi);
+      gimple *phi = gsi_stmt (gsi);
       add_phi_arg (phi, info->target_inbound_names[i], e1f, UNKNOWN_LOCATION);
       add_phi_arg (phi, info->target_outbound_names[i], e2f, UNKNOWN_LOCATION);
     }
@@ -1217,18 +1217,18 @@ fix_phi_nodes (edge e1f, edge e2f, basic_block bbf,
 */
 
 static void
-gen_inbound_check (gimple swtch, struct switch_conv_info *info)
+gen_inbound_check (gimple *swtch, struct switch_conv_info *info)
 {
   tree label_decl1 = create_artificial_label (UNKNOWN_LOCATION);
   tree label_decl2 = create_artificial_label (UNKNOWN_LOCATION);
   tree label_decl3 = create_artificial_label (UNKNOWN_LOCATION);
-  gimple label1, label2, label3;
+  gimple *label1, *label2, *label3;
   tree utype, tidx;
   tree bound;
 
-  gimple cond_stmt;
+  gimple *cond_stmt;
 
-  gimple last_assign;
+  gimple *last_assign;
   gimple_stmt_iterator gsi;
   basic_block bb0, bb1, bb2, bbf, bbd;
   edge e01, e02, e21, e1d, e1f, e2f;
@@ -1337,7 +1337,7 @@ gen_inbound_check (gimple swtch, struct switch_conv_info *info)
    conversion failed.  */
 
 static const char *
-process_switch (gimple swtch)
+process_switch (gimple *swtch)
 {
   struct switch_conv_info info;
 
@@ -1459,7 +1459,7 @@ pass_convert_switch::execute (function *fun)
   FOR_EACH_BB_FN (bb, fun)
   {
     const char *failure_reason;
-    gimple stmt = last_stmt (bb);
+    gimple *stmt = last_stmt (bb);
     if (stmt && gimple_code (stmt) == GIMPLE_SWITCH)
       {
 	if (dump_file)
diff --git a/gcc/tree-tailcall.c b/gcc/tree-tailcall.c
index f7beaef..06cd18d 100644
--- a/gcc/tree-tailcall.c
+++ b/gcc/tree-tailcall.c
@@ -196,7 +196,7 @@ suitable_for_tail_call_opt_p (void)
    containing the value of EXPR at GSI.  */
 
 static tree
-independent_of_stmt_p (tree expr, gimple at, gimple_stmt_iterator gsi)
+independent_of_stmt_p (tree expr, gimple *at, gimple_stmt_iterator gsi)
 {
   basic_block bb, call_bb, at_bb;
   edge e;
@@ -267,7 +267,7 @@ independent_of_stmt_p (tree expr, gimple at, gimple_stmt_iterator gsi)
    additive factor for the real return value.  */
 
 static bool
-process_assignment (gimple stmt, gimple_stmt_iterator call, tree *m,
+process_assignment (gimple *stmt, gimple_stmt_iterator call, tree *m,
 		    tree *a, tree *ass_var)
 {
   tree op0, op1 = NULL_TREE, non_ass_var = NULL_TREE;
@@ -392,7 +392,7 @@ propagate_through_phis (tree var, edge e)
 
   for (gsi = gsi_start_phis (dest); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple phi = gsi_stmt (gsi);
+      gimple *phi = gsi_stmt (gsi);
       if (PHI_ARG_DEF_FROM_EDGE (phi, e) == var)
         return PHI_RESULT (phi);
     }
@@ -406,7 +406,7 @@ static void
 find_tail_calls (basic_block bb, struct tailcall **ret)
 {
   tree ass_var = NULL_TREE, ret_var, func, param;
-  gimple stmt, call = NULL;
+  gimple *stmt, *call = NULL;
   gimple_stmt_iterator gsi, agsi;
   bool tail_recursion;
   struct tailcall *nw;
@@ -641,7 +641,7 @@ adjust_return_value_with_ops (enum tree_code code, const char *label,
 
   tree ret_type = TREE_TYPE (DECL_RESULT (current_function_decl));
   tree result = make_temp_ssa_name (ret_type, NULL, label);
-  gimple stmt;
+  gimple *stmt;
 
   if (POINTER_TYPE_P (ret_type))
     {
@@ -678,7 +678,7 @@ static tree
 update_accumulator_with_ops (enum tree_code code, tree acc, tree op1,
 			     gimple_stmt_iterator gsi)
 {
-  gimple stmt;
+  gimple *stmt;
   tree var = copy_ssa_name (acc, NULL);
   if (types_compatible_p (TREE_TYPE (acc), TREE_TYPE (op1)))
     stmt = gimple_build_assign_with_ops (code, var, acc, op1);
@@ -745,7 +745,7 @@ static void
 adjust_return_value (basic_block bb, tree m, tree a)
 {
   tree retval;
-  gimple ret_stmt = gimple_seq_last_stmt (bb_seq (bb));
+  gimple *ret_stmt = gimple_seq_last_stmt (bb_seq (bb));
   gimple_stmt_iterator gsi = gsi_last_bb (bb);
 
   gcc_assert (gimple_code (ret_stmt) == GIMPLE_RETURN);
@@ -813,14 +813,14 @@ static void
 eliminate_tail_call (struct tailcall *t)
 {
   tree param, rslt;
-  gimple stmt, call;
+  gimple *stmt, *call;
   tree arg;
   size_t idx;
   basic_block bb, first;
   edge e;
-  gimple phi;
+  gimple *phi;
   gimple_stmt_iterator gsi;
-  gimple orig_stmt;
+  gimple *orig_stmt;
 
   stmt = orig_stmt = gsi_stmt (t->call_gsi);
   bb = gsi_bb (t->call_gsi);
@@ -844,7 +844,7 @@ eliminate_tail_call (struct tailcall *t)
   gsi_next (&gsi);
   while (!gsi_end_p (gsi))
     {
-      gimple t = gsi_stmt (gsi);
+      gimple *t = gsi_stmt (gsi);
       /* Do not remove the return statement, so that redirect_edge_and_branch
 	 sees how the block ends.  */
       if (gimple_code (t) == GIMPLE_RETURN)
@@ -916,7 +916,7 @@ optimize_tail_call (struct tailcall *t, bool opt_tailcalls)
 
   if (opt_tailcalls)
     {
-      gimple stmt = gsi_stmt (t->call_gsi);
+      gimple *stmt = gsi_stmt (t->call_gsi);
 
       gimple_call_set_tail (stmt, true);
       cfun->tail_call_marked = true;
@@ -945,7 +945,7 @@ create_tailcall_accumulator (const char *label, basic_block bb, tree init)
     ret_type = sizetype;
 
   tree tmp = make_temp_ssa_name (ret_type, NULL, label);
-  gimple phi;
+  gimple *phi;
 
   phi = create_phi_node (tmp, bb);
   /* RET_TYPE can be a float when -ffast-maths is enabled.  */
@@ -966,7 +966,7 @@ tree_optimize_tail_calls_1 (bool opt_tailcalls)
   bool changed = false;
   basic_block first = single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun));
   tree param;
-  gimple stmt;
+  gimple *stmt;
   edge_iterator ei;
 
   if (!suitable_for_tail_opt_p ())
@@ -1009,7 +1009,7 @@ tree_optimize_tail_calls_1 (bool opt_tailcalls)
 	      {
 		tree name = ssa_default_def (cfun, param);
 		tree new_name = make_ssa_name (param, SSA_NAME_DEF_STMT (name));
-		gimple phi;
+		gimple *phi;
 
 		set_ssa_default_def (cfun, param, new_name);
 		phi = create_phi_node (name, first);
diff --git a/gcc/tree-vect-data-refs.c b/gcc/tree-vect-data-refs.c
index c486405..c5a80d6 100644
--- a/gcc/tree-vect-data-refs.c
+++ b/gcc/tree-vect-data-refs.c
@@ -118,7 +118,7 @@ vect_lanes_optab_supported_p (const char *name, convert_optab optab,
    types.  */
 
 tree
-vect_get_smallest_scalar_type (gimple stmt, HOST_WIDE_INT *lhs_size_unit,
+vect_get_smallest_scalar_type (gimple *stmt, HOST_WIDE_INT *lhs_size_unit,
                                HOST_WIDE_INT *rhs_size_unit)
 {
   tree scalar_type = gimple_expr_type (stmt);
@@ -379,7 +379,7 @@ vect_analyze_data_ref_dependence (struct data_dependence_relation *ddr,
 	      || (STMT_VINFO_GROUPED_ACCESS (stmtinfo_b)
 		  && GROUP_SAME_DR_STMT (stmtinfo_b)))
 	    {
-	      gimple earlier_stmt;
+	      gimple *earlier_stmt;
 	      earlier_stmt = get_earlier_stmt (DR_STMT (dra), DR_STMT (drb));
 	      if (DR_IS_WRITE
 		    (STMT_VINFO_DATA_REF (vinfo_for_stmt (earlier_stmt))))
@@ -548,7 +548,7 @@ vect_slp_analyze_data_ref_dependence (struct data_dependence_relation *ddr)
      corresponding scalar load, and vector store can be only after its
      corresponding scalar store.  So the order of the acceses is preserved in
      case the load is before the store.  */
-  gimple earlier_stmt = get_earlier_stmt (DR_STMT (dra), DR_STMT (drb));
+  gimple *earlier_stmt = get_earlier_stmt (DR_STMT (dra), DR_STMT (drb));
   if (DR_IS_READ (STMT_VINFO_DATA_REF (vinfo_for_stmt (earlier_stmt))))
     {
       /* That only holds for load-store pairs taking part in vectorization.  */
@@ -605,7 +605,7 @@ vect_slp_analyze_data_ref_dependences (bb_vec_info bb_vinfo)
 static bool
 vect_compute_data_ref_alignment (struct data_reference *dr)
 {
-  gimple stmt = DR_STMT (dr);
+  gimple *stmt = DR_STMT (dr);
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
   struct loop *loop = NULL;
@@ -899,7 +899,7 @@ vect_verify_datarefs_alignment (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
 
   FOR_EACH_VEC_ELT (datarefs, i, dr)
     {
-      gimple stmt = DR_STMT (dr);
+      gimple *stmt = DR_STMT (dr);
       stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
 
       if (!STMT_VINFO_RELEVANT_P (stmt_info))
@@ -964,7 +964,7 @@ not_size_aligned (tree exp)
 static bool
 vector_alignment_reachable_p (struct data_reference *dr)
 {
-  gimple stmt = DR_STMT (dr);
+  gimple *stmt = DR_STMT (dr);
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
   tree vectype = STMT_VINFO_VECTYPE (stmt_info);
 
@@ -1035,7 +1035,7 @@ vect_get_data_access_cost (struct data_reference *dr,
                            unsigned int *outside_cost,
 			   stmt_vector_for_cost *body_cost_vec)
 {
-  gimple stmt = DR_STMT (dr);
+  gimple *stmt = DR_STMT (dr);
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
   int nunits = TYPE_VECTOR_SUBPARTS (STMT_VINFO_VECTYPE (stmt_info));
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
@@ -1117,7 +1117,7 @@ vect_peeling_hash_get_lowest_cost (_vect_peel_info **slot,
   vect_peel_info elem = *slot;
   int save_misalignment, dummy;
   unsigned int inside_cost = 0, outside_cost = 0, i;
-  gimple stmt = DR_STMT (elem->dr);
+  gimple *stmt = DR_STMT (elem->dr);
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
   vec<data_reference_p> datarefs = LOOP_VINFO_DATAREFS (loop_vinfo);
@@ -1315,7 +1315,7 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo)
   bool do_peeling = false;
   bool do_versioning = false;
   bool stat;
-  gimple stmt;
+  gimple *stmt;
   stmt_vec_info stmt_info;
   unsigned int npeel = 0;
   bool all_misalignments_unknown = true;
@@ -1690,7 +1690,7 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo)
               unsigned max_peel = npeel;
               if (max_peel == 0)
                 {
-                  gimple dr_stmt = DR_STMT (dr0);
+                  gimple *dr_stmt = DR_STMT (dr0);
                   stmt_vec_info vinfo = vinfo_for_stmt (dr_stmt);
                   tree vtype = STMT_VINFO_VECTYPE (vinfo);
                   max_peel = TYPE_VECTOR_SUBPARTS (vtype) - 1;
@@ -1794,7 +1794,7 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo)
 
           if (!supportable_dr_alignment)
             {
-              gimple stmt;
+              gimple *stmt;
               int mask;
               tree vectype;
 
@@ -1838,9 +1838,9 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo)
 
   if (do_versioning)
     {
-      vec<gimple> may_misalign_stmts
+      vec<gimple *> may_misalign_stmts
         = LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo);
-      gimple stmt;
+      gimple *stmt;
 
       /* It can now be assumed that the data references in the statements
          in LOOP_VINFO_MAY_MISALIGN_STMTS will be aligned in the version
@@ -1997,7 +1997,7 @@ vect_analyze_group_access (struct data_reference *dr)
   tree step = DR_STEP (dr);
   tree scalar_type = TREE_TYPE (DR_REF (dr));
   HOST_WIDE_INT type_size = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (scalar_type));
-  gimple stmt = DR_STMT (dr);
+  gimple *stmt = DR_STMT (dr);
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
   bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info);
@@ -2080,11 +2080,11 @@ vect_analyze_group_access (struct data_reference *dr)
   if (GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt)) == stmt)
     {
       /* First stmt in the interleaving chain. Check the chain.  */
-      gimple next = GROUP_NEXT_ELEMENT (vinfo_for_stmt (stmt));
+      gimple *next = GROUP_NEXT_ELEMENT (vinfo_for_stmt (stmt));
       struct data_reference *data_ref = dr;
       unsigned int count = 1;
       tree prev_init = DR_INIT (data_ref);
-      gimple prev = stmt;
+      gimple *prev = stmt;
       HOST_WIDE_INT diff, gaps = 0;
       unsigned HOST_WIDE_INT count_in_bytes;
 
@@ -2260,7 +2260,7 @@ vect_analyze_data_ref_access (struct data_reference *dr)
 {
   tree step = DR_STEP (dr);
   tree scalar_type = TREE_TYPE (DR_REF (dr));
-  gimple stmt = DR_STMT (dr);
+  gimple *stmt = DR_STMT (dr);
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
   struct loop *loop = NULL;
@@ -2783,9 +2783,9 @@ vect_prune_runtime_alias_test_list (loop_vec_info loop_vinfo)
   FOR_EACH_VEC_ELT (may_alias_ddrs, i, ddr)
     {
       struct data_reference *dr_a, *dr_b;
-      gimple dr_group_first_a, dr_group_first_b;
+      gimple *dr_group_first_a, *dr_group_first_b;
       tree segment_length_a, segment_length_b;
-      gimple stmt_a, stmt_b;
+      gimple *stmt_a, *stmt_b;
 
       dr_a = DDR_A (ddr);
       stmt_a = DR_STMT (DDR_A (ddr));
@@ -2945,7 +2945,7 @@ vect_prune_runtime_alias_test_list (loop_vec_info loop_vinfo)
    and if so, return a builtin decl for that operation.  */
 
 tree
-vect_check_gather (gimple stmt, loop_vec_info loop_vinfo, tree *basep,
+vect_check_gather (gimple *stmt, loop_vec_info loop_vinfo, tree *basep,
 		   tree *offp, int *scalep)
 {
   HOST_WIDE_INT scale = 1, pbitpos, pbitsize;
@@ -2969,7 +2969,7 @@ vect_check_gather (gimple stmt, loop_vec_info loop_vinfo, tree *basep,
       && integer_zerop (TREE_OPERAND (base, 1))
       && !expr_invariant_in_loop_p (loop, TREE_OPERAND (base, 0)))
     {
-      gimple def_stmt = SSA_NAME_DEF_STMT (TREE_OPERAND (base, 0));
+      gimple *def_stmt = SSA_NAME_DEF_STMT (TREE_OPERAND (base, 0));
       if (is_gimple_assign (def_stmt)
 	  && gimple_assign_rhs_code (def_stmt) == ADDR_EXPR)
 	base = TREE_OPERAND (gimple_assign_rhs1 (def_stmt), 0);
@@ -3043,7 +3043,7 @@ vect_check_gather (gimple stmt, loop_vec_info loop_vinfo, tree *basep,
 
       if (TREE_CODE (off) == SSA_NAME)
 	{
-	  gimple def_stmt = SSA_NAME_DEF_STMT (off);
+	  gimple *def_stmt = SSA_NAME_DEF_STMT (off);
 
 	  if (expr_invariant_in_loop_p (loop, off))
 	    return NULL_TREE;
@@ -3204,7 +3204,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
 
 	  for (gsi = gsi_start_bb (bbs[i]); !gsi_end_p (gsi); gsi_next (&gsi))
 	    {
-	      gimple stmt = gsi_stmt (gsi);
+	      gimple *stmt = gsi_stmt (gsi);
 	      if (is_gimple_debug (stmt))
 		continue;
 	      ++*n_stmts;
@@ -3260,7 +3260,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
       bb = BB_VINFO_BB (bb_vinfo);
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  if (is_gimple_debug (stmt))
 	    continue;
 	  ++*n_stmts;
@@ -3285,7 +3285,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
 
   FOR_EACH_VEC_ELT (datarefs, i, dr)
     {
-      gimple stmt;
+      gimple *stmt;
       stmt_vec_info stmt_info;
       tree base, offset, init;
       bool gather = false;
@@ -3364,7 +3364,7 @@ again:
 			    off = TREE_OPERAND (off, 0);
 			  if (TREE_CODE (off) == SSA_NAME)
 			    {
-			      gimple def = SSA_NAME_DEF_STMT (off);
+			      gimple *def = SSA_NAME_DEF_STMT (off);
 			      tree reft = TREE_TYPE (DR_REF (newdr));
 			      if (is_gimple_call (def)
 				  && gimple_call_internal_p (def)
@@ -3846,7 +3846,7 @@ vect_get_new_vect_var (tree type, enum vect_var_kind var_kind, const char *name)
    FORNOW: We are only handling array accesses with step 1.  */
 
 tree
-vect_create_addr_base_for_vector_ref (gimple stmt,
+vect_create_addr_base_for_vector_ref (gimple *stmt,
 				      gimple_seq *new_stmt_list,
 				      tree offset,
 				      struct loop *loop)
@@ -3986,9 +3986,9 @@ vect_create_addr_base_for_vector_ref (gimple stmt,
    4. Return the pointer.  */
 
 tree
-vect_create_data_ref_ptr (gimple stmt, tree aggr_type, struct loop *at_loop,
+vect_create_data_ref_ptr (gimple *stmt, tree aggr_type, struct loop *at_loop,
 			  tree offset, tree *initial_address,
-			  gimple_stmt_iterator *gsi, gimple *ptr_incr,
+			  gimple_stmt_iterator *gsi, gimple **ptr_incr,
 			  bool only_init, bool *inv_p)
 {
   const char *base_name;
@@ -4000,7 +4000,7 @@ vect_create_data_ref_ptr (gimple stmt, tree aggr_type, struct loop *at_loop,
   tree aggr_ptr_type;
   tree aggr_ptr;
   tree new_temp;
-  gimple vec_stmt;
+  gimple *vec_stmt;
   gimple_seq new_stmt_list = NULL;
   edge pe = NULL;
   basic_block new_bb;
@@ -4010,7 +4010,7 @@ vect_create_data_ref_ptr (gimple stmt, tree aggr_type, struct loop *at_loop,
   gimple_stmt_iterator incr_gsi;
   bool insert_after;
   tree indx_before_incr, indx_after_incr;
-  gimple incr;
+  gimple *incr;
   tree step;
   bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info);
 
@@ -4078,7 +4078,7 @@ vect_create_data_ref_ptr (gimple stmt, tree aggr_type, struct loop *at_loop,
   /* Likewise for any of the data references in the stmt group.  */
   else if (STMT_VINFO_GROUP_SIZE (stmt_info) > 1)
     {
-      gimple orig_stmt = STMT_VINFO_GROUP_FIRST_ELEMENT (stmt_info);
+      gimple *orig_stmt = STMT_VINFO_GROUP_FIRST_ELEMENT (stmt_info);
       do
 	{
 	  stmt_vec_info sinfo = vinfo_for_stmt (orig_stmt);
@@ -4279,14 +4279,14 @@ vect_create_data_ref_ptr (gimple stmt, tree aggr_type, struct loop *at_loop,
 */
 
 tree
-bump_vector_ptr (tree dataref_ptr, gimple ptr_incr, gimple_stmt_iterator *gsi,
-		 gimple stmt, tree bump)
+bump_vector_ptr (tree dataref_ptr, gimple *ptr_incr, gimple_stmt_iterator *gsi,
+		 gimple *stmt, tree bump)
 {
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
   struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info);
   tree vectype = STMT_VINFO_VECTYPE (stmt_info);
   tree update = TYPE_SIZE_UNIT (vectype);
-  gimple incr_stmt;
+  gimple *incr_stmt;
   ssa_op_iter iter;
   use_operand_p use_p;
   tree new_dataref_ptr;
@@ -4475,12 +4475,12 @@ vect_store_lanes_supported (tree vectype, unsigned HOST_WIDE_INT count)
 void
 vect_permute_store_chain (vec<tree> dr_chain,
 			  unsigned int length,
-			  gimple stmt,
+			  gimple *stmt,
 			  gimple_stmt_iterator *gsi,
 			  vec<tree> *result_chain)
 {
   tree vect1, vect2, high, low;
-  gimple perm_stmt;
+  gimple *perm_stmt;
   tree vectype = STMT_VINFO_VECTYPE (vinfo_for_stmt (stmt));
   tree perm_mask_low, perm_mask_high;
   unsigned int i, n;
@@ -4587,7 +4587,7 @@ vect_permute_store_chain (vec<tree> dr_chain,
    Return value - the result of the loop-header phi node.  */
 
 tree
-vect_setup_realignment (gimple stmt, gimple_stmt_iterator *gsi,
+vect_setup_realignment (gimple *stmt, gimple_stmt_iterator *gsi,
                         tree *realignment_token,
 			enum dr_alignment_support alignment_support_scheme,
 			tree init_addr,
@@ -4601,14 +4601,14 @@ vect_setup_realignment (gimple stmt, gimple_stmt_iterator *gsi,
   edge pe = NULL;
   tree scalar_dest = gimple_assign_lhs (stmt);
   tree vec_dest;
-  gimple inc;
+  gimple *inc;
   tree ptr;
   tree data_ref;
-  gimple new_stmt;
+  gimple *new_stmt;
   basic_block new_bb;
   tree msq_init = NULL_TREE;
   tree new_temp;
-  gimple phi_stmt;
+  gimple *phi_stmt;
   tree msq = NULL_TREE;
   gimple_seq stmts = NULL;
   bool inv_p;
@@ -4974,14 +4974,14 @@ vect_load_lanes_supported (tree vectype, unsigned HOST_WIDE_INT count)
 static void
 vect_permute_load_chain (vec<tree> dr_chain,
 			 unsigned int length,
-			 gimple stmt,
+			 gimple *stmt,
 			 gimple_stmt_iterator *gsi,
 			 vec<tree> *result_chain)
 {
   tree data_ref, first_vect, second_vect;
   tree perm_mask_even, perm_mask_odd;
   tree perm3_mask_low, perm3_mask_high;
-  gimple perm_stmt;
+  gimple *perm_stmt;
   tree vectype = STMT_VINFO_VECTYPE (vinfo_for_stmt (stmt));
   unsigned int i, j, log_length = exact_log2 (length);
   unsigned nelt = TYPE_VECTOR_SUBPARTS (vectype);
@@ -5091,7 +5091,7 @@ vect_permute_load_chain (vec<tree> dr_chain,
 */
 
 void
-vect_transform_grouped_load (gimple stmt, vec<tree> dr_chain, int size,
+vect_transform_grouped_load (gimple *stmt, vec<tree> dr_chain, int size,
 			     gimple_stmt_iterator *gsi)
 {
   vec<tree> result_chain = vNULL;
@@ -5110,10 +5110,10 @@ vect_transform_grouped_load (gimple stmt, vec<tree> dr_chain, int size,
    for each vector to the associated scalar statement.  */
 
 void
-vect_record_grouped_load_vectors (gimple stmt, vec<tree> result_chain)
+vect_record_grouped_load_vectors (gimple *stmt, vec<tree> result_chain)
 {
-  gimple first_stmt = GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt));
-  gimple next_stmt, new_stmt;
+  gimple *first_stmt = GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt));
+  gimple *next_stmt, *new_stmt;
   unsigned int i, gap_count;
   tree tmp_data_ref;
 
@@ -5152,9 +5152,9 @@ vect_record_grouped_load_vectors (gimple stmt, vec<tree> result_chain)
             {
               if (!GROUP_SAME_DR_STMT (vinfo_for_stmt (next_stmt)))
                 {
- 	          gimple prev_stmt =
+ 	          gimple *prev_stmt =
 		    STMT_VINFO_VEC_STMT (vinfo_for_stmt (next_stmt));
-	          gimple rel_stmt =
+	          gimple *rel_stmt =
 		    STMT_VINFO_RELATED_STMT (vinfo_for_stmt (prev_stmt));
 	          while (rel_stmt)
 		    {
@@ -5233,7 +5233,7 @@ enum dr_alignment_support
 vect_supportable_dr_alignment (struct data_reference *dr,
                                bool check_aligned_accesses)
 {
-  gimple stmt = DR_STMT (dr);
+  gimple *stmt = DR_STMT (dr);
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
   tree vectype = STMT_VINFO_VECTYPE (stmt_info);
   enum machine_mode mode = TYPE_MODE (vectype);
diff --git a/gcc/tree-vect-generic.c b/gcc/tree-vect-generic.c
index 43a695d..e427504 100644
--- a/gcc/tree-vect-generic.c
+++ b/gcc/tree-vect-generic.c
@@ -619,7 +619,7 @@ expand_vector_divmod (gimple_stmt_iterator *gsi, tree type, tree op0,
 	      && expand_vec_cond_expr_p (type, type))
 	    {
 	      tree zero, cst, cond;
-	      gimple stmt;
+	      gimple *stmt;
 
 	      zero = build_zero_cst (type);
 	      cond = build2 (LT_EXPR, type, op0, zero);
@@ -835,7 +835,7 @@ expand_vector_divmod (gimple_stmt_iterator *gsi, tree type, tree op0,
 static void
 expand_vector_condition (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   tree type = gimple_expr_type (stmt);
   tree a = gimple_assign_rhs1 (stmt);
   tree a1 = a;
@@ -898,7 +898,7 @@ expand_vector_condition (gimple_stmt_iterator *gsi)
 
 static tree
 expand_vector_operation (gimple_stmt_iterator *gsi, tree type, tree compute_type,
-			 gimple assign, enum tree_code code)
+			 gimple *assign, enum tree_code code)
 {
   enum machine_mode compute_mode = TYPE_MODE (compute_type);
 
@@ -1004,7 +1004,7 @@ expand_vector_operation (gimple_stmt_iterator *gsi, tree type, tree compute_type
 static void
 optimize_vector_constructor (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   tree lhs = gimple_assign_lhs (stmt);
   tree rhs = gimple_assign_rhs1 (stmt);
   tree type = TREE_TYPE (rhs);
@@ -1012,7 +1012,7 @@ optimize_vector_constructor (gimple_stmt_iterator *gsi)
   bool all_same = true;
   constructor_elt *elt;
   tree *cst;
-  gimple g;
+  gimple *g;
   tree base = NULL_TREE;
   optab op;
 
@@ -1126,7 +1126,7 @@ static tree
 vector_element (gimple_stmt_iterator *gsi, tree vect, tree idx, tree *ptmpvec)
 {
   tree vect_type, vect_elt_type;
-  gimple asgn;
+  gimple *asgn;
   tree tmpvec;
   tree arraytype;
   bool need_asgn = true;
@@ -1153,7 +1153,7 @@ vector_element (gimple_stmt_iterator *gsi, tree vect, tree idx, tree *ptmpvec)
          simplification by looking through intermediate vector results.  */
       if (TREE_CODE (vect) == SSA_NAME)
 	{
-	  gimple def_stmt = SSA_NAME_DEF_STMT (vect);
+	  gimple *def_stmt = SSA_NAME_DEF_STMT (vect);
 	  if (is_gimple_assign (def_stmt)
 	      && (gimple_assign_rhs_code (def_stmt) == VECTOR_CST
 		  || gimple_assign_rhs_code (def_stmt) == CONSTRUCTOR))
@@ -1219,7 +1219,7 @@ vector_element (gimple_stmt_iterator *gsi, tree vect, tree idx, tree *ptmpvec)
 static void
 lower_vec_perm (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   tree mask = gimple_assign_rhs3 (stmt);
   tree vec0 = gimple_assign_rhs1 (stmt);
   tree vec1 = gimple_assign_rhs2 (stmt);
@@ -1237,7 +1237,7 @@ lower_vec_perm (gimple_stmt_iterator *gsi)
 
   if (TREE_CODE (mask) == SSA_NAME)
     {
-      gimple def_stmt = SSA_NAME_DEF_STMT (mask);
+      gimple *def_stmt = SSA_NAME_DEF_STMT (mask);
       if (is_gimple_assign (def_stmt)
 	  && gimple_assign_rhs_code (def_stmt) == VECTOR_CST)
 	mask = gimple_assign_rhs1 (def_stmt);
@@ -1339,7 +1339,7 @@ lower_vec_perm (gimple_stmt_iterator *gsi)
 static void
 expand_vector_operations_1 (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   tree lhs, rhs1, rhs2 = NULL, type, compute_type;
   enum tree_code code;
   enum machine_mode compute_mode;
@@ -1432,7 +1432,7 @@ expand_vector_operations_1 (gimple_stmt_iterator *gsi)
       if (VECTOR_INTEGER_TYPE_P (TREE_TYPE (rhs2)))
         {
           tree first;
-          gimple def_stmt;
+          gimple *def_stmt;
 
           if ((TREE_CODE (rhs2) == VECTOR_CST
 	       && (first = uniform_vector_p (rhs2)) != NULL_TREE)
diff --git a/gcc/tree-vect-loop-manip.c b/gcc/tree-vect-loop-manip.c
index 7b79ab1..015aa40 100644
--- a/gcc/tree-vect-loop-manip.c
+++ b/gcc/tree-vect-loop-manip.c
@@ -86,7 +86,7 @@ static void
 rename_variables_in_bb (basic_block bb)
 {
   gimple_stmt_iterator gsi;
-  gimple stmt;
+  gimple *stmt;
   use_operand_p use_p;
   ssa_op_iter iter;
   edge e;
@@ -135,7 +135,7 @@ adjust_debug_stmts_now (adjust_info *ai)
   tree orig_def = ai->from;
   tree new_def = ai->to;
   imm_use_iterator imm_iter;
-  gimple stmt;
+  gimple *stmt;
   basic_block bbdef = gimple_bb (SSA_NAME_DEF_STMT (orig_def));
 
   gcc_assert (dom_info_available_p (CDI_DOMINATORS));
@@ -222,7 +222,7 @@ adjust_debug_stmts (tree from, tree to, basic_block bb)
    transformations.  */
 
 static void
-adjust_phi_and_debug_stmts (gimple update_phi, edge e, tree new_def)
+adjust_phi_and_debug_stmts (gimple *update_phi, edge e, tree new_def)
 {
   tree orig_def = PHI_ARG_DEF_FROM_EDGE (update_phi, e);
 
@@ -391,8 +391,8 @@ static void
 slpeel_update_phi_nodes_for_guard1 (edge guard_edge, struct loop *loop,
                                     bool is_new_loop, basic_block *new_exit_bb)
 {
-  gimple orig_phi, new_phi;
-  gimple update_phi, update_phi2;
+  gimple *orig_phi, *new_phi;
+  gimple *update_phi, *update_phi2;
   tree guard_arg, loop_arg;
   basic_block new_merge_bb = guard_edge->dest;
   edge e = EDGE_SUCC (new_merge_bb, 0);
@@ -488,7 +488,7 @@ slpeel_update_phi_nodes_for_guard1 (edge guard_edge, struct loop *loop,
 	 set this earlier.  Verify the PHI has the same value.  */
       if (new_name)
 	{
-	  gimple phi = SSA_NAME_DEF_STMT (new_name);
+	  gimple *phi = SSA_NAME_DEF_STMT (new_name);
 	  gcc_assert (gimple_code (phi) == GIMPLE_PHI
 		      && gimple_bb (phi) == *new_exit_bb
 		      && (PHI_ARG_DEF_FROM_EDGE (phi, single_exit (loop))
@@ -531,8 +531,8 @@ static void
 slpeel_update_phi_nodes_for_guard2 (edge guard_edge, struct loop *loop,
                                     bool is_new_loop, basic_block *new_exit_bb)
 {
-  gimple orig_phi, new_phi;
-  gimple update_phi, update_phi2;
+  gimple *orig_phi, *new_phi;
+  gimple *update_phi, *update_phi2;
   tree guard_arg, loop_arg;
   basic_block new_merge_bb = guard_edge->dest;
   edge e = EDGE_SUCC (new_merge_bb, 0);
@@ -667,8 +667,8 @@ void
 slpeel_make_loop_iterate_ntimes (struct loop *loop, tree niters)
 {
   tree indx_before_incr, indx_after_incr;
-  gimple cond_stmt;
-  gimple orig_cond;
+  gimple *cond_stmt;
+  gimple *orig_cond;
   edge exit_edge = single_exit (loop);
   gimple_stmt_iterator loop_cond_gsi;
   gimple_stmt_iterator incr_gsi;
@@ -729,8 +729,8 @@ slpeel_duplicate_current_defs_from_edges (edge from, edge to)
        !gsi_end_p (gsi_from) && !gsi_end_p (gsi_to);
        gsi_next (&gsi_from), gsi_next (&gsi_to))
     {
-      gimple from_phi = gsi_stmt (gsi_from);
-      gimple to_phi = gsi_stmt (gsi_to);
+      gimple *from_phi = gsi_stmt (gsi_from);
+      gimple *to_phi = gsi_stmt (gsi_to);
       tree from_arg = PHI_ARG_DEF_FROM_EDGE (from_phi, from);
       tree to_arg = PHI_ARG_DEF_FROM_EDGE (to_phi, to);
       if (TREE_CODE (from_arg) == SSA_NAME
@@ -826,7 +826,7 @@ slpeel_tree_duplicate_loop_to_edge_cfg (struct loop *loop,
 	  for (gsi = gsi_start_phis (exit_dest); !gsi_end_p (gsi);
 	       gsi_next (&gsi))
 	    {
-	      gimple phi = gsi_stmt (gsi);
+	      gimple *phi = gsi_stmt (gsi);
 	      tree orig_arg = PHI_ARG_DEF_FROM_EDGE (phi, e);
 	      location_t orig_locus
 		= gimple_phi_arg_location_from_edge (phi, e);
@@ -895,8 +895,8 @@ slpeel_tree_duplicate_loop_to_edge_cfg (struct loop *loop,
 	   !gsi_end_p (gsi_orig) && !gsi_end_p (gsi_new);
 	   gsi_next (&gsi_orig), gsi_next (&gsi_new))
 	{
-	  gimple orig_phi = gsi_stmt (gsi_orig);
-	  gimple new_phi = gsi_stmt (gsi_new);
+	  gimple *orig_phi = gsi_stmt (gsi_orig);
+	  gimple *new_phi = gsi_stmt (gsi_new);
 	  tree orig_arg = PHI_ARG_DEF_FROM_EDGE (orig_phi, orig_e);
 	  location_t orig_locus
 	    = gimple_phi_arg_location_from_edge (orig_phi, orig_e);
@@ -929,7 +929,7 @@ slpeel_add_loop_guard (basic_block guard_bb, tree cond,
 {
   gimple_stmt_iterator gsi;
   edge new_e, enter_e;
-  gimple cond_stmt;
+  gimple *cond_stmt;
   gimple_seq gimplify_stmt_list = NULL;
 
   enter_e = EDGE_SUCC (guard_bb, 0);
@@ -974,7 +974,7 @@ slpeel_can_duplicate_loop_p (const struct loop *loop, const_edge e)
 {
   edge exit_e = single_exit (loop);
   edge entry_e = loop_preheader_edge (loop);
-  gimple orig_cond = get_loop_exit_condition (loop);
+  gimple *orig_cond = get_loop_exit_condition (loop);
   gimple_stmt_iterator loop_exit_gsi = gsi_last_bb (exit_e->src);
 
   if (loop->inner
@@ -1042,9 +1042,9 @@ set_prologue_iterations (basic_block bb_before_first_loop,
   basic_block cond_bb, then_bb;
   tree var, prologue_after_cost_adjust_name;
   gimple_stmt_iterator gsi;
-  gimple newphi;
+  gimple *newphi;
   edge e_true, e_false, e_fallthru;
-  gimple cond_stmt;
+  gimple *cond_stmt;
   gimple_seq stmts = NULL;
   tree cost_pre_condition = NULL_TREE;
   tree scalar_loop_iters =
@@ -1205,7 +1205,7 @@ slpeel_tree_peel_loop_to_edge (struct loop *loop, struct loop *scalar_loop,
   for (gsi = gsi_start_phis (loop->header); !gsi_end_p (gsi); gsi_next (&gsi))
     if (virtual_operand_p (gimple_phi_result (gsi_stmt (gsi))))
       {
-	gimple phi = gsi_stmt (gsi);
+	gimple *phi = gsi_stmt (gsi);
 	for (gsi = gsi_start_phis (exit_e->dest);
 	     !gsi_end_p (gsi); gsi_next (&gsi))
 	  if (virtual_operand_p (gimple_phi_result (gsi_stmt (gsi))))
@@ -1213,10 +1213,10 @@ slpeel_tree_peel_loop_to_edge (struct loop *loop, struct loop *scalar_loop,
 	if (gsi_end_p (gsi))
 	  {
 	    tree new_vop = copy_ssa_name (PHI_RESULT (phi), NULL);
-	    gimple new_phi = create_phi_node (new_vop, exit_e->dest);
+	    gimple *new_phi = create_phi_node (new_vop, exit_e->dest);
 	    tree vop = PHI_ARG_DEF_FROM_EDGE (phi, EDGE_SUCC (loop->latch, 0));
 	    imm_use_iterator imm_iter;
-	    gimple stmt;
+	    gimple *stmt;
 	    use_operand_p use_p;
 
 	    add_phi_arg (new_phi, vop, exit_e, UNKNOWN_LOCATION);
@@ -1482,7 +1482,7 @@ slpeel_tree_peel_loop_to_edge (struct loop *loop, struct loop *scalar_loop,
 source_location
 find_loop_location (struct loop *loop)
 {
-  gimple stmt = NULL;
+  gimple *stmt = NULL;
   basic_block bb;
   gimple_stmt_iterator si;
 
@@ -1528,7 +1528,7 @@ vect_can_advance_ivs_p (loop_vec_info loop_vinfo)
 {
   struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
   basic_block bb = loop->header;
-  gimple phi;
+  gimple *phi;
   gimple_stmt_iterator gsi;
 
   /* Analyze phi functions of the loop header.  */
@@ -1638,7 +1638,7 @@ vect_update_ivs_after_vectorizer (loop_vec_info loop_vinfo, tree niters,
 {
   struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
   basic_block exit_bb = single_exit (loop)->dest;
-  gimple phi, phi1;
+  gimple *phi, *phi1;
   gimple_stmt_iterator gsi, gsi1;
   basic_block update_bb = update_e->dest;
 
@@ -1843,7 +1843,7 @@ vect_gen_niters_for_prolog_loop (loop_vec_info loop_vinfo, tree loop_niters, int
   tree iters, iters_name;
   edge pe;
   basic_block new_bb;
-  gimple dr_stmt = DR_STMT (dr);
+  gimple *dr_stmt = DR_STMT (dr);
   stmt_vec_info stmt_info = vinfo_for_stmt (dr_stmt);
   tree vectype = STMT_VINFO_VECTYPE (stmt_info);
   int vectype_align = TYPE_ALIGN (vectype) / BITS_PER_UNIT;
@@ -2099,9 +2099,9 @@ vect_create_cond_for_align_checks (loop_vec_info loop_vinfo,
 				   gimple_seq *cond_expr_stmt_list)
 {
   struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
-  vec<gimple> may_misalign_stmts
+  vec<gimple *> may_misalign_stmts
     = LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo);
-  gimple ref_stmt;
+  gimple *ref_stmt;
   int mask = LOOP_VINFO_PTR_MASK (loop_vinfo);
   tree mask_cst;
   unsigned int i;
@@ -2109,7 +2109,7 @@ vect_create_cond_for_align_checks (loop_vec_info loop_vinfo,
   char tmp_name[20];
   tree or_tmp_name = NULL_TREE;
   tree and_tmp_name;
-  gimple and_stmt;
+  gimple *and_stmt;
   tree ptrsize_zero;
   tree part_cond_expr;
 
@@ -2128,7 +2128,7 @@ vect_create_cond_for_align_checks (loop_vec_info loop_vinfo,
       tree addr_base;
       tree addr_tmp_name;
       tree new_or_tmp_name;
-      gimple addr_stmt, or_stmt;
+      gimple *addr_stmt, *or_stmt;
       stmt_vec_info stmt_vinfo = vinfo_for_stmt (ref_stmt);
       tree vectype = STMT_VINFO_VECTYPE (stmt_vinfo);
       bool negative = tree_int_cst_compare
@@ -2321,7 +2321,7 @@ vect_loop_versioning (loop_vec_info loop_vinfo,
   basic_block merge_bb;
   basic_block new_exit_bb;
   edge new_exit_e, e;
-  gimple orig_phi, new_phi;
+  gimple *orig_phi, *new_phi;
   tree cond_expr = NULL_TREE;
   gimple_seq cond_expr_stmt_list = NULL;
   tree arg;
diff --git a/gcc/tree-vect-loop.c b/gcc/tree-vect-loop.c
index 1f6ac1a..6012510 100644
--- a/gcc/tree-vect-loop.c
+++ b/gcc/tree-vect-loop.c
@@ -190,13 +190,13 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo)
   gimple_stmt_iterator si;
   unsigned int vectorization_factor = 0;
   tree scalar_type;
-  gimple phi;
+  gimple *phi;
   tree vectype;
   unsigned int nunits;
   stmt_vec_info stmt_info;
   int i;
   HOST_WIDE_INT dummy;
-  gimple stmt, pattern_stmt = NULL;
+  gimple *stmt, *pattern_stmt = NULL;
   gimple_seq pattern_def_seq = NULL;
   gimple_stmt_iterator pattern_def_si = gsi_none ();
   bool analyze_pattern_stmt = false;
@@ -336,7 +336,7 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo)
 		gsi_next (&pattern_def_si);
 	      if (pattern_def_seq != NULL)
 		{
-		  gimple pattern_def_stmt = NULL;
+		  gimple *pattern_def_stmt = NULL;
 		  stmt_vec_info pattern_def_stmt_info = NULL;
 
 		  while (!gsi_end_p (pattern_def_si))
@@ -621,7 +621,7 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop)
 {
   basic_block bb = loop->header;
   tree init, step;
-  auto_vec<gimple, 64> worklist;
+  auto_vec<gimple *, 64> worklist;
   gimple_stmt_iterator gsi;
   bool double_reduc;
 
@@ -634,7 +634,7 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop)
      changed.  */
   for (gsi = gsi_start_phis  (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple phi = gsi_stmt (gsi);
+      gimple *phi = gsi_stmt (gsi);
       tree access_fn = NULL;
       tree def = PHI_RESULT (phi);
       stmt_vec_info stmt_vinfo = vinfo_for_stmt (phi);
@@ -689,10 +689,10 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop)
   /* Second - identify all reductions and nested cycles.  */
   while (worklist.length () > 0)
     {
-      gimple phi = worklist.pop ();
+      gimple *phi = worklist.pop ();
       tree def = PHI_RESULT (phi);
       stmt_vec_info stmt_vinfo = vinfo_for_stmt (phi);
-      gimple reduc_stmt;
+      gimple *reduc_stmt;
       bool nested_cycle;
 
       if (dump_enabled_p ())
@@ -805,7 +805,7 @@ vect_analyze_scalar_cycles (loop_vec_info loop_vinfo)
 
    Return the loop exit condition.  */
 
-static gimple
+static gimple *
 vect_get_loop_niters (struct loop *loop, tree *number_of_iterations,
 		      tree *number_of_iterationsm1)
 {
@@ -881,7 +881,7 @@ new_loop_vec_info (struct loop *loop)
           gcc_assert (loop->inner && bb->loop_father == loop->inner);
           for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
             {
-              gimple phi = gsi_stmt (si);
+              gimple *phi = gsi_stmt (si);
               stmt_vec_info stmt_info = vinfo_for_stmt (phi);
               loop_vec_info inner_loop_vinfo =
                 STMT_VINFO_LOOP_VINFO (stmt_info);
@@ -890,7 +890,7 @@ new_loop_vec_info (struct loop *loop)
             }
           for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
            {
-              gimple stmt = gsi_stmt (si);
+              gimple *stmt = gsi_stmt (si);
               stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
               loop_vec_info inner_loop_vinfo =
                  STMT_VINFO_LOOP_VINFO (stmt_info);
@@ -903,14 +903,14 @@ new_loop_vec_info (struct loop *loop)
           /* bb in current nest.  */
           for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
             {
-              gimple phi = gsi_stmt (si);
+              gimple *phi = gsi_stmt (si);
               gimple_set_uid (phi, 0);
               set_vinfo_for_stmt (phi, new_stmt_vec_info (phi, res, NULL));
             }
 
           for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
             {
-              gimple stmt = gsi_stmt (si);
+              gimple *stmt = gsi_stmt (si);
               gimple_set_uid (stmt, 0);
               set_vinfo_for_stmt (stmt, new_stmt_vec_info (stmt, res, NULL));
             }
@@ -993,7 +993,7 @@ destroy_loop_vec_info (loop_vec_info loop_vinfo, bool clean_stmts)
 
       for (si = gsi_start_bb (bb); !gsi_end_p (si); )
         {
-          gimple stmt = gsi_stmt (si);
+          gimple *stmt = gsi_stmt (si);
 
 	  /* We may have broken canonical form by moving a constant
 	     into RHS1 of a commutative op.  Fix such occurrences.  */
@@ -1085,7 +1085,7 @@ loop_vec_info
 vect_analyze_loop_form (struct loop *loop)
 {
   loop_vec_info loop_vinfo;
-  gimple loop_cond;
+  gimple *loop_cond;
   tree number_of_iterations = NULL, number_of_iterationsm1 = NULL;
   loop_vec_info inner_loop_vinfo = NULL;
 
@@ -1336,7 +1336,7 @@ vect_analyze_loop_operations (loop_vec_info loop_vinfo, bool slp)
   gimple_stmt_iterator si;
   unsigned int vectorization_factor = 0;
   int i;
-  gimple phi;
+  gimple *phi;
   stmt_vec_info stmt_info;
   bool need_to_vectorize = false;
   int min_profitable_iters;
@@ -1365,7 +1365,7 @@ vect_analyze_loop_operations (loop_vec_info loop_vinfo, bool slp)
 	  basic_block bb = bbs[i];
 	  for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
 	    {
-	      gimple stmt = gsi_stmt (si);
+	      gimple *stmt = gsi_stmt (si);
 	      stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
 	      gcc_assert (stmt_info);
 	      if ((STMT_VINFO_RELEVANT_P (stmt_info)
@@ -1431,7 +1431,7 @@ vect_analyze_loop_operations (loop_vec_info loop_vinfo, bool slp)
               if (STMT_VINFO_RELEVANT_P (stmt_info))
                 {
                   tree phi_op;
-                  gimple op_def_stmt;
+                  gimple *op_def_stmt;
 
                   if (gimple_phi_num_args (phi) != 1)
                     return false;
@@ -1500,7 +1500,7 @@ vect_analyze_loop_operations (loop_vec_info loop_vinfo, bool slp)
 
       for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
         {
-          gimple stmt = gsi_stmt (si);
+          gimple *stmt = gsi_stmt (si);
 	  if (!gimple_clobber_p (stmt)
 	      && !vect_analyze_stmt (stmt, &need_to_vectorize, NULL))
 	    return false;
@@ -1934,7 +1934,7 @@ reduction_code_for_scalar_code (enum tree_code code,
    STMT is printed with a message MSG. */
 
 static void
-report_vect_op (int msg_type, gimple stmt, const char *msg)
+report_vect_op (int msg_type, gimple *stmt, const char *msg)
 {
   dump_printf_loc (msg_type, vect_location, "%s", msg);
   dump_gimple_stmt (msg_type, TDF_SLIM, stmt, 0);
@@ -1959,12 +1959,12 @@ report_vect_op (int msg_type, gimple stmt, const char *msg)
    Return TRUE if a reduction chain was detected.  */
 
 static bool
-vect_is_slp_reduction (loop_vec_info loop_info, gimple phi, gimple first_stmt)
+vect_is_slp_reduction (loop_vec_info loop_info, gimple *phi, gimple *first_stmt)
 {
   struct loop *loop = (gimple_bb (phi))->loop_father;
   struct loop *vect_loop = LOOP_VINFO_LOOP (loop_info);
   enum tree_code code;
-  gimple current_stmt = NULL, loop_use_stmt = NULL, first, next_stmt;
+  gimple *current_stmt = NULL, *loop_use_stmt = NULL, *first, *next_stmt;
   stmt_vec_info use_stmt_info, current_stmt_info;
   tree lhs;
   imm_use_iterator imm_iter;
@@ -1983,7 +1983,7 @@ vect_is_slp_reduction (loop_vec_info loop_info, gimple phi, gimple first_stmt)
       n_out_of_loop_uses = 0;
       FOR_EACH_IMM_USE_FAST (use_p, imm_iter, lhs)
         {
-	  gimple use_stmt = USE_STMT (use_p);
+	  gimple *use_stmt = USE_STMT (use_p);
 	  if (is_gimple_debug (use_stmt))
 	    continue;
 
@@ -2058,7 +2058,7 @@ vect_is_slp_reduction (loop_vec_info loop_info, gimple phi, gimple first_stmt)
       if (gimple_assign_rhs2 (next_stmt) == lhs)
 	{
 	  tree op = gimple_assign_rhs1 (next_stmt);
-          gimple def_stmt = NULL;
+          gimple *def_stmt = NULL;
 
           if (TREE_CODE (op) == SSA_NAME)
             def_stmt = SSA_NAME_DEF_STMT (op);
@@ -2088,7 +2088,7 @@ vect_is_slp_reduction (loop_vec_info loop_info, gimple phi, gimple first_stmt)
       else
 	{
           tree op = gimple_assign_rhs2 (next_stmt);
-          gimple def_stmt = NULL;
+          gimple *def_stmt = NULL;
 
           if (TREE_CODE (op) == SSA_NAME)
             def_stmt = SSA_NAME_DEF_STMT (op);
@@ -2182,8 +2182,8 @@ vect_is_slp_reduction (loop_vec_info loop_info, gimple phi, gimple first_stmt)
    "res -= RHS" into "rhs += -RHS" when it seems worthwhile.
 */
 
-static gimple
-vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
+static gimple *
+vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple *phi,
 			    bool check_reduction, bool *double_reduc,
 			    bool modify)
 {
@@ -2191,7 +2191,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
   struct loop *vect_loop = LOOP_VINFO_LOOP (loop_info);
   edge latch_e = loop_latch_edge (loop);
   tree loop_arg = PHI_ARG_DEF_FROM_EDGE (phi, latch_e);
-  gimple def_stmt, def1 = NULL, def2 = NULL;
+  gimple *def_stmt, *def1 = NULL, *def2 = NULL;
   enum tree_code orig_code, code;
   tree op1, op2, op3 = NULL_TREE, op4 = NULL_TREE;
   tree type;
@@ -2218,7 +2218,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
   nloop_uses = 0;
   FOR_EACH_IMM_USE_FAST (use_p, imm_iter, name)
     {
-      gimple use_stmt = USE_STMT (use_p);
+      gimple *use_stmt = USE_STMT (use_p);
       if (is_gimple_debug (use_stmt))
 	continue;
 
@@ -2288,7 +2288,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
   nloop_uses = 0;
   FOR_EACH_IMM_USE_FAST (use_p, imm_iter, name)
     {
-      gimple use_stmt = USE_STMT (use_p);
+      gimple *use_stmt = USE_STMT (use_p);
       if (is_gimple_debug (use_stmt))
 	continue;
       if (flow_bb_inside_loop_p (loop, gimple_bb (use_stmt))
@@ -2487,7 +2487,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
     {
       tree rhs = gimple_assign_rhs2 (def_stmt);
       tree negrhs = make_ssa_name (TREE_TYPE (rhs), NULL);
-      gimple negate_stmt = gimple_build_assign_with_ops (NEGATE_EXPR, negrhs,
+      gimple *negate_stmt = gimple_build_assign_with_ops (NEGATE_EXPR, negrhs,
 							 rhs, NULL);
       gimple_stmt_iterator gsi = gsi_for_stmt (def_stmt);
       set_vinfo_for_stmt (negate_stmt, new_stmt_vec_info (negate_stmt, 
@@ -2597,8 +2597,8 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
 /* Wrapper around vect_is_simple_reduction_1, that won't modify code
    in-place.  Arguments as there.  */
 
-static gimple
-vect_is_simple_reduction (loop_vec_info loop_info, gimple phi,
+static gimple *
+vect_is_simple_reduction (loop_vec_info loop_info, gimple *phi,
                           bool check_reduction, bool *double_reduc)
 {
   return vect_is_simple_reduction_1 (loop_info, phi, check_reduction,
@@ -2609,8 +2609,8 @@ vect_is_simple_reduction (loop_vec_info loop_info, gimple phi,
    in-place if it enables detection of more reductions.  Arguments
    as there.  */
 
-gimple
-vect_force_simple_reduction (loop_vec_info loop_info, gimple phi,
+gimple *
+vect_force_simple_reduction (loop_vec_info loop_info, gimple *phi,
                           bool check_reduction, bool *double_reduc)
 {
   return vect_is_simple_reduction_1 (loop_info, phi, check_reduction,
@@ -2651,7 +2651,7 @@ vect_get_single_scalar_iteration_cost (loop_vec_info loop_vinfo)
 
       for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
         {
-          gimple stmt = gsi_stmt (si);
+          gimple *stmt = gsi_stmt (si);
           stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
 
           if (!is_gimple_assign (stmt) && !is_gimple_call (stmt))
@@ -3088,7 +3088,7 @@ vect_model_reduction_cost (stmt_vec_info stmt_info, enum tree_code reduc_code,
   enum tree_code code;
   optab optab;
   tree vectype;
-  gimple stmt, orig_stmt;
+  gimple *stmt, *orig_stmt;
   tree reduction_op;
   enum machine_mode mode;
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
@@ -3243,7 +3243,7 @@ vect_model_induction_cost (stmt_vec_info stmt_info, int ncopies)
    [X, X + S, X + 2*S, X + 3*S].  */
 
 static tree
-get_initial_def_for_induction (gimple iv_phi)
+get_initial_def_for_induction (gimple *iv_phi)
 {
   stmt_vec_info stmt_vinfo = vinfo_for_stmt (iv_phi);
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
@@ -3256,7 +3256,7 @@ get_initial_def_for_induction (gimple iv_phi)
   tree new_vec, vec_init, vec_step, t;
   tree new_var;
   tree new_name;
-  gimple init_stmt, induction_phi, new_stmt;
+  gimple *init_stmt, *induction_phi, *new_stmt;
   tree induc_def, vec_def, vec_dest;
   tree init_expr, step_expr;
   int vf = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
@@ -3268,7 +3268,7 @@ get_initial_def_for_induction (gimple iv_phi)
   gimple_seq stmts = NULL;
   imm_use_iterator imm_iter;
   use_operand_p use_p;
-  gimple exit_phi;
+  gimple *exit_phi;
   edge latch_e;
   tree loop_arg;
   gimple_stmt_iterator si;
@@ -3527,7 +3527,7 @@ get_initial_def_for_induction (gimple iv_phi)
       exit_phi = NULL;
       FOR_EACH_IMM_USE_FAST (use_p, imm_iter, loop_arg)
         {
-	  gimple use_stmt = USE_STMT (use_p);
+	  gimple *use_stmt = USE_STMT (use_p);
 	  if (is_gimple_debug (use_stmt))
 	    continue;
 
@@ -3633,7 +3633,7 @@ get_initial_def_for_induction (gimple iv_phi)
    A cost model should help decide between these two schemes.  */
 
 tree
-get_initial_def_for_reduction (gimple stmt, tree init_val,
+get_initial_def_for_reduction (gimple *stmt, tree init_val,
                                tree *adjustment_def)
 {
   stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt);
@@ -3651,7 +3651,7 @@ get_initial_def_for_reduction (gimple stmt, tree init_val,
   tree init_value;
   REAL_VALUE_TYPE real_init_val = dconst0;
   int int_init_val = 0;
-  gimple def_stmt = NULL;
+  gimple *def_stmt = NULL;
 
   gcc_assert (vectype);
   nunits = TYPE_VECTOR_SUBPARTS (vectype);
@@ -3837,9 +3837,9 @@ get_initial_def_for_reduction (gimple stmt, tree init_val,
 */
 
 static void
-vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple stmt,
+vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple *stmt,
 				  int ncopies, enum tree_code reduc_code,
-				  vec<gimple> reduction_phis,
+				  vec<gimple *> reduction_phis,
                                   int reduc_index, bool double_reduc, 
                                   slp_tree slp_node)
 {
@@ -3852,13 +3852,13 @@ vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple stmt,
   basic_block exit_bb;
   tree scalar_dest;
   tree scalar_type;
-  gimple new_phi = NULL, phi;
+  gimple *new_phi = NULL, *phi;
   gimple_stmt_iterator exit_gsi;
   tree vec_dest;
   tree new_temp = NULL_TREE, new_dest, new_name, new_scalar_dest;
-  gimple epilog_stmt = NULL;
+  gimple *epilog_stmt = NULL;
   enum tree_code code = gimple_assign_rhs_code (stmt);
-  gimple exit_phi;
+  gimple *exit_phi;
   tree bitsize, bitpos;
   tree adjustment_def = NULL;
   tree vec_initial_def = NULL;
@@ -3867,19 +3867,19 @@ vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple stmt,
   imm_use_iterator imm_iter, phi_imm_iter;
   use_operand_p use_p, phi_use_p;
   bool extract_scalar_result = false;
-  gimple use_stmt, orig_stmt, reduction_phi = NULL;
+  gimple *use_stmt, *orig_stmt, *reduction_phi = NULL;
   bool nested_in_vect_loop = false;
-  auto_vec<gimple> new_phis;
-  auto_vec<gimple> inner_phis;
+  auto_vec<gimple *> new_phis;
+  auto_vec<gimple *> inner_phis;
   enum vect_def_type dt = vect_unknown_def_type;
   int j, i;
   auto_vec<tree> scalar_results;
   unsigned int group_size = 1, k, ratio;
   auto_vec<tree> vec_initial_defs;
-  auto_vec<gimple> phis;
+  auto_vec<gimple *> phis;
   bool slp_reduc = false;
   tree new_phi_result;
-  gimple inner_phi = NULL;
+  gimple *inner_phi = NULL;
 
   if (slp_node)
     group_size = SLP_TREE_SCALAR_STMTS (slp_node).length (); 
@@ -4048,7 +4048,7 @@ vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple stmt,
       FOR_EACH_VEC_ELT (new_phis, i, phi)
 	{
 	  tree new_result = copy_ssa_name (PHI_RESULT (phi), NULL);
-	  gimple outer_phi = create_phi_node (new_result, exit_bb);
+	  gimple *outer_phi = create_phi_node (new_result, exit_bb);
 	  SET_PHI_ARG_DEF (outer_phi, single_exit (loop)->dest_idx,
 			   PHI_RESULT (phi));
 	  set_vinfo_for_stmt (outer_phi, new_stmt_vec_info (outer_phi,
@@ -4135,12 +4135,12 @@ vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple stmt,
     {
       tree first_vect = PHI_RESULT (new_phis[0]);
       tree tmp;
-      gimple new_vec_stmt = NULL;
+      gimple *new_vec_stmt = NULL;
 
       vec_dest = vect_create_destination_var (scalar_dest, vectype);
       for (k = 1; k < new_phis.length (); k++)
         {
-          gimple next_phi = new_phis[k];
+          gimple *next_phi = new_phis[k];
           tree second_vect = PHI_RESULT (next_phi);
 
           tmp = build2 (code, vectype,  first_vect, second_vect);
@@ -4323,7 +4323,7 @@ vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple stmt,
           if (slp_reduc)
             {
               tree res, first_res, new_res;
-              gimple new_stmt;
+              gimple *new_stmt;
             
               /* Reduce multiple scalar results in case of SLP unrolling.  */
               for (j = group_size; scalar_results.iterate (j, &res);
@@ -4486,7 +4486,7 @@ vect_finalize_reduction:
 
       if (slp_reduc)
         {
-          gimple current_stmt = SLP_TREE_SCALAR_STMTS (slp_node)[k];
+          gimple *current_stmt = SLP_TREE_SCALAR_STMTS (slp_node)[k];
 
           orig_stmt = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (current_stmt));
           /* SLP statements can't participate in patterns.  */
@@ -4511,7 +4511,7 @@ vect_finalize_reduction:
           if (outer_loop)
             {
               stmt_vec_info exit_phi_vinfo = vinfo_for_stmt (exit_phi);
-              gimple vect_phi;
+              gimple *vect_phi;
 
               /* FORNOW. Currently not supporting the case that an inner-loop
                  reduction is not used in the outer-loop (but only outside the
@@ -4547,7 +4547,7 @@ vect_finalize_reduction:
                   stmt_vec_info new_phi_vinfo;
                   tree vect_phi_init, preheader_arg, vect_phi_res, init_def;
                   basic_block bb = gimple_bb (use_stmt);
-                  gimple use;
+                  gimple *use;
 
                   /* Check that USE_STMT is really double reduction phi
                      node.  */
@@ -4707,8 +4707,8 @@ vect_finalize_reduction:
    does *NOT* necessarily hold for reduction patterns.  */
 
 bool
-vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi,
-			gimple *vec_stmt, slp_tree slp_node)
+vectorizable_reduction (gimple *stmt, gimple_stmt_iterator *gsi,
+			gimple **vec_stmt, slp_tree slp_node)
 {
   tree vec_dest;
   tree scalar_dest;
@@ -4724,12 +4724,12 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi,
   optab optab, reduc_optab;
   tree new_temp = NULL_TREE;
   tree def;
-  gimple def_stmt;
+  gimple *def_stmt;
   enum vect_def_type dt;
-  gimple new_phi = NULL;
+  gimple *new_phi = NULL;
   tree scalar_type;
   bool is_simple_use;
-  gimple orig_stmt;
+  gimple *orig_stmt;
   stmt_vec_info orig_stmt_info;
   tree expr = NULL_TREE;
   int i;
@@ -4738,22 +4738,22 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi,
   stmt_vec_info prev_stmt_info, prev_phi_info;
   bool single_defuse_cycle = false;
   tree reduc_def = NULL_TREE;
-  gimple new_stmt = NULL;
+  gimple *new_stmt = NULL;
   int j;
   tree ops[3];
   bool nested_cycle = false, found_nested_cycle_def = false;
-  gimple reduc_def_stmt = NULL;
+  gimple *reduc_def_stmt = NULL;
   /* The default is that the reduction variable is the last in statement.  */
   int reduc_index = 2;
   bool double_reduc = false, dummy;
   basic_block def_bb;
   struct loop * def_stmt_loop, *outer_loop = NULL;
   tree def_arg;
-  gimple def_arg_stmt;
+  gimple *def_arg_stmt;
   auto_vec<tree> vec_oprnds0;
   auto_vec<tree> vec_oprnds1;
   auto_vec<tree> vect_defs;
-  auto_vec<gimple> phis;
+  auto_vec<gimple *> phis;
   int vec_num;
   tree def0, def1, tem, op0, op1 = NULL_TREE;
 
@@ -4923,7 +4923,7 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi,
                                                        &dummy));
   else
     {
-      gimple tmp = vect_is_simple_reduction (loop_vinfo, reduc_def_stmt,
+      gimple *tmp = vect_is_simple_reduction (loop_vinfo, reduc_def_stmt,
                                              !nested_cycle, &dummy);
       /* We changed STMT to be the first stmt in reduction chain, hence we
          check that in this case the first element in the chain is STMT.  */
@@ -5275,7 +5275,7 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi,
           if (!slp_node)
             {
               enum vect_def_type dt;
-              gimple dummy_stmt;
+              gimple *dummy_stmt;
               tree dummy;
 
               vect_is_simple_use (ops[!reduc_index], stmt, loop_vinfo, NULL,
@@ -5407,8 +5407,8 @@ vect_min_worthwhile_factor (enum tree_code code)
    Return FALSE if not a vectorizable STMT, TRUE otherwise.  */
 
 bool
-vectorizable_induction (gimple phi, gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED,
-			gimple *vec_stmt)
+vectorizable_induction (gimple *phi, gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED,
+			gimple **vec_stmt)
 {
   stmt_vec_info stmt_info = vinfo_for_stmt (phi);
   tree vectype = STMT_VINFO_VECTYPE (stmt_info);
@@ -5424,7 +5424,7 @@ vectorizable_induction (gimple phi, gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED,
     {
       imm_use_iterator imm_iter;
       use_operand_p use_p;
-      gimple exit_phi;
+      gimple *exit_phi;
       edge latch_e;
       tree loop_arg;
 
@@ -5441,7 +5441,7 @@ vectorizable_induction (gimple phi, gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED,
       loop_arg = PHI_ARG_DEF_FROM_EDGE (phi, latch_e);
       FOR_EACH_IMM_USE_FAST (use_p, imm_iter, loop_arg)
 	{
-	  gimple use_stmt = USE_STMT (use_p);
+	  gimple *use_stmt = USE_STMT (use_p);
 	  if (is_gimple_debug (use_stmt))
 	    continue;
 
@@ -5504,9 +5504,9 @@ vectorizable_induction (gimple phi, gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED,
    it can be supported.  */
 
 bool
-vectorizable_live_operation (gimple stmt,
+vectorizable_live_operation (gimple *stmt,
 			     gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED,
-			     gimple *vec_stmt)
+			     gimple **vec_stmt)
 {
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
@@ -5515,7 +5515,7 @@ vectorizable_live_operation (gimple stmt,
   int op_type;
   tree op;
   tree def;
-  gimple def_stmt;
+  gimple *def_stmt;
   enum vect_def_type dt;
   enum tree_code code;
   enum gimple_rhs_class rhs_class;
@@ -5543,7 +5543,7 @@ vectorizable_live_operation (gimple stmt,
 
 	  FOR_EACH_IMM_USE_FAST (use_p, imm_iter, lhs)
 	    {
-	      gimple use_stmt = USE_STMT (use_p);
+	      gimple *use_stmt = USE_STMT (use_p);
 	      if (gimple_code (use_stmt) == GIMPLE_PHI
 		  && gimple_bb (use_stmt) == merge_bb)
 		{
@@ -5606,12 +5606,12 @@ vectorizable_live_operation (gimple stmt,
 /* Kill any debug uses outside LOOP of SSA names defined in STMT.  */
 
 static void
-vect_loop_kill_debug_uses (struct loop *loop, gimple stmt)
+vect_loop_kill_debug_uses (struct loop *loop, gimple *stmt)
 {
   ssa_op_iter op_iter;
   imm_use_iterator imm_iter;
   def_operand_p def_p;
-  gimple ustmt;
+  gimple *ustmt;
 
   FOR_EACH_PHI_OR_STMT_DEF (def_p, stmt, op_iter, SSA_OP_DEF)
     {
@@ -5703,7 +5703,7 @@ vect_generate_tmps_on_preheader (loop_vec_info loop_vinfo,
       if (!is_gimple_val (ni_minus_gap_name))
 	{
 	  var = create_tmp_var (TREE_TYPE (ni_name), "ni_gap");
-          gimple stmts = NULL;
+          gimple *stmts = NULL;
           ni_minus_gap_name = force_gimple_operand (ni_minus_gap_name, &stmts,
 						    true, var);
 	  gsi_insert_seq_on_edge_immediate (pe, stmts);
@@ -5729,7 +5729,7 @@ vect_generate_tmps_on_preheader (loop_vec_info loop_vinfo,
   if (!is_gimple_val (ratio_name))
     {
       var = create_tmp_var (TREE_TYPE (ni_name), "bnd");
-      gimple stmts = NULL;
+      gimple *stmts = NULL;
       ratio_name = force_gimple_operand (ratio_name, &stmts, true, var);
       gsi_insert_seq_on_edge_immediate (pe, stmts);
     }
@@ -5744,7 +5744,7 @@ vect_generate_tmps_on_preheader (loop_vec_info loop_vinfo,
       if (!is_gimple_val (ratio_mult_vf_name))
 	{
 	  var = create_tmp_var (TREE_TYPE (ni_name), "ratio_mult_vf");
-	  gimple stmts = NULL;
+	  gimple *stmts = NULL;
 	  ratio_mult_vf_name = force_gimple_operand (ratio_mult_vf_name, &stmts,
 						     true, var);
 	  gsi_insert_seq_on_edge_immediate (pe, stmts);
@@ -5774,7 +5774,7 @@ vect_transform_loop (loop_vec_info loop_vinfo)
   int vectorization_factor = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
   bool grouped_store;
   bool slp_scheduled = false;
-  gimple stmt, pattern_stmt;
+  gimple *stmt, *pattern_stmt;
   gimple_seq pattern_def_seq = NULL;
   gimple_stmt_iterator pattern_def_si = gsi_none ();
   bool transform_pattern_stmt = false;
@@ -5877,7 +5877,7 @@ vect_transform_loop (loop_vec_info loop_vinfo)
     {
       basic_block bb = bbs[i];
       stmt_vec_info stmt_info;
-      gimple phi;
+      gimple *phi;
 
       for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
         {
@@ -5991,7 +5991,7 @@ vect_transform_loop (loop_vec_info loop_vinfo)
 		gsi_next (&pattern_def_si);
 	      if (pattern_def_seq != NULL)
 		{
-		  gimple pattern_def_stmt = NULL;
+		  gimple *pattern_def_stmt = NULL;
 		  stmt_vec_info pattern_def_stmt_info = NULL;
 
 		  while (!gsi_end_p (pattern_def_si))
@@ -6089,7 +6089,7 @@ vect_transform_loop (loop_vec_info loop_vinfo)
 	      else
 		{
 		  /* Free the attached stmt_vec_info and remove the stmt.  */
-		  gimple store = gsi_stmt (si);
+		  gimple *store = gsi_stmt (si);
 		  free_stmt_vec_info (store);
 		  unlink_stmt_vdef (store);
 		  gsi_remove (&si, true);
diff --git a/gcc/tree-vect-patterns.c b/gcc/tree-vect-patterns.c
index 094cf04..ed34192 100644
--- a/gcc/tree-vect-patterns.c
+++ b/gcc/tree-vect-patterns.c
@@ -51,25 +51,25 @@ along with GCC; see the file COPYING3.  If not see
 #include "dumpfile.h"
 
 /* Pattern recognition functions  */
-static gimple vect_recog_widen_sum_pattern (vec<gimple> *, tree *,
+static gimple *vect_recog_widen_sum_pattern (vec<gimple *> *, tree *,
 					    tree *);
-static gimple vect_recog_widen_mult_pattern (vec<gimple> *, tree *,
+static gimple *vect_recog_widen_mult_pattern (vec<gimple *> *, tree *,
 					     tree *);
-static gimple vect_recog_dot_prod_pattern (vec<gimple> *, tree *,
+static gimple *vect_recog_dot_prod_pattern (vec<gimple *> *, tree *,
 					   tree *);
-static gimple vect_recog_pow_pattern (vec<gimple> *, tree *, tree *);
-static gimple vect_recog_over_widening_pattern (vec<gimple> *, tree *,
+static gimple *vect_recog_pow_pattern (vec<gimple *> *, tree *, tree *);
+static gimple *vect_recog_over_widening_pattern (vec<gimple *> *, tree *,
                                                  tree *);
-static gimple vect_recog_widen_shift_pattern (vec<gimple> *,
+static gimple *vect_recog_widen_shift_pattern (vec<gimple *> *,
 	                                tree *, tree *);
-static gimple vect_recog_rotate_pattern (vec<gimple> *, tree *, tree *);
-static gimple vect_recog_vector_vector_shift_pattern (vec<gimple> *,
+static gimple *vect_recog_rotate_pattern (vec<gimple *> *, tree *, tree *);
+static gimple *vect_recog_vector_vector_shift_pattern (vec<gimple *> *,
 						      tree *, tree *);
-static gimple vect_recog_divmod_pattern (vec<gimple> *,
+static gimple *vect_recog_divmod_pattern (vec<gimple *> *,
 					 tree *, tree *);
-static gimple vect_recog_mixed_size_cond_pattern (vec<gimple> *,
+static gimple *vect_recog_mixed_size_cond_pattern (vec<gimple *> *,
 						  tree *, tree *);
-static gimple vect_recog_bool_pattern (vec<gimple> *, tree *, tree *);
+static gimple *vect_recog_bool_pattern (vec<gimple *> *, tree *, tree *);
 static vect_recog_func_ptr vect_vect_recog_func_ptrs[NUM_PATTERNS] = {
 	vect_recog_widen_mult_pattern,
 	vect_recog_widen_sum_pattern,
@@ -84,14 +84,14 @@ static vect_recog_func_ptr vect_vect_recog_func_ptrs[NUM_PATTERNS] = {
 	vect_recog_bool_pattern};
 
 static inline void
-append_pattern_def_seq (stmt_vec_info stmt_info, gimple stmt)
+append_pattern_def_seq (stmt_vec_info stmt_info, gimple *stmt)
 {
   gimple_seq_add_stmt_without_update (&STMT_VINFO_PATTERN_DEF_SEQ (stmt_info),
 				      stmt);
 }
 
 static inline void
-new_pattern_def_seq (stmt_vec_info stmt_info, gimple stmt)
+new_pattern_def_seq (stmt_vec_info stmt_info, gimple *stmt)
 {
   STMT_VINFO_PATTERN_DEF_SEQ (stmt_info) = NULL;
   append_pattern_def_seq (stmt_info, stmt);
@@ -106,7 +106,7 @@ new_pattern_def_seq (stmt_vec_info stmt_info, gimple stmt)
    to be defined as well.  */
 
 static bool
-vect_same_loop_or_bb_p (gimple stmt1, gimple stmt2)
+vect_same_loop_or_bb_p (gimple *stmt1, gimple *stmt2)
 {
   stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt1);
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
@@ -135,12 +135,12 @@ vect_same_loop_or_bb_p (gimple stmt1, gimple stmt2)
 /* If the LHS of DEF_STMT has a single use, and that statement is
    in the same loop or basic block, return it.  */
 
-static gimple
-vect_single_imm_use (gimple def_stmt)
+static gimple *
+vect_single_imm_use (gimple *def_stmt)
 {
   tree lhs = gimple_assign_lhs (def_stmt);
   use_operand_p use_p;
-  gimple use_stmt;
+  gimple *use_stmt;
 
   if (!single_imm_use (lhs, &use_p, &use_stmt))
     return NULL;
@@ -159,11 +159,11 @@ vect_single_imm_use (gimple def_stmt)
    unsigned.  */
 
 static bool
-type_conversion_p (tree name, gimple use_stmt, bool check_sign,
-		   tree *orig_type, gimple *def_stmt, bool *promotion)
+type_conversion_p (tree name, gimple *use_stmt, bool check_sign,
+		   tree *orig_type, gimple **def_stmt, bool *promotion)
 {
   tree dummy;
-  gimple dummy_gimple;
+  gimple *dummy_gimple;
   loop_vec_info loop_vinfo;
   stmt_vec_info stmt_vinfo;
   tree type = TREE_TYPE (name);
@@ -217,7 +217,7 @@ type_conversion_p (tree name, gimple use_stmt, bool check_sign,
    is NULL, the caller must set SSA_NAME_DEF_STMT for the returned SSA var. */
 
 static tree
-vect_recog_temp_ssa_var (tree type, gimple stmt)
+vect_recog_temp_ssa_var (tree type, gimple *stmt)
 {
   return make_temp_ssa_name (type, stmt, "patt");
 }
@@ -267,16 +267,16 @@ vect_recog_temp_ssa_var (tree type, gimple stmt)
          the correct order (as is the case when this computation is in an
          inner-loop nested in an outer-loop that us being vectorized).  */
 
-static gimple
-vect_recog_dot_prod_pattern (vec<gimple> *stmts, tree *type_in,
+static gimple *
+vect_recog_dot_prod_pattern (vec<gimple *> *stmts, tree *type_in,
 			     tree *type_out)
 {
-  gimple stmt, last_stmt = (*stmts)[0];
+  gimple *stmt, *last_stmt = (*stmts)[0];
   tree oprnd0, oprnd1;
   tree oprnd00, oprnd01;
   stmt_vec_info stmt_vinfo = vinfo_for_stmt (last_stmt);
   tree type, half_type;
-  gimple pattern_stmt;
+  gimple *pattern_stmt;
   tree prod_type;
   loop_vec_info loop_info = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
   struct loop *loop;
@@ -334,7 +334,7 @@ vect_recog_dot_prod_pattern (vec<gimple> *stmts, tree *type_in,
     }
   else
     {
-      gimple def_stmt;
+      gimple *def_stmt;
 
       if (STMT_VINFO_DEF_TYPE (stmt_vinfo) != vect_reduction_def)
         return NULL;
@@ -398,7 +398,7 @@ vect_recog_dot_prod_pattern (vec<gimple> *stmts, tree *type_in,
   else
     {
       tree half_type0, half_type1;
-      gimple def_stmt;
+      gimple *def_stmt;
       tree oprnd0, oprnd1;
 
       oprnd0 = gimple_assign_rhs1 (stmt);
@@ -460,13 +460,13 @@ vect_recog_dot_prod_pattern (vec<gimple> *stmts, tree *type_in,
    with a_it = (interm_type) a_t;  */
 
 static bool
-vect_handle_widen_op_by_const (gimple stmt, enum tree_code code,
+vect_handle_widen_op_by_const (gimple *stmt, enum tree_code code,
 		               tree const_oprnd, tree *oprnd,
-   		               vec<gimple> *stmts, tree type,
-			       tree *half_type, gimple def_stmt)
+   		               vec<gimple *> *stmts, tree type,
+			       tree *half_type, gimple *def_stmt)
 {
   tree new_type, new_oprnd;
-  gimple new_stmt;
+  gimple *new_stmt;
 
   if (code != MULT_EXPR && code != LSHIFT_EXPR)
     return false;
@@ -604,15 +604,15 @@ vect_handle_widen_op_by_const (gimple stmt, enum tree_code code,
    returned stmt will be this type conversion stmt.
 */
 
-static gimple
-vect_recog_widen_mult_pattern (vec<gimple> *stmts,
+static gimple *
+vect_recog_widen_mult_pattern (vec<gimple *> *stmts,
                                tree *type_in, tree *type_out)
 {
-  gimple last_stmt = stmts->pop ();
-  gimple def_stmt0, def_stmt1;
+  gimple *last_stmt = stmts->pop ();
+  gimple *def_stmt0, *def_stmt1;
   tree oprnd0, oprnd1;
   tree type, half_type0, half_type1;
-  gimple new_stmt = NULL, pattern_stmt = NULL;
+  gimple *new_stmt = NULL, *pattern_stmt = NULL;
   tree vectype, vecitype;
   tree var;
   enum tree_code dummy_code;
@@ -672,7 +672,7 @@ vect_recog_widen_mult_pattern (vec<gimple> *stmts,
   if (TYPE_PRECISION (half_type0) != TYPE_PRECISION (half_type1))
     {
       tree* oprnd = NULL;
-      gimple def_stmt = NULL;
+      gimple *def_stmt = NULL;
 
       if (TYPE_PRECISION (half_type0) < TYPE_PRECISION (half_type1))
 	{
@@ -699,7 +699,7 @@ vect_recog_widen_mult_pattern (vec<gimple> *stmts,
      Use unsigned TYPE as the type for WIDEN_MULT_EXPR.  */
   if (TYPE_UNSIGNED (type) != TYPE_UNSIGNED (half_type0))
     {
-      gimple use_stmt;
+      gimple *use_stmt;
       tree use_lhs;
       tree use_type;
 
@@ -825,13 +825,13 @@ vect_recog_widen_mult_pattern (vec<gimple> *stmts,
 	x = sqrt (x)
 */
 
-static gimple
-vect_recog_pow_pattern (vec<gimple> *stmts, tree *type_in,
+static gimple *
+vect_recog_pow_pattern (vec<gimple *> *stmts, tree *type_in,
 			tree *type_out)
 {
-  gimple last_stmt = (*stmts)[0];
+  gimple *last_stmt = (*stmts)[0];
   tree fn, base, exp = NULL;
-  gimple stmt;
+  gimple *stmt;
   tree var;
 
   if (!is_gimple_call (last_stmt) || gimple_call_lhs (last_stmt) == NULL)
@@ -884,7 +884,7 @@ vect_recog_pow_pattern (vec<gimple> *stmts, tree *type_in,
       *type_in = get_vectype_for_scalar_type (TREE_TYPE (base));
       if (*type_in)
 	{
-	  gimple stmt = gimple_build_call (newfn, 1, base);
+	  gimple *stmt = gimple_build_call (newfn, 1, base);
 	  if (vectorizable_function (stmt, *type_in, *type_in)
 	      != NULL_TREE)
 	    {
@@ -938,15 +938,15 @@ vect_recog_pow_pattern (vec<gimple> *stmts, tree *type_in,
 	 the correct order (as is the case when this computation is in an
 	 inner-loop nested in an outer-loop that us being vectorized).  */
 
-static gimple
-vect_recog_widen_sum_pattern (vec<gimple> *stmts, tree *type_in,
+static gimple *
+vect_recog_widen_sum_pattern (vec<gimple *> *stmts, tree *type_in,
 			      tree *type_out)
 {
-  gimple stmt, last_stmt = (*stmts)[0];
+  gimple *stmt, *last_stmt = (*stmts)[0];
   tree oprnd0, oprnd1;
   stmt_vec_info stmt_vinfo = vinfo_for_stmt (last_stmt);
   tree type, half_type;
-  gimple pattern_stmt;
+  gimple *pattern_stmt;
   loop_vec_info loop_info = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
   struct loop *loop;
   tree var;
@@ -1049,14 +1049,14 @@ vect_recog_widen_sum_pattern (vec<gimple> *stmts, tree *type_in,
          the second pattern statement.  */
 
 static bool
-vect_operation_fits_smaller_type (gimple stmt, tree def, tree *new_type,
-                                  tree *op0, tree *op1, gimple *new_def_stmt,
-                                  vec<gimple> *stmts)
+vect_operation_fits_smaller_type (gimple *stmt, tree def, tree *new_type,
+                                  tree *op0, tree *op1, gimple **new_def_stmt,
+                                  vec<gimple *> *stmts)
 {
   enum tree_code code;
   tree const_oprnd, oprnd;
   tree interm_type = NULL_TREE, half_type, new_oprnd, type;
-  gimple def_stmt, new_stmt;
+  gimple *def_stmt, *new_stmt;
   bool first = false;
   bool promotion;
 
@@ -1255,12 +1255,12 @@ vect_operation_fits_smaller_type (gimple stmt, tree def, tree *new_type,
    be 'type' or some intermediate type.  For now, we expect S5 to be a type
    demotion operation.  We also check that S3 and S4 have only one use.  */
 
-static gimple
-vect_recog_over_widening_pattern (vec<gimple> *stmts,
+static gimple *
+vect_recog_over_widening_pattern (vec<gimple *> *stmts,
                                   tree *type_in, tree *type_out)
 {
-  gimple stmt = stmts->pop ();
-  gimple pattern_stmt = NULL, new_def_stmt, prev_stmt = NULL, use_stmt = NULL;
+  gimple *stmt = stmts->pop ();
+  gimple *pattern_stmt = NULL, *new_def_stmt, *prev_stmt = NULL, *use_stmt = NULL;
   tree op0, op1, vectype = NULL_TREE, use_lhs, use_type;
   tree var = NULL_TREE, new_type = NULL_TREE, new_oprnd;
   bool first;
@@ -1447,21 +1447,21 @@ vect_recog_over_widening_pattern (vec<gimple> *stmts,
     stmts that constitute the pattern.  In this case it will be:
     WIDEN_LSHIFT_EXPR <a_t, CONST>.  */
 
-static gimple
-vect_recog_widen_shift_pattern (vec<gimple> *stmts,
+static gimple *
+vect_recog_widen_shift_pattern (vec<gimple *> *stmts,
 				tree *type_in, tree *type_out)
 {
-  gimple last_stmt = stmts->pop ();
-  gimple def_stmt0;
+  gimple *last_stmt = stmts->pop ();
+  gimple *def_stmt0;
   tree oprnd0, oprnd1;
   tree type, half_type0;
-  gimple pattern_stmt;
+  gimple *pattern_stmt;
   tree vectype, vectype_out = NULL_TREE;
   tree var;
   enum tree_code dummy_code;
   int dummy_int;
   vec<tree>  dummy_vec;
-  gimple use_stmt;
+  gimple *use_stmt;
   bool promotion;
 
   if (!is_gimple_assign (last_stmt) || !vinfo_for_stmt (last_stmt))
@@ -1576,12 +1576,12 @@ vect_recog_widen_shift_pattern (vec<gimple> *stmts,
   * Return value: A new stmt that will be used to replace the rotate
     S0 stmt.  */
 
-static gimple
-vect_recog_rotate_pattern (vec<gimple> *stmts, tree *type_in, tree *type_out)
+static gimple *
+vect_recog_rotate_pattern (vec<gimple *> *stmts, tree *type_in, tree *type_out)
 {
-  gimple last_stmt = stmts->pop ();
+  gimple *last_stmt = stmts->pop ();
   tree oprnd0, oprnd1, lhs, var, var1, var2, vectype, type, stype, def, def2;
-  gimple pattern_stmt, def_stmt;
+  gimple *pattern_stmt, *def_stmt;
   enum tree_code rhs_code;
   stmt_vec_info stmt_vinfo = vinfo_for_stmt (last_stmt);
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
@@ -1837,13 +1837,13 @@ vect_recog_rotate_pattern (vec<gimple> *stmts, tree *type_in, tree *type_out)
   * Return value: A new stmt that will be used to replace the shift/rotate
     S3 stmt.  */
 
-static gimple
-vect_recog_vector_vector_shift_pattern (vec<gimple> *stmts,
+static gimple *
+vect_recog_vector_vector_shift_pattern (vec<gimple *> *stmts,
 					tree *type_in, tree *type_out)
 {
-  gimple last_stmt = stmts->pop ();
+  gimple *last_stmt = stmts->pop ();
   tree oprnd0, oprnd1, lhs, var;
-  gimple pattern_stmt, def_stmt;
+  gimple *pattern_stmt, *def_stmt;
   enum tree_code rhs_code;
   stmt_vec_info stmt_vinfo = vinfo_for_stmt (last_stmt);
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
@@ -1967,13 +1967,13 @@ vect_recog_vector_vector_shift_pattern (vec<gimple> *stmts,
   * Return value: A new stmt that will be used to replace the division
     S1 or modulo S4 stmt.  */
 
-static gimple
-vect_recog_divmod_pattern (vec<gimple> *stmts,
+static gimple *
+vect_recog_divmod_pattern (vec<gimple *> *stmts,
 			   tree *type_in, tree *type_out)
 {
-  gimple last_stmt = stmts->pop ();
+  gimple *last_stmt = stmts->pop ();
   tree oprnd0, oprnd1, vectype, itype, cond;
-  gimple pattern_stmt, def_stmt;
+  gimple *pattern_stmt, *def_stmt;
   enum tree_code rhs_code;
   stmt_vec_info stmt_vinfo = vinfo_for_stmt (last_stmt);
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
@@ -2449,20 +2449,20 @@ vect_recog_divmod_pattern (vec<gimple> *stmts,
 	a_it = x_t CMP y_t ? b_it : c_it;
 	a_T = (TYPE) a_it;  */
 
-static gimple
-vect_recog_mixed_size_cond_pattern (vec<gimple> *stmts, tree *type_in,
+static gimple *
+vect_recog_mixed_size_cond_pattern (vec<gimple *> *stmts, tree *type_in,
 				    tree *type_out)
 {
-  gimple last_stmt = (*stmts)[0];
+  gimple *last_stmt = (*stmts)[0];
   tree cond_expr, then_clause, else_clause;
   stmt_vec_info stmt_vinfo = vinfo_for_stmt (last_stmt), def_stmt_info;
   tree type, vectype, comp_vectype, itype = NULL_TREE, vecitype;
   enum machine_mode cmpmode;
-  gimple pattern_stmt, def_stmt;
+  gimple *pattern_stmt, *def_stmt;
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
   bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_vinfo);
   tree orig_type0 = NULL_TREE, orig_type1 = NULL_TREE;
-  gimple def_stmt0 = NULL, def_stmt1 = NULL;
+  gimple *def_stmt0 = NULL, *def_stmt1 = NULL;
   bool promotion;
   tree comp_scalar_type;
 
@@ -2587,7 +2587,7 @@ vect_recog_mixed_size_cond_pattern (vec<gimple> *stmts, tree *type_in,
 static bool
 check_bool_pattern (tree var, loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
 {
-  gimple def_stmt;
+  gimple *def_stmt;
   enum vect_def_type dt;
   tree def, rhs1;
   enum tree_code rhs_code;
@@ -2670,7 +2670,7 @@ static tree
 adjust_bool_pattern_cast (tree type, tree var)
 {
   stmt_vec_info stmt_vinfo = vinfo_for_stmt (SSA_NAME_DEF_STMT (var));
-  gimple cast_stmt, pattern_stmt;
+  gimple *cast_stmt, *pattern_stmt;
 
   gcc_assert (!STMT_VINFO_PATTERN_DEF_SEQ (stmt_vinfo));
   pattern_stmt = STMT_VINFO_RELATED_STMT (stmt_vinfo);
@@ -2695,13 +2695,13 @@ adjust_bool_pattern_cast (tree type, tree var)
 
 static tree
 adjust_bool_pattern (tree var, tree out_type, tree trueval,
-		     vec<gimple> *stmts)
+		     vec<gimple *> *stmts)
 {
-  gimple stmt = SSA_NAME_DEF_STMT (var);
+  gimple *stmt = SSA_NAME_DEF_STMT (var);
   enum tree_code rhs_code, def_rhs_code;
   tree itype, cond_expr, rhs1, rhs2, irhs1, irhs2;
   location_t loc;
-  gimple pattern_stmt, def_stmt;
+  gimple *pattern_stmt, *def_stmt;
 
   rhs1 = gimple_assign_rhs1 (stmt);
   rhs2 = gimple_assign_rhs2 (stmt);
@@ -2771,7 +2771,7 @@ adjust_bool_pattern (tree var, tree out_type, tree trueval,
 	  if (TYPE_PRECISION (TREE_TYPE (irhs1))
 	      == GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (def_rhs1))))
 	    {
-	      gimple tstmt;
+	      gimple *tstmt;
 	      stmt_vec_info stmt_def_vinfo = vinfo_for_stmt (def_stmt);
 	      irhs2 = adjust_bool_pattern (rhs2, out_type, irhs1, stmts);
 	      tstmt = stmts->pop ();
@@ -2796,7 +2796,7 @@ adjust_bool_pattern (tree var, tree out_type, tree trueval,
 	  if (TYPE_PRECISION (TREE_TYPE (irhs2))
 	      == GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (def_rhs1))))
 	    {
-	      gimple tstmt;
+	      gimple *tstmt;
 	      stmt_vec_info stmt_def_vinfo = vinfo_for_stmt (def_stmt);
 	      irhs1 = adjust_bool_pattern (rhs1, out_type, irhs2, stmts);
 	      tstmt = stmts->pop ();
@@ -2919,17 +2919,17 @@ adjust_bool_pattern (tree var, tree out_type, tree trueval,
 	S3'  c_T = a_T | b_T;
 	but the above is more efficient.  */
 
-static gimple
-vect_recog_bool_pattern (vec<gimple> *stmts, tree *type_in,
+static gimple *
+vect_recog_bool_pattern (vec<gimple *> *stmts, tree *type_in,
 			 tree *type_out)
 {
-  gimple last_stmt = stmts->pop ();
+  gimple *last_stmt = stmts->pop ();
   enum tree_code rhs_code;
   tree var, lhs, rhs, vectype;
   stmt_vec_info stmt_vinfo = vinfo_for_stmt (last_stmt);
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
   bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_vinfo);
-  gimple pattern_stmt;
+  gimple *pattern_stmt;
 
   if (!is_gimple_assign (last_stmt))
     return NULL;
@@ -2988,7 +2988,7 @@ vect_recog_bool_pattern (vec<gimple> *stmts, tree *type_in,
       if (!useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (rhs)))
 	{
 	  tree rhs2 = vect_recog_temp_ssa_var (TREE_TYPE (lhs), NULL);
-	  gimple cast_stmt
+	  gimple *cast_stmt
 	    = gimple_build_assign_with_ops (NOP_EXPR, rhs2, rhs, NULL_TREE);
 	  new_pattern_def_seq (stmt_vinfo, cast_stmt);
 	  rhs = rhs2;
@@ -3025,14 +3025,14 @@ vect_recog_bool_pattern (vec<gimple> *stmts, tree *type_in,
 /* Mark statements that are involved in a pattern.  */
 
 static inline void
-vect_mark_pattern_stmts (gimple orig_stmt, gimple pattern_stmt,
+vect_mark_pattern_stmts (gimple *orig_stmt, gimple *pattern_stmt,
                          tree pattern_vectype)
 {
   stmt_vec_info pattern_stmt_info, def_stmt_info;
   stmt_vec_info orig_stmt_info = vinfo_for_stmt (orig_stmt);
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (orig_stmt_info);
   bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (orig_stmt_info);
-  gimple def_stmt;
+  gimple *def_stmt;
 
   pattern_stmt_info = vinfo_for_stmt (pattern_stmt);
   if (pattern_stmt_info == NULL)
@@ -3099,16 +3099,16 @@ vect_mark_pattern_stmts (gimple orig_stmt, gimple pattern_stmt,
 static void
 vect_pattern_recog_1 (vect_recog_func_ptr vect_recog_func,
 		      gimple_stmt_iterator si,
-		      vec<gimple> *stmts_to_replace)
+		      vec<gimple *> *stmts_to_replace)
 {
-  gimple stmt = gsi_stmt (si), pattern_stmt;
+  gimple *stmt = gsi_stmt (si), *pattern_stmt;
   stmt_vec_info stmt_info;
   loop_vec_info loop_vinfo;
   tree pattern_vectype;
   tree type_in, type_out;
   enum tree_code code;
   int i;
-  gimple next;
+  gimple *next;
 
   stmts_to_replace->truncate (0);
   stmts_to_replace->quick_push (stmt);
@@ -3287,8 +3287,8 @@ vect_pattern_recog (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
   gimple_stmt_iterator si;
   unsigned int i, j;
   vect_recog_func_ptr vect_recog_func;
-  auto_vec<gimple, 1> stmts_to_replace;
-  gimple stmt;
+  auto_vec<gimple *, 1> stmts_to_replace;
+  gimple *stmt;
 
   if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
diff --git a/gcc/tree-vect-slp.c b/gcc/tree-vect-slp.c
index 0ab267f..9a79261 100644
--- a/gcc/tree-vect-slp.c
+++ b/gcc/tree-vect-slp.c
@@ -54,7 +54,7 @@ along with GCC; see the file COPYING3.  If not see
 source_location
 find_bb_location (basic_block bb)
 {
-  gimple stmt = NULL;
+  gimple *stmt = NULL;
   gimple_stmt_iterator si;
 
   if (!bb)
@@ -109,10 +109,10 @@ vect_free_slp_instance (slp_instance instance)
 /* Create an SLP node for SCALAR_STMTS.  */
 
 static slp_tree
-vect_create_new_slp_node (vec<gimple> scalar_stmts)
+vect_create_new_slp_node (vec<gimple *> scalar_stmts)
 {
   slp_tree node;
-  gimple stmt = scalar_stmts[0];
+  gimple *stmt = scalar_stmts[0];
   unsigned int nops;
 
   if (is_gimple_call (stmt))
@@ -182,9 +182,9 @@ vect_free_oprnd_info (vec<slp_oprnd_info> &oprnds_info)
    from FIRST_STMT.  Return -1 if the data-ref is not a part of the chain.  */
 
 static int
-vect_get_place_in_interleaving_chain (gimple stmt, gimple first_stmt)
+vect_get_place_in_interleaving_chain (gimple *stmt, gimple *first_stmt)
 {
-  gimple next_stmt = first_stmt;
+  gimple *next_stmt = first_stmt;
   int result = 0;
 
   if (first_stmt != GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt)))
@@ -209,13 +209,13 @@ vect_get_place_in_interleaving_chain (gimple stmt, gimple first_stmt)
 
 static bool
 vect_get_and_check_slp_defs (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
-                             gimple stmt, bool first,
+                             gimple *stmt, bool first,
                              vec<slp_oprnd_info> *oprnds_info)
 {
   tree oprnd;
   unsigned int i, number_of_oprnds;
   tree def;
-  gimple def_stmt;
+  gimple *def_stmt;
   enum vect_def_type dt = vect_uninitialized_def;
   struct loop *loop = NULL;
   bool pattern = false;
@@ -399,12 +399,12 @@ vect_get_and_check_slp_defs (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
 
 static bool
 vect_build_slp_tree_1 (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
-		       vec<gimple> stmts, unsigned int group_size,
+		       vec<gimple *> stmts, unsigned int group_size,
 		       unsigned nops, unsigned int *max_nunits,
 		       unsigned int vectorization_factor, bool *matches)
 {
   unsigned int i;
-  gimple stmt = stmts[0];
+  gimple *stmt = stmts[0];
   enum tree_code first_stmt_code = ERROR_MARK, rhs_code = ERROR_MARK;
   enum tree_code first_cond_code = ERROR_MARK;
   tree lhs;
@@ -416,7 +416,7 @@ vect_build_slp_tree_1 (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
   enum machine_mode vec_mode;
   struct data_reference *first_dr;
   HOST_WIDE_INT dummy;
-  gimple first_load = NULL, prev_first_load = NULL, old_first_load = NULL;
+  gimple *first_load = NULL, *prev_first_load = NULL, *old_first_load = NULL;
   tree cond;
 
   /* For every stmt in NODE find its def stmt/s.  */
@@ -630,7 +630,7 @@ vect_build_slp_tree_1 (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
 
 	  if (rhs_code == CALL_EXPR)
 	    {
-	      gimple first_stmt = stmts[0];
+	      gimple *first_stmt = stmts[0];
 	      if (gimple_call_num_args (stmt) != nops
 		  || !operand_equal_p (gimple_call_fn (first_stmt),
 				       gimple_call_fn (stmt), 0)
@@ -853,7 +853,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
 		     unsigned max_tree_size)
 {
   unsigned nops, i, this_npermutes = 0, this_tree_size = 0;
-  gimple stmt;
+  gimple *stmt;
 
   if (!matches)
     matches = XALLOCAVEC (bool, group_size);
@@ -961,7 +961,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
 	  for (unsigned j = 0; j < group_size; ++j)
 	    if (!matches[j])
 	      {
-		gimple tem = oprnds_info[0]->def_stmts[j];
+		gimple *tem = oprnds_info[0]->def_stmts[j];
 		oprnds_info[0]->def_stmts[j] = oprnds_info[1]->def_stmts[j];
 		oprnds_info[1]->def_stmts[j] = tem;
 	      }
@@ -999,7 +999,7 @@ static void
 vect_print_slp_tree (int dump_kind, slp_tree node)
 {
   int i;
-  gimple stmt;
+  gimple *stmt;
   slp_tree child;
 
   if (!node)
@@ -1027,7 +1027,7 @@ static void
 vect_mark_slp_stmts (slp_tree node, enum slp_vect_type mark, int j)
 {
   int i;
-  gimple stmt;
+  gimple *stmt;
   slp_tree child;
 
   if (!node)
@@ -1048,7 +1048,7 @@ static void
 vect_mark_slp_stmts_relevant (slp_tree node)
 {
   int i;
-  gimple stmt;
+  gimple *stmt;
   stmt_vec_info stmt_info;
   slp_tree child;
 
@@ -1074,8 +1074,8 @@ static void
 vect_slp_rearrange_stmts (slp_tree node, unsigned int group_size,
                           vec<unsigned> permutation)
 {
-  gimple stmt;
-  vec<gimple> tmp_stmts;
+  gimple *stmt;
+  vec<gimple *> tmp_stmts;
   unsigned int i;
   slp_tree child;
 
@@ -1104,7 +1104,7 @@ vect_supported_load_permutation_p (slp_instance slp_instn)
   unsigned int i, j, k, next;
   sbitmap load_index;
   slp_tree node;
-  gimple stmt, load, next_load, first_load;
+  gimple *stmt, *load, *next_load, *first_load;
   struct data_reference *dr;
 
   if (dump_enabled_p ())
@@ -1294,12 +1294,12 @@ vect_supported_load_permutation_p (slp_instance slp_instn)
    they must be inserted before the first load of the SLP instance and not
    before the first load of the first node of the instance.  */
 
-static gimple
+static gimple *
 vect_find_first_load_in_slp_instance (slp_instance instance)
 {
   int i, j;
   slp_tree load_node;
-  gimple first_load = NULL, load;
+  gimple *first_load = NULL, *load;
 
   FOR_EACH_VEC_ELT (SLP_INSTANCE_LOADS (instance), i, load_node)
     FOR_EACH_VEC_ELT (SLP_TREE_SCALAR_STMTS (load_node), j, load)
@@ -1311,12 +1311,12 @@ vect_find_first_load_in_slp_instance (slp_instance instance)
 
 /* Find the last store in SLP INSTANCE.  */
 
-static gimple
+static gimple *
 vect_find_last_store_in_slp_instance (slp_instance instance)
 {
   int i;
   slp_tree node;
-  gimple last_store = NULL, store;
+  gimple *last_store = NULL, *store;
 
   node = SLP_INSTANCE_TREE (instance);
   for (i = 0; SLP_TREE_SCALAR_STMTS (node).iterate (i, &store); i++)
@@ -1337,7 +1337,7 @@ vect_analyze_slp_cost_1 (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
 
   unsigned i;
   slp_tree child;
-  gimple stmt, s;
+  gimple *stmt, *s;
   stmt_vec_info stmt_info;
   tree lhs;
   unsigned group_size = SLP_INSTANCE_GROUP_SIZE (instance);
@@ -1390,7 +1390,7 @@ vect_analyze_slp_cost_1 (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
   for (i = 0; i < gimple_num_ops (stmt); ++i)
     {
       tree def, op = gimple_op (stmt, i);
-      gimple def_stmt;
+      gimple *def_stmt;
       enum vect_def_type dt;
       if (!op || op == lhs)
 	continue;
@@ -1448,20 +1448,20 @@ vect_analyze_slp_cost (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
 
 static bool
 vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
-                           gimple stmt, unsigned max_tree_size)
+                           gimple *stmt, unsigned max_tree_size)
 {
   slp_instance new_instance;
   slp_tree node;
   unsigned int group_size = GROUP_SIZE (vinfo_for_stmt (stmt));
   unsigned int unrolling_factor = 1, nunits;
   tree vectype, scalar_type = NULL_TREE;
-  gimple next;
+  gimple *next;
   unsigned int vectorization_factor = 0;
   int i;
   unsigned int max_nunits = 0;
   vec<slp_tree> loads;
   struct data_reference *dr = STMT_VINFO_DATA_REF (vinfo_for_stmt (stmt));
-  vec<gimple> scalar_stmts;
+  vec<gimple *> scalar_stmts;
 
   if (GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt)))
     {
@@ -1536,7 +1536,7 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
   else
     {
       /* Collect reduction statements.  */
-      vec<gimple> reductions = LOOP_VINFO_REDUCTIONS (loop_vinfo);
+      vec<gimple *> reductions = LOOP_VINFO_REDUCTIONS (loop_vinfo);
       for (i = 0; reductions.iterate (i, &next); i++)
 	scalar_stmts.safe_push (next);
     }
@@ -1583,7 +1583,7 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
 	{
 	  vec<unsigned> load_permutation;
 	  int j;
-	  gimple load, first_stmt;
+	  gimple *load, *first_stmt;
 	  bool this_load_permuted = false;
 	  load_permutation.create (group_size);
 	  first_stmt = GROUP_FIRST_ELEMENT
@@ -1658,10 +1658,10 @@ vect_analyze_slp (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo,
 		  unsigned max_tree_size)
 {
   unsigned int i;
-  vec<gimple> grouped_stores;
-  vec<gimple> reductions = vNULL;
-  vec<gimple> reduc_chains = vNULL;
-  gimple first_element;
+  vec<gimple *> grouped_stores;
+  vec<gimple *> reductions = vNULL;
+  vec<gimple *> reduc_chains = vNULL;
+  gimple *first_element;
   bool ok = false;
 
   if (dump_enabled_p ())
@@ -1764,10 +1764,10 @@ static void
 vect_detect_hybrid_slp_stmts (slp_tree node)
 {
   int i;
-  vec<gimple> stmts = SLP_TREE_SCALAR_STMTS (node);
-  gimple stmt = stmts[0];
+  vec<gimple *> stmts = SLP_TREE_SCALAR_STMTS (node);
+  gimple *stmt = stmts[0];
   imm_use_iterator imm_iter;
-  gimple use_stmt;
+  gimple *use_stmt;
   stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt);
   slp_tree child;
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
@@ -1836,7 +1836,7 @@ new_bb_vec_info (basic_block bb)
 
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       gimple_set_uid (stmt, 0);
       set_vinfo_for_stmt (stmt, new_stmt_vec_info (stmt, NULL, res));
     }
@@ -1869,7 +1869,7 @@ destroy_bb_vec_info (bb_vec_info bb_vinfo)
 
   for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
     {
-      gimple stmt = gsi_stmt (si);
+      gimple *stmt = gsi_stmt (si);
       stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
 
       if (stmt_info)
@@ -1898,7 +1898,7 @@ vect_slp_analyze_node_operations (bb_vec_info bb_vinfo, slp_tree node)
 {
   bool dummy;
   int i;
-  gimple stmt;
+  gimple *stmt;
   slp_tree child;
 
   if (!node)
@@ -1961,7 +1961,7 @@ vect_bb_slp_scalar_cost (basic_block bb,
 {
   unsigned scalar_cost = 0;
   unsigned i;
-  gimple stmt;
+  gimple *stmt;
   slp_tree child;
 
   FOR_EACH_VEC_ELT (SLP_TREE_SCALAR_STMTS (node), i, stmt)
@@ -1982,7 +1982,7 @@ vect_bb_slp_scalar_cost (basic_block bb,
       FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, op_iter, SSA_OP_DEF)
 	{
 	  imm_use_iterator use_iter;
-	  gimple use_stmt;
+	  gimple *use_stmt;
 	  FOR_EACH_IMM_USE_STMT (use_stmt, use_iter, DEF_FROM_PTR (def_p))
 	    if (!is_gimple_debug (use_stmt)
 		&& (gimple_code (use_stmt) == GIMPLE_PHI
@@ -2240,7 +2240,7 @@ vect_slp_analyze_bb (basic_block bb)
 
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
-      gimple stmt = gsi_stmt (gsi);
+      gimple *stmt = gsi_stmt (gsi);
       if (!is_gimple_debug (stmt)
           && !gimple_nop_p (stmt)
           && gimple_code (stmt) != GIMPLE_LABEL)
@@ -2336,8 +2336,8 @@ vect_get_constant_vectors (tree op, slp_tree slp_node,
 			   unsigned int op_num, unsigned int number_of_vectors,
                            int reduc_index)
 {
-  vec<gimple> stmts = SLP_TREE_SCALAR_STMTS (slp_node);
-  gimple stmt = stmts[0];
+  vec<gimple *> stmts = SLP_TREE_SCALAR_STMTS (slp_node);
+  gimple *stmt = stmts[0];
   stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt);
   unsigned nunits;
   tree vec_cst;
@@ -2353,7 +2353,7 @@ vect_get_constant_vectors (tree op, slp_tree slp_node,
   bool constant_p, is_store;
   tree neutral_op = NULL;
   enum tree_code code = gimple_expr_code (stmt);
-  gimple def_stmt;
+  gimple *def_stmt;
   struct loop *loop;
   gimple_seq ctor_seq = NULL;
 
@@ -2526,7 +2526,7 @@ vect_get_constant_vectors (tree op, slp_tree slp_node,
 		{
 		  tree new_temp
 		    = make_ssa_name (TREE_TYPE (vector_type), NULL);
-		  gimple init_stmt;
+		  gimple *init_stmt;
 		  op = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (vector_type),
 			       op);		  
 		  init_stmt
@@ -2559,7 +2559,7 @@ vect_get_constant_vectors (tree op, slp_tree slp_node,
 						    vector_type, NULL));
 	      if (ctor_seq != NULL)
 		{
-		  gimple init_stmt = SSA_NAME_DEF_STMT (voprnds.last ());
+		  gimple *init_stmt = SSA_NAME_DEF_STMT (voprnds.last ());
 		  gimple_stmt_iterator gsi = gsi_for_stmt (init_stmt);
 		  gsi_insert_seq_before_without_update (&gsi, ctor_seq,
 							GSI_SAME_STMT);
@@ -2611,7 +2611,7 @@ static void
 vect_get_slp_vect_defs (slp_tree slp_node, vec<tree> *vec_oprnds)
 {
   tree vec_oprnd;
-  gimple vec_def_stmt;
+  gimple *vec_def_stmt;
   unsigned int i;
 
   gcc_assert (SLP_TREE_VEC_STMTS (slp_node).exists ());
@@ -2636,7 +2636,7 @@ void
 vect_get_slp_defs (vec<tree> ops, slp_tree slp_node,
 		   vec<vec<tree> > *vec_oprnds, int reduc_index)
 {
-  gimple first_stmt;
+  gimple *first_stmt;
   int number_of_vects = 0, i;
   unsigned int child_index = 0;
   HOST_WIDE_INT lhs_size_unit, rhs_size_unit;
@@ -2660,8 +2660,8 @@ vect_get_slp_defs (vec<tree> ops, slp_tree slp_node,
           child = SLP_TREE_CHILDREN (slp_node)[child_index];
 
 	  /* We have to check both pattern and original def, if available.  */
-	  gimple first_def = SLP_TREE_SCALAR_STMTS (child)[0];
-	  gimple related = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (first_def));
+	  gimple *first_def = SLP_TREE_SCALAR_STMTS (child)[0];
+	  gimple *related = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (first_def));
 
 	  if (operand_equal_p (oprnd, gimple_get_lhs (first_def), 0)
 	      || (related
@@ -2728,14 +2728,14 @@ vect_get_slp_defs (vec<tree> ops, slp_tree slp_node,
    the created stmts must be inserted.  */
 
 static inline void
-vect_create_mask_and_perm (gimple stmt, gimple next_scalar_stmt,
+vect_create_mask_and_perm (gimple *stmt, gimple *next_scalar_stmt,
                            tree mask, int first_vec_indx, int second_vec_indx,
                            gimple_stmt_iterator *gsi, slp_tree node,
                            tree vectype, vec<tree> dr_chain,
                            int ncopies, int vect_stmts_counter)
 {
   tree perm_dest;
-  gimple perm_stmt = NULL;
+  gimple *perm_stmt = NULL;
   stmt_vec_info next_stmt_info;
   int i, stride;
   tree first_vec, second_vec, data_ref;
@@ -2781,7 +2781,7 @@ vect_create_mask_and_perm (gimple stmt, gimple next_scalar_stmt,
    the next vector, i.e., the current first vector is not needed.  */
 
 static bool
-vect_get_mask_element (gimple stmt, int first_mask_element, int m,
+vect_get_mask_element (gimple *stmt, int first_mask_element, int m,
                        int mask_nunits, bool only_one_vec, int index,
 		       unsigned char *mask, int *current_mask_element,
                        bool *need_next_vector, int *number_of_mask_fixes,
@@ -2868,12 +2868,12 @@ vect_transform_slp_perm_load (slp_tree node, vec<tree> dr_chain,
                               gimple_stmt_iterator *gsi, int vf,
                               slp_instance slp_node_instance, bool analyze_only)
 {
-  gimple stmt = SLP_TREE_SCALAR_STMTS (node)[0];
+  gimple *stmt = SLP_TREE_SCALAR_STMTS (node)[0];
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
   tree mask_element_type = NULL_TREE, mask_type;
   int i, j, k, nunits, vec_index = 0, scalar_index;
   tree vectype = STMT_VINFO_VECTYPE (stmt_info);
-  gimple next_scalar_stmt;
+  gimple *next_scalar_stmt;
   int group_size = SLP_INSTANCE_GROUP_SIZE (slp_node_instance);
   int first_mask_element;
   int index, unroll_factor, current_mask_element, ncopies;
@@ -3024,7 +3024,7 @@ static bool
 vect_schedule_slp_instance (slp_tree node, slp_instance instance,
                             unsigned int vectorization_factor)
 {
-  gimple stmt;
+  gimple *stmt;
   bool grouped_store, is_store;
   gimple_stmt_iterator si;
   stmt_vec_info stmt_info;
@@ -3083,7 +3083,7 @@ vect_schedule_slp_instance (slp_tree node, slp_instance instance,
   if (STMT_VINFO_GROUPED_ACCESS (stmt_info)
       && REFERENCE_CLASS_P (gimple_get_lhs (stmt)))
     { 
-      gimple last_store = vect_find_last_store_in_slp_instance (instance);
+      gimple *last_store = vect_find_last_store_in_slp_instance (instance);
       if (is_pattern_stmt_p (vinfo_for_stmt (last_store)))
        last_store = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (last_store));
       si = gsi_for_stmt (last_store);
@@ -3111,7 +3111,7 @@ vect_schedule_slp_instance (slp_tree node, slp_instance instance,
 static void
 vect_remove_slp_scalar_calls (slp_tree node)
 {
-  gimple stmt, new_stmt;
+  gimple *stmt, *new_stmt;
   gimple_stmt_iterator gsi;
   int i;
   slp_tree child;
@@ -3178,7 +3178,7 @@ vect_schedule_slp (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
   FOR_EACH_VEC_ELT (slp_instances, i, instance)
     {
       slp_tree root = SLP_INSTANCE_TREE (instance);
-      gimple store;
+      gimple *store;
       unsigned int j;
       gimple_stmt_iterator gsi;
 
@@ -3228,7 +3228,7 @@ vect_slp_transform_bb (basic_block bb)
 
   for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
     {
-      gimple stmt = gsi_stmt (si);
+      gimple *stmt = gsi_stmt (si);
       stmt_vec_info stmt_info;
 
       if (dump_enabled_p ())
diff --git a/gcc/tree-vect-stmts.c b/gcc/tree-vect-stmts.c
index ec9cc68..1b21253 100644
--- a/gcc/tree-vect-stmts.c
+++ b/gcc/tree-vect-stmts.c
@@ -72,7 +72,7 @@ stmt_vectype (struct _stmt_vec_info *stmt_info)
 bool
 stmt_in_inner_loop_p (struct _stmt_vec_info *stmt_info)
 {
-  gimple stmt = STMT_VINFO_STMT (stmt_info);
+  gimple *stmt = STMT_VINFO_STMT (stmt_info);
   basic_block bb = gimple_bb (stmt);
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
   struct loop* loop;
@@ -135,11 +135,11 @@ create_vector_array (tree elem_type, unsigned HOST_WIDE_INT nelems)
    with scalar destination SCALAR_DEST.  */
 
 static tree
-read_vector_array (gimple stmt, gimple_stmt_iterator *gsi, tree scalar_dest,
+read_vector_array (gimple *stmt, gimple_stmt_iterator *gsi, tree scalar_dest,
 		   tree array, unsigned HOST_WIDE_INT n)
 {
   tree vect_type, vect, vect_name, array_ref;
-  gimple new_stmt;
+  gimple *new_stmt;
 
   gcc_assert (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE);
   vect_type = TREE_TYPE (TREE_TYPE (array));
@@ -161,11 +161,11 @@ read_vector_array (gimple stmt, gimple_stmt_iterator *gsi, tree scalar_dest,
    The store is part of the vectorization of STMT.  */
 
 static void
-write_vector_array (gimple stmt, gimple_stmt_iterator *gsi, tree vect,
+write_vector_array (gimple *stmt, gimple_stmt_iterator *gsi, tree vect,
 		    tree array, unsigned HOST_WIDE_INT n)
 {
   tree array_ref;
-  gimple new_stmt;
+  gimple *new_stmt;
 
   array_ref = build4 (ARRAY_REF, TREE_TYPE (vect), array,
 		      build_int_cst (size_type_node, n),
@@ -198,14 +198,14 @@ create_array_ref (tree type, tree ptr, struct data_reference *first_dr)
    Mark STMT as "relevant for vectorization" and add it to WORKLIST.  */
 
 static void
-vect_mark_relevant (vec<gimple> *worklist, gimple stmt,
+vect_mark_relevant (vec<gimple *> *worklist, gimple *stmt,
 		    enum vect_relevant relevant, bool live_p,
 		    bool used_in_pattern)
 {
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
   enum vect_relevant save_relevant = STMT_VINFO_RELEVANT (stmt_info);
   bool save_live_p = STMT_VINFO_LIVE_P (stmt_info);
-  gimple pattern_stmt;
+  gimple *pattern_stmt;
 
   if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
@@ -222,7 +222,7 @@ vect_mark_relevant (vec<gimple> *worklist, gimple stmt,
         {
           imm_use_iterator imm_iter;
           use_operand_p use_p;
-          gimple use_stmt;
+          gimple *use_stmt;
           tree lhs;
 	  loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
 	  struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
@@ -305,7 +305,7 @@ vect_mark_relevant (vec<gimple> *worklist, gimple stmt,
    CHECKME: what other side effects would the vectorizer allow?  */
 
 static bool
-vect_stmt_relevant_p (gimple stmt, loop_vec_info loop_vinfo,
+vect_stmt_relevant_p (gimple *stmt, loop_vec_info loop_vinfo,
 		      enum vect_relevant *relevant, bool *live_p)
 {
   struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
@@ -368,7 +368,7 @@ vect_stmt_relevant_p (gimple stmt, loop_vec_info loop_vinfo,
    used in STMT for anything other than indexing an array.  */
 
 static bool
-exist_non_indexing_operands_for_use_p (tree use, gimple stmt)
+exist_non_indexing_operands_for_use_p (tree use, gimple *stmt)
 {
   tree operand;
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
@@ -455,8 +455,8 @@ exist_non_indexing_operands_for_use_p (tree use, gimple stmt)
    Return true if everything is as expected. Return false otherwise.  */
 
 static bool
-process_use (gimple stmt, tree use, loop_vec_info loop_vinfo, bool live_p,
-	     enum vect_relevant relevant, vec<gimple> *worklist,
+process_use (gimple *stmt, tree use, loop_vec_info loop_vinfo, bool live_p,
+	     enum vect_relevant relevant, vec<gimple *> *worklist,
 	     bool force)
 {
   struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
@@ -464,7 +464,7 @@ process_use (gimple stmt, tree use, loop_vec_info loop_vinfo, bool live_p,
   stmt_vec_info dstmt_vinfo;
   basic_block bb, def_bb;
   tree def;
-  gimple def_stmt;
+  gimple *def_stmt;
   enum vect_def_type dt;
 
   /* case 1: we are only interested in uses that need to be vectorized.  Uses
@@ -616,11 +616,11 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info loop_vinfo)
   basic_block *bbs = LOOP_VINFO_BBS (loop_vinfo);
   unsigned int nbbs = loop->num_nodes;
   gimple_stmt_iterator si;
-  gimple stmt;
+  gimple *stmt;
   unsigned int i;
   stmt_vec_info stmt_vinfo;
   basic_block bb;
-  gimple phi;
+  gimple *phi;
   bool live_p;
   enum vect_relevant relevant, tmp_relevant;
   enum vect_def_type def_type;
@@ -629,7 +629,7 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info loop_vinfo)
     dump_printf_loc (MSG_NOTE, vect_location,
                      "=== vect_mark_stmts_to_be_vectorized ===\n");
 
-  auto_vec<gimple, 64> worklist;
+  auto_vec<gimple *, 64> worklist;
 
   /* 1. Init worklist.  */
   for (i = 0; i < nbbs; i++)
@@ -911,7 +911,7 @@ vect_model_promotion_demotion_cost (stmt_vec_info stmt_info,
 static int
 vect_cost_group_size (stmt_vec_info stmt_info)
 {
-  gimple first_stmt = GROUP_FIRST_ELEMENT (stmt_info);
+  gimple *first_stmt = GROUP_FIRST_ELEMENT (stmt_info);
 
   if (first_stmt == STMT_VINFO_STMT (stmt_info))
     return GROUP_SIZE (stmt_info);
@@ -935,7 +935,7 @@ vect_model_store_cost (stmt_vec_info stmt_info, int ncopies,
   int group_size;
   unsigned int inside_cost = 0, prologue_cost = 0;
   struct data_reference *first_dr;
-  gimple first_stmt;
+  gimple *first_stmt;
 
   /* The SLP costs were already calculated during SLP tree build.  */
   if (PURE_SLP_STMT (stmt_info))
@@ -1003,7 +1003,7 @@ vect_get_store_cost (struct data_reference *dr, int ncopies,
 		     stmt_vector_for_cost *body_cost_vec)
 {
   int alignment_support_scheme = vect_supportable_dr_alignment (dr, false);
-  gimple stmt = DR_STMT (dr);
+  gimple *stmt = DR_STMT (dr);
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
 
   switch (alignment_support_scheme)
@@ -1063,7 +1063,7 @@ vect_model_load_cost (stmt_vec_info stmt_info, int ncopies,
 		      stmt_vector_for_cost *body_cost_vec)
 {
   int group_size;
-  gimple first_stmt;
+  gimple *first_stmt;
   struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info), *first_dr;
   unsigned int inside_cost = 0, prologue_cost = 0;
 
@@ -1138,7 +1138,7 @@ vect_get_load_cost (struct data_reference *dr, int ncopies,
 		    bool record_prologue_costs)
 {
   int alignment_support_scheme = vect_supportable_dr_alignment (dr, false);
-  gimple stmt = DR_STMT (dr);
+  gimple *stmt = DR_STMT (dr);
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
 
   switch (alignment_support_scheme)
@@ -1245,7 +1245,7 @@ vect_get_load_cost (struct data_reference *dr, int ncopies,
    the loop preheader for the vectorized stmt STMT.  */
 
 static void
-vect_init_vector_1 (gimple stmt, gimple new_stmt, gimple_stmt_iterator *gsi)
+vect_init_vector_1 (gimple *stmt, gimple *new_stmt, gimple_stmt_iterator *gsi)
 {
   if (gsi)
     vect_finish_stmt_generation (stmt, new_stmt, gsi);
@@ -1300,10 +1300,10 @@ vect_init_vector_1 (gimple stmt, gimple new_stmt, gimple_stmt_iterator *gsi)
    It will be used in the vectorization of STMT.  */
 
 tree
-vect_init_vector (gimple stmt, tree val, tree type, gimple_stmt_iterator *gsi)
+vect_init_vector (gimple *stmt, tree val, tree type, gimple_stmt_iterator *gsi)
 {
   tree new_var;
-  gimple init_stmt;
+  gimple *init_stmt;
   tree vec_oprnd;
   tree new_temp;
 
@@ -1349,11 +1349,11 @@ vect_init_vector (gimple stmt, tree val, tree type, gimple_stmt_iterator *gsi)
    needs to be introduced.  */
 
 tree
-vect_get_vec_def_for_operand (tree op, gimple stmt, tree *scalar_def)
+vect_get_vec_def_for_operand (tree op, gimple *stmt, tree *scalar_def)
 {
   tree vec_oprnd;
-  gimple vec_stmt;
-  gimple def_stmt;
+  gimple *vec_stmt;
+  gimple *def_stmt;
   stmt_vec_info def_stmt_info = NULL;
   stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt);
   unsigned int nunits;
@@ -1552,7 +1552,7 @@ vect_get_vec_def_for_operand (tree op, gimple stmt, tree *scalar_def)
 tree
 vect_get_vec_def_for_stmt_copy (enum vect_def_type dt, tree vec_oprnd)
 {
-  gimple vec_stmt_for_operand;
+  gimple *vec_stmt_for_operand;
   stmt_vec_info def_stmt_info;
 
   /* Do nothing; can reuse same def.  */
@@ -1600,7 +1600,7 @@ vect_get_vec_defs_for_stmt_copy (enum vect_def_type *dt,
    and -1 otherwise.  */
 
 void
-vect_get_vec_defs (tree op0, tree op1, gimple stmt,
+vect_get_vec_defs (tree op0, tree op1, gimple *stmt,
 		   vec<tree> *vec_oprnds0,
 		   vec<tree> *vec_oprnds1,
 		   slp_tree slp_node, int reduc_index)
@@ -1644,7 +1644,7 @@ vect_get_vec_defs (tree op0, tree op1, gimple stmt,
    Insert a new stmt.  */
 
 void
-vect_finish_stmt_generation (gimple stmt, gimple vec_stmt,
+vect_finish_stmt_generation (gimple *stmt, gimple *vec_stmt,
 			     gimple_stmt_iterator *gsi)
 {
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
@@ -1656,7 +1656,7 @@ vect_finish_stmt_generation (gimple stmt, gimple vec_stmt,
   if (!gsi_end_p (*gsi)
       && gimple_has_mem_ops (vec_stmt))
     {
-      gimple at_stmt = gsi_stmt (*gsi);
+      gimple *at_stmt = gsi_stmt (*gsi);
       tree vuse = gimple_vuse (at_stmt);
       if (vuse && TREE_CODE (vuse) == SSA_NAME)
 	{
@@ -1706,7 +1706,7 @@ vect_finish_stmt_generation (gimple stmt, gimple vec_stmt,
    of the function, or NULL_TREE if the function cannot be vectorized.  */
 
 tree
-vectorizable_function (gimple call, tree vectype_out, tree vectype_in)
+vectorizable_function (gimple *call, tree vectype_out, tree vectype_in)
 {
   tree fndecl = gimple_call_fndecl (call);
 
@@ -1725,7 +1725,7 @@ vectorizable_function (gimple call, tree vectype_out, tree vectype_in)
 }
 
 
-static tree permute_vec_elements (tree, tree, tree, gimple,
+static tree permute_vec_elements (tree, tree, tree, gimple *,
 				  gimple_stmt_iterator *);
 
 
@@ -1737,8 +1737,8 @@ static tree permute_vec_elements (tree, tree, tree, gimple,
    Return FALSE if not a vectorizable STMT, TRUE otherwise.  */
 
 static bool
-vectorizable_mask_load_store (gimple stmt, gimple_stmt_iterator *gsi,
-			      gimple *vec_stmt, slp_tree slp_node)
+vectorizable_mask_load_store (gimple *stmt, gimple_stmt_iterator *gsi,
+			      gimple **vec_stmt, slp_tree slp_node)
 {
   tree vec_dest = NULL;
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
@@ -1749,10 +1749,10 @@ vectorizable_mask_load_store (gimple stmt, gimple_stmt_iterator *gsi,
   struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info);
   tree vectype = STMT_VINFO_VECTYPE (stmt_info);
   tree elem_type;
-  gimple new_stmt;
+  gimple *new_stmt;
   tree dummy;
   tree dataref_ptr = NULL_TREE;
-  gimple ptr_incr;
+  gimple *ptr_incr;
   int nunits = TYPE_VECTOR_SUBPARTS (vectype);
   int ncopies;
   int i, j;
@@ -1763,7 +1763,7 @@ vectorizable_mask_load_store (gimple stmt, gimple_stmt_iterator *gsi,
   enum vect_def_type gather_dt = vect_unknown_def_type;
   bool is_store;
   tree mask;
-  gimple def_stmt;
+  gimple *def_stmt;
   tree def;
   enum vect_def_type dt;
 
@@ -1807,7 +1807,7 @@ vectorizable_mask_load_store (gimple stmt, gimple_stmt_iterator *gsi,
 
   if (STMT_VINFO_GATHER_P (stmt_info))
     {
-      gimple def_stmt;
+      gimple *def_stmt;
       tree def;
       gather_decl = vect_check_gather (stmt, loop_vinfo, &gather_base,
 				       &gather_off, &gather_scale);
@@ -2183,7 +2183,7 @@ vectorizable_mask_load_store (gimple stmt, gimple_stmt_iterator *gsi,
    Return FALSE if not a vectorizable STMT, TRUE otherwise.  */
 
 static bool
-vectorizable_call (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
+vectorizable_call (gimple *stmt, gimple_stmt_iterator *gsi, gimple **vec_stmt,
 		   slp_tree slp_node)
 {
   tree vec_dest;
@@ -2197,10 +2197,10 @@ vectorizable_call (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
   bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info);
   tree fndecl, new_temp, def, rhs_type;
-  gimple def_stmt;
+  gimple *def_stmt;
   enum vect_def_type dt[3]
     = {vect_unknown_def_type, vect_unknown_def_type, vect_unknown_def_type};
-  gimple new_stmt = NULL;
+  gimple *new_stmt = NULL;
   int ncopies, j;
   vec<tree> vargs = vNULL;
   enum { NARROW, NONE, WIDEN } modifier;
@@ -2452,7 +2452,7 @@ vectorizable_call (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
 	      tree cst = build_vector (vectype_out, v);
 	      tree new_var
 		= vect_get_new_vect_var (vectype_out, vect_simple_var, "cst_");
-	      gimple init_stmt = gimple_build_assign (new_var, cst);
+	      gimple *init_stmt = gimple_build_assign (new_var, cst);
 	      new_temp = make_ssa_name (new_var, init_stmt);
 	      gimple_assign_set_lhs (init_stmt, new_temp);
 	      vect_init_vector_1 (stmt, init_stmt, NULL);
@@ -2611,8 +2611,8 @@ struct simd_call_arg_info
    Return FALSE if not a vectorizable STMT, TRUE otherwise.  */
 
 static bool
-vectorizable_simd_clone_call (gimple stmt, gimple_stmt_iterator *gsi,
-			      gimple *vec_stmt, slp_tree slp_node)
+vectorizable_simd_clone_call (gimple *stmt, gimple_stmt_iterator *gsi,
+			      gimple **vec_stmt, slp_tree slp_node)
 {
   tree vec_dest;
   tree scalar_dest;
@@ -2625,8 +2625,8 @@ vectorizable_simd_clone_call (gimple stmt, gimple_stmt_iterator *gsi,
   bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info);
   struct loop *loop = loop_vinfo ? LOOP_VINFO_LOOP (loop_vinfo) : NULL;
   tree fndecl, new_temp, def;
-  gimple def_stmt;
-  gimple new_stmt = NULL;
+  gimple *def_stmt;
+  gimple *new_stmt = NULL;
   int ncopies, j;
   vec<simd_call_arg_info> arginfo = vNULL;
   vec<tree> vargs = vNULL;
@@ -2982,7 +2982,7 @@ vectorizable_simd_clone_call (gimple stmt, gimple_stmt_iterator *gsi,
 		      gcc_assert (!new_bb);
 		    }
 		  tree phi_res = copy_ssa_name (op, NULL);
-		  gimple new_phi = create_phi_node (phi_res, loop->header);
+		  gimple *new_phi = create_phi_node (phi_res, loop->header);
 		  set_vinfo_for_stmt (new_phi,
 				      new_stmt_vec_info (new_phi, loop_vinfo,
 							 NULL));
@@ -3199,14 +3199,14 @@ vectorizable_simd_clone_call (gimple stmt, gimple_stmt_iterator *gsi,
    needs to be created (DECL is a function-decl of a target-builtin).
    STMT is the original scalar stmt that we are vectorizing.  */
 
-static gimple
+static gimple *
 vect_gen_widened_results_half (enum tree_code code,
 			       tree decl,
                                tree vec_oprnd0, tree vec_oprnd1, int op_type,
 			       tree vec_dest, gimple_stmt_iterator *gsi,
-			       gimple stmt)
+			       gimple *stmt)
 {
-  gimple new_stmt;
+  gimple *new_stmt;
   tree new_temp;
 
   /* Generate half of the widened result:  */
@@ -3245,7 +3245,7 @@ vect_gen_widened_results_half (enum tree_code code,
    The vectors are collected into VEC_OPRNDS.  */
 
 static void
-vect_get_loop_based_defs (tree *oprnd, gimple stmt, enum vect_def_type dt,
+vect_get_loop_based_defs (tree *oprnd, gimple *stmt, enum vect_def_type dt,
 			  vec<tree> *vec_oprnds, int multi_step_cvt)
 {
   tree vec_oprnd;
@@ -3279,7 +3279,7 @@ vect_get_loop_based_defs (tree *oprnd, gimple stmt, enum vect_def_type dt,
 
 static void
 vect_create_vectorized_demotion_stmts (vec<tree> *vec_oprnds,
-				       int multi_step_cvt, gimple stmt,
+				       int multi_step_cvt, gimple *stmt,
 				       vec<tree> vec_dsts,
 				       gimple_stmt_iterator *gsi,
 				       slp_tree slp_node, enum tree_code code,
@@ -3287,7 +3287,7 @@ vect_create_vectorized_demotion_stmts (vec<tree> *vec_oprnds,
 {
   unsigned int i;
   tree vop0, vop1, new_tmp, vec_dest;
-  gimple new_stmt;
+  gimple *new_stmt;
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
 
   vec_dest = vec_dsts.pop ();
@@ -3350,7 +3350,7 @@ vect_create_vectorized_demotion_stmts (vec<tree> *vec_oprnds,
 static void
 vect_create_vectorized_promotion_stmts (vec<tree> *vec_oprnds0,
 					vec<tree> *vec_oprnds1,
-					gimple stmt, tree vec_dest,
+					gimple *stmt, tree vec_dest,
 					gimple_stmt_iterator *gsi,
 					enum tree_code code1,
 					enum tree_code code2, tree decl1,
@@ -3358,7 +3358,7 @@ vect_create_vectorized_promotion_stmts (vec<tree> *vec_oprnds0,
 {
   int i;
   tree vop0, vop1, new_tmp1, new_tmp2;
-  gimple new_stmt1, new_stmt2;
+  gimple *new_stmt1, *new_stmt2;
   vec<tree> vec_tmp = vNULL;
 
   vec_tmp.create (vec_oprnds0->length () * 2);
@@ -3401,8 +3401,8 @@ vect_create_vectorized_promotion_stmts (vec<tree> *vec_oprnds0,
    Return FALSE if not a vectorizable STMT, TRUE otherwise.  */
 
 static bool
-vectorizable_conversion (gimple stmt, gimple_stmt_iterator *gsi,
-			 gimple *vec_stmt, slp_tree slp_node)
+vectorizable_conversion (gimple *stmt, gimple_stmt_iterator *gsi,
+			 gimple **vec_stmt, slp_tree slp_node)
 {
   tree vec_dest;
   tree scalar_dest;
@@ -3415,9 +3415,9 @@ vectorizable_conversion (gimple stmt, gimple_stmt_iterator *gsi,
   tree decl1 = NULL_TREE, decl2 = NULL_TREE;
   tree new_temp;
   tree def;
-  gimple def_stmt;
+  gimple *def_stmt;
   enum vect_def_type dt[2] = {vect_unknown_def_type, vect_unknown_def_type};
-  gimple new_stmt = NULL;
+  gimple *new_stmt = NULL;
   stmt_vec_info prev_stmt_info;
   int nunits_in;
   int nunits_out;
@@ -3982,8 +3982,8 @@ vectorizable_conversion (gimple stmt, gimple_stmt_iterator *gsi,
    Return FALSE if not a vectorizable STMT, TRUE otherwise.  */
 
 static bool
-vectorizable_assignment (gimple stmt, gimple_stmt_iterator *gsi,
-			 gimple *vec_stmt, slp_tree slp_node)
+vectorizable_assignment (gimple *stmt, gimple_stmt_iterator *gsi,
+			 gimple **vec_stmt, slp_tree slp_node)
 {
   tree vec_dest;
   tree scalar_dest;
@@ -3993,7 +3993,7 @@ vectorizable_assignment (gimple stmt, gimple_stmt_iterator *gsi,
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
   tree new_temp;
   tree def;
-  gimple def_stmt;
+  gimple *def_stmt;
   enum vect_def_type dt[2] = {vect_unknown_def_type, vect_unknown_def_type};
   unsigned int nunits = TYPE_VECTOR_SUBPARTS (vectype);
   int ncopies;
@@ -4001,7 +4001,7 @@ vectorizable_assignment (gimple stmt, gimple_stmt_iterator *gsi,
   vec<tree> vec_oprnds = vNULL;
   tree vop;
   bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info);
-  gimple new_stmt = NULL;
+  gimple *new_stmt = NULL;
   stmt_vec_info prev_stmt_info = NULL;
   enum tree_code code;
   tree vectype_in;
@@ -4180,8 +4180,8 @@ vect_supportable_shift (enum tree_code code, tree scalar_type)
    Return FALSE if not a vectorizable STMT, TRUE otherwise.  */
 
 static bool
-vectorizable_shift (gimple stmt, gimple_stmt_iterator *gsi,
-                    gimple *vec_stmt, slp_tree slp_node)
+vectorizable_shift (gimple *stmt, gimple_stmt_iterator *gsi,
+                    gimple **vec_stmt, slp_tree slp_node)
 {
   tree vec_dest;
   tree scalar_dest;
@@ -4197,9 +4197,9 @@ vectorizable_shift (gimple stmt, gimple_stmt_iterator *gsi,
   int icode;
   enum machine_mode optab_op2_mode;
   tree def;
-  gimple def_stmt;
+  gimple *def_stmt;
   enum vect_def_type dt[2] = {vect_unknown_def_type, vect_unknown_def_type};
-  gimple new_stmt = NULL;
+  gimple *new_stmt = NULL;
   stmt_vec_info prev_stmt_info;
   int nunits_in;
   int nunits_out;
@@ -4312,8 +4312,8 @@ vectorizable_shift (gimple stmt, gimple_stmt_iterator *gsi,
 	 a scalar shift.  */
       if (slp_node)
 	{
-	  vec<gimple> stmts = SLP_TREE_SCALAR_STMTS (slp_node);
-	  gimple slpstmt;
+	  vec<gimple *> stmts = SLP_TREE_SCALAR_STMTS (slp_node);
+	  gimple *slpstmt;
 
 	  FOR_EACH_VEC_ELT (stmts, k, slpstmt)
 	    if (!operand_equal_p (gimple_assign_rhs2 (slpstmt), op1, 0))
@@ -4543,8 +4543,8 @@ vectorizable_shift (gimple stmt, gimple_stmt_iterator *gsi,
    Return FALSE if not a vectorizable STMT, TRUE otherwise.  */
 
 static bool
-vectorizable_operation (gimple stmt, gimple_stmt_iterator *gsi,
-			gimple *vec_stmt, slp_tree slp_node)
+vectorizable_operation (gimple *stmt, gimple_stmt_iterator *gsi,
+			gimple **vec_stmt, slp_tree slp_node)
 {
   tree vec_dest;
   tree scalar_dest;
@@ -4559,10 +4559,10 @@ vectorizable_operation (gimple stmt, gimple_stmt_iterator *gsi,
   optab optab;
   int icode;
   tree def;
-  gimple def_stmt;
+  gimple *def_stmt;
   enum vect_def_type dt[3]
     = {vect_unknown_def_type, vect_unknown_def_type, vect_unknown_def_type};
-  gimple new_stmt = NULL;
+  gimple *new_stmt = NULL;
   stmt_vec_info prev_stmt_info;
   int nunits_in;
   int nunits_out;
@@ -4937,7 +4937,7 @@ perm_mask_for_reverse (tree vectype)
    Return FALSE if not a vectorizable STMT, TRUE otherwise.  */
 
 static bool
-vectorizable_store (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
+vectorizable_store (gimple *stmt, gimple_stmt_iterator *gsi, gimple **vec_stmt,
                     slp_tree slp_node)
 {
   tree scalar_dest;
@@ -4954,16 +4954,16 @@ vectorizable_store (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
   tree dummy;
   enum dr_alignment_support alignment_support_scheme;
   tree def;
-  gimple def_stmt;
+  gimple *def_stmt;
   enum vect_def_type dt;
   stmt_vec_info prev_stmt_info = NULL;
   tree dataref_ptr = NULL_TREE;
   tree dataref_offset = NULL_TREE;
-  gimple ptr_incr = NULL;
+  gimple *ptr_incr = NULL;
   int nunits = TYPE_VECTOR_SUBPARTS (vectype);
   int ncopies;
   int j;
-  gimple next_stmt, first_stmt = NULL;
+  gimple *next_stmt, *first_stmt = NULL;
   bool grouped_store = false;
   bool store_lanes_p = false;
   unsigned int group_size, i;
@@ -5236,7 +5236,7 @@ vectorizable_store (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
   prev_stmt_info = NULL;
   for (j = 0; j < ncopies; j++)
     {
-      gimple new_stmt;
+      gimple *new_stmt;
 
       if (j == 0)
 	{
@@ -5416,7 +5416,7 @@ vectorizable_store (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
 		  tree new_temp = make_ssa_name (perm_dest, NULL);
 
 		  /* Generate the permute statement.  */
-		  gimple perm_stmt 
+		  gimple *perm_stmt 
 		    = gimple_build_assign_with_ops (VEC_PERM_EXPR, new_temp,
 						    vec_oprnd, vec_oprnd,
 						    perm_mask);
@@ -5489,12 +5489,12 @@ vect_gen_perm_mask (tree vectype, unsigned char *sel)
    permuted vector variable.  */
 
 static tree
-permute_vec_elements (tree x, tree y, tree mask_vec, gimple stmt,
+permute_vec_elements (tree x, tree y, tree mask_vec, gimple *stmt,
 		      gimple_stmt_iterator *gsi)
 {
   tree vectype = TREE_TYPE (x);
   tree perm_dest, data_ref;
-  gimple perm_stmt;
+  gimple *perm_stmt;
 
   perm_dest = vect_create_destination_var (gimple_get_lhs (stmt), vectype);
   data_ref = make_ssa_name (perm_dest, NULL);
@@ -5513,7 +5513,7 @@ permute_vec_elements (tree x, tree y, tree mask_vec, gimple stmt,
    otherwise returns false.  */
 
 static bool
-hoist_defs_of_uses (gimple stmt, struct loop *loop)
+hoist_defs_of_uses (gimple *stmt, struct loop *loop)
 {
   ssa_op_iter i;
   tree op;
@@ -5521,7 +5521,7 @@ hoist_defs_of_uses (gimple stmt, struct loop *loop)
 
   FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_USE)
     {
-      gimple def_stmt = SSA_NAME_DEF_STMT (op);
+      gimple *def_stmt = SSA_NAME_DEF_STMT (op);
       if (!gimple_nop_p (def_stmt)
 	  && flow_bb_inside_loop_p (loop, gimple_bb (def_stmt)))
 	{
@@ -5535,7 +5535,7 @@ hoist_defs_of_uses (gimple stmt, struct loop *loop)
 	    return false;
 	  FOR_EACH_SSA_TREE_OPERAND (op2, def_stmt, i2, SSA_OP_USE)
 	    {
-	      gimple def_stmt2 = SSA_NAME_DEF_STMT (op2);
+	      gimple *def_stmt2 = SSA_NAME_DEF_STMT (op2);
 	      if (!gimple_nop_p (def_stmt2)
 		  && flow_bb_inside_loop_p (loop, gimple_bb (def_stmt2)))
 		return false;
@@ -5549,7 +5549,7 @@ hoist_defs_of_uses (gimple stmt, struct loop *loop)
 
   FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_USE)
     {
-      gimple def_stmt = SSA_NAME_DEF_STMT (op);
+      gimple *def_stmt = SSA_NAME_DEF_STMT (op);
       if (!gimple_nop_p (def_stmt)
 	  && flow_bb_inside_loop_p (loop, gimple_bb (def_stmt)))
 	{
@@ -5571,7 +5571,7 @@ hoist_defs_of_uses (gimple stmt, struct loop *loop)
    Return FALSE if not a vectorizable STMT, TRUE otherwise.  */
 
 static bool
-vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
+vectorizable_load (gimple *stmt, gimple_stmt_iterator *gsi, gimple **vec_stmt,
                    slp_tree slp_node, slp_instance slp_node_instance)
 {
   tree scalar_dest;
@@ -5588,23 +5588,23 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
   tree elem_type;
   tree new_temp;
   enum machine_mode mode;
-  gimple new_stmt = NULL;
+  gimple *new_stmt = NULL;
   tree dummy;
   enum dr_alignment_support alignment_support_scheme;
   tree dataref_ptr = NULL_TREE;
   tree dataref_offset = NULL_TREE;
-  gimple ptr_incr = NULL;
+  gimple *ptr_incr = NULL;
   int nunits = TYPE_VECTOR_SUBPARTS (vectype);
   int ncopies;
   int i, j, group_size, group_gap;
   tree msq = NULL_TREE, lsq;
   tree offset = NULL_TREE;
   tree realignment_token = NULL_TREE;
-  gimple phi = NULL;
+  gimple *phi = NULL;
   vec<tree> dr_chain = vNULL;
   bool grouped_load = false;
   bool load_lanes_p = false;
-  gimple first_stmt;
+  gimple *first_stmt;
   bool inv_p;
   bool negative = false;
   bool compute_in_loop = false;
@@ -5739,7 +5739,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
 
   if (STMT_VINFO_GATHER_P (stmt_info))
     {
-      gimple def_stmt;
+      gimple *def_stmt;
       tree def;
       gather_decl = vect_check_gather (stmt, loop_vinfo, &gather_base,
 				       &gather_off, &gather_scale);
@@ -5992,7 +5992,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
     {
       gimple_stmt_iterator incr_gsi;
       bool insert_after;
-      gimple incr;
+      gimple *incr;
       tree offvar;
       tree ivstep;
       tree running_off;
@@ -6053,7 +6053,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
 	  for (i = 0; i < nunits; i++)
 	    {
 	      tree newref, newoff;
-	      gimple incr;
+	      gimple *incr;
 	      newref = build2 (MEM_REF, TREE_TYPE (vectype),
 			       running_off, alias_off);
 
@@ -6604,7 +6604,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
    condition operands are supportable using vec_is_simple_use.  */
 
 static bool
-vect_is_simple_cond (tree cond, gimple stmt, loop_vec_info loop_vinfo,
+vect_is_simple_cond (tree cond, gimple *stmt, loop_vec_info loop_vinfo,
 		     bb_vec_info bb_vinfo, tree *comp_vectype)
 {
   tree lhs, rhs;
@@ -6620,7 +6620,7 @@ vect_is_simple_cond (tree cond, gimple stmt, loop_vec_info loop_vinfo,
 
   if (TREE_CODE (lhs) == SSA_NAME)
     {
-      gimple lhs_def_stmt = SSA_NAME_DEF_STMT (lhs);
+      gimple *lhs_def_stmt = SSA_NAME_DEF_STMT (lhs);
       if (!vect_is_simple_use_1 (lhs, stmt, loop_vinfo, bb_vinfo,
 				 &lhs_def_stmt, &def, &dt, &vectype1))
 	return false;
@@ -6631,7 +6631,7 @@ vect_is_simple_cond (tree cond, gimple stmt, loop_vec_info loop_vinfo,
 
   if (TREE_CODE (rhs) == SSA_NAME)
     {
-      gimple rhs_def_stmt = SSA_NAME_DEF_STMT (rhs);
+      gimple *rhs_def_stmt = SSA_NAME_DEF_STMT (rhs);
       if (!vect_is_simple_use_1 (rhs, stmt, loop_vinfo, bb_vinfo,
 				 &rhs_def_stmt, &def, &dt, &vectype2))
 	return false;
@@ -6658,8 +6658,8 @@ vect_is_simple_cond (tree cond, gimple stmt, loop_vec_info loop_vinfo,
    Return FALSE if not a vectorizable STMT, TRUE otherwise.  */
 
 bool
-vectorizable_condition (gimple stmt, gimple_stmt_iterator *gsi,
-			gimple *vec_stmt, tree reduc_def, int reduc_index,
+vectorizable_condition (gimple *stmt, gimple_stmt_iterator *gsi,
+			gimple **vec_stmt, tree reduc_def, int reduc_index,
 			slp_tree slp_node)
 {
   tree scalar_dest = NULL_TREE;
@@ -6736,7 +6736,7 @@ vectorizable_condition (gimple stmt, gimple_stmt_iterator *gsi,
 
   if (TREE_CODE (then_clause) == SSA_NAME)
     {
-      gimple then_def_stmt = SSA_NAME_DEF_STMT (then_clause);
+      gimple *then_def_stmt = SSA_NAME_DEF_STMT (then_clause);
       if (!vect_is_simple_use (then_clause, stmt, loop_vinfo, bb_vinfo,
 			       &then_def_stmt, &def, &dt))
 	return false;
@@ -6748,7 +6748,7 @@ vectorizable_condition (gimple stmt, gimple_stmt_iterator *gsi,
 
   if (TREE_CODE (else_clause) == SSA_NAME)
     {
-      gimple else_def_stmt = SSA_NAME_DEF_STMT (else_clause);
+      gimple *else_def_stmt = SSA_NAME_DEF_STMT (else_clause);
       if (!vect_is_simple_use (else_clause, stmt, loop_vinfo, bb_vinfo,
 			       &else_def_stmt, &def, &dt))
 	return false;
@@ -6788,7 +6788,7 @@ vectorizable_condition (gimple stmt, gimple_stmt_iterator *gsi,
   /* Handle cond expr.  */
   for (j = 0; j < ncopies; j++)
     {
-      gimple new_stmt = NULL;
+      gimple *new_stmt = NULL;
       if (j == 0)
 	{
           if (slp_node)
@@ -6811,7 +6811,7 @@ vectorizable_condition (gimple stmt, gimple_stmt_iterator *gsi,
             }
           else
             {
-	      gimple gtemp;
+	      gimple *gtemp;
 	      vec_cond_lhs =
 	      vect_get_vec_def_for_operand (TREE_OPERAND (cond_expr, 0),
 					    stmt, NULL);
@@ -6906,14 +6906,14 @@ vectorizable_condition (gimple stmt, gimple_stmt_iterator *gsi,
 /* Make sure the statement is vectorizable.  */
 
 bool
-vect_analyze_stmt (gimple stmt, bool *need_to_vectorize, slp_tree node)
+vect_analyze_stmt (gimple *stmt, bool *need_to_vectorize, slp_tree node)
 {
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
   bb_vec_info bb_vinfo = STMT_VINFO_BB_VINFO (stmt_info);
   enum vect_relevant relevance = STMT_VINFO_RELEVANT (stmt_info);
   bool ok;
   tree scalar_type, vectype;
-  gimple pattern_stmt;
+  gimple *pattern_stmt;
   gimple_seq pattern_def_seq;
 
   if (dump_enabled_p ())
@@ -7001,7 +7001,7 @@ vect_analyze_stmt (gimple stmt, bool *need_to_vectorize, slp_tree node)
 
       for (si = gsi_start (pattern_def_seq); !gsi_end_p (si); gsi_next (&si))
 	{
-	  gimple pattern_def_stmt = gsi_stmt (si);
+	  gimple *pattern_def_stmt = gsi_stmt (si);
 	  if (STMT_VINFO_RELEVANT_P (vinfo_for_stmt (pattern_def_stmt))
 	      || STMT_VINFO_LIVE_P (vinfo_for_stmt (pattern_def_stmt)))
 	    {
@@ -7161,12 +7161,12 @@ vect_analyze_stmt (gimple stmt, bool *need_to_vectorize, slp_tree node)
    Create a vectorized stmt to replace STMT, and insert it at BSI.  */
 
 bool
-vect_transform_stmt (gimple stmt, gimple_stmt_iterator *gsi,
+vect_transform_stmt (gimple *stmt, gimple_stmt_iterator *gsi,
 		     bool *grouped_store, slp_tree slp_node,
                      slp_instance slp_node_instance)
 {
   bool is_store = false;
-  gimple vec_stmt = NULL;
+  gimple *vec_stmt = NULL;
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
   bool done;
 
@@ -7273,7 +7273,7 @@ vect_transform_stmt (gimple stmt, gimple_stmt_iterator *gsi,
       imm_use_iterator imm_iter;
       use_operand_p use_p;
       tree scalar_dest;
-      gimple exit_phi;
+      gimple *exit_phi;
 
       if (dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location,
@@ -7317,10 +7317,10 @@ vect_transform_stmt (gimple stmt, gimple_stmt_iterator *gsi,
    stmt_vec_info.  */
 
 void
-vect_remove_stores (gimple first_stmt)
+vect_remove_stores (gimple *first_stmt)
 {
-  gimple next = first_stmt;
-  gimple tmp;
+  gimple *next = first_stmt;
+  gimple *tmp;
   gimple_stmt_iterator next_si;
 
   while (next)
@@ -7346,7 +7346,7 @@ vect_remove_stores (gimple first_stmt)
    Create and initialize a new stmt_vec_info struct for STMT.  */
 
 stmt_vec_info
-new_stmt_vec_info (gimple stmt, loop_vec_info loop_vinfo,
+new_stmt_vec_info (gimple *stmt, loop_vec_info loop_vinfo,
                    bb_vec_info bb_vinfo)
 {
   stmt_vec_info res;
@@ -7419,7 +7419,7 @@ free_stmt_vec_info_vec (void)
 /* Free stmt vectorization related info.  */
 
 void
-free_stmt_vec_info (gimple stmt)
+free_stmt_vec_info (gimple *stmt)
 {
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
 
@@ -7437,7 +7437,7 @@ free_stmt_vec_info (gimple stmt)
       if (patt_info)
 	{
 	  gimple_seq seq = STMT_VINFO_PATTERN_DEF_SEQ (patt_info);
-	  gimple patt_stmt = STMT_VINFO_STMT (patt_info);
+	  gimple *patt_stmt = STMT_VINFO_STMT (patt_info);
 	  gimple_set_bb (patt_stmt, NULL);
 	  tree lhs = gimple_get_lhs (patt_stmt);
 	  if (TREE_CODE (lhs) == SSA_NAME)
@@ -7447,7 +7447,7 @@ free_stmt_vec_info (gimple stmt)
 	      gimple_stmt_iterator si;
 	      for (si = gsi_start (seq); !gsi_end_p (si); gsi_next (&si))
 		{
-		  gimple seq_stmt = gsi_stmt (si);
+		  gimple *seq_stmt = gsi_stmt (si);
 		  gimple_set_bb (seq_stmt, NULL);
 		  lhs = gimple_get_lhs (patt_stmt);
 		  if (TREE_CODE (lhs) == SSA_NAME)
@@ -7584,8 +7584,8 @@ get_same_sized_vectype (tree scalar_type, tree vector_type)
    For now, operands defined outside the basic block are not supported.  */
 
 bool
-vect_is_simple_use (tree operand, gimple stmt, loop_vec_info loop_vinfo,
-                    bb_vec_info bb_vinfo, gimple *def_stmt,
+vect_is_simple_use (tree operand, gimple *stmt, loop_vec_info loop_vinfo,
+                    bb_vec_info bb_vinfo, gimple **def_stmt,
 		    tree *def, enum vect_def_type *dt)
 {
   basic_block bb;
@@ -7720,8 +7720,8 @@ vect_is_simple_use (tree operand, gimple stmt, loop_vec_info loop_vinfo,
    scalar operand.  */
 
 bool
-vect_is_simple_use_1 (tree operand, gimple stmt, loop_vec_info loop_vinfo,
-		      bb_vec_info bb_vinfo, gimple *def_stmt,
+vect_is_simple_use_1 (tree operand, gimple *stmt, loop_vec_info loop_vinfo,
+		      bb_vec_info bb_vinfo, gimple **def_stmt,
 		      tree *def, enum vect_def_type *dt, tree *vectype)
 {
   if (!vect_is_simple_use (operand, stmt, loop_vinfo, bb_vinfo, def_stmt,
@@ -7780,7 +7780,7 @@ vect_is_simple_use_1 (tree operand, gimple stmt, loop_vec_info loop_vinfo,
    widening operation (short in the above example).  */
 
 bool
-supportable_widening_operation (enum tree_code code, gimple stmt,
+supportable_widening_operation (enum tree_code code, gimple *stmt,
 				tree vectype_out, tree vectype_in,
                                 enum tree_code *code1, enum tree_code *code2,
                                 int *multi_step_cvt,
@@ -7855,7 +7855,7 @@ supportable_widening_operation (enum tree_code code, gimple stmt,
              by STMT is only directly used in the reduction statement.  */
           tree lhs = gimple_assign_lhs (stmt);
           use_operand_p dummy;
-          gimple use_stmt;
+          gimple *use_stmt;
           stmt_vec_info use_stmt_info = NULL;
           if (single_imm_use (lhs, &dummy, &use_stmt)
               && (use_stmt_info = vinfo_for_stmt (use_stmt))
diff --git a/gcc/tree-vectorizer.c b/gcc/tree-vectorizer.c
index 8f5f2d6..e2bfc62 100644
--- a/gcc/tree-vectorizer.c
+++ b/gcc/tree-vectorizer.c
@@ -167,7 +167,7 @@ adjust_simduid_builtins (hash_table <simduid_to_vf> &htab)
 	{
 	  unsigned int vf = 1;
 	  enum internal_fn ifn;
-	  gimple stmt = gsi_stmt (i);
+	  gimple *stmt = gsi_stmt (i);
 	  tree t;
 	  if (!is_gimple_call (stmt)
 	      || !gimple_call_internal_p (stmt))
@@ -270,7 +270,7 @@ note_simd_array_uses (hash_table <simd_array_to_simduid> *htab)
   FOR_EACH_BB_FN (bb, cfun)
     for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
       {
-	gimple stmt = gsi_stmt (gsi);
+	gimple *stmt = gsi_stmt (gsi);
 	if (!is_gimple_call (stmt) || !gimple_call_internal_p (stmt))
 	  continue;
 	switch (gimple_call_internal_fn (stmt))
@@ -286,7 +286,7 @@ note_simd_array_uses (hash_table <simd_array_to_simduid> *htab)
 	if (lhs == NULL_TREE)
 	  continue;
 	imm_use_iterator use_iter;
-	gimple use_stmt;
+	gimple *use_stmt;
 	ns.simduid = DECL_UID (SSA_NAME_VAR (gimple_call_arg (stmt, 0)));
 	FOR_EACH_IMM_USE_STMT (use_stmt, use_iter, lhs)
 	  if (!is_gimple_debug (use_stmt))
@@ -322,11 +322,11 @@ vect_destroy_datarefs (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
 /* If LOOP has been versioned during ifcvt, return the internal call
    guarding it.  */
 
-static gimple
+static gimple *
 vect_loop_vectorized_call (struct loop *loop)
 {
   basic_block bb = loop_preheader_edge (loop)->src;
-  gimple g;
+  gimple *g;
   do
     {
       g = last_stmt (bb);
@@ -359,12 +359,12 @@ vect_loop_vectorized_call (struct loop *loop)
    update any immediate uses of it's LHS.  */
 
 static void
-fold_loop_vectorized_call (gimple g, tree value)
+fold_loop_vectorized_call (gimple *g, tree value)
 {
   tree lhs = gimple_call_lhs (g);
   use_operand_p use_p;
   imm_use_iterator iter;
-  gimple use_stmt;
+  gimple *use_stmt;
   gimple_stmt_iterator gsi = gsi_for_stmt (g);
 
   update_call_from_tree (&gsi, value);
@@ -436,7 +436,7 @@ vectorize_loops (void)
         if (!dbg_cnt (vect_loop))
 	  break;
 
-	gimple loop_vectorized_call = vect_loop_vectorized_call (loop);
+	gimple *loop_vectorized_call = vect_loop_vectorized_call (loop);
 	if (loop_vectorized_call)
 	  {
 	    tree arg = gimple_call_arg (loop_vectorized_call, 1);
@@ -456,13 +456,13 @@ vectorize_loops (void)
 		for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
 		     gsi_next (&gsi))
 		  {
-		    gimple phi = gsi_stmt (gsi);
+		    gimple *phi = gsi_stmt (gsi);
 		    gimple_set_uid (phi, 0);
 		  }
 		for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
 		     gsi_next (&gsi))
 		  {
-		    gimple stmt = gsi_stmt (gsi);
+		    gimple *stmt = gsi_stmt (gsi);
 		    gimple_set_uid (stmt, 0);
 		  }
 	      }
@@ -514,7 +514,7 @@ vectorize_loops (void)
 	loop = get_loop (cfun, i);
 	if (loop && loop->dont_vectorize)
 	  {
-	    gimple g = vect_loop_vectorized_call (loop);
+	    gimple *g = vect_loop_vectorized_call (loop);
 	    if (g)
 	      {
 		fold_loop_vectorized_call (g, boolean_false_node);
diff --git a/gcc/tree-vectorizer.h b/gcc/tree-vectorizer.h
index c5cb037..0f5fc7a 100644
--- a/gcc/tree-vectorizer.h
+++ b/gcc/tree-vectorizer.h
@@ -70,7 +70,7 @@ enum vect_def_type {
 typedef struct _stmt_info_for_cost {
   int count;
   enum vect_cost_for_stmt kind;
-  gimple stmt;
+  gimple *stmt;
   int misalign;
 } stmt_info_for_cost;
 
@@ -79,7 +79,7 @@ typedef vec<stmt_info_for_cost> stmt_vector_for_cost;
 
 static inline void
 add_stmt_info_to_vec (stmt_vector_for_cost *stmt_cost_vec, int count,
-		      enum vect_cost_for_stmt kind, gimple stmt, int misalign)
+		      enum vect_cost_for_stmt kind, gimple *stmt, int misalign)
 {
   stmt_info_for_cost si;
   si.count = count;
@@ -100,12 +100,12 @@ struct _slp_tree {
   /* Nodes that contain def-stmts of this node statements operands.  */
   vec<slp_tree> children;
   /* A group of scalar stmts to be vectorized together.  */
-  vec<gimple> stmts;
+  vec<gimple *> stmts;
   /* Load permutation relative to the stores, NULL if there is no
      permutation.  */
   vec<unsigned> load_permutation;
   /* Vectorized stmt/s.  */
-  vec<gimple> vec_stmts;
+  vec<gimple *> vec_stmts;
   /* Number of vector stmts that are created to replace the group of scalar
      stmts. It is calculated during the transformation phase as the number of
      scalar elements in one scalar iteration (GROUP_SIZE) multiplied by VF
@@ -134,7 +134,7 @@ typedef struct _slp_instance {
 
   /* The first scalar load of the instance. The created vector loads will be
      inserted before this statement.  */
-  gimple first_load;
+  gimple *first_load;
 } *slp_instance;
 
 
@@ -158,7 +158,7 @@ typedef struct _slp_instance {
 typedef struct _slp_oprnd_info
 {
   /* Def-stmts for the operands.  */
-  vec<gimple> def_stmts;
+  vec<gimple *> def_stmts;
   /* Information about the first statement, its vector def-type, type, the
      operand itself in case it's constant, and an indication if it's a pattern
      stmt.  */
@@ -310,11 +310,11 @@ typedef struct _loop_vec_info {
 
   /* Statements in the loop that have data references that are candidates for a
      runtime (loop versioning) misalignment check.  */
-  vec<gimple> may_misalign_stmts;
+  vec<gimple *> may_misalign_stmts;
 
   /* All interleaving chains of stores in the loop, represented by the first
      stmt in the chain.  */
-  vec<gimple> grouped_stores;
+  vec<gimple *> grouped_stores;
 
   /* All SLP instances in the loop. This is a subset of the set of GROUP_STORES
      of the loop.  */
@@ -325,11 +325,11 @@ typedef struct _loop_vec_info {
   unsigned slp_unrolling_factor;
 
   /* Reduction cycles detected in the loop. Used in loop-aware SLP.  */
-  vec<gimple> reductions;
+  vec<gimple *> reductions;
 
   /* All reduction chains in the loop, represented by the first
      stmt in the chain.  */
-  vec<gimple> reduction_chains;
+  vec<gimple *> reduction_chains;
 
   /* Hash table used to choose the best peeling option.  */
   hash_table <peel_info_hasher> peeling_htab;
@@ -428,7 +428,7 @@ loop_vec_info_for_loop (struct loop *loop)
 }
 
 static inline bool
-nested_in_vect_loop_p (struct loop *loop, gimple stmt)
+nested_in_vect_loop_p (struct loop *loop, gimple *stmt)
 {
   return (loop->inner
           && (loop->inner == (gimple_bb (stmt))->loop_father));
@@ -439,7 +439,7 @@ typedef struct _bb_vec_info {
   basic_block bb;
   /* All interleaving chains of stores in the basic block, represented by the
      first stmt in the chain.  */
-  vec<gimple> grouped_stores;
+  vec<gimple *> grouped_stores;
 
   /* All SLP instances in the basic block. This is a subset of the set of
      GROUP_STORES of the basic block.  */
@@ -549,7 +549,7 @@ typedef struct _stmt_vec_info {
   bool in_pattern_p;
 
   /* The stmt to which this info struct refers to.  */
-  gimple stmt;
+  gimple *stmt;
 
   /* The loop_vec_info with respect to which STMT is vectorized.  */
   loop_vec_info loop_vinfo;
@@ -558,7 +558,7 @@ typedef struct _stmt_vec_info {
   tree vectype;
 
   /* The vectorized version of the stmt.  */
-  gimple vectorized_stmt;
+  gimple *vectorized_stmt;
 
 
   /** The following is relevant only for stmts that contain a non-scalar
@@ -593,7 +593,7 @@ typedef struct _stmt_vec_info {
         related_stmt of the "pattern stmt" points back to this stmt (which is
         the last stmt in the original sequence of stmts that constitutes the
         pattern).  */
-  gimple related_stmt;
+  gimple *related_stmt;
 
   /* Used to keep a sequence of def stmts of a pattern stmt if such exists.  */
   gimple_seq pattern_def_seq;
@@ -613,12 +613,12 @@ typedef struct _stmt_vec_info {
 
   /* Interleaving and reduction chains info.  */
   /* First element in the group.  */
-  gimple first_element;
+  gimple *first_element;
   /* Pointer to the next element in the group.  */
-  gimple next_element;
+  gimple *next_element;
   /* For data-refs, in case that two or more stmts share data-ref, this is the
      pointer to the previously detected stmt with the same dr.  */
-  gimple same_dr_stmt;
+  gimple *same_dr_stmt;
   /* The size of the group.  */
   unsigned int size;
   /* For stores, number of stores from this group seen. We vectorize the last
@@ -728,7 +728,7 @@ void free_stmt_vec_info_vec (void);
 /* Return a stmt_vec_info corresponding to STMT.  */
 
 static inline stmt_vec_info
-vinfo_for_stmt (gimple stmt)
+vinfo_for_stmt (gimple *stmt)
 {
   unsigned int uid = gimple_uid (stmt);
   if (uid == 0)
@@ -740,7 +740,7 @@ vinfo_for_stmt (gimple stmt)
 /* Set vectorizer information INFO for STMT.  */
 
 static inline void
-set_vinfo_for_stmt (gimple stmt, stmt_vec_info info)
+set_vinfo_for_stmt (gimple *stmt, stmt_vec_info info)
 {
   unsigned int uid = gimple_uid (stmt);
   if (uid == 0)
@@ -756,8 +756,8 @@ set_vinfo_for_stmt (gimple stmt, stmt_vec_info info)
 
 /* Return the earlier statement between STMT1 and STMT2.  */
 
-static inline gimple
-get_earlier_stmt (gimple stmt1, gimple stmt2)
+static inline gimple *
+get_earlier_stmt (gimple *stmt1, gimple *stmt2)
 {
   unsigned int uid1, uid2;
 
@@ -784,8 +784,8 @@ get_earlier_stmt (gimple stmt1, gimple stmt2)
 
 /* Return the later statement between STMT1 and STMT2.  */
 
-static inline gimple
-get_later_stmt (gimple stmt1, gimple stmt2)
+static inline gimple *
+get_later_stmt (gimple *stmt1, gimple *stmt2)
 {
   unsigned int uid1, uid2;
 
@@ -816,7 +816,7 @@ get_later_stmt (gimple stmt1, gimple stmt2)
 static inline bool
 is_pattern_stmt_p (stmt_vec_info stmt_info)
 {
-  gimple related_stmt;
+  gimple *related_stmt;
   stmt_vec_info related_stmt_info;
 
   related_stmt = STMT_VINFO_RELATED_STMT (stmt_info);
@@ -989,22 +989,22 @@ extern bool vect_can_advance_ivs_p (loop_vec_info);
 extern unsigned int current_vector_size;
 extern tree get_vectype_for_scalar_type (tree);
 extern tree get_same_sized_vectype (tree, tree);
-extern bool vect_is_simple_use (tree, gimple, loop_vec_info,
-			        bb_vec_info, gimple *,
+extern bool vect_is_simple_use (tree, gimple *, loop_vec_info,
+			        bb_vec_info, gimple **,
                                 tree *,  enum vect_def_type *);
-extern bool vect_is_simple_use_1 (tree, gimple, loop_vec_info,
-				  bb_vec_info, gimple *,
+extern bool vect_is_simple_use_1 (tree, gimple *, loop_vec_info,
+				  bb_vec_info, gimple **,
 				  tree *,  enum vect_def_type *, tree *);
-extern bool supportable_widening_operation (enum tree_code, gimple, tree, tree,
+extern bool supportable_widening_operation (enum tree_code, gimple *, tree, tree,
                                             enum tree_code *, enum tree_code *,
 					    int *, vec<tree> *);
 extern bool supportable_narrowing_operation (enum tree_code, tree, tree,
 					     enum tree_code *,
 					     int *, vec<tree> *);
-extern stmt_vec_info new_stmt_vec_info (gimple stmt, loop_vec_info,
+extern stmt_vec_info new_stmt_vec_info (gimple *stmt, loop_vec_info,
                                         bb_vec_info);
-extern void free_stmt_vec_info (gimple stmt);
-extern tree vectorizable_function (gimple, tree, tree);
+extern void free_stmt_vec_info (gimple *stmt);
+extern tree vectorizable_function (gimple *, tree, tree);
 extern void vect_model_simple_cost (stmt_vec_info, int, enum vect_def_type *,
                                     stmt_vector_for_cost *,
 				    stmt_vector_for_cost *);
@@ -1018,18 +1018,18 @@ extern void vect_model_load_cost (stmt_vec_info, int, bool, slp_tree,
 extern unsigned record_stmt_cost (stmt_vector_for_cost *, int,
 				  enum vect_cost_for_stmt, stmt_vec_info,
 				  int, enum vect_cost_model_location);
-extern void vect_finish_stmt_generation (gimple, gimple,
+extern void vect_finish_stmt_generation (gimple *, gimple *,
                                          gimple_stmt_iterator *);
 extern bool vect_mark_stmts_to_be_vectorized (loop_vec_info);
-extern tree vect_get_vec_def_for_operand (tree, gimple, tree *);
-extern tree vect_init_vector (gimple, tree, tree,
+extern tree vect_get_vec_def_for_operand (tree, gimple *, tree *);
+extern tree vect_init_vector (gimple *, tree, tree,
                               gimple_stmt_iterator *);
 extern tree vect_get_vec_def_for_stmt_copy (enum vect_def_type, tree);
-extern bool vect_transform_stmt (gimple, gimple_stmt_iterator *,
+extern bool vect_transform_stmt (gimple *, gimple_stmt_iterator *,
                                  bool *, slp_tree, slp_instance);
-extern void vect_remove_stores (gimple);
-extern bool vect_analyze_stmt (gimple, bool *, slp_tree);
-extern bool vectorizable_condition (gimple, gimple_stmt_iterator *, gimple *,
+extern void vect_remove_stores (gimple *);
+extern bool vect_analyze_stmt (gimple *, bool *, slp_tree);
+extern bool vectorizable_condition (gimple *, gimple_stmt_iterator *, gimple **,
                                     tree, int, slp_tree);
 extern void vect_get_load_cost (struct data_reference *, int, bool,
 				unsigned int *, unsigned int *,
@@ -1038,7 +1038,7 @@ extern void vect_get_load_cost (struct data_reference *, int, bool,
 extern void vect_get_store_cost (struct data_reference *, int,
 				 unsigned int *, stmt_vector_for_cost *);
 extern bool vect_supportable_shift (enum tree_code, tree);
-extern void vect_get_vec_defs (tree, tree, gimple, vec<tree> *,
+extern void vect_get_vec_defs (tree, tree, gimple *, vec<tree> *,
 			       vec<tree> *, slp_tree, int);
 extern tree vect_gen_perm_mask (tree, unsigned char *);
 
@@ -1046,7 +1046,7 @@ extern tree vect_gen_perm_mask (tree, unsigned char *);
 extern bool vect_can_force_dr_alignment_p (const_tree, unsigned int);
 extern enum dr_alignment_support vect_supportable_dr_alignment
                                            (struct data_reference *, bool);
-extern tree vect_get_smallest_scalar_type (gimple, HOST_WIDE_INT *,
+extern tree vect_get_smallest_scalar_type (gimple *, HOST_WIDE_INT *,
                                            HOST_WIDE_INT *);
 extern bool vect_analyze_data_ref_dependences (loop_vec_info, int *);
 extern bool vect_slp_analyze_data_ref_dependences (bb_vec_info);
@@ -1055,46 +1055,46 @@ extern bool vect_analyze_data_refs_alignment (loop_vec_info, bb_vec_info);
 extern bool vect_verify_datarefs_alignment (loop_vec_info, bb_vec_info);
 extern bool vect_analyze_data_ref_accesses (loop_vec_info, bb_vec_info);
 extern bool vect_prune_runtime_alias_test_list (loop_vec_info);
-extern tree vect_check_gather (gimple, loop_vec_info, tree *, tree *,
+extern tree vect_check_gather (gimple *, loop_vec_info, tree *, tree *,
 			       int *);
 extern bool vect_analyze_data_refs (loop_vec_info, bb_vec_info, int *,
 				    unsigned *);
-extern tree vect_create_data_ref_ptr (gimple, tree, struct loop *, tree,
+extern tree vect_create_data_ref_ptr (gimple *, tree, struct loop *, tree,
 				      tree *, gimple_stmt_iterator *,
-				      gimple *, bool, bool *);
-extern tree bump_vector_ptr (tree, gimple, gimple_stmt_iterator *, gimple, tree);
+				      gimple **, bool, bool *);
+extern tree bump_vector_ptr (tree, gimple *, gimple_stmt_iterator *, gimple *, tree);
 extern tree vect_create_destination_var (tree, tree);
 extern bool vect_grouped_store_supported (tree, unsigned HOST_WIDE_INT);
 extern bool vect_store_lanes_supported (tree, unsigned HOST_WIDE_INT);
 extern bool vect_grouped_load_supported (tree, unsigned HOST_WIDE_INT);
 extern bool vect_load_lanes_supported (tree, unsigned HOST_WIDE_INT);
-extern void vect_permute_store_chain (vec<tree> ,unsigned int, gimple,
+extern void vect_permute_store_chain (vec<tree> ,unsigned int, gimple *,
                                     gimple_stmt_iterator *, vec<tree> *);
-extern tree vect_setup_realignment (gimple, gimple_stmt_iterator *, tree *,
+extern tree vect_setup_realignment (gimple *, gimple_stmt_iterator *, tree *,
                                     enum dr_alignment_support, tree,
                                     struct loop **);
-extern void vect_transform_grouped_load (gimple, vec<tree> , int,
+extern void vect_transform_grouped_load (gimple *, vec<tree> , int,
                                          gimple_stmt_iterator *);
-extern void vect_record_grouped_load_vectors (gimple, vec<tree> );
+extern void vect_record_grouped_load_vectors (gimple *, vec<tree> );
 extern tree vect_get_new_vect_var (tree, enum vect_var_kind, const char *);
-extern tree vect_create_addr_base_for_vector_ref (gimple, gimple_seq *,
+extern tree vect_create_addr_base_for_vector_ref (gimple *, gimple_seq *,
                                                   tree, struct loop *);
 
 /* In tree-vect-loop.c.  */
 /* FORNOW: Used in tree-parloops.c.  */
 extern void destroy_loop_vec_info (loop_vec_info, bool);
-extern gimple vect_force_simple_reduction (loop_vec_info, gimple, bool, bool *);
+extern gimple *vect_force_simple_reduction (loop_vec_info, gimple *, bool, bool *);
 /* Drive for loop analysis stage.  */
 extern loop_vec_info vect_analyze_loop (struct loop *);
 /* Drive for loop transformation stage.  */
 extern void vect_transform_loop (loop_vec_info);
 extern loop_vec_info vect_analyze_loop_form (struct loop *);
-extern bool vectorizable_live_operation (gimple, gimple_stmt_iterator *,
-                                         gimple *);
-extern bool vectorizable_reduction (gimple, gimple_stmt_iterator *, gimple *,
+extern bool vectorizable_live_operation (gimple *, gimple_stmt_iterator *,
+                                         gimple **);
+extern bool vectorizable_reduction (gimple *, gimple_stmt_iterator *, gimple **,
                                     slp_tree);
-extern bool vectorizable_induction (gimple, gimple_stmt_iterator *, gimple *);
-extern tree get_initial_def_for_reduction (gimple, tree, tree *);
+extern bool vectorizable_induction (gimple *, gimple_stmt_iterator *, gimple **);
+extern tree get_initial_def_for_reduction (gimple *, tree, tree *);
 extern int vect_min_worthwhile_factor (enum tree_code);
 extern int vect_get_known_peeling_cost (loop_vec_info, int, int *, int,
 					stmt_vector_for_cost *,
@@ -1122,7 +1122,7 @@ extern void vect_slp_transform_bb (basic_block);
 /* Pattern recognition functions.
    Additional pattern recognition functions can (and will) be added
    in the future.  */
-typedef gimple (* vect_recog_func_ptr) (vec<gimple> *, tree *, tree *);
+typedef gimple *(* vect_recog_func_ptr) (vec<gimple *> *, tree *, tree *);
 #define NUM_PATTERNS 11
 void vect_pattern_recog (loop_vec_info, bb_vec_info);
 
diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index 633c329..55576f9 100644
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -169,7 +169,7 @@ static bool values_propagated;
 static int *vr_phi_edge_counts;
 
 typedef struct {
-  gimple stmt;
+  gimple *stmt;
   tree vec;
 } switch_update;
 
@@ -324,7 +324,7 @@ is_overflow_infinity (const_tree val)
 /* Return whether STMT has a constant rhs that is_overflow_infinity. */
 
 static inline bool
-stmt_overflow_infinity (gimple stmt)
+stmt_overflow_infinity (gimple *stmt)
 {
   if (is_gimple_assign (stmt)
       && get_gimple_rhs_class (gimple_assign_rhs_code (stmt)) ==
@@ -963,7 +963,7 @@ usable_range_p (value_range_t *vr, bool *strict_overflow_p)
    *STRICT_OVERFLOW_P.*/
 
 static bool
-gimple_assign_nonnegative_warnv_p (gimple stmt, bool *strict_overflow_p)
+gimple_assign_nonnegative_warnv_p (gimple *stmt, bool *strict_overflow_p)
 {
   enum tree_code code = gimple_assign_rhs_code (stmt);
   switch (get_gimple_rhs_class (code))
@@ -997,7 +997,7 @@ gimple_assign_nonnegative_warnv_p (gimple stmt, bool *strict_overflow_p)
    *STRICT_OVERFLOW_P.*/
 
 static bool
-gimple_call_nonnegative_warnv_p (gimple stmt, bool *strict_overflow_p)
+gimple_call_nonnegative_warnv_p (gimple *stmt, bool *strict_overflow_p)
 {
   tree arg0 = gimple_call_num_args (stmt) > 0 ?
     gimple_call_arg (stmt, 0) : NULL_TREE;
@@ -1017,7 +1017,7 @@ gimple_call_nonnegative_warnv_p (gimple stmt, bool *strict_overflow_p)
    *STRICT_OVERFLOW_P.*/
 
 static bool
-gimple_stmt_nonnegative_warnv_p (gimple stmt, bool *strict_overflow_p)
+gimple_stmt_nonnegative_warnv_p (gimple *stmt, bool *strict_overflow_p)
 {
   switch (gimple_code (stmt))
     {
@@ -1036,7 +1036,7 @@ gimple_stmt_nonnegative_warnv_p (gimple stmt, bool *strict_overflow_p)
    *STRICT_OVERFLOW_P.*/
 
 static bool
-gimple_assign_nonzero_warnv_p (gimple stmt, bool *strict_overflow_p)
+gimple_assign_nonzero_warnv_p (gimple *stmt, bool *strict_overflow_p)
 {
   enum tree_code code = gimple_assign_rhs_code (stmt);
   switch (get_gimple_rhs_class (code))
@@ -1070,7 +1070,7 @@ gimple_assign_nonzero_warnv_p (gimple stmt, bool *strict_overflow_p)
    *STRICT_OVERFLOW_P.*/
 
 static bool
-gimple_stmt_nonzero_warnv_p (gimple stmt, bool *strict_overflow_p)
+gimple_stmt_nonzero_warnv_p (gimple *stmt, bool *strict_overflow_p)
 {
   switch (gimple_code (stmt))
     {
@@ -1099,7 +1099,7 @@ gimple_stmt_nonzero_warnv_p (gimple stmt, bool *strict_overflow_p)
    obtained so far.  */
 
 static bool
-vrp_stmt_computes_nonzero (gimple stmt, bool *strict_overflow_p)
+vrp_stmt_computes_nonzero (gimple *stmt, bool *strict_overflow_p)
 {
   if (gimple_stmt_nonzero_warnv_p (stmt, strict_overflow_p))
     return true;
@@ -3432,7 +3432,7 @@ extract_range_from_unary_expr (value_range_t *vr, enum tree_code code,
    the ranges of each of its operands and the expression code.  */
 
 static void
-extract_range_from_cond_expr (value_range_t *vr, gimple stmt)
+extract_range_from_cond_expr (value_range_t *vr, gimple *stmt)
 {
   tree op0, op1;
   value_range_t vr0 = VR_INITIALIZER;
@@ -3501,7 +3501,7 @@ extract_range_from_comparison (value_range_t *vr, enum tree_code code,
    Store the result in *VR */
 
 static void
-extract_range_basic (value_range_t *vr, gimple stmt)
+extract_range_basic (value_range_t *vr, gimple *stmt)
 {
   bool sop = false;
   tree type = gimple_expr_type (stmt);
@@ -3739,7 +3739,7 @@ extract_range_basic (value_range_t *vr, gimple stmt)
    in *VR.  */
 
 static void
-extract_range_from_assignment (value_range_t *vr, gimple stmt)
+extract_range_from_assignment (value_range_t *vr, gimple *stmt)
 {
   enum tree_code code = gimple_assign_rhs_code (stmt);
 
@@ -3779,7 +3779,7 @@ extract_range_from_assignment (value_range_t *vr, gimple stmt)
 
 static void
 adjust_range_with_scev (value_range_t *vr, struct loop *loop,
-			gimple stmt, tree var)
+			gimple *stmt, tree var)
 {
   tree init, step, chrec, tmin, tmax, min, max, type, tem;
   enum ev_direction dir;
@@ -4358,11 +4358,11 @@ debug_all_value_ranges (void)
    create a new SSA name N and return the assertion assignment
    'N = ASSERT_EXPR <V, V OP W>'.  */
 
-static gimple
+static gimple *
 build_assert_expr_for (tree cond, tree v)
 {
   tree a;
-  gimple assertion;
+  gimple *assertion;
 
   gcc_assert (TREE_CODE (v) == SSA_NAME
 	      && COMPARISON_CLASS_P (cond));
@@ -4384,7 +4384,7 @@ build_assert_expr_for (tree cond, tree v)
    point values.  */
 
 static inline bool
-fp_predicate (gimple stmt)
+fp_predicate (gimple *stmt)
 {
   GIMPLE_CHECK (stmt, GIMPLE_COND);
 
@@ -4397,7 +4397,7 @@ fp_predicate (gimple stmt)
    inferred.  */
 
 static bool
-infer_value_range (gimple stmt, tree op, enum tree_code *comp_code_p, tree *val_p)
+infer_value_range (gimple *stmt, tree op, enum tree_code *comp_code_p, tree *val_p)
 {
   *val_p = NULL_TREE;
   *comp_code_p = ERROR_MARK;
@@ -4757,7 +4757,7 @@ register_edge_assert_for_2 (tree name, edge e, gimple_stmt_iterator bsi,
       && TREE_CODE (val) == INTEGER_CST
       && TYPE_UNSIGNED (TREE_TYPE (val)))
     {
-      gimple def_stmt = SSA_NAME_DEF_STMT (name);
+      gimple *def_stmt = SSA_NAME_DEF_STMT (name);
       tree cst2 = NULL_TREE, name2 = NULL_TREE, name3 = NULL_TREE;
 
       /* Extract CST2 from the (optional) addition.  */
@@ -4852,7 +4852,7 @@ register_edge_assert_for_2 (tree name, edge e, gimple_stmt_iterator bsi,
       && TREE_CODE (val) == INTEGER_CST)
     {
       imm_use_iterator ui;
-      gimple use_stmt;
+      gimple *use_stmt;
       FOR_EACH_IMM_USE_STMT (use_stmt, ui, name)
 	{
 	  /* Cut off to use-stmts that are in the predecessor.  */
@@ -4885,7 +4885,7 @@ register_edge_assert_for_2 (tree name, edge e, gimple_stmt_iterator bsi,
   if (TREE_CODE_CLASS (comp_code) == tcc_comparison
       && TREE_CODE (val) == INTEGER_CST)
     {
-      gimple def_stmt = SSA_NAME_DEF_STMT (name);
+      gimple *def_stmt = SSA_NAME_DEF_STMT (name);
       tree name2 = NULL_TREE, names[2], cst2 = NULL_TREE;
       tree val2 = NULL_TREE;
       unsigned int prec = TYPE_PRECISION (TREE_TYPE (val));
@@ -5059,7 +5059,7 @@ register_edge_assert_for_2 (tree name, edge e, gimple_stmt_iterator bsi,
 	      && (nprec > 1
 		  || TYPE_UNSIGNED (TREE_TYPE (val))))
 	    {
-	      gimple def_stmt2 = SSA_NAME_DEF_STMT (name2);
+	      gimple *def_stmt2 = SSA_NAME_DEF_STMT (name2);
 	      if (gimple_assign_cast_p (def_stmt2))
 		{
 		  names[1] = gimple_assign_rhs1 (def_stmt2);
@@ -5287,7 +5287,7 @@ register_edge_assert_for_1 (tree op, enum tree_code code,
 			    edge e, gimple_stmt_iterator bsi)
 {
   bool retval = false;
-  gimple op_def;
+  gimple *op_def;
   tree val;
   enum tree_code rhs_code;
 
@@ -5410,7 +5410,7 @@ register_edge_assert_for (tree name, edge e, gimple_stmt_iterator si,
   if (((comp_code == EQ_EXPR && integer_onep (val))
        || (comp_code == NE_EXPR && integer_zerop (val))))
     {
-      gimple def_stmt = SSA_NAME_DEF_STMT (name);
+      gimple *def_stmt = SSA_NAME_DEF_STMT (name);
 
       if (is_gimple_assign (def_stmt)
 	  && gimple_assign_rhs_code (def_stmt) == BIT_AND_EXPR)
@@ -5428,7 +5428,7 @@ register_edge_assert_for (tree name, edge e, gimple_stmt_iterator si,
   if (((comp_code == EQ_EXPR && integer_zerop (val))
        || (comp_code == NE_EXPR && integer_onep (val))))
     {
-      gimple def_stmt = SSA_NAME_DEF_STMT (name);
+      gimple *def_stmt = SSA_NAME_DEF_STMT (name);
 
       /* For BIT_IOR_EXPR only if NAME == 0 both operands have
 	 necessarily zero value, or if type-precision is one.  */
@@ -5457,7 +5457,7 @@ register_edge_assert_for (tree name, edge e, gimple_stmt_iterator si,
    list of assertions for the corresponding operands.  */
 
 static bool
-find_conditional_asserts (basic_block bb, gimple last)
+find_conditional_asserts (basic_block bb, gimple *last)
 {
   bool need_assert;
   gimple_stmt_iterator bsi;
@@ -5535,7 +5535,7 @@ compare_case_labels (const void *p1, const void *p2)
    list of assertions for the corresponding operands.  */
 
 static bool
-find_switch_asserts (basic_block bb, gimple last)
+find_switch_asserts (basic_block bb, gimple *last)
 {
   bool need_assert;
   gimple_stmt_iterator bsi;
@@ -5687,7 +5687,7 @@ static bool
 find_assert_locations_1 (basic_block bb, sbitmap live)
 {
   gimple_stmt_iterator si;
-  gimple last;
+  gimple *last;
   bool need_assert;
 
   need_assert = false;
@@ -5712,7 +5712,7 @@ find_assert_locations_1 (basic_block bb, sbitmap live)
      for statements that may infer assertions for their used operands.  */
   for (si = gsi_last_bb (bb); !gsi_end_p (si); gsi_prev (&si))
     {
-      gimple stmt;
+      gimple *stmt;
       tree op;
       ssa_op_iter i;
 
@@ -5746,7 +5746,7 @@ find_assert_locations_1 (basic_block bb, sbitmap live)
 	      if (comp_code == NE_EXPR && integer_zerop (value))
 		{
 		  tree t = op;
-		  gimple def_stmt = SSA_NAME_DEF_STMT (t);
+		  gimple *def_stmt = SSA_NAME_DEF_STMT (t);
 
 		  while (is_gimple_assign (def_stmt)
 			 && gimple_assign_rhs_code (def_stmt)  == NOP_EXPR
@@ -5787,7 +5787,7 @@ find_assert_locations_1 (basic_block bb, sbitmap live)
     {
       use_operand_p arg_p;
       ssa_op_iter i;
-      gimple phi = gsi_stmt (si);
+      gimple *phi = gsi_stmt (si);
       tree res = gimple_phi_result (phi);
 
       if (virtual_operand_p (res))
@@ -5835,7 +5835,7 @@ find_assert_locations (void)
       for (gimple_stmt_iterator gsi = gsi_start_phis (loop->header);
 	   !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple phi = gsi_stmt (gsi);
+	  gimple *phi = gsi_stmt (gsi);
 	  if (virtual_operand_p (gimple_phi_result (phi)))
 	    continue;
 	  tree arg = gimple_phi_arg_def (phi, j);
@@ -5928,9 +5928,9 @@ static bool
 process_assert_insertions_for (tree name, assert_locus_t loc)
 {
   /* Build the comparison expression NAME_i COMP_CODE VAL.  */
-  gimple stmt;
+  gimple *stmt;
   tree cond;
-  gimple assert_stmt;
+  gimple *assert_stmt;
   edge_iterator ei;
   edge e;
 
@@ -6185,7 +6185,7 @@ search_for_addr_array (tree t, location_t location)
 {
   while (TREE_CODE (t) == SSA_NAME)
     {
-      gimple g = SSA_NAME_DEF_STMT (t);
+      gimple *g = SSA_NAME_DEF_STMT (t);
 
       if (gimple_code (g) != GIMPLE_ASSIGN)
 	return;
@@ -6324,7 +6324,7 @@ check_all_array_refs (void)
 
       for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
 	{
-	  gimple stmt = gsi_stmt (si);
+	  gimple *stmt = gsi_stmt (si);
 	  struct walk_stmt_info wi;
 	  if (!gimple_has_location (stmt))
 	    continue;
@@ -6358,7 +6358,7 @@ check_all_array_refs (void)
    in basic block COND_BB.  */
 
 static bool
-all_imm_uses_in_stmt_or_feed_cond (tree var, gimple stmt, basic_block cond_bb)
+all_imm_uses_in_stmt_or_feed_cond (tree var, gimple *stmt, basic_block cond_bb)
 {
   use_operand_p use_p, use2_p;
   imm_use_iterator iter;
@@ -6366,7 +6366,7 @@ all_imm_uses_in_stmt_or_feed_cond (tree var, gimple stmt, basic_block cond_bb)
   FOR_EACH_IMM_USE_FAST (use_p, iter, var)
     if (USE_STMT (use_p) != stmt)
       {
-	gimple use_stmt = USE_STMT (use_p), use_stmt2;
+	gimple *use_stmt = USE_STMT (use_p), *use_stmt2;
 	if (is_gimple_debug (use_stmt))
 	  continue;
 	while (is_gimple_assign (use_stmt)
@@ -6400,7 +6400,7 @@ maybe_set_nonzero_bits (basic_block bb, tree var)
 {
   edge e = single_pred_edge (bb);
   basic_block cond_bb = e->src;
-  gimple stmt = last_stmt (cond_bb);
+  gimple *stmt = last_stmt (cond_bb);
   tree cst;
 
   if (stmt == NULL
@@ -6418,7 +6418,7 @@ maybe_set_nonzero_bits (basic_block bb, tree var)
     return;
   if (gimple_assign_rhs1 (stmt) != var)
     {
-      gimple stmt2;
+      gimple *stmt2;
 
       if (TREE_CODE (gimple_assign_rhs1 (stmt)) != SSA_NAME)
 	return;
@@ -6474,8 +6474,8 @@ remove_range_assertions (void)
   FOR_EACH_BB_FN (bb, cfun)
     for (si = gsi_after_labels (bb), is_unreachable = -1; !gsi_end_p (si);)
       {
-	gimple stmt = gsi_stmt (si);
-	gimple use_stmt;
+	gimple *stmt = gsi_stmt (si);
+	gimple *use_stmt;
 
 	if (is_gimple_assign (stmt)
 	    && gimple_assign_rhs_code (stmt) == ASSERT_EXPR)
@@ -6543,7 +6543,7 @@ remove_range_assertions (void)
 /* Return true if STMT is interesting for VRP.  */
 
 static bool
-stmt_interesting_for_vrp (gimple stmt)
+stmt_interesting_for_vrp (gimple *stmt)
 {
   if (gimple_code (stmt) == GIMPLE_PHI)
     {
@@ -6592,7 +6592,7 @@ vrp_initialize (void)
 
       for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
 	{
-	  gimple phi = gsi_stmt (si);
+	  gimple *phi = gsi_stmt (si);
 	  if (!stmt_interesting_for_vrp (phi))
 	    {
 	      tree lhs = PHI_RESULT (phi);
@@ -6605,7 +6605,7 @@ vrp_initialize (void)
 
       for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
         {
-	  gimple stmt = gsi_stmt (si);
+	  gimple *stmt = gsi_stmt (si);
 
  	  /* If the statement is a control insn, then we do not
  	     want to avoid simulating the statement once.  Failure
@@ -6646,7 +6646,7 @@ vrp_valueize (tree name)
    the SSA name in *OUTPUT_P.  */
 
 static enum ssa_prop_result
-vrp_visit_assignment_or_call (gimple stmt, tree *output_p)
+vrp_visit_assignment_or_call (gimple *stmt, tree *output_p)
 {
   tree def, lhs;
   ssa_op_iter iter;
@@ -6979,7 +6979,7 @@ vrp_evaluate_conditional_warnv_with_ops (enum tree_code code, tree op0,
    appropriate.  */
 
 static tree
-vrp_evaluate_conditional (enum tree_code code, tree op0, tree op1, gimple stmt)
+vrp_evaluate_conditional (enum tree_code code, tree op0, tree op1, gimple *stmt)
 {
   bool sop;
   tree ret;
@@ -7072,7 +7072,7 @@ vrp_evaluate_conditional (enum tree_code code, tree op0, tree op1, gimple stmt)
    SSA_PROP_VARYING.  */
 
 static enum ssa_prop_result
-vrp_visit_cond_stmt (gimple stmt, edge *taken_edge_p)
+vrp_visit_cond_stmt (gimple *stmt, edge *taken_edge_p)
 {
   tree val;
   bool sop;
@@ -7187,7 +7187,7 @@ vrp_visit_cond_stmt (gimple stmt, edge *taken_edge_p)
    returned. */
 
 static bool
-find_case_label_index (gimple stmt, size_t start_idx, tree val, size_t *idx)
+find_case_label_index (gimple *stmt, size_t start_idx, tree val, size_t *idx)
 {
   size_t n = gimple_switch_num_labels (stmt);
   size_t low, high;
@@ -7237,7 +7237,7 @@ find_case_label_index (gimple stmt, size_t start_idx, tree val, size_t *idx)
    Returns true if the default label is not needed. */
 
 static bool
-find_case_label_range (gimple stmt, tree min, tree max, size_t *min_idx,
+find_case_label_range (gimple *stmt, tree min, tree max, size_t *min_idx,
 		       size_t *max_idx)
 {
   size_t i, j;
@@ -7293,7 +7293,7 @@ find_case_label_range (gimple stmt, tree min, tree max, size_t *min_idx,
    Returns true if the default label is not needed.  */
 
 static bool
-find_case_label_ranges (gimple stmt, value_range_t *vr, size_t *min_idx1,
+find_case_label_ranges (gimple *stmt, value_range_t *vr, size_t *min_idx1,
 			size_t *max_idx1, size_t *min_idx2,
 			size_t *max_idx2)
 {
@@ -7371,7 +7371,7 @@ find_case_label_ranges (gimple stmt, value_range_t *vr, size_t *min_idx1,
    SSA_PROP_VARYING.  */
 
 static enum ssa_prop_result
-vrp_visit_switch_stmt (gimple stmt, edge *taken_edge_p)
+vrp_visit_switch_stmt (gimple *stmt, edge *taken_edge_p)
 {
   tree op, val;
   value_range_t *vr;
@@ -7468,7 +7468,7 @@ vrp_visit_switch_stmt (gimple stmt, edge *taken_edge_p)
    If STMT produces a varying value, return SSA_PROP_VARYING.  */
 
 static enum ssa_prop_result
-vrp_visit_stmt (gimple stmt, edge *taken_edge_p, tree *output_p)
+vrp_visit_stmt (gimple *stmt, edge *taken_edge_p, tree *output_p)
 {
   tree def;
   ssa_op_iter iter;
@@ -8222,7 +8222,7 @@ vrp_meet (value_range_t *vr0, value_range_t *vr1)
    value ranges, set a new range for the LHS of PHI.  */
 
 static enum ssa_prop_result
-vrp_visit_phi_node (gimple phi)
+vrp_visit_phi_node (gimple *phi)
 {
   size_t i;
   tree lhs = PHI_RESULT (phi);
@@ -8412,7 +8412,7 @@ varying:
 /* Simplify boolean operations if the source is known
    to be already a boolean.  */
 static bool
-simplify_truth_ops_using_ranges (gimple_stmt_iterator *gsi, gimple stmt)
+simplify_truth_ops_using_ranges (gimple_stmt_iterator *gsi, gimple *stmt)
 {
   enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
   tree lhs, op0, op1;
@@ -8461,7 +8461,7 @@ simplify_truth_ops_using_ranges (gimple_stmt_iterator *gsi, gimple stmt)
   else if (need_conversion)
     {
       tree tem = make_ssa_name (TREE_TYPE (op0), NULL);
-      gimple newop = gimple_build_assign_with_ops (BIT_XOR_EXPR, tem, op0, op1);
+      gimple *newop = gimple_build_assign_with_ops (BIT_XOR_EXPR, tem, op0, op1);
       gsi_insert_before (gsi, newop, GSI_SAME_STMT);
       gimple_assign_set_rhs_with_ops (gsi, NOP_EXPR, tem, NULL_TREE);
     }
@@ -8478,7 +8478,7 @@ simplify_truth_ops_using_ranges (gimple_stmt_iterator *gsi, gimple stmt)
    than zero and the second operand is an exact power of two.  */
 
 static bool
-simplify_div_or_mod_using_ranges (gimple stmt)
+simplify_div_or_mod_using_ranges (gimple *stmt)
 {
   enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
   tree val = NULL;
@@ -8547,7 +8547,7 @@ simplify_div_or_mod_using_ranges (gimple stmt)
    ABS_EXPR into a NEGATE_EXPR.  */
 
 static bool
-simplify_abs_using_ranges (gimple stmt)
+simplify_abs_using_ranges (gimple *stmt)
 {
   tree val = NULL;
   tree op = gimple_assign_rhs1 (stmt);
@@ -8614,7 +8614,7 @@ simplify_abs_using_ranges (gimple stmt)
    operation is redundant.  */
 
 static bool
-simplify_bit_ops_using_ranges (gimple_stmt_iterator *gsi, gimple stmt)
+simplify_bit_ops_using_ranges (gimple_stmt_iterator *gsi, gimple *stmt)
 {
   tree op0 = gimple_assign_rhs1 (stmt);
   tree op1 = gimple_assign_rhs2 (stmt);
@@ -8809,7 +8809,7 @@ range_fits_type_p (value_range_t *vr, unsigned dest_precision, signop dest_sgn)
    the original conditional.  */
 
 static bool
-simplify_cond_using_ranges (gimple stmt)
+simplify_cond_using_ranges (gimple *stmt)
 {
   tree op0 = gimple_cond_lhs (stmt);
   tree op1 = gimple_cond_rhs (stmt);
@@ -8896,7 +8896,7 @@ simplify_cond_using_ranges (gimple stmt)
   if (TREE_CODE (op0) == SSA_NAME
       && TREE_CODE (op1) == INTEGER_CST)
     {
-      gimple def_stmt = SSA_NAME_DEF_STMT (op0);
+      gimple *def_stmt = SSA_NAME_DEF_STMT (op0);
       tree innerop;
 
       if (!is_gimple_assign (def_stmt)
@@ -8955,7 +8955,7 @@ simplify_cond_using_ranges (gimple stmt)
    argument.  */
 
 static bool
-simplify_switch_using_ranges (gimple stmt)
+simplify_switch_using_ranges (gimple *stmt)
 {
   tree op = gimple_switch_index (stmt);
   value_range_t *vr;
@@ -9053,10 +9053,10 @@ simplify_switch_using_ranges (gimple stmt)
 /* Simplify an integral conversion from an SSA name in STMT.  */
 
 static bool
-simplify_conversion_using_ranges (gimple stmt)
+simplify_conversion_using_ranges (gimple *stmt)
 {
   tree innerop, middleop, finaltype;
-  gimple def_stmt;
+  gimple *def_stmt;
   value_range_t *innervr;
   signop inner_sgn, middle_sgn, final_sgn;
   unsigned inner_prec, middle_prec, final_prec;
@@ -9132,14 +9132,14 @@ simplify_conversion_using_ranges (gimple stmt)
 /* Simplify a conversion from integral SSA name to float in STMT.  */
 
 static bool
-simplify_float_conversion_using_ranges (gimple_stmt_iterator *gsi, gimple stmt)
+simplify_float_conversion_using_ranges (gimple_stmt_iterator *gsi, gimple *stmt)
 {
   tree rhs1 = gimple_assign_rhs1 (stmt);
   value_range_t *vr = get_value_range (rhs1);
   enum machine_mode fltmode = TYPE_MODE (TREE_TYPE (gimple_assign_lhs (stmt)));
   enum machine_mode mode;
   tree tem;
-  gimple conv;
+  gimple *conv;
 
   /* We can only handle constant ranges.  */
   if (vr->type != VR_RANGE
@@ -9197,7 +9197,7 @@ simplify_float_conversion_using_ranges (gimple_stmt_iterator *gsi, gimple stmt)
 /* Simplify an internal fn call using ranges if possible.  */
 
 static bool
-simplify_internal_call_using_ranges (gimple_stmt_iterator *gsi, gimple stmt)
+simplify_internal_call_using_ranges (gimple_stmt_iterator *gsi, gimple *stmt)
 {
   enum tree_code subcode;
   switch (gimple_call_internal_fn (stmt))
@@ -9277,7 +9277,7 @@ simplify_internal_call_using_ranges (gimple_stmt_iterator *gsi, gimple stmt)
 	}
     }
 
-  gimple g = gimple_build_assign_with_ops (subcode, gimple_call_lhs (stmt),
+  gimple *g = gimple_build_assign_with_ops (subcode, gimple_call_lhs (stmt),
 					   op0, op1);
   gsi_replace (gsi, g, false);
   return true;
@@ -9288,7 +9288,7 @@ simplify_internal_call_using_ranges (gimple_stmt_iterator *gsi, gimple stmt)
 static bool
 simplify_stmt_using_ranges (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   if (is_gimple_assign (stmt))
     {
       enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
@@ -9367,7 +9367,7 @@ fold_predicate_in (gimple_stmt_iterator *si)
 {
   bool assignment_p = false;
   tree val;
-  gimple stmt = gsi_stmt (*si);
+  gimple *stmt = gsi_stmt (*si);
 
   if (is_gimple_assign (stmt)
       && TREE_CODE_CLASS (gimple_assign_rhs_code (stmt)) == tcc_comparison)
@@ -9443,7 +9443,7 @@ static vec<tree> equiv_stack;
    for any overflow warnings.  */
 
 static tree
-simplify_stmt_for_jump_threading (gimple stmt, gimple within_stmt)
+simplify_stmt_for_jump_threading (gimple *stmt, gimple *within_stmt)
 {
   if (gimple_code (stmt) == GIMPLE_COND)
     return vrp_evaluate_conditional (gimple_cond_code (stmt),
@@ -9492,7 +9492,7 @@ static void
 identify_jump_threads (void)
 {
   basic_block bb;
-  gimple dummy;
+  gimple *dummy;
   int i;
   edge e;
 
@@ -9532,7 +9532,7 @@ identify_jump_threads (void)
      point in compilation.  */
   FOR_EACH_BB_FN (bb, cfun)
     {
-      gimple last;
+      gimple *last;
 
       /* If the generic jump threading code does not find this block
 	 interesting, then there is nothing to do.  */
diff --git a/gcc/tree.c b/gcc/tree.c
index 4655227..024f1ca 100644
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -5460,7 +5460,7 @@ find_decls_types_in_node (struct cgraph_node *n, struct free_lang_data_d *fld)
 
       for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
 	{
-	  gimple phi = gsi_stmt (si);
+	  gimple *phi = gsi_stmt (si);
 
 	  for (i = 0; i < gimple_phi_num_args (phi); i++)
 	    {
@@ -5471,7 +5471,7 @@ find_decls_types_in_node (struct cgraph_node *n, struct free_lang_data_d *fld)
 
       for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
 	{
-	  gimple stmt = gsi_stmt (si);
+	  gimple *stmt = gsi_stmt (si);
 
 	  if (is_gimple_call (stmt))
 	    find_decls_types (gimple_call_fntype (stmt), fld);
diff --git a/gcc/tree.h b/gcc/tree.h
index 14bbeb1..e10fc64 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -4778,8 +4778,8 @@ extern unsigned int get_object_alignment (tree);
 extern bool get_pointer_alignment_1 (tree, unsigned int *,
 				     unsigned HOST_WIDE_INT *);
 extern unsigned int get_pointer_alignment (tree);
-extern tree fold_call_stmt (gimple, bool);
-extern tree gimple_fold_builtin_snprintf_chk (gimple, tree, enum built_in_function);
+extern tree fold_call_stmt (gimple *, bool);
+extern tree gimple_fold_builtin_snprintf_chk (gimple *, tree, enum built_in_function);
 extern void set_builtin_user_assembler_name (tree decl, const char *asmspec);
 extern bool is_simple_builtin (tree);
 extern bool is_inexpensive_builtin (tree);
diff --git a/gcc/tsan.c b/gcc/tsan.c
index 1de108b..9efd9cc 100644
--- a/gcc/tsan.c
+++ b/gcc/tsan.c
@@ -83,7 +83,7 @@ get_memory_access_decl (bool is_write, unsigned size)
 /* Check as to whether EXPR refers to a store to vptr.  */
 
 static tree
-is_vptr_store (gimple stmt, tree expr, bool is_write)
+is_vptr_store (gimple *stmt, tree expr, bool is_write)
 {
   if (is_write == true
       && gimple_assign_single_p (stmt)
@@ -106,7 +106,7 @@ instrument_expr (gimple_stmt_iterator gsi, tree expr, bool is_write)
   tree base, rhs, expr_ptr, builtin_decl;
   basic_block bb;
   HOST_WIDE_INT size;
-  gimple stmt, g;
+  gimple *stmt, *g;
   gimple_seq seq;
   location_t loc;
 
@@ -434,7 +434,7 @@ static const struct tsan_map_atomic
 static void
 instrument_builtin_call (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi), g;
+  gimple *stmt = gsi_stmt (*gsi), *g;
   tree callee = gimple_call_fndecl (stmt), last_arg, args[6], t, lhs;
   enum built_in_function fcode = DECL_FUNCTION_CODE (callee);
   unsigned int i, num = gimple_call_num_args (stmt), j;
@@ -600,7 +600,7 @@ instrument_builtin_call (gimple_stmt_iterator *gsi)
 static bool
 instrument_gimple (gimple_stmt_iterator *gsi)
 {
-  gimple stmt;
+  gimple *stmt;
   tree rhs, lhs;
   bool instrumented = false;
 
@@ -654,7 +654,7 @@ instrument_func_entry (void)
   basic_block succ_bb;
   gimple_stmt_iterator gsi;
   tree ret_addr, builtin_decl;
-  gimple g;
+  gimple *g;
 
   succ_bb = single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun));
   gsi = gsi_after_labels (succ_bb);
@@ -680,7 +680,7 @@ instrument_func_exit (void)
   location_t loc;
   basic_block exit_bb;
   gimple_stmt_iterator gsi;
-  gimple stmt, g;
+  gimple *stmt, *g;
   tree builtin_decl;
   edge e;
   edge_iterator ei;
diff --git a/gcc/ubsan.c b/gcc/ubsan.c
index d9d740c..17996f4 100644
--- a/gcc/ubsan.c
+++ b/gcc/ubsan.c
@@ -541,7 +541,7 @@ is_ubsan_builtin_p (tree t)
 void
 ubsan_expand_null_ifn (gimple_stmt_iterator gsi)
 {
-  gimple stmt = gsi_stmt (gsi);
+  gimple *stmt = gsi_stmt (gsi);
   location_t loc = gimple_location (stmt);
   gcc_assert (gimple_call_num_args (stmt) == 2);
   tree ptr = gimple_call_arg (stmt, 0);
@@ -586,7 +586,7 @@ ubsan_expand_null_ifn (gimple_stmt_iterator gsi)
     set_immediate_dominator (CDI_DOMINATORS, then_bb, cond_bb);
 
   /* Put the ubsan builtin call into the newly created BB.  */
-  gimple g;
+  gimple *g;
   if (flag_sanitize_undefined_trap_on_error)
     g = gimple_build_call (builtin_decl_implicit (BUILT_IN_TRAP), 0);
   else
@@ -627,7 +627,7 @@ instrument_member_call (gimple_stmt_iterator *iter)
 {
   tree this_parm = gimple_call_arg (gsi_stmt (*iter), 0);
   tree kind = build_int_cst (unsigned_char_type_node, UBSAN_MEMBER_CALL);
-  gimple g = gimple_build_call_internal (IFN_UBSAN_NULL, 2, this_parm, kind);
+  gimple *g = gimple_build_call_internal (IFN_UBSAN_NULL, 2, this_parm, kind);
   gimple_set_location (g, gimple_location (gsi_stmt (*iter)));
   gsi_insert_before (iter, g, GSI_SAME_STMT);
 }
@@ -642,7 +642,7 @@ instrument_mem_ref (tree t, gimple_stmt_iterator *iter, bool is_lhs)
   if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (TREE_TYPE (t))))
     ikind = UBSAN_MEMBER_ACCESS;
   tree kind = build_int_cst (unsigned_char_type_node, ikind);
-  gimple g = gimple_build_call_internal (IFN_UBSAN_NULL, 2, t, kind);
+  gimple *g = gimple_build_call_internal (IFN_UBSAN_NULL, 2, t, kind);
   gimple_set_location (g, gimple_location (gsi_stmt (*iter)));
   gsi_insert_before (iter, g, GSI_SAME_STMT);
 }
@@ -652,7 +652,7 @@ instrument_mem_ref (tree t, gimple_stmt_iterator *iter, bool is_lhs)
 static void
 instrument_null (gimple_stmt_iterator gsi, bool is_lhs)
 {
-  gimple stmt = gsi_stmt (gsi);
+  gimple *stmt = gsi_stmt (gsi);
   tree t = is_lhs ? gimple_get_lhs (stmt) : gimple_assign_rhs1 (stmt);
   t = get_base_address (t);
   const enum tree_code code = TREE_CODE (t);
@@ -721,12 +721,12 @@ ubsan_build_overflow_builtin (tree_code code, location_t loc, tree lhstype,
 static void
 instrument_si_overflow (gimple_stmt_iterator gsi)
 {
-  gimple stmt = gsi_stmt (gsi);
+  gimple *stmt = gsi_stmt (gsi);
   tree_code code = gimple_assign_rhs_code (stmt);
   tree lhs = gimple_assign_lhs (stmt);
   tree lhstype = TREE_TYPE (lhs);
   tree a, b;
-  gimple g;
+  gimple *g;
 
   /* If this is not a signed operation, don't instrument anything here.
      Also punt on bit-fields.  */
@@ -791,7 +791,7 @@ instrument_si_overflow (gimple_stmt_iterator gsi)
 static void
 instrument_bool_enum_load (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   tree rhs = gimple_assign_rhs1 (stmt);
   tree type = TREE_TYPE (rhs);
   tree minv = NULL_TREE, maxv = NULL_TREE;
@@ -833,7 +833,7 @@ instrument_bool_enum_load (gimple_stmt_iterator *gsi)
   location_t loc = gimple_location (stmt);
   tree ptype = build_pointer_type (TREE_TYPE (rhs));
   tree atype = reference_alias_ptr_type (rhs);
-  gimple g = gimple_build_assign (make_ssa_name (ptype, NULL),
+  gimple *g = gimple_build_assign (make_ssa_name (ptype, NULL),
 				  build_fold_addr_expr (rhs));
   gimple_set_location (g, loc);
   gsi_insert_before (gsi, g, GSI_SAME_STMT);
@@ -937,7 +937,7 @@ pass_ubsan::execute (function *fun)
     {
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  if (is_gimple_debug (stmt) || gimple_clobber_p (stmt))
 	    {
 	      gsi_next (&gsi);
diff --git a/gcc/value-prof.c b/gcc/value-prof.c
index 0d033ef..967b01f 100644
--- a/gcc/value-prof.c
+++ b/gcc/value-prof.c
@@ -125,9 +125,9 @@ along with GCC; see the file COPYING3.  If not see
      and gimple_value_profile_transformations table-driven, perhaps...
 */
 
-static tree gimple_divmod_fixed_value (gimple, tree, int, gcov_type, gcov_type);
-static tree gimple_mod_pow2 (gimple, int, gcov_type, gcov_type);
-static tree gimple_mod_subtract (gimple, int, int, int, gcov_type, gcov_type,
+static tree gimple_divmod_fixed_value (gimple *, tree, int, gcov_type, gcov_type);
+static tree gimple_mod_pow2 (gimple *, int, gcov_type, gcov_type);
+static tree gimple_mod_subtract (gimple *, int, int, int, gcov_type, gcov_type,
 				 gcov_type);
 static bool gimple_divmod_fixed_value_transform (gimple_stmt_iterator *);
 static bool gimple_mod_pow2_value_transform (gimple_stmt_iterator *);
@@ -139,7 +139,7 @@ static bool gimple_ic_transform (gimple_stmt_iterator *);
 
 static histogram_value
 gimple_alloc_histogram_value (struct function *fun ATTRIBUTE_UNUSED,
-			      enum hist_type type, gimple stmt, tree value)
+			      enum hist_type type, gimple *stmt, tree value)
 {
    histogram_value hist = (histogram_value) xcalloc (1, sizeof (*hist));
    hist->hvalue.value = value;
@@ -161,13 +161,13 @@ histogram_hash (const void *x)
 static int
 histogram_eq (const void *x, const void *y)
 {
-  return ((const_histogram_value) x)->hvalue.stmt == (const_gimple) y;
+  return ((const_histogram_value) x)->hvalue.stmt == (const gimple *) y;
 }
 
 /* Set histogram for STMT.  */
 
 static void
-set_histogram_value (struct function *fun, gimple stmt, histogram_value hist)
+set_histogram_value (struct function *fun, gimple *stmt, histogram_value hist)
 {
   void **loc;
   if (!hist && !VALUE_HISTOGRAMS (fun))
@@ -190,7 +190,7 @@ set_histogram_value (struct function *fun, gimple stmt, histogram_value hist)
 /* Get histogram list for STMT.  */
 
 histogram_value
-gimple_histogram_value (struct function *fun, gimple stmt)
+gimple_histogram_value (struct function *fun, gimple *stmt)
 {
   if (!VALUE_HISTOGRAMS (fun))
     return NULL;
@@ -201,7 +201,7 @@ gimple_histogram_value (struct function *fun, gimple stmt)
 /* Add histogram for STMT.  */
 
 void
-gimple_add_histogram_value (struct function *fun, gimple stmt,
+gimple_add_histogram_value (struct function *fun, gimple *stmt,
 			    histogram_value hist)
 {
   hist->hvalue.next = gimple_histogram_value (fun, stmt);
@@ -213,7 +213,7 @@ gimple_add_histogram_value (struct function *fun, gimple stmt,
 /* Remove histogram HIST from STMT's histogram list.  */
 
 void
-gimple_remove_histogram_value (struct function *fun, gimple stmt,
+gimple_remove_histogram_value (struct function *fun, gimple *stmt,
 			       histogram_value hist)
 {
   histogram_value hist2 = gimple_histogram_value (fun, stmt);
@@ -238,7 +238,7 @@ gimple_remove_histogram_value (struct function *fun, gimple stmt,
 /* Lookup histogram of type TYPE in the STMT.  */
 
 histogram_value
-gimple_histogram_value_of_type (struct function *fun, gimple stmt,
+gimple_histogram_value_of_type (struct function *fun, gimple *stmt,
 				enum hist_type type)
 {
   histogram_value hist;
@@ -392,7 +392,7 @@ stream_out_histogram_value (struct output_block *ob, histogram_value hist)
 /* Dump information about HIST to DUMP_FILE.  */
 
 void
-stream_in_histogram_value (struct lto_input_block *ib, gimple stmt)
+stream_in_histogram_value (struct lto_input_block *ib, gimple *stmt)
 {
   enum hist_type type;
   unsigned int ncounters = 0;
@@ -453,7 +453,7 @@ stream_in_histogram_value (struct lto_input_block *ib, gimple stmt)
 /* Dump all histograms attached to STMT to DUMP_FILE.  */
 
 void
-dump_histograms_for_stmt (struct function *fun, FILE *dump_file, gimple stmt)
+dump_histograms_for_stmt (struct function *fun, FILE *dump_file, gimple *stmt)
 {
   histogram_value hist;
   for (hist = gimple_histogram_value (fun, stmt); hist; hist = hist->hvalue.next)
@@ -463,7 +463,7 @@ dump_histograms_for_stmt (struct function *fun, FILE *dump_file, gimple stmt)
 /* Remove all histograms associated with STMT.  */
 
 void
-gimple_remove_stmt_histograms (struct function *fun, gimple stmt)
+gimple_remove_stmt_histograms (struct function *fun, gimple *stmt)
 {
   histogram_value val;
   while ((val = gimple_histogram_value (fun, stmt)) != NULL)
@@ -473,8 +473,8 @@ gimple_remove_stmt_histograms (struct function *fun, gimple stmt)
 /* Duplicate all histograms associates with OSTMT to STMT.  */
 
 void
-gimple_duplicate_stmt_histograms (struct function *fun, gimple stmt,
-				  struct function *ofun, gimple ostmt)
+gimple_duplicate_stmt_histograms (struct function *fun, gimple *stmt,
+				  struct function *ofun, gimple *ostmt)
 {
   histogram_value val;
   for (val = gimple_histogram_value (ofun, ostmt); val != NULL; val = val->hvalue.next)
@@ -492,7 +492,7 @@ gimple_duplicate_stmt_histograms (struct function *fun, gimple stmt,
 /* Move all histograms associated with OSTMT to STMT.  */
 
 void
-gimple_move_stmt_histograms (struct function *fun, gimple stmt, gimple ostmt)
+gimple_move_stmt_histograms (struct function *fun, gimple *stmt, gimple *ostmt)
 {
   histogram_value val = gimple_histogram_value (fun, ostmt);
   if (val)
@@ -545,7 +545,7 @@ verify_histograms (void)
   FOR_EACH_BB_FN (bb, cfun)
     for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
       {
-	gimple stmt = gsi_stmt (gsi);
+	gimple *stmt = gsi_stmt (gsi);
 
 	for (hist = gimple_histogram_value (cfun, stmt); hist;
 	     hist = hist->hvalue.next)
@@ -601,7 +601,7 @@ free_histograms (void)
    somehow.  */
 
 static bool
-check_counter (gimple stmt, const char * name,
+check_counter (gimple *stmt, const char * name,
 	       gcov_type *count, gcov_type *all, gcov_type bb_count)
 {
   if (*all != bb_count || *count > *all)
@@ -652,7 +652,7 @@ gimple_value_profile_transformations (void)
     {
       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
-	  gimple stmt = gsi_stmt (gsi);
+	  gimple *stmt = gsi_stmt (gsi);
 	  histogram_value th = gimple_histogram_value (cfun, stmt);
 	  if (!th)
 	    continue;
@@ -705,12 +705,12 @@ gimple_value_profile_transformations (void)
    alter the original STMT.  */
 
 static tree
-gimple_divmod_fixed_value (gimple stmt, tree value, int prob, gcov_type count,
+gimple_divmod_fixed_value (gimple *stmt, tree value, int prob, gcov_type count,
 			   gcov_type all)
 {
-  gimple stmt1, stmt2, stmt3;
+  gimple *stmt1, *stmt2, *stmt3;
   tree tmp0, tmp1, tmp2;
-  gimple bb1end, bb2end, bb3end;
+  gimple *bb1end, *bb2end, *bb3end;
   basic_block bb, bb2, bb3, bb4;
   tree optype, op1, op2;
   edge e12, e13, e23, e24, e34;
@@ -792,7 +792,7 @@ gimple_divmod_fixed_value_transform (gimple_stmt_iterator *si)
   gcov_type val, count, all;
   tree result, value, tree_val;
   gcov_type prob;
-  gimple stmt;
+  gimple *stmt;
 
   stmt = gsi_stmt (*si);
   if (gimple_code (stmt) != GIMPLE_ASSIGN)
@@ -868,11 +868,11 @@ gimple_divmod_fixed_value_transform (gimple_stmt_iterator *si)
    within roundoff error).  This generates the result into a temp and returns
    the temp; it does not replace or alter the original STMT.  */
 static tree
-gimple_mod_pow2 (gimple stmt, int prob, gcov_type count, gcov_type all)
+gimple_mod_pow2 (gimple *stmt, int prob, gcov_type count, gcov_type all)
 {
-  gimple stmt1, stmt2, stmt3, stmt4;
+  gimple *stmt1, *stmt2, *stmt3, *stmt4;
   tree tmp2, tmp3;
-  gimple bb1end, bb2end, bb3end;
+  gimple *bb1end, *bb2end, *bb3end;
   basic_block bb, bb2, bb3, bb4;
   tree optype, op1, op2;
   edge e12, e13, e23, e24, e34;
@@ -954,7 +954,7 @@ gimple_mod_pow2_value_transform (gimple_stmt_iterator *si)
   gcov_type count, wrong_values, all;
   tree lhs_type, result, value;
   gcov_type prob;
-  gimple stmt;
+  gimple *stmt;
 
   stmt = gsi_stmt (*si);
   if (gimple_code (stmt) != GIMPLE_ASSIGN)
@@ -1020,12 +1020,12 @@ gimple_mod_pow2_value_transform (gimple_stmt_iterator *si)
 /* FIXME: Generalize the interface to handle NCOUNTS > 1.  */
 
 static tree
-gimple_mod_subtract (gimple stmt, int prob1, int prob2, int ncounts,
+gimple_mod_subtract (gimple *stmt, int prob1, int prob2, int ncounts,
 		     gcov_type count1, gcov_type count2, gcov_type all)
 {
-  gimple stmt1, stmt2, stmt3;
+  gimple *stmt1, *stmt2, *stmt3;
   tree tmp1;
-  gimple bb1end, bb2end = NULL, bb3end;
+  gimple *bb1end, *bb2end = NULL, *bb3end;
   basic_block bb, bb2, bb3, bb4;
   tree optype, op1, op2;
   edge e12, e23 = 0, e24, e34, e14;
@@ -1126,7 +1126,7 @@ gimple_mod_subtract_transform (gimple_stmt_iterator *si)
   gcov_type prob1, prob2;
   unsigned int i, steps;
   gcov_type count1, count2;
-  gimple stmt;
+  gimple *stmt;
 
   stmt = gsi_stmt (*si);
   if (gimple_code (stmt) != GIMPLE_ASSIGN)
@@ -1301,7 +1301,7 @@ find_func_by_profile_id (int profile_id)
    Returns true if TARGET is considered ok for call CALL_STMT.  */
 
 static bool
-check_ic_target (gimple call_stmt, struct cgraph_node *target)
+check_ic_target (gimple *call_stmt, struct cgraph_node *target)
 {
    location_t locus;
    if (gimple_check_call_matching_types (call_stmt, target->decl, true))
@@ -1323,11 +1323,11 @@ check_ic_target (gimple call_stmt, struct cgraph_node *target)
     old call
  */
 
-gimple
-gimple_ic (gimple icall_stmt, struct cgraph_node *direct_call,
+gimple *
+gimple_ic (gimple *icall_stmt, struct cgraph_node *direct_call,
 	   int prob, gcov_type count, gcov_type all)
 {
-  gimple dcall_stmt, load_stmt, cond_stmt;
+  gimple *dcall_stmt, *load_stmt, *cond_stmt;
   tree tmp0, tmp1, tmp;
   basic_block cond_bb, dcall_bb, icall_bb, join_bb = NULL;
   tree optype = build_pointer_type (void_type_node);
@@ -1426,7 +1426,7 @@ gimple_ic (gimple icall_stmt, struct cgraph_node *direct_call,
       && (dflags & ECF_NORETURN) == 0)
     {
       tree result = gimple_call_lhs (icall_stmt);
-      gimple phi = create_phi_node (result, join_bb);
+      gimple *phi = create_phi_node (result, join_bb);
       gimple_call_set_lhs (icall_stmt,
 			   duplicate_ssa_name (result, icall_stmt));
       add_phi_arg (phi, gimple_call_lhs (icall_stmt), e_ij, UNKNOWN_LOCATION);
@@ -1449,7 +1449,7 @@ gimple_ic (gimple icall_stmt, struct cgraph_node *direct_call,
 	for (psi = gsi_start_phis (e_eh->dest);
 	     !gsi_end_p (psi); gsi_next (&psi))
 	  {
-	    gimple phi = gsi_stmt (psi);
+	    gimple *phi = gsi_stmt (psi);
 	    SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi, e),
 		     PHI_ARG_DEF_FROM_EDGE (phi, e_eh));
 	  }
@@ -1466,7 +1466,7 @@ gimple_ic (gimple icall_stmt, struct cgraph_node *direct_call,
 static bool
 gimple_ic_transform (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   histogram_value histogram;
   gcov_type val, count, all, bb_all;
   struct cgraph_node *direct_call;
@@ -1553,7 +1553,7 @@ gimple_ic_transform (gimple_stmt_iterator *gsi)
    operation.
 */
 static bool
-interesting_stringop_to_profile_p (tree fndecl, gimple call, int *size_arg)
+interesting_stringop_to_profile_p (tree fndecl, gimple *call, int *size_arg)
 {
   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
 
@@ -1590,10 +1590,10 @@ interesting_stringop_to_profile_p (tree fndecl, gimple call, int *size_arg)
    assuming we'll propagate a true constant into ICALL_SIZE later.  */
 
 static void
-gimple_stringop_fixed_value (gimple vcall_stmt, tree icall_size, int prob,
+gimple_stringop_fixed_value (gimple *vcall_stmt, tree icall_size, int prob,
 			     gcov_type count, gcov_type all)
 {
-  gimple tmp_stmt, cond_stmt, icall_stmt;
+  gimple *tmp_stmt, *cond_stmt, *icall_stmt;
   tree tmp0, tmp1, vcall_size, optype;
   basic_block cond_bb, icall_bb, vcall_bb, join_bb;
   edge e_ci, e_cv, e_iv, e_ij, e_vj;
@@ -1665,7 +1665,7 @@ gimple_stringop_fixed_value (gimple vcall_stmt, tree icall_size, int prob,
       && TREE_CODE (gimple_call_lhs (vcall_stmt)) == SSA_NAME)
     {
       tree result = gimple_call_lhs (vcall_stmt);
-      gimple phi = create_phi_node (result, join_bb);
+      gimple *phi = create_phi_node (result, join_bb);
       gimple_call_set_lhs (vcall_stmt,
 			   duplicate_ssa_name (result, vcall_stmt));
       add_phi_arg (phi, gimple_call_lhs (vcall_stmt), e_vj, UNKNOWN_LOCATION);
@@ -1684,7 +1684,7 @@ gimple_stringop_fixed_value (gimple vcall_stmt, tree icall_size, int prob,
 static bool
 gimple_stringops_transform (gimple_stmt_iterator *gsi)
 {
-  gimple stmt = gsi_stmt (*gsi);
+  gimple *stmt = gsi_stmt (*gsi);
   tree fndecl;
   tree blck_size;
   enum built_in_function fcode;
@@ -1777,7 +1777,7 @@ gimple_stringops_transform (gimple_stmt_iterator *gsi)
 }
 
 void
-stringop_block_profile (gimple stmt, unsigned int *expected_align,
+stringop_block_profile (gimple *stmt, unsigned int *expected_align,
 			HOST_WIDE_INT *expected_size)
 {
   histogram_value histogram;
@@ -1829,7 +1829,7 @@ stringop_block_profile (gimple stmt, unsigned int *expected_align,
 /* Find values inside STMT for that we want to measure histograms for
    division/modulo optimization.  */
 static void
-gimple_divmod_values_to_profile (gimple stmt, histogram_values *values)
+gimple_divmod_values_to_profile (gimple *stmt, histogram_values *values)
 {
   tree lhs, divisor, op0, type;
   histogram_value hist;
@@ -1887,7 +1887,7 @@ gimple_divmod_values_to_profile (gimple stmt, histogram_values *values)
    indirect/virtual call optimization. */
 
 static void
-gimple_indirect_call_to_profile (gimple stmt, histogram_values *values)
+gimple_indirect_call_to_profile (gimple *stmt, histogram_values *values)
 {
   tree callee;
 
@@ -1909,7 +1909,7 @@ gimple_indirect_call_to_profile (gimple stmt, histogram_values *values)
 /* Find values inside STMT for that we want to measure histograms for
    string operations.  */
 static void
-gimple_stringops_values_to_profile (gimple stmt, histogram_values *values)
+gimple_stringops_values_to_profile (gimple *stmt, histogram_values *values)
 {
   tree fndecl;
   tree blck_size;
@@ -1945,7 +1945,7 @@ gimple_stringops_values_to_profile (gimple stmt, histogram_values *values)
    them to list VALUES.  */
 
 static void
-gimple_values_to_profile (gimple stmt, histogram_values *values)
+gimple_values_to_profile (gimple *stmt, histogram_values *values)
 {
   gimple_divmod_values_to_profile (stmt, values);
   gimple_stringops_values_to_profile (stmt, values);
diff --git a/gcc/value-prof.h b/gcc/value-prof.h
index 9d2c351..9fe619a 100644
--- a/gcc/value-prof.h
+++ b/gcc/value-prof.h
@@ -49,7 +49,7 @@ struct histogram_value_t
   struct
     {
       tree value;		/* The value to profile.  */
-      gimple stmt;		/* Insn containing the value.  */
+      gimple *stmt;		/* Insn containing the value.  */
       gcov_type *counters;		        /* Pointer to first counter.  */
       struct histogram_value_t *next;		/* Linked list pointer.  */
     } hvalue;
@@ -75,20 +75,20 @@ typedef vec<histogram_value> histogram_values;
 extern void gimple_find_values_to_profile (histogram_values *);
 extern bool gimple_value_profile_transformations (void);
 
-histogram_value gimple_histogram_value (struct function *, gimple);
-histogram_value gimple_histogram_value_of_type (struct function *, gimple,
+histogram_value gimple_histogram_value (struct function *, gimple *);
+histogram_value gimple_histogram_value_of_type (struct function *, gimple *,
 						enum hist_type);
-void gimple_add_histogram_value (struct function *, gimple, histogram_value);
-void dump_histograms_for_stmt (struct function *, FILE *, gimple);
-void gimple_remove_histogram_value (struct function *, gimple, histogram_value);
-void gimple_remove_stmt_histograms (struct function *, gimple);
-void gimple_duplicate_stmt_histograms (struct function *, gimple,
-				       struct function *, gimple);
-void gimple_move_stmt_histograms (struct function *, gimple, gimple);
+void gimple_add_histogram_value (struct function *, gimple *, histogram_value);
+void dump_histograms_for_stmt (struct function *, FILE *, gimple *);
+void gimple_remove_histogram_value (struct function *, gimple *, histogram_value);
+void gimple_remove_stmt_histograms (struct function *, gimple *);
+void gimple_duplicate_stmt_histograms (struct function *, gimple *,
+				       struct function *, gimple *);
+void gimple_move_stmt_histograms (struct function *, gimple *, gimple *);
 void verify_histograms (void);
 void free_histograms (void);
-void stringop_block_profile (gimple, unsigned int *, HOST_WIDE_INT *);
-gimple gimple_ic (gimple, struct cgraph_node *, int, gcov_type, gcov_type);
+void stringop_block_profile (gimple *, unsigned int *, HOST_WIDE_INT *);
+gimple *gimple_ic (gimple *, struct cgraph_node *, int, gcov_type, gcov_type);
 
 
 /* In tree-profile.c.  */
@@ -106,7 +106,7 @@ extern void gimple_gen_const_delta_profiler (histogram_value,
 extern void gimple_gen_average_profiler (histogram_value, unsigned, unsigned);
 extern void gimple_gen_ior_profiler (histogram_value, unsigned, unsigned);
 extern void stream_out_histogram_value (struct output_block *, histogram_value);
-extern void stream_in_histogram_value (struct lto_input_block *, gimple);
+extern void stream_in_histogram_value (struct lto_input_block *, gimple *);
 extern struct cgraph_node* find_func_by_profile_id (int func_id);
 
 
diff --git a/gcc/vtable-verify.c b/gcc/vtable-verify.c
index b99ff6c..408e73c 100644
--- a/gcc/vtable-verify.c
+++ b/gcc/vtable-verify.c
@@ -416,7 +416,7 @@ find_or_create_vtbl_map_node (tree base_class_type)
    call).  */
 
 static bool
-is_vtable_assignment_stmt (gimple stmt)
+is_vtable_assignment_stmt (gimple *stmt)
 {
 
   if (gimple_code (stmt) != GIMPLE_ASSIGN)
@@ -510,7 +510,7 @@ var_is_used_for_virtual_call_p (tree lhs, int *mem_ref_depth)
 
   FOR_EACH_IMM_USE_FAST (use_p, imm_iter, lhs)
     {
-      gimple stmt2 = USE_STMT (use_p);
+      gimple *stmt2 = USE_STMT (use_p);
 
       if (is_gimple_call (stmt2))
         {
@@ -574,7 +574,7 @@ static void
 verify_bb_vtables (basic_block bb)
 {
   gimple_seq stmts;
-  gimple stmt = NULL;
+  gimple *stmt = NULL;
   gimple_stmt_iterator gsi_vtbl_assign;
   gimple_stmt_iterator gsi_virtual_call;
 
@@ -598,7 +598,7 @@ verify_bb_vtables (basic_block bb)
           tree vtbl_var_decl = NULL_TREE;
           struct vtbl_map_node *vtable_map_node;
           tree vtbl_decl = NULL_TREE;
-          gimple call_stmt;
+          gimple *call_stmt;
           const char *vtable_name = "<unknown>";
           tree tmp0;
           bool found;
@@ -694,7 +694,7 @@ verify_bb_vtables (basic_block bb)
                   /* Replace all uses of lhs with tmp0. */
                   found = false;
                   imm_use_iterator iterator;
-                  gimple use_stmt;
+                  gimple *use_stmt;
                   FOR_EACH_IMM_USE_STMT (use_stmt, iterator, lhs)
                     {
                       use_operand_p use_p;
-- 
1.8.5.3

