Eliminate ENTRY_BLOCK_PTR and EXIT_BLOCK_PTR macros

gcc/

	* basic-block.h (ENTRY_BLOCK_PTR_FOR_FUNCTION): Rename macro to...
	(EXIT_BLOCK_PTR_FOR_FUNCTION): ...this.
	(ENTRY_BLOCK_PTR_FOR_FN): Renamed macro to...
	(EXIT_BLOCK_PTR_FOR_FN): ...this.
	(ENTRY_BLOCK_PTR): Eliminate macro as work towards making uses of
	cfun be explicit.
	(EXIT_BLOCK_PTR): Likewise.
	(FOR_ALL_BB): Rework for now to eliminate use of "ENTRY_BLOCK_PTR".
	(FOR_ALL_BB_FN): Update for renaming of
	"ENTRY_BLOCK_PTR_FOR_FUNCTION" to "ENTRY_BLOCK_PTR_FOR_FN".

	* cfg.c (init_flow): Likewise.
	(check_bb_profile): Likewise.
	* cfganal.c (pre_and_rev_post_order_compute_fn): Likewise.
	* cfgcleanup.c (walk_to_nondebug_insn): Likewise.
	* cfghooks.c (account_profile_record): Likewise.
	* cfgloop.c (init_loops_structure): Likewise.
	* cgraphbuild.c (record_eh_tables): Likewise.
	(compute_call_stmt_bb_frequency): Likewise.
	* ipa-inline-analysis.c (compute_bb_predicates): Likewise.
	* lto-streamer-in.c (input_cfg): Likewise.
	* predict.c (maybe_hot_frequency_p): Likewise.
	* tree-cfg.c (init_empty_tree_cfg_for_function): Likewise.
	* tree-inline.c (initialize_cfun): Likewise.
	(copy_cfg_body): Likewise.
	(copy_body): Likewise.
	(tree_function_versioning): Likewise.

	* bb-reorder.c (add_labels_and_missing_jumps): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	(duplicate_computed_gotos): Remove usage of EXIT_BLOCK_PTR macro.
	(find_rarely_executed_basic_blocks_and_crossing_edges): Remove uses of
	macros: ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	(connect_traces): Likewise.
	(rest_of_handle_reorder_blocks): Remove usage of EXIT_BLOCK_PTR macro.
	(bb_to_key): Remove usage of ENTRY_BLOCK_PTR macro.
	(fix_crossing_conditional_branches): Remove usage of EXIT_BLOCK_PTR
	macro.
	(find_traces_1_round): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	(fix_up_fall_thru_edges): Remove usage of EXIT_BLOCK_PTR macro.
	(find_traces): Remove usage of ENTRY_BLOCK_PTR macro.
	(fix_up_crossing_landing_pad): Remove usage of EXIT_BLOCK_PTR macro.
	(rotate_loop): Likewise.
	* bt-load.c (migrate_btr_def): Remove usage of ENTRY_BLOCK_PTR macro.
	* cfg.c (clear_aux_for_edges): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	(alloc_aux_for_edges): Likewise.
	(clear_bb_flags): Remove usage of ENTRY_BLOCK_PTR macro.
	(cached_make_edge): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	(compact_blocks): Likewise.
	(clear_edges): Likewise.
	* cfganal.c (single_pred_before_succ_order): Remove usage of
	ENTRY_BLOCK_PTR macro.
	(bitmap_union_of_succs): Remove usage of EXIT_BLOCK_PTR macro.
	(bitmap_union_of_preds): Remove usage of ENTRY_BLOCK_PTR macro.
	(bitmap_intersection_of_succs): Remove usage of EXIT_BLOCK_PTR macro.
	(bitmap_intersection_of_preds): Remove usage of ENTRY_BLOCK_PTR macro.
	(inverted_post_order_compute): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	(compute_dominance_frontiers_1): Remove usage of ENTRY_BLOCK_PTR
	macro.
	(post_order_compute): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	(connect_infinite_loops_to_exit): Remove usage of EXIT_BLOCK_PTR
	macro.
	(remove_fake_edges): Remove usage of ENTRY_BLOCK_PTR macro.
	(add_noreturn_fake_exit_edges): Remove usage of EXIT_BLOCK_PTR macro.
	(find_pdom): Remove uses of macros: ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	(remove_fake_exit_edges): Remove usage of EXIT_BLOCK_PTR macro.
	(verify_edge_list): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	(print_edge_list): Likewise.
	(create_edge_list): Likewise.
	(find_unreachable_blocks): Remove usage of ENTRY_BLOCK_PTR macro.
	(mark_dfs_back_edges): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	* cfgbuild.c (find_bb_boundaries): Remove usage of ENTRY_BLOCK_PTR
	macro.
	(find_many_sub_basic_blocks): Remove usage of EXIT_BLOCK_PTR macro.
	(make_edges): Remove uses of macros: ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	* cfgcleanup.c (delete_unreachable_blocks): Likewise.
	(try_optimize_cfg): Likewise.
	(try_head_merge_bb): Remove usage of EXIT_BLOCK_PTR macro.
	(try_crossjump_to_edge): Remove usage of ENTRY_BLOCK_PTR macro.
	(try_crossjump_bb): Remove usage of EXIT_BLOCK_PTR macro.
	(merge_blocks_move): Remove usage of ENTRY_BLOCK_PTR macro.
	(outgoing_edges_match): Remove usage of EXIT_BLOCK_PTR macro.
	(try_forward_edges): Likewise.
	(try_simplify_condjump): Likewise.
	* cfgexpand.c (gimple_expand_cfg): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	(construct_exit_block): Remove usage of EXIT_BLOCK_PTR macro.
	(construct_init_block): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	(expand_gimple_basic_block): Remove usage of EXIT_BLOCK_PTR macro.
	(expand_gimple_tailcall): Likewise.
	* cfghooks.c (can_duplicate_block_p): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	(tidy_fallthru_edges): Likewise.
	(verify_flow_info): Likewise.
	* cfgloop.c (flow_bb_inside_loop_p): Likewise.
	(num_loop_branches): Remove usage of EXIT_BLOCK_PTR macro.
	(disambiguate_multiple_latches): Remove usage of ENTRY_BLOCK_PTR
	macro.
	(get_loop_exit_edges): Remove usage of EXIT_BLOCK_PTR macro.
	(bb_loop_header_p): Remove usage of ENTRY_BLOCK_PTR macro.
	(get_loop_body_in_bfs_order): Remove usage of EXIT_BLOCK_PTR macro.
	(get_loop_body_in_dom_order): Likewise.
	(get_loop_body): Likewise.
	* cfgloopanal.c (mark_irreducible_loops): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	* cfgloopmanip.c (create_preheader): Remove usage of ENTRY_BLOCK_PTR
	macro.
	(remove_path): Remove usage of EXIT_BLOCK_PTR macro.
	(fix_bb_placement): Likewise.
	* cfgrtl.c (rtl_block_empty_p): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	(rtl_can_remove_branch_p): Remove usage of EXIT_BLOCK_PTR macro.
	(cfg_layout_split_edge): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	(rtl_flow_call_edges_add): Remove usage of EXIT_BLOCK_PTR macro.
	(cfg_layout_can_merge_blocks_p): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	(cfg_layout_redirect_edge_and_branch): Remove usage of ENTRY_BLOCK_PTR
	macro.
	(fixup_fallthru_exit_predecessor): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	(fixup_reorder_chain): Likewise.
	(relink_block_chain): Likewise.
	(cfg_layout_delete_block): Remove usage of EXIT_BLOCK_PTR macro.
	(rtl_verify_bb_layout): Remove usage of ENTRY_BLOCK_PTR macro.
	(cfg_layout_duplicate_bb): Remove usage of EXIT_BLOCK_PTR macro.
	(force_one_exit_fallthru): Likewise.
	(rtl_verify_fallthru): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	(rtl_verify_edges): Likewise.
	(commit_edge_insertions): Likewise.
	(commit_one_edge_insertion): Likewise.
	(rtl_split_edge): Likewise.
	(force_nonfallthru_and_redirect): Likewise.
	(outof_cfg_layout_mode): Remove usage of EXIT_BLOCK_PTR macro.
	(skip_insns_after_block): Likewise.
	(fixup_partition_crossing): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	(purge_dead_edges): Remove usage of EXIT_BLOCK_PTR macro.
	(rtl_can_merge_blocks): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	(contains_no_active_insn_p): Likewise.
	(emit_insn_at_entry): Remove usage of ENTRY_BLOCK_PTR macro.
	(entry_of_function): Likewise.
	(last_bb_in_partition): Remove usage of EXIT_BLOCK_PTR macro.
	(fixup_new_cold_bb): Likewise.
	(patch_jump_insn): Likewise.
	(try_redirect_by_replacing_jump): Likewise.
	(block_label): Likewise.
	(could_fall_through): Likewise.
	(can_fallthru): Likewise.
	* cgraphbuild.c (cgraph_rebuild_references): Remove usage of
	ENTRY_BLOCK_PTR macro.
	(rebuild_cgraph_edges): Likewise.
	* cgraphunit.c (init_lowered_empty_function): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	(expand_thunk): Remove usage of EXIT_BLOCK_PTR macro.
	* combine.c (get_last_value): Remove usage of ENTRY_BLOCK_PTR macro.
	(distribute_links): Remove usage of EXIT_BLOCK_PTR macro.
	(get_last_value_validate): Remove usage of ENTRY_BLOCK_PTR macro.
	(try_combine): Remove usage of EXIT_BLOCK_PTR macro.
	(reg_num_sign_bit_copies_for_combine): Remove usage of ENTRY_BLOCK_PTR
	macro.
	(reg_nonzero_bits_for_combine): Likewise.
	(set_nonzero_bits_and_sign_copies): Likewise.
	(combine_instructions): Likewise.
	* cprop.c (one_cprop_pass): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	(bypass_conditional_jumps): Likewise.
	(bypass_block): Remove usage of EXIT_BLOCK_PTR macro.
	(find_implicit_sets): Likewise.
	(cprop_jump): Likewise.
	* cse.c (cse_cc_succs): Likewise.
	(cse_find_path): Likewise.
	* df-problems.c (df_lr_confluence_0): Likewise.
	* df-scan.c (df_entry_block_defs_collect): Remove usage of
	ENTRY_BLOCK_PTR macro.
	(df_exit_block_uses_collect): Remove usage of EXIT_BLOCK_PTR macro.
	* dominance.c (iterate_fix_dominators): Remove usage of
	ENTRY_BLOCK_PTR macro.
	(calc_idoms): Remove uses of macros: ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	(determine_dominators_for_sons): Remove usage of ENTRY_BLOCK_PTR
	macro.
	(calc_dfs_tree): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	(prune_bbs_to_update_dominators): Remove usage of ENTRY_BLOCK_PTR
	macro.
	(calc_dfs_tree_nonrec): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	* domwalk.c (cmp_bb_postorder): Likewise.
	* dse.c (dse_step1): Remove usage of EXIT_BLOCK_PTR macro.
	* except.c (finish_eh_generation): Remove usage of ENTRY_BLOCK_PTR
	macro.
	(sjlj_emit_function_enter): Likewise.
	* final.c (compute_alignments): Likewise.
	* function.c (thread_prologue_and_epilogue_insns): Remove uses of
	macros: ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	(reposition_prologue_and_epilogue_notes): Remove usage of
	EXIT_BLOCK_PTR macro.
	(convert_jumps_to_returns): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	(regno_clobbered_at_setjmp): Remove usage of ENTRY_BLOCK_PTR macro.
	(next_block_for_reg): Remove usage of EXIT_BLOCK_PTR macro.
	* gcse.c (hoist_code): Remove usage of ENTRY_BLOCK_PTR macro.
	(update_bb_reg_pressure): Remove usage of EXIT_BLOCK_PTR macro.
	(compute_code_hoist_vbeinout): Likewise.
	(should_hoist_expr_to_dom): Remove usage of ENTRY_BLOCK_PTR macro.
	(pre_expr_reaches_here_p_work): Likewise.
	* gimple-iterator.c (gsi_commit_edge_inserts): Likewise.
	(gimple_find_edge_insert_loc): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	* gimple-ssa-strength-reduction.c (slsr_process_phi): Remove usage of
	ENTRY_BLOCK_PTR macro.
	* graph.c (draw_cfg_nodes_for_loop): Remove usage of EXIT_BLOCK_PTR
	macro.
	* graphite-clast-to-gimple.c (translate_clast_user): Remove usage of
	ENTRY_BLOCK_PTR macro.
	* graphite-scop-detection.c (build_scops): Likewise.
	(create_sese_edges): Remove usage of EXIT_BLOCK_PTR macro.
	(scopdet_basic_block_info): Remove usage of ENTRY_BLOCK_PTR macro.
	* haifa-sched.c (restore_bb_notes): Remove usage of EXIT_BLOCK_PTR
	macro.
	(unlink_bb_notes): Likewise.
	(create_check_block_twin): Likewise.
	(init_before_recovery): Likewise.
	(sched_extend_bb): Likewise.
	(priority): Likewise.
	* hw-doloop.c (reorder_loops): Likewise.
	(discover_loop): Likewise.
	* ifcvt.c (dead_or_predicable): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	(find_if_case_1): Remove usage of EXIT_BLOCK_PTR macro.
	(block_has_only_trap): Likewise.
	(cond_exec_find_if_block): Likewise.
	(merge_if_block): Likewise.
	* ipa-inline-analysis.c (param_change_prob): Remove usage of
	ENTRY_BLOCK_PTR macro.
	(record_modified): Likewise.
	* ipa-pure-const.c (execute_warn_function_noreturn): Remove usage of
	EXIT_BLOCK_PTR macro.
	(local_pure_const): Likewise.
	* ipa-split.c (split_function): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	(find_split_points): Likewise.
	(consider_split): Likewise.
	(find_return_bb): Remove usage of EXIT_BLOCK_PTR macro.
	(verify_non_ssa_vars): Remove usage of ENTRY_BLOCK_PTR macro.
	* ira-build.c (ira_loop_tree_body_rev_postorder): Likewise.
	* ira-color.c (print_loop_title): Remove usage of EXIT_BLOCK_PTR
	macro.
	* ira-emit.c (entered_from_non_parent_p): Remove usage of
	ENTRY_BLOCK_PTR macro.
	(ira_emit): Remove usage of EXIT_BLOCK_PTR macro.
	* ira-int.h (ira_assert): Remove usage of ENTRY_BLOCK_PTR macro.
	* ira.c (split_live_ranges_for_shrink_wrap): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	* lcm.c (compute_rev_insert_delete): Remove usage of ENTRY_BLOCK_PTR
	macro.
	(compute_nearerout): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	(compute_farthest): Likewise.
	(compute_available): Likewise.
	(compute_insert_delete): Remove usage of EXIT_BLOCK_PTR macro.
	(compute_laterin): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	(compute_earliest): Likewise.
	(compute_antinout_edge): Likewise.
	* loop-iv.c (simplify_using_initial_values): Remove usage of
	ENTRY_BLOCK_PTR macro.
	* loop-unswitch.c (unswitch_loop): Remove usage of EXIT_BLOCK_PTR
	macro.
	* lra-assigns.c (find_hard_regno_for): Remove usage of ENTRY_BLOCK_PTR
	macro.
	* lra-constraints.c (lra_inheritance): Remove usage of EXIT_BLOCK_PTR
	macro.
	* lra-lives.c (lra_create_live_ranges): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	* lra.c (has_nonexceptional_receiver): Remove usage of EXIT_BLOCK_PTR
	macro.
	* lto-streamer-in.c (input_function): Remove usage of ENTRY_BLOCK_PTR
	macro.
	* lto-streamer-out.c (output_cfg): Likewise.
	* mcf.c (adjust_cfg_counts): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	(create_fixup_graph): Remove usage of ENTRY_BLOCK_PTR macro.
	* mode-switching.c (optimize_mode_switching): Likewise.
	(create_pre_exit): Remove usage of EXIT_BLOCK_PTR macro.
	* modulo-sched.c (rest_of_handle_sms): Likewise.
	(canon_loop): Likewise.
	* omp-low.c (build_omp_regions): Remove usage of ENTRY_BLOCK_PTR
	macro.
	* postreload-gcse.c (eliminate_partially_redundant_loads): Remove uses
	of macros: ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	* predict.c (rebuild_frequencies): Remove usage of ENTRY_BLOCK_PTR
	macro.
	(propagate_freq): Remove usage of EXIT_BLOCK_PTR macro.
	(estimate_bb_frequencies): Remove usage of ENTRY_BLOCK_PTR macro.
	(tree_estimate_probability_bb): Remove usage of EXIT_BLOCK_PTR macro.
	(expensive_function_p): Remove usage of ENTRY_BLOCK_PTR macro.
	(tree_bb_level_predictions): Remove usage of EXIT_BLOCK_PTR macro.
	(counts_to_freqs): Remove usage of ENTRY_BLOCK_PTR macro.
	(apply_return_prediction): Remove usage of EXIT_BLOCK_PTR macro.
	(estimate_loops): Remove usage of ENTRY_BLOCK_PTR macro.
	(gimple_predict_edge): Likewise.
	(probably_never_executed): Likewise.
	* profile.c (find_spanning_tree): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	(branch_prob): Likewise.
	(compute_branch_probabilities): Likewise.
	(compute_frequency_overlap): Remove usage of ENTRY_BLOCK_PTR macro.
	(is_inconsistent): Remove usage of EXIT_BLOCK_PTR macro.
	(read_profile_edge_counts): Remove usage of ENTRY_BLOCK_PTR macro.
	(set_bb_counts): Likewise.
	(correct_negative_edge_counts): Likewise.
	(get_exec_counts): Likewise.
	(instrument_values): Likewise.
	(instrument_edges): Likewise.
	* reg-stack.c (convert_regs): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	(compensate_edges): Remove usage of ENTRY_BLOCK_PTR macro.
	(convert_regs_exit): Remove usage of EXIT_BLOCK_PTR macro.
	(convert_regs_entry): Remove usage of ENTRY_BLOCK_PTR macro.
	(reg_to_stack): Likewise.
	* regs.h (REG_N_SETS): Likewise.
	* reload.c (find_dummy_reload): Likewise.
	(combine_reloads): Likewise.
	(push_reload): Likewise.
	* reload1.c (has_nonexceptional_receiver): Remove usage of
	EXIT_BLOCK_PTR macro.
	* resource.c (mark_target_live_regs): Remove usage of ENTRY_BLOCK_PTR
	macro.
	(find_basic_block): Likewise.
	* sched-ebb.c (ebb_add_block): Remove usage of EXIT_BLOCK_PTR macro.
	(schedule_ebbs): Likewise.
	* sched-int.h (sel_sched_p): Likewise.
	* sched-rgn.c (compute_dom_prob_ps): Remove usage of ENTRY_BLOCK_PTR
	macro.
	(rgn_add_block): Remove usage of EXIT_BLOCK_PTR macro.
	(haifa_find_rgns): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	(propagate_deps): Remove usage of EXIT_BLOCK_PTR macro.
	(extend_rgns): Likewise.
	(find_single_block_region): Likewise.
	* sel-sched-ir.c (sel_remove_loop_preheader): Remove usage of
	ENTRY_BLOCK_PTR macro.
	(setup_nop_and_exit_insns): Remove usage of EXIT_BLOCK_PTR macro.
	(sel_create_recovery_block): Likewise.
	(bb_ends_ebb_p): Likewise.
	(sel_bb_end): Likewise.
	(sel_bb_head): Likewise.
	(free_lv_sets): Likewise.
	(init_lv_sets): Likewise.
	(tidy_control_flow): Likewise.
	(maybe_tidy_empty_bb): Likewise.
	* sel-sched-ir.h (_succ_iter_cond): Likewise.
	(_succ_iter_start): Likewise.
	(sel_bb_empty_or_nop_p): Likewise.
	(get_loop_exit_edges_unique_dests): Likewise.
	(inner_loop_header_p): Likewise.
	* sel-sched.c (create_block_for_bookkeeping): Likewise.
	(find_block_for_bookkeeping): Likewise.
	* store-motion.c (remove_reachable_equiv_notes): Likewise.
	(insert_store): Likewise.
	* trans-mem.c (ipa_tm_transform_clone): Remove usage of
	ENTRY_BLOCK_PTR macro.
	(tm_memopt_compute_available): Remove usage of EXIT_BLOCK_PTR macro.
	(ipa_tm_scan_irr_function): Remove usage of ENTRY_BLOCK_PTR macro.
	(gate_tm_init): Likewise.
	(tm_region_init): Likewise.
	* tree-cfg.c (execute_fixup_cfg): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	(execute_warn_function_return): Remove usage of EXIT_BLOCK_PTR macro.
	(split_critical_edges): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	(print_loops): Remove usage of ENTRY_BLOCK_PTR macro.
	(move_sese_region_to_fn): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	(gimple_redirect_edge_and_branch): Remove usage of ENTRY_BLOCK_PTR
	macro.
	(gimple_verify_flow_info): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	(remove_edge_and_dominated_blocks): Remove usage of EXIT_BLOCK_PTR
	macro.
	(make_edges): Remove uses of macros: ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	(gimple_flow_call_edges_add): Remove usage of EXIT_BLOCK_PTR macro.
	(make_blocks): Remove usage of ENTRY_BLOCK_PTR macro.
	(build_gimple_cfg): Likewise.
	(gimple_duplicate_bb): Remove usage of EXIT_BLOCK_PTR macro.
	(gimple_can_merge_blocks_p): Likewise.
	* tree-cfgcleanup.c (tree_forwarder_block_p): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	* tree-complex.c (update_parameter_components): Remove usage of
	ENTRY_BLOCK_PTR macro.
	* tree-if-conv.c (get_loop_body_in_if_conv_order): Remove usage of
	EXIT_BLOCK_PTR macro.
	* tree-inline.c (tree_function_versioning): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	(delete_unreachable_blocks_update_callgraph): Likewise.
	(initialize_cfun): Likewise.
	(copy_cfg_body): Remove usage of ENTRY_BLOCK_PTR macro.
	(copy_edges_for_bb): Remove usage of EXIT_BLOCK_PTR macro.
	(remap_ssa_name): Remove usage of ENTRY_BLOCK_PTR macro.
	* tree-into-ssa.c (update_ssa): Likewise.
	(maybe_register_def): Remove usage of EXIT_BLOCK_PTR macro.
	(insert_updated_phi_nodes_for): Remove usage of ENTRY_BLOCK_PTR macro.
	(rewrite_into_ssa): Likewise.
	(rewrite_debug_stmt_uses): Likewise.
	* tree-outof-ssa.c (expand_phi_nodes): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	* tree-profile.c (gimple_gen_ic_func_profiler): Remove usage of
	ENTRY_BLOCK_PTR macro.
	* tree-scalar-evolution.h (block_before_loop): Likewise.
	* tree-sra.c (sra_ipa_reset_debug_stmts): Likewise.
	(dump_dereferences_table): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	(analyze_caller_dereference_legality): Remove usage of ENTRY_BLOCK_PTR
	macro.
	(propagate_dereference_distances): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	(initialize_parameter_reductions): Remove usage of ENTRY_BLOCK_PTR
	macro.
	* tree-ssa-ccp.c (gsi_prev_dom_bb_nondebug): Likewise.
	(optimize_stack_restore): Remove usage of EXIT_BLOCK_PTR macro.
	* tree-ssa-coalesce.c (create_outofssa_var_map): Likewise.
	* tree-ssa-dce.c (eliminate_unnecessary_stmts): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	(remove_dead_stmt): Remove usage of EXIT_BLOCK_PTR macro.
	(propagate_necessity): Remove usage of ENTRY_BLOCK_PTR macro.
	(mark_control_dependent_edges_necessary): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	* tree-ssa-dom.c (eliminate_degenerate_phis): Remove usage of
	ENTRY_BLOCK_PTR macro.
	(tree_ssa_dominator_optimize): Remove usage of EXIT_BLOCK_PTR macro.
	* tree-ssa-live.c (verify_live_on_entry): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	(calculate_live_on_exit): Likewise.
	(set_var_live_on_entry): Remove usage of ENTRY_BLOCK_PTR macro.
	(loe_visit_block): Likewise.
	* tree-ssa-live.h (live_on_exit): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	(live_on_entry): Likewise.
	* tree-ssa-loop-ivopts.c (find_interesting_uses): Remove usage of
	EXIT_BLOCK_PTR macro.
	* tree-ssa-loop-manip.c (compute_live_loop_exits): Remove usage of
	ENTRY_BLOCK_PTR macro.
	* tree-ssa-loop-niter.c (simplify_using_initial_conditions): Likewise.
	(bound_difference): Likewise.
	* tree-ssa-loop-prefetch.c (may_use_storent_in_loop_p): Remove usage
	of EXIT_BLOCK_PTR macro.
	* tree-ssa-loop-unswitch.c (simplify_using_entry_checks): Remove usage
	of ENTRY_BLOCK_PTR macro.
	* tree-ssa-math-opts.c (register_division_in): Likewise.
	* tree-ssa-phiprop.c (tree_ssa_phiprop): Likewise.
	* tree-ssa-pre.c (compute_avail): Likewise.
	(compute_antic): Remove usage of EXIT_BLOCK_PTR macro.
	(insert): Remove usage of ENTRY_BLOCK_PTR macro.
	* tree-ssa-propagate.c (ssa_prop_init): Likewise.
	(simulate_block): Remove usage of EXIT_BLOCK_PTR macro.
	(cfg_blocks_add): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	(add_control_edge): Remove usage of EXIT_BLOCK_PTR macro.
	* tree-ssa-reassoc.c (do_reassoc): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	(build_and_add_sum): Remove usage of ENTRY_BLOCK_PTR macro.
	* tree-ssa-sink.c (nearest_common_dominator_of_uses): Likewise.
	(execute_sink_code): Remove usage of EXIT_BLOCK_PTR macro.
	* tree-ssa-uninit.c (find_dom): Remove usage of ENTRY_BLOCK_PTR macro.
	(compute_control_dep_chain): Remove usage of EXIT_BLOCK_PTR macro.
	(find_pdom): Likewise.
	(warn_uninitialized_vars): Remove usage of ENTRY_BLOCK_PTR macro.
	* tree-stdarg.c (reachable_at_most_once): Likewise.
	* tree-tailcall.c (tree_optimize_tail_calls_1): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	(eliminate_tail_call): Likewise.
	* tsan.c (instrument_func_entry): Remove usage of ENTRY_BLOCK_PTR
	macro.
	(instrument_func_exit): Remove usage of EXIT_BLOCK_PTR macro.
	* var-tracking.c (vt_initialize): Remove uses of macros:
	ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR.
	(vt_add_function_parameter): Remove usage of ENTRY_BLOCK_PTR macro.
	(vt_find_locations): Remove usage of EXIT_BLOCK_PTR macro.
	(vt_stack_adjustments): Remove uses of macros: ENTRY_BLOCK_PTR,
	EXIT_BLOCK_PTR.
	* varasm.c (assemble_start_function): Remove usage of ENTRY_BLOCK_PTR
	macro.
	* config/bfin/bfin.c (hwloop_optimize): Likewise.
	* config/nds32/nds32.c (nds32_fp_as_gp_check_available): Remove usage
	of EXIT_BLOCK_PTR macro.
	* config/arm/arm.c (require_pic_register): Remove usage of
	ENTRY_BLOCK_PTR macro.
	(arm_r3_live_at_start_p): Likewise.
	(any_sibcall_could_use_r3): Remove usage of EXIT_BLOCK_PTR macro.
	* config/rs6000/rs6000.c (rs6000_emit_prologue): Likewise.
	* config/frv/frv.c (frv_optimize_membar_global): Likewise.
	* config/alpha/alpha.c (alpha_gp_save_rtx): Remove usage of
	ENTRY_BLOCK_PTR macro.
	* config/i386/i386.c (ix86_count_insn): Likewise.
	(ix86_seh_fixup_eh_fallthru): Remove usage of EXIT_BLOCK_PTR macro.
	(ix86_pad_short_function): Likewise.
	(ix86_compute_frame_layout): Remove usage of ENTRY_BLOCK_PTR macro.
	(ix86_pad_returns): Remove usage of EXIT_BLOCK_PTR macro.
	(ix86_eax_live_at_start_p): Remove usage of ENTRY_BLOCK_PTR macro.
	(add_condition_to_bb): Remove usage of EXIT_BLOCK_PTR macro.
	(ix86_expand_epilogue): Likewise.
	* config/ia64/ia64.c (ia64_asm_unwind_emit): Likewise.
	(ia64_expand_prologue): Likewise.

From-SVN: r205055

1 files changed, 95 insertions, 77 deletions

diff --git a/gcc/cfgrtl.c b/gcc/cfgrtl.c
index c81d3a5..7ad3872 100644
--- a/gcc/cfgrtl.c
+++ b/gcc/cfgrtl.c
@@ -501,7 +501,7 @@ rtx
 entry_of_function (void)
 {
   return (n_basic_blocks_for_fn (cfun) > NUM_FIXED_BLOCKS ?
-	  BB_HEAD (ENTRY_BLOCK_PTR->next_bb) : get_insns ());
+	  BB_HEAD (ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb) : get_insns ());
 }
 
 /* Emit INSN at the entry point of the function, ensuring that it is only
@@ -509,7 +509,7 @@ entry_of_function (void)
 void
 emit_insn_at_entry (rtx insn)
 {
-  edge_iterator ei = ei_start (ENTRY_BLOCK_PTR->succs);
+  edge_iterator ei = ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs);
   edge e = ei_safe_edge (ei);
   gcc_assert (e->flags & EDGE_FALLTHRU);
 
@@ -573,7 +573,7 @@ contains_no_active_insn_p (const_basic_block bb)
 {
   rtx insn;
 
-  if (bb == EXIT_BLOCK_PTR || bb == ENTRY_BLOCK_PTR
+  if (bb == EXIT_BLOCK_PTR_FOR_FN (cfun) || bb == ENTRY_BLOCK_PTR_FOR_FN (cfun)
       || !single_succ_p (bb))
     return false;
 
@@ -620,7 +620,7 @@ can_fallthru (basic_block src, basic_block target)
   edge e;
   edge_iterator ei;
 
-  if (target == EXIT_BLOCK_PTR)
+  if (target == EXIT_BLOCK_PTR_FOR_FN (cfun))
     return true;
   if (src->next_bb != target)
     return false;
@@ -630,7 +630,7 @@ can_fallthru (basic_block src, basic_block target)
     return false;
 
   FOR_EACH_EDGE (e, ei, src->succs)
-    if (e->dest == EXIT_BLOCK_PTR
+    if (e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun)
 	&& e->flags & EDGE_FALLTHRU)
       return false;
 
@@ -650,10 +650,10 @@ could_fall_through (basic_block src, basic_block target)
   edge e;
   edge_iterator ei;
 
-  if (target == EXIT_BLOCK_PTR)
+  if (target == EXIT_BLOCK_PTR_FOR_FN (cfun))
     return true;
   FOR_EACH_EDGE (e, ei, src->succs)
-    if (e->dest == EXIT_BLOCK_PTR
+    if (e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun)
 	&& e->flags & EDGE_FALLTHRU)
       return 0;
   return true;
@@ -958,7 +958,8 @@ rtl_can_merge_blocks (basic_block a, basic_block b)
 	  /* Must be simple edge.  */
 	  && !(single_succ_edge (a)->flags & EDGE_COMPLEX)
 	  && a->next_bb == b
-	  && a != ENTRY_BLOCK_PTR && b != EXIT_BLOCK_PTR
+	  && a != ENTRY_BLOCK_PTR_FOR_FN (cfun)
+	  && b != EXIT_BLOCK_PTR_FOR_FN (cfun)
 	  /* If the jump insn has side effects,
 	     we can't kill the edge.  */
 	  && (!JUMP_P (BB_END (a))
@@ -972,7 +973,7 @@ rtl_can_merge_blocks (basic_block a, basic_block b)
 rtx
 block_label (basic_block block)
 {
-  if (block == EXIT_BLOCK_PTR)
+  if (block == EXIT_BLOCK_PTR_FOR_FN (cfun))
     return NULL_RTX;
 
   if (!LABEL_P (BB_HEAD (block)))
@@ -1084,13 +1085,13 @@ try_redirect_by_replacing_jump (edge e, basic_block target, bool in_cfglayout)
 		 INSN_UID (insn), e->dest->index, target->index);
       if (!redirect_jump (insn, block_label (target), 0))
 	{
-	  gcc_assert (target == EXIT_BLOCK_PTR);
+	  gcc_assert (target == EXIT_BLOCK_PTR_FOR_FN (cfun));
 	  return NULL;
 	}
     }
 
   /* Cannot do anything for target exit block.  */
-  else if (target == EXIT_BLOCK_PTR)
+  else if (target == EXIT_BLOCK_PTR_FOR_FN (cfun))
     return NULL;
 
   /* Or replace possibly complicated jump insn by simple jump insn.  */
@@ -1178,7 +1179,7 @@ patch_jump_insn (rtx insn, rtx old_label, basic_block new_bb)
       int j;
       rtx new_label = block_label (new_bb);
 
-      if (new_bb == EXIT_BLOCK_PTR)
+      if (new_bb == EXIT_BLOCK_PTR_FOR_FN (cfun))
 	return false;
       if (GET_CODE (PATTERN (tmp)) == ADDR_VEC)
 	vec = XVEC (PATTERN (tmp), 0);
@@ -1211,7 +1212,7 @@ patch_jump_insn (rtx insn, rtx old_label, basic_block new_bb)
       int i, n = ASM_OPERANDS_LABEL_LENGTH (tmp);
       rtx new_label, note;
 
-      if (new_bb == EXIT_BLOCK_PTR)
+      if (new_bb == EXIT_BLOCK_PTR_FOR_FN (cfun))
 	return false;
       new_label = block_label (new_bb);
 
@@ -1268,7 +1269,7 @@ patch_jump_insn (rtx insn, rtx old_label, basic_block new_bb)
 	     target is exit block on some arches.  */
 	  if (!redirect_jump (insn, block_label (new_bb), 0))
 	    {
-	      gcc_assert (new_bb == EXIT_BLOCK_PTR);
+	      gcc_assert (new_bb == EXIT_BLOCK_PTR_FOR_FN (cfun));
 	      return false;
 	    }
 	}
@@ -1324,7 +1325,8 @@ fixup_partition_crossing (edge e)
 {
   rtx note;
 
-  if (e->src == ENTRY_BLOCK_PTR || e->dest == EXIT_BLOCK_PTR)
+  if (e->src == ENTRY_BLOCK_PTR_FOR_FN (cfun) || e->dest
+      == EXIT_BLOCK_PTR_FOR_FN (cfun))
     return;
   /* If we redirected an existing edge, it may already be marked
      crossing, even though the new src is missing a reg crossing note.
@@ -1392,7 +1394,7 @@ fixup_new_cold_bb (basic_block bb)
          boundary fixup by calling fixup_partition_crossing itself.  */
       if ((e->flags & EDGE_FALLTHRU)
           && BB_PARTITION (bb) != BB_PARTITION (e->dest)
-          && e->dest != EXIT_BLOCK_PTR)
+	  && e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun))
         force_nonfallthru (e);
       else
         fixup_partition_crossing (e);
@@ -1470,7 +1472,8 @@ force_nonfallthru_and_redirect (edge e, basic_block target, rtx jump_label)
   /* In the case the last instruction is conditional jump to the next
      instruction, first redirect the jump itself and then continue
      by creating a basic block afterwards to redirect fallthru edge.  */
-  if (e->src != ENTRY_BLOCK_PTR && e->dest != EXIT_BLOCK_PTR
+  if (e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)
+      && e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun)
       && any_condjump_p (BB_END (e->src))
       && JUMP_LABEL (BB_END (e->src)) == BB_HEAD (e->dest))
     {
@@ -1512,7 +1515,7 @@ force_nonfallthru_and_redirect (edge e, basic_block target, rtx jump_label)
   else
     {
       gcc_assert (e->flags & EDGE_FALLTHRU);
-      if (e->src == ENTRY_BLOCK_PTR)
+      if (e->src == ENTRY_BLOCK_PTR_FOR_FN (cfun))
 	{
 	  /* We can't redirect the entry block.  Create an empty block
 	     at the start of the function which we use to add the new
@@ -1521,16 +1524,18 @@ force_nonfallthru_and_redirect (edge e, basic_block target, rtx jump_label)
 	  edge_iterator ei;
 	  bool found = false;
 
-	  basic_block bb = create_basic_block (BB_HEAD (e->dest), NULL, ENTRY_BLOCK_PTR);
+	  basic_block bb = create_basic_block (BB_HEAD (e->dest), NULL,
+					       ENTRY_BLOCK_PTR_FOR_FN (cfun));
 
 	  /* Change the existing edge's source to be the new block, and add
 	     a new edge from the entry block to the new block.  */
 	  e->src = bb;
-	  for (ei = ei_start (ENTRY_BLOCK_PTR->succs); (tmp = ei_safe_edge (ei)); )
+	  for (ei = ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs);
+	       (tmp = ei_safe_edge (ei)); )
 	    {
 	      if (tmp == e)
 		{
-		  ENTRY_BLOCK_PTR->succs->unordered_remove (ei.index);
+		  ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs->unordered_remove (ei.index);
 		  found = true;
 		  break;
 		}
@@ -1541,14 +1546,15 @@ force_nonfallthru_and_redirect (edge e, basic_block target, rtx jump_label)
 	  gcc_assert (found);
 
 	  vec_safe_push (bb->succs, e);
-	  make_single_succ_edge (ENTRY_BLOCK_PTR, bb, EDGE_FALLTHRU);
+	  make_single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun), bb,
+				 EDGE_FALLTHRU);
 	}
     }
 
   /* If e->src ends with asm goto, see if any of the ASM_OPERANDS_LABELs
      don't point to the target or fallthru label.  */
   if (JUMP_P (BB_END (e->src))
-      && target != EXIT_BLOCK_PTR
+      && target != EXIT_BLOCK_PTR_FOR_FN (cfun)
       && (e->flags & EDGE_FALLTHRU)
       && (note = extract_asm_operands (PATTERN (BB_END (e->src)))))
     {
@@ -1650,7 +1656,7 @@ force_nonfallthru_and_redirect (edge e, basic_block target, rtx jump_label)
 
   loc = e->goto_locus;
   e->flags &= ~EDGE_FALLTHRU;
-  if (target == EXIT_BLOCK_PTR)
+  if (target == EXIT_BLOCK_PTR_FOR_FN (cfun))
     {
       if (jump_label == ret_rtx)
 	{
@@ -1784,7 +1790,7 @@ static basic_block
 last_bb_in_partition (basic_block start_bb)
 {
   basic_block bb;
-  FOR_BB_BETWEEN (bb, start_bb, EXIT_BLOCK_PTR, next_bb)
+  FOR_BB_BETWEEN (bb, start_bb, EXIT_BLOCK_PTR_FOR_FN (cfun), next_bb)
     {
       if (BB_PARTITION (start_bb) != BB_PARTITION (bb->next_bb))
         return bb;
@@ -1820,14 +1826,15 @@ rtl_split_edge (edge edge_in)
     }
 
   /* Create the basic block note.  */
-  if (edge_in->dest != EXIT_BLOCK_PTR)
+  if (edge_in->dest != EXIT_BLOCK_PTR_FOR_FN (cfun))
     before = BB_HEAD (edge_in->dest);
   else
     before = NULL_RTX;
 
   /* If this is a fall through edge to the exit block, the blocks might be
      not adjacent, and the right place is after the source.  */
-  if ((edge_in->flags & EDGE_FALLTHRU) && edge_in->dest == EXIT_BLOCK_PTR)
+  if ((edge_in->flags & EDGE_FALLTHRU)
+      && edge_in->dest == EXIT_BLOCK_PTR_FOR_FN (cfun))
     {
       before = NEXT_INSN (BB_END (edge_in->src));
       bb = create_basic_block (before, NULL, edge_in->src);
@@ -1835,7 +1842,7 @@ rtl_split_edge (edge edge_in)
     }
   else
     {
-      if (edge_in->src == ENTRY_BLOCK_PTR)
+      if (edge_in->src == ENTRY_BLOCK_PTR_FOR_FN (cfun))
         {
           bb = create_basic_block (before, NULL, edge_in->dest->prev_bb);
           BB_COPY_PARTITION (bb, edge_in->dest);
@@ -1873,7 +1880,7 @@ rtl_split_edge (edge edge_in)
 
   /* Can't allow a region crossing edge to be fallthrough.  */
   if (BB_PARTITION (bb) != BB_PARTITION (edge_in->dest)
-      && edge_in->dest != EXIT_BLOCK_PTR)
+      && edge_in->dest != EXIT_BLOCK_PTR_FOR_FN (cfun))
     {
       new_bb = force_nonfallthru (single_succ_edge (bb));
       gcc_assert (!new_bb);
@@ -1888,7 +1895,7 @@ rtl_split_edge (edge edge_in)
     }
   else
     {
-      if (edge_in->src != ENTRY_BLOCK_PTR)
+      if (edge_in->src != ENTRY_BLOCK_PTR_FOR_FN (cfun))
 	{
 	  /* For asm goto even splitting of fallthru edge might
 	     need insn patching, as other labels might point to the
@@ -1896,7 +1903,7 @@ rtl_split_edge (edge edge_in)
 	  rtx last = BB_END (edge_in->src);
 	  if (last
 	      && JUMP_P (last)
-	      && edge_in->dest != EXIT_BLOCK_PTR
+	      && edge_in->dest != EXIT_BLOCK_PTR_FOR_FN (cfun)
 	      && extract_asm_operands (PATTERN (last)) != NULL_RTX
 	      && patch_jump_insn (last, before, bb))
 	    df_set_bb_dirty (edge_in->src);
@@ -1943,7 +1950,7 @@ commit_one_edge_insertion (edge e)
 
   /* Figure out where to put these insns.  If the destination has
      one predecessor, insert there.  Except for the exit block.  */
-  if (single_pred_p (e->dest) && e->dest != EXIT_BLOCK_PTR)
+  if (single_pred_p (e->dest) && e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun))
     {
       bb = e->dest;
 
@@ -1972,7 +1979,7 @@ commit_one_edge_insertion (edge e)
      the basic block.  */
   else if ((e->flags & EDGE_ABNORMAL) == 0
 	   && single_succ_p (e->src)
-	   && e->src != ENTRY_BLOCK_PTR
+	   && e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)
 	   && (!JUMP_P (BB_END (e->src))
 	       || simplejump_p (BB_END (e->src))))
     {
@@ -2025,7 +2032,7 @@ commit_one_edge_insertion (edge e)
 	 to EXIT.  */
 
       e = single_succ_edge (bb);
-      gcc_assert (e->dest == EXIT_BLOCK_PTR
+      gcc_assert (e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun)
 		  && single_succ_p (bb) && (e->flags & EDGE_FALLTHRU));
 
       e->flags &= ~EDGE_FALLTHRU;
@@ -2057,7 +2064,8 @@ commit_edge_insertions (void)
   verify_flow_info ();
 #endif
 
-  FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
+  FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun),
+		  EXIT_BLOCK_PTR_FOR_FN (cfun), next_bb)
     {
       edge e;
       edge_iterator ei;
@@ -2428,8 +2436,8 @@ rtl_verify_edges (void)
 	    n_fallthru++, fallthru = e;
 
 	  is_crossing = (BB_PARTITION (e->src) != BB_PARTITION (e->dest)
-			 && e->src != ENTRY_BLOCK_PTR
-			 && e->dest != EXIT_BLOCK_PTR);
+			 && e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)
+			 && e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun));
           has_crossing_edge |= is_crossing;
 	  if (e->flags & EDGE_CROSSING)
 	    {
@@ -2832,8 +2840,8 @@ rtl_verify_fallthru (void)
 		break;
 	    }
 	}
-      else if (e->src != ENTRY_BLOCK_PTR
-	       && e->dest != EXIT_BLOCK_PTR)
+      else if (e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)
+	       && e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun))
 	{
 	  rtx insn;
 
@@ -2872,10 +2880,10 @@ rtl_verify_bb_layout (void)
   rtx x;
   int num_bb_notes;
   const rtx rtx_first = get_insns ();
-  basic_block last_bb_seen = ENTRY_BLOCK_PTR, curr_bb = NULL;
+  basic_block last_bb_seen = ENTRY_BLOCK_PTR_FOR_FN (cfun), curr_bb = NULL;
 
   num_bb_notes = 0;
-  last_bb_seen = ENTRY_BLOCK_PTR;
+  last_bb_seen = ENTRY_BLOCK_PTR_FOR_FN (cfun);
 
   for (x = rtx_first; x; x = NEXT_INSN (x))
     {
@@ -3062,7 +3070,7 @@ purge_dead_edges (basic_block bb)
 	      ei_next (&ei);
 	      continue;
 	    }
-	  else if (e->dest != EXIT_BLOCK_PTR
+	  else if (e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun)
 		   && BB_HEAD (e->dest) == JUMP_LABEL (insn))
 	    /* If the destination block is the target of the jump,
 	       keep the edge.  */
@@ -3070,7 +3078,8 @@ purge_dead_edges (basic_block bb)
 	      ei_next (&ei);
 	      continue;
 	    }
-	  else if (e->dest == EXIT_BLOCK_PTR && returnjump_p (insn))
+	  else if (e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun)
+		   && returnjump_p (insn))
 	    /* If the destination block is the exit block, and this
 	       instruction is a return, then keep the edge.  */
 	    {
@@ -3319,7 +3328,7 @@ skip_insns_after_block (basic_block bb)
   rtx insn, last_insn, next_head, prev;
 
   next_head = NULL_RTX;
-  if (bb->next_bb != EXIT_BLOCK_PTR)
+  if (bb->next_bb != EXIT_BLOCK_PTR_FOR_FN (cfun))
     next_head = BB_HEAD (bb->next_bb);
 
   for (last_insn = insn = BB_END (bb); (insn = NEXT_INSN (insn)) != 0; )
@@ -3468,7 +3477,7 @@ outof_cfg_layout_mode (void)
   basic_block bb;
 
   FOR_EACH_BB (bb)
-    if (bb->next_bb != EXIT_BLOCK_PTR)
+    if (bb->next_bb != EXIT_BLOCK_PTR_FOR_FN (cfun))
       bb->aux = bb->next_bb;
 
   cfg_layout_finalize ();
@@ -3577,7 +3586,8 @@ relink_block_chain (bool stay_in_cfglayout_mode)
   if (dump_file)
     {
       fprintf (dump_file, "Reordered sequence:\n");
-      for (bb = ENTRY_BLOCK_PTR->next_bb, index = NUM_FIXED_BLOCKS;
+      for (bb = ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb, index =
+	   NUM_FIXED_BLOCKS;
 	   bb;
 	   bb = (basic_block) bb->aux, index++)
 	{
@@ -3595,15 +3605,15 @@ relink_block_chain (bool stay_in_cfglayout_mode)
     }
 
   /* Now reorder the blocks.  */
-  prev_bb = ENTRY_BLOCK_PTR;
-  bb = ENTRY_BLOCK_PTR->next_bb;
+  prev_bb = ENTRY_BLOCK_PTR_FOR_FN (cfun);
+  bb = ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb;
   for (; bb; prev_bb = bb, bb = (basic_block) bb->aux)
     {
       bb->prev_bb = prev_bb;
       prev_bb->next_bb = bb;
     }
-  prev_bb->next_bb = EXIT_BLOCK_PTR;
-  EXIT_BLOCK_PTR->prev_bb = prev_bb;
+  prev_bb->next_bb = EXIT_BLOCK_PTR_FOR_FN (cfun);
+  EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb = prev_bb;
 
   /* Then, clean up the aux fields.  */
   FOR_ALL_BB (bb)
@@ -3644,7 +3654,8 @@ fixup_reorder_chain (void)
   /* First do the bulk reordering -- rechain the blocks without regard to
      the needed changes to jumps and labels.  */
 
-  for (bb = ENTRY_BLOCK_PTR->next_bb; bb; bb = (basic_block) bb->aux)
+  for (bb = ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb; bb; bb = (basic_block)
+       bb->aux)
     {
       if (BB_HEADER (bb))
 	{
@@ -3687,7 +3698,8 @@ fixup_reorder_chain (void)
   /* Now add jumps and labels as needed to match the blocks new
      outgoing edges.  */
 
-  for (bb = ENTRY_BLOCK_PTR->next_bb; bb ; bb = (basic_block) bb->aux)
+  for (bb = ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb; bb ; bb = (basic_block)
+       bb->aux)
     {
       edge e_fall, e_taken, e;
       rtx bb_end_insn;
@@ -3728,7 +3740,7 @@ fixup_reorder_chain (void)
 
 	      /* If the old fallthru is still next, nothing to do.  */
 	      if (bb->aux == e_fall->dest
-		  || e_fall->dest == EXIT_BLOCK_PTR)
+		  || e_fall->dest == EXIT_BLOCK_PTR_FOR_FN (cfun))
 		continue;
 
 	      /* The degenerated case of conditional jump jumping to the next
@@ -3749,7 +3761,8 @@ fixup_reorder_chain (void)
 		  if (note
 		      && XINT (note, 0) < REG_BR_PROB_BASE / 2
 		      && invert_jump (bb_end_insn,
-				      (e_fall->dest == EXIT_BLOCK_PTR
+				      (e_fall->dest
+				       == EXIT_BLOCK_PTR_FOR_FN (cfun)
 				       ? NULL_RTX
 				       : label_for_bb (e_fall->dest)), 0))
 		    {
@@ -3771,7 +3784,8 @@ fixup_reorder_chain (void)
 	      /* Otherwise we can try to invert the jump.  This will
 		 basically never fail, however, keep up the pretense.  */
 	      else if (invert_jump (bb_end_insn,
-				    (e_fall->dest == EXIT_BLOCK_PTR
+				    (e_fall->dest
+				     == EXIT_BLOCK_PTR_FOR_FN (cfun)
 				     ? NULL_RTX
 				     : label_for_bb (e_fall->dest)), 0))
 		{
@@ -3793,7 +3807,7 @@ fixup_reorder_chain (void)
 		 __builtin_unreachable ()), nothing to do.  */
 	      if (! e_fall
 		  || bb->aux == e_fall->dest
-		  || e_fall->dest == EXIT_BLOCK_PTR)
+		  || e_fall->dest == EXIT_BLOCK_PTR_FOR_FN (cfun))
 		continue;
 
 	      /* Otherwise we'll have to use the fallthru fixup below.  */
@@ -3820,7 +3834,7 @@ fixup_reorder_chain (void)
 	    continue;
 
 	  /* A fallthru to exit block.  */
-	  if (e_fall->dest == EXIT_BLOCK_PTR)
+	  if (e_fall->dest == EXIT_BLOCK_PTR_FOR_FN (cfun))
 	    continue;
 	}
 
@@ -3880,7 +3894,7 @@ fixup_reorder_chain (void)
 		  continue;
 		}
 	      dest = e->dest;
-	      if (dest == EXIT_BLOCK_PTR)
+	      if (dest == EXIT_BLOCK_PTR_FOR_FN (cfun))
 		{
 		  /* Non-fallthru edges to the exit block cannot be split.  */
 		  if (!(e->flags & EDGE_FALLTHRU))
@@ -3958,13 +3972,13 @@ fixup_fallthru_exit_predecessor (void)
      value.  */
   gcc_assert (reload_completed);
 
-  e = find_fallthru_edge (EXIT_BLOCK_PTR->preds);
+  e = find_fallthru_edge (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds);
   if (e)
     bb = e->src;
 
   if (bb && bb->aux)
     {
-      basic_block c = ENTRY_BLOCK_PTR->next_bb;
+      basic_block c = ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb;
 
       /* If the very first block is the one with the fall-through exit
 	 edge, we have to split that block.  */
@@ -4000,7 +4014,7 @@ force_one_exit_fallthru (void)
   edge_iterator ei;
   basic_block forwarder, bb;
 
-  FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
+  FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)
     if (e->flags & EDGE_FALLTHRU)
       {
 	if (predecessor == NULL)
@@ -4018,7 +4032,8 @@ force_one_exit_fallthru (void)
   /* Exit has several fallthru predecessors.  Create a forwarder block for
      them.  */
   forwarder = split_edge (predecessor);
-  for (ei = ei_start (EXIT_BLOCK_PTR->preds); (e = ei_safe_edge (ei)); )
+  for (ei = ei_start (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds);
+       (e = ei_safe_edge (ei)); )
     {
       if (e->src == forwarder
 	  || !(e->flags & EDGE_FALLTHRU))
@@ -4166,7 +4181,7 @@ cfg_layout_duplicate_bb (basic_block bb)
   insn = duplicate_insn_chain (BB_HEAD (bb), BB_END (bb));
   new_bb = create_basic_block (insn,
 			       insn ? get_last_insn () : NULL,
-			       EXIT_BLOCK_PTR->prev_bb);
+			       EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb);
 
   BB_COPY_PARTITION (new_bb, bb);
   if (BB_HEADER (bb))
@@ -4313,14 +4328,14 @@ cfg_layout_redirect_edge_and_branch (edge e, basic_block dest)
   if (e->dest == dest)
     return e;
 
-  if (e->src != ENTRY_BLOCK_PTR
+  if (e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)
       && (ret = try_redirect_by_replacing_jump (e, dest, true)))
     {
       df_set_bb_dirty (src);
       return ret;
     }
 
-  if (e->src == ENTRY_BLOCK_PTR
+  if (e->src == ENTRY_BLOCK_PTR_FOR_FN (cfun)
       && (e->flags & EDGE_FALLTHRU) && !(e->flags & EDGE_COMPLEX))
     {
       if (dump_file)
@@ -4447,7 +4462,7 @@ cfg_layout_delete_block (basic_block bb)
 	    set_last_insn (insn);
 	}
     }
-  if (bb->next_bb != EXIT_BLOCK_PTR)
+  if (bb->next_bb != EXIT_BLOCK_PTR_FOR_FN (cfun))
     to = &BB_HEADER (bb->next_bb);
   else
     to = &cfg_layout_function_footer;
@@ -4504,7 +4519,7 @@ cfg_layout_can_merge_blocks_p (basic_block a, basic_block b)
   if (NEXT_INSN (BB_END (a)) != BB_HEAD (b))
     {
       edge e = find_fallthru_edge (b->succs);
-      if (e && e->dest == EXIT_BLOCK_PTR)
+      if (e && e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun))
 	return false;
     }
 
@@ -4515,7 +4530,8 @@ cfg_layout_can_merge_blocks_p (basic_block a, basic_block b)
 	  && a != b
 	  /* Must be simple edge.  */
 	  && !(single_succ_edge (a)->flags & EDGE_COMPLEX)
-	  && a != ENTRY_BLOCK_PTR && b != EXIT_BLOCK_PTR
+	  && a != ENTRY_BLOCK_PTR_FOR_FN (cfun)
+	  && b != EXIT_BLOCK_PTR_FOR_FN (cfun)
 	  /* If the jump insn has side effects, we can't kill the edge.
 	     When not optimizing, try_redirect_by_replacing_jump will
 	     not allow us to redirect an edge by replacing a table jump.  */
@@ -4634,11 +4650,11 @@ static basic_block
 cfg_layout_split_edge (edge e)
 {
   basic_block new_bb =
-    create_basic_block (e->src != ENTRY_BLOCK_PTR
+    create_basic_block (e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)
 			? NEXT_INSN (BB_END (e->src)) : get_insns (),
 			NULL_RTX, e->src);
 
-  if (e->dest == EXIT_BLOCK_PTR)
+  if (e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun))
     BB_COPY_PARTITION (new_bb, e->src);
   else
     BB_COPY_PARTITION (new_bb, e->dest);
@@ -4663,7 +4679,8 @@ rtl_block_empty_p (basic_block bb)
 {
   rtx insn;
 
-  if (bb == ENTRY_BLOCK_PTR || bb == EXIT_BLOCK_PTR)
+  if (bb == ENTRY_BLOCK_PTR_FOR_FN (cfun)
+      || bb == EXIT_BLOCK_PTR_FOR_FN (cfun))
     return true;
 
   FOR_BB_INSNS (bb, insn)
@@ -4770,7 +4787,8 @@ rtl_flow_call_edges_add (sbitmap blocks)
   if (! blocks)
     check_last_block = true;
   else
-    check_last_block = bitmap_bit_p (blocks, EXIT_BLOCK_PTR->prev_bb->index);
+    check_last_block = bitmap_bit_p (blocks,
+				     EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb->index);
 
   /* In the last basic block, before epilogue generation, there will be
      a fallthru edge to EXIT.  Special care is required if the last insn
@@ -4786,7 +4804,7 @@ rtl_flow_call_edges_add (sbitmap blocks)
      Handle this by adding a dummy instruction in a new last basic block.  */
   if (check_last_block)
     {
-      basic_block bb = EXIT_BLOCK_PTR->prev_bb;
+      basic_block bb = EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb;
       rtx insn = BB_END (bb);
 
       /* Back up past insns that must be kept in the same block as a call.  */
@@ -4798,7 +4816,7 @@ rtl_flow_call_edges_add (sbitmap blocks)
 	{
 	  edge e;
 
-	  e = find_edge (bb, EXIT_BLOCK_PTR);
+	  e = find_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun));
 	  if (e)
 	    {
 	      insert_insn_on_edge (gen_use (const0_rtx), e);
@@ -4846,7 +4864,7 @@ rtl_flow_call_edges_add (sbitmap blocks)
 #ifdef ENABLE_CHECKING
 	      if (split_at_insn == BB_END (bb))
 		{
-		  e = find_edge (bb, EXIT_BLOCK_PTR);
+		  e = find_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun));
 		  gcc_assert (e == NULL);
 		}
 #endif
@@ -4860,7 +4878,7 @@ rtl_flow_call_edges_add (sbitmap blocks)
 		    blocks_split++;
 		}
 
-	      make_edge (bb, EXIT_BLOCK_PTR, EDGE_FAKE);
+	      make_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun), EDGE_FAKE);
 	    }
 
 	  if (insn == BB_HEAD (bb))
@@ -4952,7 +4970,7 @@ rtl_can_remove_branch_p (const_edge e)
   const_rtx insn = BB_END (src), set;
 
   /* The conditions are taken from try_redirect_by_replacing_jump.  */
-  if (target == EXIT_BLOCK_PTR)
+  if (target == EXIT_BLOCK_PTR_FOR_FN (cfun))
     return false;
 
   if (e->flags & (EDGE_ABNORMAL_CALL | EDGE_EH))