#include "config.h"#include "system.h"#include "coretypes.h"#include "backend.h"#include "target.h"#include "rtl.h"#include "tree.h"#include "predict.h"#include "df.h"#include "memmodel.h"#include "tm_p.h"#include "insn-config.h"#include "regs.h"#include "ira.h"#include "ira-int.h"#include "reload.h"#include "cfgloop.h"
Data Structures | |
| struct | allocno_hard_regs |
| struct | allocno_hard_regs_node |
| struct | update_cost_record |
| struct | allocno_color_data |
| struct | allocno_hard_regs_hasher |
| struct | allocno_hard_regs_subnode |
| struct | update_cost_queue_elem |
| struct | coalesce_data |
Macros | |
| #define | ALLOCNO_COLOR_DATA(a) ((allocno_color_data_t) ALLOCNO_ADD_DATA (a)) |
| #define | SORTGT(x, y) (((x) > (y)) ? 1 : -1) |
| #define | COST_HOP_DIVISOR 4 |
| #define | ALLOCNO_COALESCE_DATA(a) ((coalesce_data_t) ALLOCNO_ADD_DATA (a)) |
Macro Definition Documentation
◆ ALLOCNO_COALESCE_DATA
| #define ALLOCNO_COALESCE_DATA | ( | a | ) | ((coalesce_data_t) ALLOCNO_ADD_DATA (a)) |
Macro to access the data concerning coalescing.
Referenced by coalesce_spill_slots(), coalesced_allocno_conflict_p(), collect_spilled_coalesced_allocnos(), ira_sort_regnos_for_alter_reg(), merge_allocnos(), setup_coalesced_allocno_costs_and_nums(), setup_slot_coalesced_allocno_live_ranges(), and slot_coalesced_allocno_live_ranges_intersect_p().
◆ ALLOCNO_COLOR_DATA
| #define ALLOCNO_COLOR_DATA | ( | a | ) | ((allocno_color_data_t) ALLOCNO_ADD_DATA (a)) |
Macro to access the data concerning coloring.
Referenced by add_allocno_to_bucket(), add_allocno_to_ordered_colorable_bucket(), allocno_spill_priority(), allocno_spill_priority_compare(), allocno_thread_conflict_p(), assign_hard_reg(), bucket_allocno_compare_func(), color_allocnos(), delete_allocno_from_bucket(), empty_profitable_hard_regs(), form_allocno_hard_regs_nodes_forest(), form_threads_from_bucket(), form_threads_from_colorable_allocno(), form_threads_from_copies(), get_conflict_and_start_profitable_regs(), improve_allocation(), init_allocno_threads(), merge_threads(), pop_allocnos_from_stack(), push_allocno_to_stack(), push_allocnos_to_stack(), push_only_colorable(), put_allocno_into_bucket(), remove_allocno_from_bucket_and_push(), restore_costs_from_copies(), setup_allocno_available_regs_num(), setup_left_conflict_sizes_p(), setup_profitable_hard_regs(), sort_bucket(), update_conflict_allocno_hard_prefs(), update_conflict_hard_regno_costs(), update_costs_from_allocno(), and update_left_conflict_sizes_p().
◆ COST_HOP_DIVISOR
| #define COST_HOP_DIVISOR 4 |
When we traverse allocnos to update hard register costs, the cost divisor will be multiplied by the following macro value for each hop from given allocno to directly connected allocnos.
Referenced by assign_hard_reg(), update_conflict_hard_regno_costs(), update_costs_from_allocno(), and update_costs_from_prefs().
◆ SORTGT
Helper for qsort comparison callbacks - return a positive integer if X > Y, or a negative value otherwise. Use a conditional expression instead of a difference computation to insulate from possible overflow issues, e.g. X - Y < 0 for some X > 0 and Y < 0.
Referenced by allocno_hard_regs_compare(), and allocno_priority_compare_func().
Typedef Documentation
◆ allocno_color_data_t
See above.
◆ allocno_hard_regs_node_t
◆ allocno_hard_regs_subnode_t
◆ allocno_hard_regs_t
◆ coalesce_data_t
See below.
Function Documentation
◆ add_allocno_hard_regs()
|
static |
Add (or update info about) allocno hard registers with SET and COST.
References allocno_hard_regs_vec, allocno_hard_regs::cost, find_hard_regs(), gcc_assert, ggc_alloc(), hard_reg_set_empty_p(), insert_hard_regs(), ira_allocate(), NULL, and allocno_hard_regs::set.
Referenced by add_allocno_hard_regs_to_forest(), and form_allocno_hard_regs_nodes_forest().
◆ add_allocno_hard_regs_to_forest()
|
static |
Add allocno hard registers HV (or its best approximation if it is not possible) to the forest on its level given by ROOTS.
References add_allocno_hard_regs(), add_allocno_hard_regs_to_forest(), add_new_allocno_hard_regs_node_to_forest(), CLEAR_HARD_REG_SET, create_new_allocno_hard_regs_node(), allocno_hard_regs_node::first, ggc_alloc(), hard_reg_set_intersect_p(), hard_reg_set_subset_p(), allocno_hard_regs_node::hard_regs, hard_regs_node_vec, i, allocno_hard_regs_node::next, NULL, allocno_hard_regs_node::prev, and allocno_hard_regs::set.
Referenced by add_allocno_hard_regs_to_forest(), and form_allocno_hard_regs_nodes_forest().
◆ add_allocno_to_bucket()
|
static |
Add allocno A to bucket *BUCKET_PTR. A should be not in a bucket before the call.
References a, ALLOCNO_CLASS, ALLOCNO_COLOR_DATA, ggc_alloc(), ira_assert, NULL, uncolorable_allocno_bucket, and uncolorable_allocnos_num.
Referenced by put_allocno_into_bucket().
◆ add_allocno_to_ordered_colorable_bucket()
|
static |
Add ALLOCNO to colorable bucket maintaining the order according their priority. ALLOCNO should be not in a bucket before the call.
References ALLOCNO_COLOR_DATA, bucket_allocno_compare_func(), colorable_allocno_bucket, form_threads_from_colorable_allocno(), ggc_alloc(), and NULL.
Referenced by push_allocno_to_stack().
◆ add_new_allocno_hard_regs_node_to_forest()
|
static |
Add allocno hard registers node NEW_NODE to the forest on its level given by ROOTS.
References allocno_hard_regs_node::next, NULL, and allocno_hard_regs_node::prev.
Referenced by add_allocno_hard_regs_to_forest(), and form_allocno_hard_regs_nodes_forest().
◆ allocno_copy_cost_saving()
|
static |
Return savings on removed copies when ALLOCNO is assigned to HARD_REGNO.
References ALLOCNO_CLASS, ALLOCNO_COPIES, ALLOCNO_HARD_REGNO, ALLOCNO_MODE, gcc_unreachable, ggc_alloc(), update_cost_record::hard_regno, ira_class_hard_regs_num, ira_init_register_move_cost_if_necessary(), ira_reg_class_max_nregs, ira_register_move_cost, and NULL.
Referenced by improve_allocation().
◆ allocno_cost_compare_func()
Sort allocnos according to the profit of usage of a hard register instead of memory for them.
References ALLOCNO_NUM, ALLOCNO_UPDATED_CLASS_COST, ALLOCNO_UPDATED_MEMORY_COST, and ggc_alloc().
Referenced by improve_allocation().
◆ allocno_hard_regs_compare()
Sort hard regs according to their frequency of usage.
References ggc_alloc(), allocno_hard_regs_hasher::hash(), and SORTGT.
Referenced by form_allocno_hard_regs_nodes_forest().
◆ allocno_priority_compare_func()
Sort allocnos according to their priorities.
References ALLOCNO_NUM, allocno_priorities, ALLOCNO_REGNO, ggc_alloc(), non_spilled_static_chain_regno_p(), and SORTGT.
Referenced by color_allocnos(), fast_allocation(), and ira_reassign_conflict_allocnos().
◆ allocno_reload_assign()
|
static |
Try to assign a hard register (except for FORBIDDEN_REGS) to allocno A and return TRUE in the case of success.
References a, ALLOCNO_ASSIGNED_P, ALLOCNO_CALLS_CROSSED_NUM, ALLOCNO_CLASS, ALLOCNO_CLASS_COST, ALLOCNO_HARD_REG_COSTS, ALLOCNO_HARD_REGNO, ALLOCNO_MEMORY_COST, ALLOCNO_NUM_OBJECTS, ALLOCNO_OBJECT, ALLOCNO_REGNO, assign_hard_reg(), caller_save_needed, ggc_alloc(), i, internal_flag_ira_verbose, ira_assert, ira_class_hard_reg_index, ira_dump_file, ira_need_caller_save_p(), ira_need_caller_save_regs(), ira_overall_cost, mark_home_live(), NULL, OBJECT_TOTAL_CONFLICT_HARD_REGS, reg_renumber, regno_reg_rtx, SET_REGNO, and update_curr_costs().
Referenced by ira_reassign_pseudos().
◆ allocno_spill_priority()
|
inlinestatic |
Return the current spill priority of allocno A. The less the number, the more preferable the allocno for spilling.
References a, ALLOCNO_CLASS, ALLOCNO_COLOR_DATA, ALLOCNO_EXCESS_PRESSURE_POINTS_NUM, ALLOCNO_MODE, and ira_reg_class_max_nregs.
Referenced by allocno_spill_priority_compare(), and remove_allocno_from_bucket_and_push().
◆ allocno_spill_priority_compare()
|
inlinestatic |
Used for sorting allocnos for spilling.
References ALLOCNO_BAD_SPILL_P, ALLOCNO_COLOR_DATA, ALLOCNO_NUM, ALLOCNO_REGNO, allocno_spill_priority(), ggc_alloc(), and non_spilled_static_chain_regno_p().
Referenced by allocno_spill_sort_compare().
◆ allocno_spill_sort_compare()
Used for sorting allocnos for spilling.
References allocno_spill_priority_compare(), and ggc_alloc().
Referenced by push_allocnos_to_stack().
◆ allocno_thread_conflict_p()
|
static |
Return true if any allocno from thread of A1 conflicts with any allocno from thread A2.
References a, ALLOCNO_COLOR_DATA, allocnos_conflict_by_live_ranges_p(), and ggc_alloc().
Referenced by form_threads_from_copies().
◆ allocnos_conflict_by_live_ranges_p()
|
static |
Return TRUE if live ranges of allocnos A1 and A2 intersect. It is used to find a conflict for new allocnos or allocnos with the different allocno classes.
References ALLOCNO_NUM_OBJECTS, ALLOCNO_OBJECT, ALLOCNO_REGNO, get_cap_member(), ggc_alloc(), i, ira_live_ranges_intersect_p(), NULL, OBJECT_LIVE_RANGES, ORIGINAL_REGNO, and regno_reg_rtx.
Referenced by allocno_thread_conflict_p(), coalesced_allocno_conflict_p(), and ira_reuse_stack_slot().
◆ allocnos_conflict_p()
|
static |
Return TRUE if allocnos A1 and A2 conflicts. Here we are interested only in conflicts of allocnos with intersecting allocno classes.
References ALLOCNO_NUM_OBJECTS, ALLOCNO_OBJECT, ggc_alloc(), OBJECT_CONFLICT_VEC_P, object_conflicts_with_allocno_p(), and OBJECT_NUM_CONFLICTS.
Referenced by update_conflict_hard_regno_costs().
◆ assign_hard_reg()
|
static |
Choose a hard register for allocno A. If RETRY_P is TRUE, it means that the function called from function `ira_reassign_conflict_allocnos' and `allocno_reload_assign'. In this case some allocno data are not defined or updated and we should not touch these data. The function returns true if we managed to assign a hard register to the allocno. To assign a hard register, first of all we calculate all conflict hard registers which can come from conflicting allocnos with already assigned hard registers. After that we find first free hard register with the minimal cost. During hard register cost calculation we take conflict hard register costs into account to give a chance for conflicting allocnos to get a better hard register in the future. If the best hard register cost is bigger than cost of memory usage for the allocno, we don't assign a hard register to given allocno at all. If we assign a hard register to the allocno, we update costs of the hard register for allocnos connected by copies to improve a chance to coalesce insns represented by the copies when we assign hard registers to the allocnos connected by the copies.
References a, add_cost(), allocated_hardreg_p, ALLOCNO_ASSIGNED_P, ALLOCNO_CLASS, ALLOCNO_COLOR_DATA, ALLOCNO_CONFLICT_HARD_REG_COSTS, ALLOCNO_HARD_REG_COSTS, ALLOCNO_HARD_REGNO, ALLOCNO_MODE, ALLOCNO_NUM, ALLOCNO_NUM_OBJECTS, ALLOCNO_OBJECT, ALLOCNO_REGISTER_FILTERS, ALLOCNO_REGNO, ALLOCNO_UPDATED_CLASS_COST, ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS, ALLOCNO_UPDATED_HARD_REG_COSTS, ALLOCNO_UPDATED_MEMORY_COST, bitmap_bit_p, bitmap_set_bit, calculate_saved_nregs(), check_hard_reg_p(), consideration_allocno_bitmap, COST_HOP_DIVISOR, curr_allocno_process, end_hard_regno(), FOR_EACH_OBJECT_CONFLICT, get_conflict_and_start_profitable_regs(), ggc_alloc(), hard_reg_set_intersect_p(), hard_reg_set_subset_p(), update_cost_record::hard_regno, hard_regno_nregs(), HONOR_REG_ALLOC_ORDER, i, INT_MAX, internal_flag_ira_verbose, ira_allocate_and_copy_costs(), ira_assert, ira_class_hard_reg_index, ira_class_hard_regs, ira_class_hard_regs_num, ira_dump_file, ira_free_allocno_updated_costs(), ira_hard_reg_set_intersection_p(), ira_memory_move_cost, ira_reg_classes_intersect_p, ira_reg_mode_hard_regset, ira_soft_conflict(), non_spilled_static_chain_regno_p(), NULL, OBJECT_ALLOCNO, OBJECT_SUBWORD, queue_update_cost(), r, reg_class_contents, REG_WORDS_BIG_ENDIAN, restore_costs_from_copies(), SET_HARD_REG_BIT, spill_soft_conflicts(), start_update_cost(), TEST_HARD_REG_BIT, update_conflict_hard_regno_costs(), and update_costs_from_copies().
Referenced by allocno_reload_assign(), color_allocnos(), improve_allocation(), ira_reassign_conflict_allocnos(), and pop_allocnos_from_stack().
◆ bucket_allocno_compare_func()
Compare two allocnos to define which allocno should be pushed first into the coloring stack. If the return is a negative number, the allocno given by the first parameter will be pushed first. In this case such allocno has less priority than the second one and the hard register will be assigned to it after assignment to the second one. As the result of such assignment order, the second allocno has a better chance to get the best hard register.
References ALLOCNO_CLASS, ALLOCNO_COLOR_DATA, ALLOCNO_FREQ, ALLOCNO_MODE, ALLOCNO_NUM, ggc_alloc(), and ira_reg_class_max_nregs.
Referenced by add_allocno_to_ordered_colorable_bucket(), and push_only_colorable().
◆ calculate_allocno_spill_cost()
|
static |
Calculate and return the cost of putting allocno A into memory.
References a, ALLOCNO_CAP, ALLOCNO_HARD_REGNO, ALLOCNO_LOOP_TREE_NODE, ALLOCNO_REGNO, ALLOCNO_UPDATED_CLASS_COST, ALLOCNO_UPDATED_MEMORY_COST, ggc_alloc(), and NULL.
Referenced by push_allocnos_to_stack().
◆ calculate_saved_nregs()
|
static |
Return number of registers needed to be saved and restored at function prologue/epilogue if we allocate HARD_REGNO to hold value of MODE.
References allocated_hardreg_p, crtl, update_cost_record::hard_regno, hard_regno_nregs(), i, ira_assert, and LOCAL_REGNO.
Referenced by assign_hard_reg(), and improve_allocation().
◆ calculate_spill_cost()
|
static |
Return spill cost for pseudo-registers whose numbers are in array REGNOS (with a negative number as an end marker) for reload with given IN and OUT for INSN. Return also number points (through EXCESS_PRESSURE_LIVE_LENGTH) where the pseudo-register lives and the register pressure is high, number of references of the pseudo-registers (through NREFS), the number of psuedo registers whose allocated register wouldn't need saving in the prologue (through CALL_USED_COUNT), and the first hard regno occupied by the pseudo-registers (through FIRST_HARD_REGNO).
References a, ALLOCNO_CLASS, ALLOCNO_CLASS_COST, ALLOCNO_EXCESS_PRESSURE_POINTS_NUM, ALLOCNO_MEMORY_COST, ALLOCNO_MODE, ALLOCNO_NUM_OBJECTS, BLOCK_FOR_INSN(), count, crtl, find_regno_note(), ggc_alloc(), i, in_hard_reg_set_p(), ira_assert, ira_memory_move_cost, ira_regno_allocno_map, NULL_RTX, REG_FREQ_FROM_BB, REG_N_REFS(), REG_P, reg_renumber, and REGNO.
Referenced by ira_better_spill_reload_regno_p().
◆ check_hard_reg_p()
|
inlinestatic |
Return true if HARD_REGNO is ok for assigning to allocno A with PROFITABLE_REGS and whose objects have CONFLICT_REGS.
References a, ALLOCNO_CLASS, ALLOCNO_MODE, ALLOCNO_NUM_OBJECTS, ggc_alloc(), update_cost_record::hard_regno, hard_regno_nregs(), ira_prohibited_class_mode_regs, REG_WORDS_BIG_ENDIAN, and TEST_HARD_REG_BIT.
Referenced by assign_hard_reg(), and improve_allocation().
◆ coalesce_allocnos()
The major function for aggressive allocno coalescing. We coalesce only spilled allocnos. If some allocnos have been coalesced, we set up flag allocno_coalesced_p.
References a, ALLOCNO_ASSIGNED_P, allocno_coalesce_data, allocno_coalesced_p, ALLOCNO_COPIES, ALLOCNO_HARD_REGNO, ALLOCNO_NUM, ALLOCNO_REGNO, coalesced_allocno_conflict_p(), coloring_allocno_bitmap, copy_freq_compare_func(), EXECUTE_IF_SET_IN_BITMAP, coalesce_data::first, gcc_unreachable, ggc_alloc(), i, internal_flag_ira_verbose, ira_allocnos, ira_dump_file, ira_equiv_no_lvalue_p(), merge_allocnos(), NULL, qsort, and sorted_copies.
Referenced by ira_sort_regnos_for_alter_reg().
◆ coalesce_spill_slots()
|
static |
We have coalesced allocnos involving in copies. Coalesce allocnos further in order to share the same memory stack slot. Allocnos representing sets of allocnos coalesced before the call are given in array SPILLED_COALESCED_ALLOCNOS of length NUM. Return TRUE if some allocnos were coalesced in the function.
References a, ALLOCNO_COALESCE_DATA, allocno_coalesced_p, ALLOCNO_NUM, ALLOCNO_REGNO, bitmap_bit_p, ggc_alloc(), i, internal_flag_ira_verbose, ira_allocate(), ira_allocnos_num, ira_assert, ira_dump_file, ira_equiv_no_lvalue_p(), ira_finish_live_range_list(), ira_free(), merge_allocnos(), NULL, regstat_get_setjmp_crosses(), setup_slot_coalesced_allocno_live_ranges(), slot_coalesced_allocno_live_ranges_intersect_p(), and slot_coalesced_allocnos_live_ranges.
Referenced by ira_sort_regnos_for_alter_reg().
◆ coalesced_allocno_conflict_p()
|
static |
Return TRUE if there are conflicting allocnos from two sets of coalesced allocnos given correspondingly by allocnos A1 and A2. We use live ranges to find conflicts because conflicts are represented only for allocnos of the same allocno class and during the reload pass we coalesce allocnos for sharing stack memory slots.
References a, ALLOCNO_COALESCE_DATA, allocno_coalesced_p, ALLOCNO_NUM, allocnos_conflict_by_live_ranges_p(), bitmap_clear(), bitmap_set_bit, ggc_alloc(), and processed_coalesced_allocno_bitmap.
Referenced by coalesce_allocnos().
◆ coalesced_pseudo_reg_freq_compare()
Sort pseudos according frequencies of coalesced allocno sets they belong to (putting most frequently ones first), and according to coalesced allocno set order numbers.
References ggc_alloc(), regno_coalesced_allocno_cost, and regno_coalesced_allocno_num.
Referenced by ira_sort_regnos_for_alter_reg().
◆ coalesced_pseudo_reg_slot_compare()
Sort pseudos according their slot numbers (putting ones with smaller numbers first, or last when the frame pointer is not needed).
References ALLOCNO_HARD_REGNO, FRAME_GROWS_DOWNWARD, frame_pointer_needed, GET_MODE_SIZE(), ggc_alloc(), ira_regno_allocno_map, NULL, PSEUDO_REGNO_MODE, regno_max_ref_mode, STACK_GROWS_DOWNWARD, and wider_subreg_mode().
Referenced by ira_sort_regnos_for_alter_reg().
◆ collect_allocno_hard_regs_cover()
|
static |
Add allocno hard registers nodes starting with the forest level given by FIRST which contains biggest set inside SET.
References collect_allocno_hard_regs_cover(), allocno_hard_regs_node::first, hard_reg_set_intersect_p(), hard_reg_set_subset_p(), allocno_hard_regs_node::hard_regs, hard_regs_node_vec, ira_assert, allocno_hard_regs_node::next, NULL, and allocno_hard_regs::set.
Referenced by collect_allocno_hard_regs_cover(), and form_allocno_hard_regs_nodes_forest().
◆ collect_spilled_coalesced_allocnos()
|
static |
Collect spilled allocnos representing coalesced allocno sets (the first coalesced allocno). The collected allocnos are returned through array SPILLED_COALESCED_ALLOCNOS. The function returns the number of the collected allocnos. The allocnos are given by their regnos in array PSEUDO_REGNOS of length N.
References ALLOCNO_COALESCE_DATA, ALLOCNO_HARD_REGNO, ggc_alloc(), i, ira_regno_allocno_map, and NULL.
Referenced by ira_sort_regnos_for_alter_reg().
◆ color()
Entry function doing color-based register allocation.
References allocated_hardreg_p, allocno_stack_vec, do_coloring(), ggc_alloc(), ira_allocnos_num, ira_finish_assign(), ira_initiate_assign(), and move_spill_restore().
Referenced by draw_cfg_node_succ_edges(), and ira_color().
◆ color_allocnos()
Chaitin-Briggs coloring for allocnos in COLORING_ALLOCNO_BITMAP taking into account allocnos in CONSIDERATION_ALLOCNO_BITMAP.
References a, ALLOCNO_ASSIGNED_P, ALLOCNO_CLASS, ALLOCNO_COLOR_DATA, ALLOCNO_HARD_REGNO, ALLOCNO_MODE, ALLOCNO_PREFS, allocno_priority_compare_func(), ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS, ALLOCNO_UPDATED_HARD_REG_COSTS, assign_hard_reg(), colorable_allocno_bucket, coloring_allocno_bitmap, empty_profitable_hard_regs(), EXECUTE_IF_SET_IN_BITMAP, finish_allocno_hard_regs_nodes_forest(), form_allocno_hard_regs_nodes_forest(), ggc_alloc(), i, improve_allocation(), internal_flag_ira_verbose, IRA_ALGORITHM_PRIORITY, ira_allocnos, ira_assert, ira_dump_file, ira_free_allocno_updated_costs(), ira_hard_reg_in_set_p(), ira_print_expanded_allocno(), ira_remove_pref(), ira_allocno_pref::next_pref, NULL, pop_allocnos_from_stack(), pref, print_hard_regs_forest(), push_allocnos_to_stack(), put_allocno_into_bucket(), qsort, setup_allocno_priorities(), setup_profitable_hard_regs(), sorted_allocnos, uncolorable_allocno_bucket, and update_conflict_allocno_hard_prefs().
Referenced by color_pass().
◆ color_pass()
|
static |
Color the allocnos inside loop (in the extreme case it can be all of the function) given the corresponding LOOP_TREE_NODE. The function is called for each loop during top-down traverse of the loop tree.
References a, ira_loop_tree_node::all_allocnos, ALLOCNO_ADD_DATA, ALLOCNO_ASSIGNED_P, ALLOCNO_CAP, ALLOCNO_CAP_MEMBER, ALLOCNO_CLASS, ALLOCNO_CONFLICT_HARD_REG_COSTS, ALLOCNO_HARD_REG_COSTS, ALLOCNO_HARD_REGNO, ALLOCNO_LOOP_TREE_NODE, ALLOCNO_MIGHT_CONFLICT_WITH_PARENT_P, ALLOCNO_MODE, ALLOCNO_NUM, ALLOCNO_REGNO, ALLOCNO_UPDATED_CLASS_COST, ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS, ALLOCNO_UPDATED_HARD_REG_COSTS, ALLOCNO_UPDATED_MEMORY_COST, ira_loop_tree_node::bb, bitmap_bit_p, bitmap_clear_bit(), bitmap_copy(), color_allocnos(), coloring_allocno_bitmap, consideration_allocno_bitmap, curr_allocno_process, EXECUTE_IF_SET_IN_BITMAP, gcc_assert, ggc_alloc(), update_cost_record::hard_regno, init_allocno_threads(), internal_flag_ira_verbose, ira_allocate(), ira_allocate_and_set_or_copy_costs(), ira_allocnos, ira_assert, ira_class_hard_reg_index, ira_dump_file, ira_free(), ira_free_allocno_updated_costs(), ira_init_register_move_cost_if_necessary(), IRA_REGION_ALL, IRA_REGION_MIXED, ira_single_region_allocno_p(), ira_subloop_allocnos_can_differ_p(), NULL, print_loop_title(), ira_loop_tree_node::subloops, and update_costs_from_copies().
Referenced by do_coloring().
◆ copy_freq_compare_func()
The function is used to sort copies according to their execution frequencies.
References ggc_alloc().
Referenced by coalesce_allocnos(), and form_threads_from_copies().
◆ create_new_allocno_hard_regs_node()
|
static |
Create and return allocno hard registers node containing allocno hard registers HV.
References allocno_hard_regs_node::check, allocno_hard_regs_node::first, ggc_alloc(), hard_reg_set_size(), allocno_hard_regs_node::hard_regs, allocno_hard_regs_node::hard_regs_num, ira_allocate(), NULL, and allocno_hard_regs_node::used_p.
Referenced by add_allocno_hard_regs_to_forest(), and form_allocno_hard_regs_nodes_forest().
◆ debug_hard_reg_set()
| DEBUG_FUNCTION void debug_hard_reg_set | ( | HARD_REG_SET | set | ) |
Dump a hard reg set SET to stderr.
References ggc_alloc(), and print_hard_reg_set().
◆ delete_allocno_from_bucket()
|
static |
Delete ALLOCNO from bucket *BUCKET_PTR. It should be there before the call.
References ALLOCNO_CLASS, ALLOCNO_COLOR_DATA, ggc_alloc(), ira_assert, NULL, uncolorable_allocno_bucket, and uncolorable_allocnos_num.
Referenced by push_allocno_to_stack(), and remove_allocno_from_bucket_and_push().
◆ do_coloring()
Initialize the common data for coloring and calls functions to do Chaitin-Briggs and regional coloring.
References color_pass(), coloring_allocno_bitmap, ggc_alloc(), internal_flag_ira_verbose, ira_allocate_bitmap(), ira_dump_file, ira_free_bitmap(), ira_loop_tree_root, ira_print_disposition(), ira_traverse_loop_tree(), and NULL.
Referenced by color().
◆ empty_profitable_hard_regs()
|
static |
Return true if allocno A has empty profitable hard regs.
References a, ALLOCNO_COLOR_DATA, and hard_reg_set_empty_p().
Referenced by color_allocnos(), improve_allocation(), and setup_profitable_hard_regs().
◆ enumerate_allocno_hard_regs_nodes()
|
static |
Set up fields preorder_num starting with START_NUM in all allocno hard registers nodes in forest given by FIRST. Return biggest set PREORDER_NUM increased by 1.
References enumerate_allocno_hard_regs_nodes(), allocno_hard_regs_node::first, ggc_alloc(), allocno_hard_regs_node::next, NULL, allocno_hard_regs_node::parent, and allocno_hard_regs_node::preorder_num.
Referenced by enumerate_allocno_hard_regs_nodes(), and form_allocno_hard_regs_nodes_forest().
◆ fast_allocation()
This page contains a simple register allocator without usage of allocno conflicts. This is used for fast allocation for -O0.
Do register allocation by not using allocno conflicts. It uses only allocno live ranges. The algorithm is close to Chow's priority coloring.
References a, ALLOCNO_ASSIGNED_P, ALLOCNO_CLASS, ALLOCNO_HARD_REG_COSTS, ALLOCNO_HARD_REGNO, ALLOCNO_MODE, ALLOCNO_NUM_OBJECTS, ALLOCNO_OBJECT, allocno_priorities, allocno_priority_compare_func(), ALLOCNO_REGISTER_FILTERS, CLEAR_HARD_REG_SET, costs, FOR_EACH_ALLOCNO, ggc_alloc(), hard_reg_set_subset_p(), i, INT_MAX, internal_flag_ira_verbose, ira_allocate(), ira_allocnos_num, ira_class_hard_regs, ira_class_hard_regs_num, ira_dump_file, ira_free(), ira_hard_reg_set_intersection_p(), ira_max_point, ira_print_disposition(), ira_prohibited_class_mode_regs, ira_reg_mode_hard_regset, nr, NULL, OBJECT_CONFLICT_HARD_REGS, OBJECT_LIVE_RANGES, qsort, r, reg_class_contents, setup_allocno_priorities(), sorted_allocnos, and TEST_HARD_REG_BIT.
Referenced by ira_color().
◆ find_hard_regs()
|
static |
Return allocno hard registers in the hash table equal to HV.
References allocno_hard_regs_htab, and ggc_alloc().
Referenced by add_allocno_hard_regs().
◆ finish_allocno_hard_regs()
Finalize data concerning allocno hard registers.
References allocno_hard_regs_htab, allocno_hard_regs_vec, ggc_alloc(), i, ira_free(), and NULL.
Referenced by finish_allocno_hard_regs_nodes_forest().
◆ finish_allocno_hard_regs_nodes_forest()
Finish work with the forest of allocno hard registers nodes.
References allocno_hard_regs_nodes, allocno_hard_regs_subnode_index, allocno_hard_regs_subnodes, finish_allocno_hard_regs(), finish_allocno_hard_regs_nodes_tree(), hard_regs_roots, ira_free(), allocno_hard_regs_node::next, and NULL.
Referenced by color_allocnos().
◆ finish_allocno_hard_regs_nodes_tree()
|
static |
Free tree of allocno hard registers nodes given by its ROOT.
References finish_allocno_hard_regs_nodes_tree(), allocno_hard_regs_node::first, ira_free(), allocno_hard_regs_node::next, and NULL.
Referenced by finish_allocno_hard_regs_nodes_forest(), and finish_allocno_hard_regs_nodes_tree().
◆ finish_cost_update()
Deallocate data used by function update_costs_from_copies.
References finish_update_cost_records(), ira_free(), and update_cost_queue_elems.
Referenced by ira_finish_assign().
◆ finish_update_cost_records()
Free memory allocated for all update cost records.
References update_cost_record_pool.
Referenced by finish_cost_update().
◆ first_common_ancestor_node()
|
static |
Return allocno hard registers node which is a first common ancestor node of FIRST and SECOND in the forest.
References allocno_hard_regs_node::check, allocno_hard_regs_node::first, first_common_ancestor_node(), node_check_tick, NULL, and allocno_hard_regs_node::parent.
Referenced by first_common_ancestor_node(), and form_allocno_hard_regs_nodes_forest().
◆ form_allocno_hard_regs_nodes_forest()
Build the forest of allocno hard registers nodes and assign each allocno a node from the forest.
References a, add_allocno_hard_regs(), add_allocno_hard_regs_to_forest(), add_new_allocno_hard_regs_node_to_forest(), ALLOCNO_CLASS_COST, ALLOCNO_COLOR_DATA, allocno_hard_regs_compare(), allocno_hard_regs_nodes, allocno_hard_regs_nodes_num, allocno_hard_regs_subnode_index, allocno_hard_regs_subnodes, allocno_hard_regs_vec, ALLOCNO_MEMORY_COST, CLEAR_HARD_REG_SET, collect_allocno_hard_regs_cover(), coloring_allocno_bitmap, create_new_allocno_hard_regs_node(), enumerate_allocno_hard_regs_nodes(), EXECUTE_IF_SET_IN_BITMAP, first_common_ancestor_node(), get_allocno_hard_regs_subnodes_num(), ggc_alloc(), hard_reg_set_empty_p(), hard_regs_node_vec, hard_regs_roots, i, init_allocno_hard_regs(), ira_allocate(), ira_allocnos, ira_assert, ira_no_alloc_regs, allocno_hard_regs_node::next, node_check_tick, NULL, qsort, remove_unused_allocno_hard_regs_nodes(), SET_HARD_REG_BIT, setup_allocno_hard_regs_nodes_parent(), setup_allocno_hard_regs_subnode_index(), TEST_HARD_REG_BIT, and allocno_hard_regs_node::used_p.
Referenced by color_allocnos().
◆ form_threads_from_bucket()
|
static |
Create threads by processing copies of all alocnos from BUCKET. We process the most expensive copies first.
References a, ALLOCNO_COLOR_DATA, ALLOCNO_COPIES, form_threads_from_copies(), gcc_unreachable, ggc_alloc(), NULL, and sorted_copies.
Referenced by push_only_colorable().
◆ form_threads_from_colorable_allocno()
|
static |
Create threads by processing copies of colorable allocno A. We process most expensive copies first.
References a, ALLOCNO_COLOR_DATA, ALLOCNO_COPIES, ALLOCNO_NUM, ALLOCNO_REGNO, form_threads_from_copies(), gcc_unreachable, ggc_alloc(), internal_flag_ira_verbose, ira_dump_file, NULL, and sorted_copies.
Referenced by add_allocno_to_ordered_colorable_bucket().
◆ form_threads_from_copies()
Create threads by processing CP_NUM copies from sorted copies. We process the most expensive copies first.
References a, ALLOCNO_COLOR_DATA, ALLOCNO_FREQ, ALLOCNO_NUM, ALLOCNO_REGNO, allocno_thread_conflict_p(), copy_freq_compare_func(), ggc_alloc(), i, internal_flag_ira_verbose, ira_dump_file, merge_threads(), NULL, qsort, and sorted_copies.
Referenced by form_threads_from_bucket(), and form_threads_from_colorable_allocno().
◆ free_update_cost_record_list()
|
static |
Free memory for all records in LIST.
References update_cost_record::next, NULL, and update_cost_record_pool.
Referenced by restore_costs_from_copies().
◆ get_allocno_hard_regs_subnodes_num()
|
static |
Count all allocno hard registers nodes in tree ROOT.
References allocno_hard_regs_node::first, get_allocno_hard_regs_subnodes_num(), allocno_hard_regs_node::next, and NULL.
Referenced by form_allocno_hard_regs_nodes_forest(), and get_allocno_hard_regs_subnodes_num().
◆ get_cap_member()
|
static |
If allocno A is a cap, return non-cap allocno from which A is created. Otherwise, return A.
References a, ALLOCNO_CAP_MEMBER, ggc_alloc(), and NULL.
Referenced by allocnos_conflict_by_live_ranges_p().
◆ get_conflict_and_start_profitable_regs()
|
inlinestatic |
Set up conflicting (through CONFLICT_REGS) for each object of allocno A and the start allocno profitable regs (through START_PROFITABLE_REGS). Remember that the start profitable regs exclude hard regs which cannot hold value of mode of allocno A. This covers mostly cases when multi-register value should be aligned.
References a, ALLOCNO_CLASS, ALLOCNO_COLOR_DATA, ALLOCNO_MODE, ALLOCNO_NUM_OBJECTS, ALLOCNO_OBJECT, ggc_alloc(), i, ira_prohibited_class_mode_regs, OBJECT_TOTAL_CONFLICT_HARD_REGS, and reg_class_contents.
Referenced by assign_hard_reg(), and improve_allocation().
◆ get_next_update_cost()
|
inlinestatic |
Try to remove the first element from update_cost_queue. Return false if the queue was empty, otherwise make (*ALLOCNO, *START, *FROM, *DIVISOR) describe the removed element.
References ALLOCNO_NUM, update_cost_queue_elem::divisor, update_cost_queue_elem::from, update_cost_queue_elem::next, NULL, update_cost_queue_elem::start, update_cost_queue, and update_cost_queue_elems.
Referenced by update_conflict_hard_regno_costs(), and update_costs_from_allocno().
◆ get_update_cost_record()
|
static |
Return new update cost record with given params.
References update_cost_record::divisor, ggc_alloc(), update_cost_record::hard_regno, update_cost_record::next, and update_cost_record_pool.
Referenced by update_costs_from_allocno().
◆ improve_allocation()
We used Chaitin-Briggs coloring to assign as many pseudos as possible to hard registers. Let us try to improve allocation with cost point of view. This function improves the allocation by spilling some allocnos and assigning the freed hard registers to other allocnos if it decreases the overall allocation cost.
References a, add_cost(), allocated_hardreg_p, ALLOCNO_ASSIGNED_P, ALLOCNO_CLASS, ALLOCNO_COLOR_DATA, allocno_copy_cost_saving(), allocno_cost_compare_func(), ALLOCNO_HARD_REG_COSTS, ALLOCNO_HARD_REGNO, ALLOCNO_MODE, ALLOCNO_NUM, ALLOCNO_NUM_OBJECTS, ALLOCNO_OBJECT, ALLOCNO_REGISTER_FILTERS, ALLOCNO_REGNO, ALLOCNO_UPDATED_CLASS_COST, ALLOCNO_UPDATED_MEMORY_COST, assign_hard_reg(), bitmap_set_bit, calculate_saved_nregs(), cfun, check_hard_reg_p(), coloring_allocno_bitmap, crtl, empty_profitable_hard_regs(), end_hard_regno(), ENTRY_BLOCK_PTR_FOR_FN, EXECUTE_IF_SET_IN_BITMAP, FOR_EACH_OBJECT_CONFLICT, get_conflict_and_start_profitable_regs(), ggc_alloc(), hard_regno_nregs(), i, INT_MAX, internal_flag_ira_verbose, ira_allocnos, ira_assert, ira_class_hard_reg_index, ira_class_hard_regs, ira_class_hard_regs_num, ira_dump_file, ira_memory_move_cost, ira_print_expanded_allocno(), ira_soft_conflict(), NULL, OBJECT_ALLOCNO, qsort, r, REG_FREQ_FROM_BB, SET_HARD_REG_BIT, sorted_allocnos, spill_cost, and spill_soft_conflicts().
Referenced by color_allocnos().
◆ init_allocno_hard_regs()
Initialize data concerning allocno hard registers.
References allocno_hard_regs_htab, allocno_hard_regs_vec, and ggc_alloc().
Referenced by form_allocno_hard_regs_nodes_forest().
◆ init_allocno_threads()
Form initial threads which contain only one allocno.
References a, ALLOCNO_COLOR_DATA, ALLOCNO_FREQ, ALLOCNO_PREFS, consideration_allocno_bitmap, EXECUTE_IF_SET_IN_BITMAP, ggc_alloc(), ira_allocnos, NULL, and pref.
Referenced by color_pass().
◆ initiate_cost_update()
Allocate and initialize data necessary for function update_costs_from_copies.
References ggc_alloc(), ira_allocate(), ira_allocnos_num, update_cost_check, and update_cost_queue_elems.
Referenced by ira_initiate_assign().
◆ insert_hard_regs()
|
static |
Insert allocno hard registers HV in the hash table (if it is not there yet) and return the value which in the table.
References allocno_hard_regs_htab, ggc_alloc(), and NULL.
Referenced by add_allocno_hard_regs().
◆ ira_better_spill_reload_regno_p()
| bool ira_better_spill_reload_regno_p | ( | int * | regnos, |
| int * | other_regnos, | ||
| rtx | in, | ||
| rtx | out, | ||
| rtx_insn * | insn ) |
Return TRUE if spilling pseudo-registers whose numbers are in array REGNOS is better than spilling pseudo-registers with numbers in OTHER_REGNOS for reload with given IN and OUT for INSN. The function used by the reload pass to make better register spilling decisions.
References calculate_spill_cost(), ggc_alloc(), and inv_reg_alloc_order.
Referenced by find_reg().
◆ ira_color()
Entry function doing coloring.
References a, ALLOCNO_CLASS_COST, ALLOCNO_MEMORY_COST, ALLOCNO_UPDATED_CLASS_COST, ALLOCNO_UPDATED_MEMORY_COST, color(), fast_allocation(), FOR_EACH_ALLOCNO, ggc_alloc(), and ira_conflicts_p.
Referenced by ira().
◆ ira_debug_hard_regs_forest()
Print the allocno hard register forest to stderr.
References ggc_alloc(), and print_hard_regs_forest().
◆ ira_finish_assign()
Deallocate data used by assign_hard_reg.
References allocno_priorities, consideration_allocno_bitmap, finish_cost_update(), ira_free(), ira_free_bitmap(), sorted_allocnos, and sorted_copies.
Referenced by color(), and do_reload().
◆ ira_initiate_assign()
Allocate and initialize data necessary for assign_hard_reg.
References allocno_priorities, consideration_allocno_bitmap, initiate_cost_update(), ira_allocate(), ira_allocate_bitmap(), ira_allocnos_num, ira_copies_num, sorted_allocnos, and sorted_copies.
◆ ira_loop_edge_freq()
| int ira_loop_edge_freq | ( | ira_loop_tree_node_t | loop_node, |
| int | regno, | ||
| bool | exit_p ) |
Return the frequency of exit edges (if EXIT_P) or entry from/to the loop given by its LOOP_NODE.
References bitmap_bit_p, current_loops, df_get_live_in(), df_get_live_out(), EDGE_FREQUENCY, FOR_EACH_EDGE, FOR_EACH_VEC_ELT, get_loop_exit_edges(), ggc_alloc(), i, ira_assert, NULL, and REG_FREQ_FROM_EDGE_FREQ.
◆ ira_mark_allocation_change()
| void ira_mark_allocation_change | ( | int | regno | ) |
This page contains code used by the reload pass to improve the final code.
The function is called from reload to mark changes in the allocation of REGNO made by the reload. Remember that reg_renumber reflects the change result.
References a, ALLOCNO_CLASS, ALLOCNO_CLASS_COST, ALLOCNO_HARD_REG_COSTS, ALLOCNO_HARD_REGNO, ALLOCNO_MEMORY_COST, ggc_alloc(), ira_assert, ira_class_hard_reg_index, ira_overall_cost, ira_regno_allocno_map, NULL, reg_renumber, and update_costs_from_copies().
Referenced by delete_output_reload(), emit_input_reload_insns(), finish_spills(), and ira_reassign_pseudos().
◆ ira_mark_memory_move_deletion()
| void ira_mark_memory_move_deletion | ( | int | dst_regno, |
| int | src_regno ) |
This function is called when reload deletes memory-memory move. In this case we marks that the allocation of the corresponding allocnos should be not changed in future. Otherwise we risk to get a wrong code.
References ALLOCNO_DONT_REASSIGN_P, ALLOCNO_HARD_REGNO, ggc_alloc(), ira_assert, ira_regno_allocno_map, and NULL.
Referenced by calculate_needs_all_insns().
◆ ira_mark_new_stack_slot()
| void ira_mark_new_stack_slot | ( | rtx | x, |
| int | regno, | ||
| poly_uint64 | total_size ) |
This is called by reload every time a new stack slot X with TOTAL_SIZE was allocated for REGNO. We store this info for subsequent ira_reuse_stack_slot calls.
References ALLOCNO_HARD_REGNO, ggc_alloc(), INIT_REG_SET, internal_flag_ira_verbose, ira_assert, ira_dump_file, ira_regno_allocno_map, ira_spilled_reg_stack_slots, ira_spilled_reg_stack_slots_num, ira_use_lra_p, known_le, slot::mem, PSEUDO_REGNO_BYTES, REG_FREQ, and SET_REGNO_REG_SET.
Referenced by alter_reg().
◆ ira_reassign_conflict_allocnos()
| void ira_reassign_conflict_allocnos | ( | int | start_regno | ) |
Try to assign hard registers to the unassigned allocnos and allocnos conflicting with them or conflicting with allocnos whose regno >= START_REGNO. The function is called after ira_flattening, so more allocnos (including ones created in ira-emit.cc) will have a chance to get a hard register. We use simple assignment algorithm based on priorities.
References a, ALLOCNO_ASSIGNED_P, ALLOCNO_CLASS, ALLOCNO_HARD_REGNO, ALLOCNO_NUM, ALLOCNO_NUM_OBJECTS, ALLOCNO_OBJECT, allocno_priority_compare_func(), ALLOCNO_REGNO, ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS, ALLOCNO_UPDATED_HARD_REG_COSTS, assign_hard_reg(), bitmap_bit_p, bitmap_set_bit, FOR_EACH_ALLOCNO, FOR_EACH_OBJECT_CONFLICT, ggc_alloc(), i, internal_flag_ira_verbose, ira_allocate_bitmap(), ira_assert, ira_dump_file, ira_free_bitmap(), ira_reg_classes_intersect_p, NULL, OBJECT_ALLOCNO, qsort, setup_allocno_priorities(), sorted_allocnos, and update_curr_costs().
Referenced by ira().
◆ ira_reassign_pseudos()
| bool ira_reassign_pseudos | ( | int * | spilled_pseudo_regs, |
| int | num, | ||
| HARD_REG_SET | bad_spill_regs, | ||
| HARD_REG_SET * | pseudo_forbidden_regs, | ||
| HARD_REG_SET * | pseudo_previous_regs, | ||
| bitmap | spilled ) |
Try to allocate hard registers to SPILLED_PSEUDO_REGS (there are NUM of them) or spilled pseudos conflicting with pseudos in SPILLED_PSEUDO_REGS. Return TRUE and update SPILLED, if the allocation has been changed. The function doesn't use BAD_SPILL_REGS and hard registers in PSEUDO_FORBIDDEN_REGS and PSEUDO_PREVIOUS_REGS for the corresponding pseudos. The function is called by the reload pass at the end of each reload iteration.
References a, ALLOCNO_CLASS_COST, ALLOCNO_DONT_REASSIGN_P, ALLOCNO_HARD_REGNO, ALLOCNO_MEMORY_COST, ALLOCNO_NUM, ALLOCNO_NUM_OBJECTS, ALLOCNO_OBJECT, ALLOCNO_REGNO, allocno_reload_assign(), bad_spill_regs, BITMAP_ALLOC, BITMAP_FREE, bitmap_set_bit, CLEAR_REGNO_REG_SET, consideration_allocno_bitmap, FOR_EACH_OBJECT_CONFLICT, gcc_assert, ggc_alloc(), i, internal_flag_ira_verbose, ira_assert, ira_dump_file, ira_mark_allocation_change(), ira_regno_allocno_map, nr, NULL, OBJECT_ALLOCNO, pseudo_forbidden_regs, pseudo_previous_regs, pseudo_reg_compare(), qsort, and reg_renumber.
Referenced by finish_spills().
◆ ira_reuse_stack_slot()
| rtx ira_reuse_stack_slot | ( | int | regno, |
| poly_uint64 | inherent_size, | ||
| poly_uint64 | total_size ) |
The function is called by reload and returns already allocated stack slot (if any) for REGNO with given INHERENT_SIZE and TOTAL_SIZE. In the case of failure to find a slot which can be used for REGNO, the function returns NULL.
References ALLOCNO_COPIES, ALLOCNO_HARD_REGNO, ALLOCNO_REGNO, allocnos_conflict_by_live_ranges_p(), bitmap_bit_p, EXECUTE_IF_SET_IN_BITMAP, gcc_unreachable, GET_MODE, GET_MODE_SIZE(), ggc_alloc(), i, internal_flag_ira_verbose, ira_assert, ira_dump_file, ira_regno_allocno_map, ira_spilled_reg_stack_slots, ira_spilled_reg_stack_slots_num, ira_use_lra_p, known_eq, known_ge, known_le, slot::mem, NULL, NULL_RTX, PSEUDO_REGNO_BYTES, REG_FREQ, and SET_REGNO_REG_SET.
Referenced by alter_reg().
◆ ira_soft_conflict()
| ira_allocno_t ira_soft_conflict | ( | ira_allocno_t | a1, |
| ira_allocno_t | a2 ) |
Allocnos A1 and A2 are known to conflict. Check whether, in some loop L that is either the current loop or a nested subloop, the conflict is of the following form: - One allocno (X) is a cap allocno for some non-cap allocno X2. - X2 belongs to some loop L2. - The other allocno (Y) is a non-cap allocno. - Y is an ancestor of some allocno Y2 in L2. (Note that such a Y2 must exist, given that X and Y conflict.) - Y2 is not referenced in L2 (that is, ALLOCNO_NREFS (Y2) == 0). - Y can use a different allocation from Y2. In this case, Y's register is live across L2 but is not used within it, whereas X's register is used only within L2. The conflict is therefore only "soft", in that it can easily be avoided by spilling Y2 inside L2 without affecting any insn references. If the conflict does have this form, return the Y2 that would need to be spilled in order to allow X and Y (and thus A1 and A2) to use the same register. Return null otherwise. Returning null is conservatively correct; any nonnnull return value is an optimization.
References ALLOCNO_CAP_MEMBER, ALLOCNO_LOOP_TREE_NODE, ALLOCNO_NREFS, ALLOCNO_REGNO, ggc_alloc(), ira_assert, ira_parent_allocno(), ira_subloop_allocnos_can_differ_p(), and max_soft_conflict_loop_depth.
Referenced by assign_hard_reg(), improve_allocation(), and spill_soft_conflicts().
◆ ira_sort_regnos_for_alter_reg()
| void ira_sort_regnos_for_alter_reg | ( | int * | pseudo_regnos, |
| int | n, | ||
| machine_mode * | reg_max_ref_mode ) |
Sort pseudo-register numbers in array PSEUDO_REGNOS of length N for subsequent assigning stack slots to them in the reload pass. To do this we coalesce spilled allocnos first to decrease the number of memory-memory move insns. This function is called by the reload.
References a, ALLOCNO_ADD_DATA, allocno_coalesce_data, ALLOCNO_COALESCE_DATA, allocno_coalesced_p, ALLOCNO_FREQ, ALLOCNO_HARD_REGNO, ALLOCNO_NUM, ALLOCNO_REGNO, bitmap_set_bit, coalesce_allocnos(), coalesce_spill_slots(), coalesced_pseudo_reg_freq_compare(), coalesced_pseudo_reg_slot_compare(), collect_spilled_coalesced_allocnos(), coloring_allocno_bitmap, FOR_EACH_ALLOCNO, GET_MODE_SIZE(), ggc_alloc(), i, internal_flag_ira_verbose, ira_allocate(), ira_allocate_bitmap(), ira_allocnos_num, ira_assert, ira_dump_file, ira_equiv_no_lvalue_p(), ira_free(), ira_free_bitmap(), ira_regno_allocno_map, ira_spilled_reg_stack_slots_num, ira_use_lra_p, max_reg_num(), max_regno, NULL, print_dec(), processed_coalesced_allocno_bitmap, PSEUDO_REGNO_MODE, qsort, reg_max_ref_mode, regno_coalesced_allocno_cost, regno_coalesced_allocno_num, regno_max_ref_mode, setup_coalesced_allocno_costs_and_nums(), SIGNED, and wider_subreg_mode().
Referenced by reload().
◆ merge_allocnos()
|
static |
Merge two sets of coalesced allocnos given correspondingly by allocnos A1 and A2 (more accurately merging A2 set into A1 set).
References a, allocno_coalesce_data, ALLOCNO_COALESCE_DATA, ALLOCNO_NUM, ggc_alloc(), last, and coalesce_data::next.
Referenced by coalesce_allocnos(), and coalesce_spill_slots().
◆ merge_threads()
|
static |
Merge two threads given correspondingly by their first allocnos T1 and T2 (more accurately merging T2 into T1).
References a, ALLOCNO_COLOR_DATA, gcc_assert, last, and update_cost_record::next.
Referenced by form_threads_from_copies().
◆ move_spill_restore()
Move spill/restore code, which are to be generated in ira-emit.cc, to less frequent points (if it is profitable) by reassigning some allocnos (in loop with subloops containing in another loop) to memory which results in longer live-range where the corresponding pseudo-registers will be in memory.
References a, ALLOCNO_CAP, ALLOCNO_CAP_MEMBER, ALLOCNO_CLASS, ALLOCNO_CLASS_COST, ALLOCNO_HARD_REG_COSTS, ALLOCNO_HARD_REGNO, ALLOCNO_LOOP_TREE_NODE, ALLOCNO_MEMORY_COST, ALLOCNO_MODE, ALLOCNO_NUM, ALLOCNO_REGNO, bitmap_bit_p, conflicts, FOR_EACH_ALLOCNO, ggc_alloc(), update_cost_record::hard_regno, internal_flag_ira_verbose, ira_assert, ira_caller_save_loop_spill_p(), ira_class_hard_reg_index, ira_dump_file, ira_equiv_no_lvalue_p(), ira_init_register_move_cost_if_necessary(), ira_need_caller_save_p(), ira_subloop_allocnos_can_differ_p(), ira_total_conflict_hard_regs(), MIN, non_spilled_static_chain_regno_p(), NULL, ira_loop_tree_node::regno_allocno_map, spill_cost, and TEST_HARD_REG_BIT.
Referenced by color().
◆ object_conflicts_with_allocno_p()
|
static |
Return TRUE if the object OBJ conflicts with the allocno A.
References a, ALLOCNO_NUM_OBJECTS, ALLOCNO_OBJECT, FOR_EACH_OBJECT_CONFLICT, ggc_alloc(), OBJECT_ALLOCNO, OBJECT_CONFLICT_BITVEC, OBJECT_CONFLICT_ID, OBJECT_CONFLICT_VEC_P, OBJECT_MAX, OBJECT_MIN, and TEST_MINMAX_SET_BIT.
Referenced by allocnos_conflict_p().
◆ pop_allocnos_from_stack()
Pop the coloring stack and assign hard registers to the popped allocnos.
References ALLOCNO_ASSIGNED_P, ALLOCNO_CLASS, ALLOCNO_COLOR_DATA, ALLOCNO_HARD_REGNO, allocno_stack_vec, ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS, ALLOCNO_UPDATED_HARD_REG_COSTS, assign_hard_reg(), ggc_alloc(), internal_flag_ira_verbose, ira_assert, ira_dump_file, ira_print_expanded_allocno(), and NULL.
Referenced by color_allocnos().
◆ print_hard_reg_set()
|
static |
Print hard reg set SET to F.
References end(), ggc_alloc(), i, and TEST_HARD_REG_BIT.
Referenced by debug_hard_reg_set(), print_hard_regs_subforest(), and setup_allocno_available_regs_num().
◆ print_hard_regs_forest()
Print the allocno hard register forest to F.
References ggc_alloc(), hard_regs_roots, and print_hard_regs_subforest().
Referenced by color_allocnos(), and ira_debug_hard_regs_forest().
◆ print_hard_regs_subforest()
|
static |
Print allocno hard register subforest given by ROOTS and its LEVEL to F.
References allocno_hard_regs::cost, allocno_hard_regs_node::first, ggc_alloc(), allocno_hard_regs_node::hard_regs, i, allocno_hard_regs_node::next, NULL, allocno_hard_regs_node::preorder_num, PRId64, print_hard_reg_set(), print_hard_regs_subforest(), and allocno_hard_regs::set.
Referenced by print_hard_regs_forest(), and print_hard_regs_subforest().
◆ print_loop_title()
|
static |
Output information about the loop given by its LOOP_TREE_NODE.
References ira_loop_tree_node::all_allocnos, ALLOCNO_REGNO, ira_loop_tree_node::border_allocnos, cfun, ira_loop_tree_node::children, current_loops, EXECUTE_IF_SET_IN_BITMAP, EXIT_BLOCK_PTR_FOR_FN, FOR_EACH_EDGE, ggc_alloc(), loop::header, basic_block_def::index, ira_allocnos, ira_assert, IRA_BB_NODE, ira_dump_file, ira_pressure_classes, ira_pressure_classes_num, ira_loop_tree_node::loop, loop_depth(), ira_loop_tree_node::loop_num, ira_loop_tree_node::modified_regnos, NULL, NUM_FIXED_BLOCKS, ira_loop_tree_node::parent, reg_class_names, and ira_loop_tree_node::reg_pressure.
Referenced by color_pass().
◆ pseudo_reg_compare()
Sort pseudos according their usage frequencies (putting most frequently ones first).
References ggc_alloc(), and REG_FREQ.
Referenced by ira_reassign_pseudos().
◆ push_allocno_to_stack()
|
static |
Put allocno A onto the coloring stack without removing it from its bucket. Pushing allocno to the coloring stack can result in moving conflicting allocnos from the uncolorable bucket to the colorable one. Update conflict_allocno_hard_prefs of the conflicting allocnos which are not on stack yet.
References a, add_allocno_to_ordered_colorable_bucket(), ALLOCNO_ASSIGNED_P, ALLOCNO_CLASS, ALLOCNO_COLOR_DATA, ALLOCNO_MODE, ALLOCNO_NUM, ALLOCNO_NUM_OBJECTS, ALLOCNO_OBJECT, ALLOCNO_PREFS, allocno_stack_vec, bitmap_bit_p, coloring_allocno_bitmap, delete_allocno_from_bucket(), FOR_EACH_OBJECT_CONFLICT, gcc_assert, ggc_alloc(), hard_reg_set_intersect_p(), i, internal_flag_ira_verbose, ira_assert, ira_dump_file, ira_print_expanded_allocno(), ira_reg_class_max_nregs, NULL, OBJECT_ALLOCNO, pref, uncolorable_allocno_bucket, and update_left_conflict_sizes_p().
Referenced by remove_allocno_from_bucket_and_push().
◆ push_allocnos_to_stack()
Push allocnos to the coloring stack. The order of allocnos in the stack defines the order for the subsequent coloring.
References a, ALLOCNO_CLASS, ALLOCNO_COLOR_DATA, allocno_spill_sort_compare(), calculate_allocno_spill_cost(), colorable_allocno_bucket, ggc_alloc(), ira_assert, NULL, push_only_colorable(), remove_allocno_from_bucket_and_push(), sort_bucket(), uncolorable_allocno_bucket, and uncolorable_allocnos_num.
Referenced by color_allocnos().
◆ push_only_colorable()
Put all allocnos from colorable bucket onto the coloring stack.
References a, ALLOCNO_COLOR_DATA, bucket_allocno_compare_func(), colorable_allocno_bucket, form_threads_from_bucket(), ggc_alloc(), internal_flag_ira_verbose, ira_dump_file, NULL, remove_allocno_from_bucket_and_push(), sort_bucket(), and update_costs_from_prefs().
Referenced by push_allocnos_to_stack().
◆ put_allocno_into_bucket()
|
static |
Put ALLOCNO in a bucket corresponding to its number and size of its conflicting allocnos and hard registers.
References add_allocno_to_bucket(), ALLOCNO_COLOR_DATA, colorable_allocno_bucket, setup_allocno_available_regs_num(), setup_left_conflict_sizes_p(), and uncolorable_allocno_bucket.
Referenced by color_allocnos().
◆ queue_update_cost()
|
inlinestatic |
Add (ALLOCNO, START, FROM, DIVISOR) to the end of update_cost_queue, unless ALLOCNO is already in the queue, or has NO_REGS class.
References ALLOCNO_CLASS, ALLOCNO_NUM, update_cost_queue_elem::check, update_cost_queue_elem::divisor, update_cost_queue_elem::from, ggc_alloc(), update_cost_queue_elem::next, NULL, update_cost_queue_elem::start, update_cost_check, update_cost_queue, update_cost_queue_elems, and update_cost_queue_tail.
Referenced by assign_hard_reg(), update_conflict_hard_regno_costs(), and update_costs_from_allocno().
◆ remove_allocno_from_bucket_and_push()
|
static |
Put ALLOCNO onto the coloring stack and remove it from its bucket. The allocno is in the colorable bucket if COLORABLE_P is TRUE.
References ALLOCNO_BAD_SPILL_P, ALLOCNO_COLOR_DATA, allocno_spill_priority(), colorable_allocno_bucket, delete_allocno_from_bucket(), ggc_alloc(), internal_flag_ira_verbose, ira_dump_file, ira_print_expanded_allocno(), NULL, push_allocno_to_stack(), and uncolorable_allocno_bucket.
Referenced by push_allocnos_to_stack(), and push_only_colorable().
◆ remove_unused_allocno_hard_regs_nodes()
|
static |
Remove unused allocno hard registers nodes from forest given by its *ROOTS.
References allocno_hard_regs_node::first, ira_free(), last, filedep::next, allocno_hard_regs_node::next, NULL, allocno_hard_regs_node::prev, remove_unused_allocno_hard_regs_nodes(), and allocno_hard_regs_node::used_p.
Referenced by form_allocno_hard_regs_nodes_forest(), and remove_unused_allocno_hard_regs_nodes().
◆ restore_costs_from_copies()
|
static |
Restore costs of allocnos connected to ALLOCNO by copies as it was before updating costs of these allocnos from given allocno. This is a wise thing to do as if given allocno did not get an expected hard reg, using smaller cost of the hard reg for allocnos connected by copies to given allocno becomes actually misleading. Free all update cost records for ALLOCNO as we don't need them anymore.
References ALLOCNO_COLOR_DATA, ALLOCNO_NUM, ALLOCNO_REGNO, free_update_cost_record_list(), ggc_alloc(), internal_flag_ira_verbose, ira_dump_file, NULL, start_update_cost(), and update_costs_from_allocno().
Referenced by assign_hard_reg().
◆ setup_allocno_available_regs_num()
|
static |
Set up number of available hard registers for allocno A.
References a, ALLOCNO_CLASS, ALLOCNO_COLOR_DATA, ALLOCNO_NUM, ALLOCNO_NUM_OBJECTS, ALLOCNO_OBJECT, ALLOCNO_REGNO, ggc_alloc(), update_cost_record::hard_regno, i, internal_flag_ira_verbose, ira_class_hard_regs, ira_class_hard_regs_num, ira_dump_file, NULL, OBJECT_TOTAL_CONFLICT_HARD_REGS, print_hard_reg_set(), reg_class_names, and TEST_HARD_REG_BIT.
Referenced by put_allocno_into_bucket().
◆ setup_allocno_hard_regs_nodes_parent()
|
static |
Set up field parent as PARENT in all allocno hard registers nodes in forest given by FIRST.
References allocno_hard_regs_node::first, allocno_hard_regs_node::next, NULL, allocno_hard_regs_node::parent, and setup_allocno_hard_regs_nodes_parent().
Referenced by form_allocno_hard_regs_nodes_forest(), and setup_allocno_hard_regs_nodes_parent().
◆ setup_allocno_hard_regs_subnode_index()
|
static |
Setup arrays ALLOCNO_HARD_REGS_NODES and ALLOCNO_HARD_REGS_SUBNODE_INDEX.
References allocno_hard_regs_nodes, allocno_hard_regs_nodes_num, allocno_hard_regs_subnode_index, allocno_hard_regs_node::first, allocno_hard_regs_node::next, NULL, allocno_hard_regs_node::parent, allocno_hard_regs_node::preorder_num, and setup_allocno_hard_regs_subnode_index().
Referenced by form_allocno_hard_regs_nodes_forest(), and setup_allocno_hard_regs_subnode_index().
◆ setup_allocno_priorities()
|
static |
Set up priorities for N allocnos in array CONSIDERATION_ALLOCNOS.
References a, ALLOCNO_CLASS, ALLOCNO_CLASS_COST, ALLOCNO_EXCESS_PRESSURE_POINTS_NUM, ALLOCNO_MEMORY_COST, ALLOCNO_MODE, ALLOCNO_NREFS, ALLOCNO_NUM, ALLOCNO_NUM_OBJECTS, allocno_priorities, floor_log2(), ggc_alloc(), i, INT_MAX, ira_assert, ira_reg_class_max_nregs, and mult.
Referenced by color_allocnos(), fast_allocation(), and ira_reassign_conflict_allocnos().
◆ setup_coalesced_allocno_costs_and_nums()
Setup REGNO_COALESCED_ALLOCNO_COST and REGNO_COALESCED_ALLOCNO_NUM for coalesced allocno sets containing allocnos with their regnos given in array PSEUDO_REGNOS of length N.
References a, ALLOCNO_COALESCE_DATA, ALLOCNO_FREQ, ALLOCNO_REGNO, ggc_alloc(), i, ira_regno_allocno_map, NULL, regno_coalesced_allocno_cost, and regno_coalesced_allocno_num.
Referenced by ira_sort_regnos_for_alter_reg().
◆ setup_left_conflict_sizes_p()
|
static |
Set up left conflict sizes and left conflict subnodes sizes of hard registers subnodes of allocno A. Return TRUE if allocno A is trivially colorable.
References a, ALLOCNO_CLASS, ALLOCNO_COLOR_DATA, allocno_hard_regs_nodes, allocno_hard_regs_nodes_num, allocno_hard_regs_subnode_index, allocno_hard_regs_subnodes, ALLOCNO_MODE, ALLOCNO_NUM_OBJECTS, ALLOCNO_OBJECT, FOR_EACH_OBJECT_CONFLICT, gcc_checking_assert, ggc_alloc(), hard_reg_set_intersect_p(), hard_reg_set_subset_p(), allocno_hard_regs_node::hard_regs, i, ira_assert, ira_class_hard_regs, ira_class_hard_regs_num, ira_reg_class_max_nregs, MIN, node_check_tick, OBJECT_ALLOCNO, allocno_hard_regs_node::parent, allocno_hard_regs_node::preorder_num, allocno_hard_regs::set, and TEST_HARD_REG_BIT.
Referenced by put_allocno_into_bucket().
◆ setup_profitable_hard_regs()
Set up profitable hard registers for each allocno being colored.
References a, ALLOCNO_ASSIGNED_P, ALLOCNO_CLASS, ALLOCNO_CLASS_COST, ALLOCNO_COLOR_DATA, ALLOCNO_HARD_REG_COSTS, ALLOCNO_HARD_REGNO, ALLOCNO_MEMORY_COST, ALLOCNO_MODE, ALLOCNO_NUM_OBJECTS, ALLOCNO_OBJECT, ALLOCNO_REGNO, ALLOCNO_UPDATED_CLASS_COST, ALLOCNO_UPDATED_HARD_REG_COSTS, ALLOCNO_UPDATED_MEMORY_COST, CLEAR_HARD_REG_BIT, CLEAR_HARD_REG_SET, coloring_allocno_bitmap, consideration_allocno_bitmap, costs, empty_profitable_hard_regs(), EXECUTE_IF_SET_IN_BITMAP, FOR_EACH_OBJECT_CONFLICT, ggc_alloc(), hard_regno_nregs(), i, INT_MAX, ira_allocnos, ira_class_hard_regs, ira_class_hard_regs_num, ira_useful_class_mode_regs, non_spilled_static_chain_regno_p(), NULL, OBJECT_ALLOCNO, OBJECT_SUBWORD, REG_WORDS_BIG_ENDIAN, and TEST_HARD_REG_BIT.
Referenced by color_allocnos().
◆ setup_slot_coalesced_allocno_live_ranges()
|
static |
Update live ranges of slot to which coalesced allocnos represented by ALLOCNO were assigned.
References a, ALLOCNO_CAP_MEMBER, ALLOCNO_COALESCE_DATA, ALLOCNO_NUM_OBJECTS, ALLOCNO_OBJECT, gcc_assert, i, ira_copy_live_range_list(), ira_merge_live_ranges(), nr, NULL, OBJECT_LIVE_RANGES, r, and slot_coalesced_allocnos_live_ranges.
Referenced by coalesce_spill_slots().
◆ slot_coalesced_allocno_live_ranges_intersect_p()
|
static |
Return TRUE if coalesced allocnos represented by ALLOCNO has live ranges intersected with live ranges of coalesced allocnos assigned to slot with number N.
References a, ALLOCNO_CAP_MEMBER, ALLOCNO_COALESCE_DATA, ALLOCNO_NUM_OBJECTS, ALLOCNO_OBJECT, gcc_assert, i, ira_live_ranges_intersect_p(), nr, NULL, OBJECT_LIVE_RANGES, and slot_coalesced_allocnos_live_ranges.
Referenced by coalesce_spill_slots().
◆ sort_bucket()
|
static |
Sort bucket *BUCKET_PTR and return the result through BUCKET_PTR.
References a, ALLOCNO_COLOR_DATA, ggc_alloc(), NULL, qsort, and sorted_allocnos.
Referenced by push_allocnos_to_stack(), and push_only_colorable().
◆ spill_soft_conflicts()
|
static |
The caller has decided to allocate HREGNO to A and has proved that this is safe. However, the allocation might require the kind of spilling described in the comment above ira_soft_conflict. The caller has recorded that: - The allocnos in ALLOCNOS_TO_SPILL are the ones that would need to be spilled to satisfy soft conflicts for at least one allocation (not necessarily HREGNO). - The soft conflicts apply only to A allocations that overlap SOFT_CONFLICT_REGS. If allocating HREGNO is subject to any soft conflicts, record the subloop allocnos that need to be spilled.
References a, ALLOCNO_HARD_REGNO, ALLOCNO_LOOP_TREE_NODE, ALLOCNO_MIGHT_CONFLICT_WITH_PARENT_P, ALLOCNO_MODE, EXECUTE_IF_SET_IN_BITMAP, ggc_alloc(), hard_regno_nregs(), i, ira_allocnos, ira_assert, ira_hard_reg_set_intersection_p(), ira_parent_or_cap_allocno(), and ira_soft_conflict().
Referenced by assign_hard_reg(), and improve_allocation().
◆ start_update_cost()
Start a new cost-updating pass.
References NULL, update_cost_check, and update_cost_queue.
Referenced by assign_hard_reg(), restore_costs_from_copies(), update_costs_from_copies(), and update_costs_from_prefs().
◆ update_allocno_cost()
|
static |
Increase costs of HARD_REGNO by UPDATE_COST and conflict cost by UPDATE_CONFLICT_COST for ALLOCNO. Return true if we really modified the cost.
References ALLOCNO_CLASS, ALLOCNO_CONFLICT_HARD_REG_COSTS, ALLOCNO_HARD_REG_COSTS, ALLOCNO_UPDATED_CLASS_COST, ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS, ALLOCNO_UPDATED_HARD_REG_COSTS, ggc_alloc(), i, ira_allocate_and_set_or_copy_costs(), and ira_class_hard_reg_index.
Referenced by update_costs_from_allocno().
◆ update_conflict_allocno_hard_prefs()
|
static |
Update conflict_allocno_hard_prefs of allocnos conflicting with ALLOCNO.
References ALLOCNO_COLOR_DATA, ALLOCNO_NUM_OBJECTS, ALLOCNO_OBJECT, ALLOCNO_PREFS, FOR_EACH_OBJECT_CONFLICT, ggc_alloc(), hard_reg_set_intersect_p(), nr, NULL, OBJECT_ALLOCNO, and pref.
Referenced by color_allocnos().
◆ update_conflict_hard_regno_costs()
|
static |
This function updates COSTS (decrease if DECR_P) for hard_registers of ACLASS by conflict costs of the unassigned allocnos connected by copies with allocnos in update_cost_queue. This update increases chances to remove some copies.
References ALLOCNO_ASSIGNED_P, ALLOCNO_CLASS, ALLOCNO_COLOR_DATA, ALLOCNO_CONFLICT_HARD_REG_COSTS, ALLOCNO_COPIES, ALLOCNO_FREQ, ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS, allocnos_conflict_p(), COST_HOP_DIVISOR, update_cost_record::divisor, gcc_unreachable, get_next_update_cost(), ggc_alloc(), update_cost_record::hard_regno, i, ira_allocate_and_copy_costs(), ira_assert, ira_class_hard_reg_index, ira_class_hard_regs, ira_class_hard_regs_num, ira_reg_classes_intersect_p, mult, NULL, and queue_update_cost().
Referenced by assign_hard_reg().
◆ update_costs_from_allocno()
|
static |
Update (decrease if DECR_P) HARD_REGNO cost of allocnos connected by copies to ALLOCNO to increase chances to remove some copies as the result of subsequent assignment. Update conflict costs. Record cost updates if RECORD_P is true.
References ALLOCNO_ASSIGNED_P, ALLOCNO_CLASS, ALLOCNO_COLOR_DATA, ALLOCNO_COPIES, ALLOCNO_MODE, ALLOCNO_NUM, ALLOCNO_REGNO, COST_HOP_DIVISOR, update_cost_queue_elem::divisor, update_cost_queue_elem::from, gcc_unreachable, get_next_update_cost(), get_update_cost_record(), ggc_alloc(), internal_flag_ira_verbose, ira_dump_file, ira_init_register_move_cost_if_necessary(), ira_register_move_cost, narrower_subreg_mode(), NULL, queue_update_cost(), reg_class_contents, update_cost_queue_elem::start, TEST_HARD_REG_BIT, and update_allocno_cost().
Referenced by restore_costs_from_copies(), update_costs_from_copies(), and update_costs_from_prefs().
◆ update_costs_from_copies()
|
static |
Update (decrease if DECR_P) the cost of allocnos connected to ALLOCNO through copies to increase chances to remove some copies as the result of subsequent assignment. ALLOCNO was just assigned to a hard register. Record cost updates if RECORD_P is true.
References ALLOCNO_CLASS, ALLOCNO_HARD_REGNO, ALLOCNO_NUM, ALLOCNO_REGNO, ggc_alloc(), internal_flag_ira_verbose, ira_assert, ira_dump_file, NULL, start_update_cost(), and update_costs_from_allocno().
Referenced by assign_hard_reg(), color_pass(), and ira_mark_allocation_change().
◆ update_costs_from_prefs()
|
static |
Decrease preferred ALLOCNO hard register costs and costs of allocnos connected to ALLOCNO through copy.
References ALLOCNO_NUM, ALLOCNO_PREFS, ALLOCNO_REGNO, COST_HOP_DIVISOR, ggc_alloc(), ira_allocno::hard_regno, internal_flag_ira_verbose, ira_dump_file, NULL, pref, start_update_cost(), and update_costs_from_allocno().
Referenced by push_only_colorable().
◆ update_curr_costs()
|
static |
Update current hard reg costs and current conflict hard reg costs for allocno A. It is done by processing its copies containing other allocnos already assigned.
References a, ALLOCNO_ASSIGNED_P, ALLOCNO_CLASS, ALLOCNO_CLASS_COST, ALLOCNO_CONFLICT_HARD_REG_COSTS, ALLOCNO_COPIES, ALLOCNO_HARD_REG_COSTS, ALLOCNO_HARD_REGNO, ALLOCNO_MODE, ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS, ALLOCNO_UPDATED_HARD_REG_COSTS, gcc_unreachable, ggc_alloc(), update_cost_record::hard_regno, i, ira_allocate_and_set_or_copy_costs(), ira_assert, ira_class_hard_reg_index, ira_free_allocno_updated_costs(), ira_init_register_move_cost_if_necessary(), ira_reg_classes_intersect_p, ira_register_move_cost, and NULL.
Referenced by allocno_reload_assign(), and ira_reassign_conflict_allocnos().
◆ update_left_conflict_sizes_p()
|
static |
Update left conflict sizes of hard registers subnodes of allocno A after removing allocno REMOVED_A with SIZE from the conflict graph. Return TRUE if A is trivially colorable.
References a, ALLOCNO_CLASS, ALLOCNO_COLOR_DATA, allocno_hard_regs_nodes, allocno_hard_regs_nodes_num, allocno_hard_regs_subnode_index, allocno_hard_regs_subnodes, ALLOCNO_MODE, ggc_alloc(), hard_reg_set_subset_p(), allocno_hard_regs_node::hard_regs, i, ira_assert, ira_reg_class_max_nregs, MIN, NULL, allocno_hard_regs_node::parent, allocno_hard_regs_node::preorder_num, and allocno_hard_regs::set.
Referenced by push_allocno_to_stack().
Variable Documentation
◆ allocated_hardreg_p
|
static |
Array whose element value is TRUE if the corresponding hard register was already allocated for an allocno.
Referenced by assign_hard_reg(), calculate_saved_nregs(), color(), and improve_allocation().
◆ allocno_coalesce_data
|
static |
Container for storing allocno data concerning coalescing.
Referenced by coalesce_allocnos(), ira_sort_regnos_for_alter_reg(), and merge_allocnos().
◆ allocno_coalesced_p
|
static |
This page contains functions used to find conflicts using allocno live ranges.
This page contains code to coalesce memory stack slots used by spilled allocnos. This results in smaller stack frame, better data locality, and in smaller code for some architectures like x86/x86_64 where insn size depends on address displacement value. On the other hand, it can worsen insn scheduling after the RA but in practice it is less important than smaller stack frames.
TRUE if we coalesced some allocnos. In other words, if we got loops formed by members first_coalesced_allocno and next_coalesced_allocno containing more one allocno.
Referenced by coalesce_allocnos(), coalesce_spill_slots(), coalesced_allocno_conflict_p(), and ira_sort_regnos_for_alter_reg().
◆ allocno_color_data
|
static |
Container for storing allocno data concerning coloring.
◆ allocno_hard_regs_htab
|
static |
Hash table of unique allocno hard registers.
Referenced by find_hard_regs(), finish_allocno_hard_regs(), init_allocno_hard_regs(), and insert_hard_regs().
◆ allocno_hard_regs_nodes
|
static |
Table preorder number of allocno hard registers node in the forest -> the allocno hard registers node.
Referenced by finish_allocno_hard_regs_nodes_forest(), form_allocno_hard_regs_nodes_forest(), setup_allocno_hard_regs_subnode_index(), setup_left_conflict_sizes_p(), and update_left_conflict_sizes_p().
◆ allocno_hard_regs_nodes_num
|
static |
Number of allocno hard registers nodes in the forest.
Referenced by form_allocno_hard_regs_nodes_forest(), setup_allocno_hard_regs_subnode_index(), setup_left_conflict_sizes_p(), and update_left_conflict_sizes_p().
◆ allocno_hard_regs_subnode_index
|
static |
Table (preorder number of allocno hard registers node in the forest, preorder number of allocno hard registers subnode) -> index of the subnode relative to the node. -1 if it is not a subnode.
Referenced by finish_allocno_hard_regs_nodes_forest(), form_allocno_hard_regs_nodes_forest(), setup_allocno_hard_regs_subnode_index(), setup_left_conflict_sizes_p(), and update_left_conflict_sizes_p().
◆ allocno_hard_regs_subnodes
|
static |
Container for hard regs subnodes of all allocnos.
Referenced by finish_allocno_hard_regs_nodes_forest(), form_allocno_hard_regs_nodes_forest(), setup_left_conflict_sizes_p(), and update_left_conflict_sizes_p().
◆ allocno_hard_regs_vec
|
static |
Definition of vector of allocno hard registers.
Vector of unique allocno hard registers.
Referenced by add_allocno_hard_regs(), finish_allocno_hard_regs(), form_allocno_hard_regs_nodes_forest(), and init_allocno_hard_regs().
◆ allocno_priorities
|
static |
Map: allocno number -> allocno priority.
Referenced by allocno_priority_compare_func(), fast_allocation(), ira_finish_assign(), ira_initiate_assign(), and setup_allocno_priorities().
◆ allocno_stack_vec
|
static |
Vec representing the stack of allocnos used during coloring.
Referenced by color(), pop_allocnos_from_stack(), and push_allocno_to_stack().
◆ colorable_allocno_bucket
|
static |
This page contains the allocator based on the Chaitin-Briggs algorithm.
Bucket of allocnos that can colored currently without spilling.
Referenced by add_allocno_to_ordered_colorable_bucket(), color_allocnos(), push_allocnos_to_stack(), push_only_colorable(), put_allocno_into_bucket(), and remove_allocno_from_bucket_and_push().
◆ coloring_allocno_bitmap
|
static |
This file contains code for regional graph coloring, spill/restore code placement optimization, and code helping the reload pass to do a better job.
Bitmap of allocnos which should be colored.
Referenced by coalesce_allocnos(), color_allocnos(), color_pass(), do_coloring(), form_allocno_hard_regs_nodes_forest(), improve_allocation(), ira_sort_regnos_for_alter_reg(), push_allocno_to_stack(), and setup_profitable_hard_regs().
◆ consideration_allocno_bitmap
|
static |
Bitmap of allocnos which should be taken into account during coloring. In general case it contains allocnos from coloring_allocno_bitmap plus other already colored conflicting allocnos.
Referenced by assign_hard_reg(), color_pass(), init_allocno_threads(), ira_finish_assign(), ira_initiate_assign(), ira_reassign_pseudos(), and setup_profitable_hard_regs().
◆ curr_allocno_process
|
static |
Used for finding allocno colorability to exclude repeated allocno processing and for updating preferencing to exclude repeated allocno processing during assignment.
Referenced by assign_hard_reg(), and color_pass().
◆ hard_regs_node_vec
|
static |
Definition of vector of allocno hard register nodes.
Vector used to create the forest.
Referenced by add_allocno_hard_regs_to_forest(), collect_allocno_hard_regs_cover(), and form_allocno_hard_regs_nodes_forest().
◆ hard_regs_roots
|
static |
Roots of the forest containing hard register sets can be assigned to allocnos.
Referenced by finish_allocno_hard_regs_nodes_forest(), form_allocno_hard_regs_nodes_forest(), and print_hard_regs_forest().
◆ max_soft_conflict_loop_depth
| const int max_soft_conflict_loop_depth = 64 |
IRA allocation based on graph coloring. Copyright (C) 2006-2024 Free Software Foundation, Inc. Contributed by Vladimir Makarov <vmakarov@redhat.com>. This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see <http://www.gnu.org/licenses/>.
To prevent soft conflict detection becoming quadratic in the loop depth. Only for very pathological cases, so it hardly seems worth a --param.
Referenced by ira_soft_conflict().
◆ node_check_tick
|
static |
Used for finding a common ancestor of two allocno hard registers nodes in the forest. We use the current value of 'node_check_tick' to mark all nodes from one node to the top and then walking up from another node until we find a marked node. It is also used to figure out allocno colorability as a mark that we already reset value of member 'conflict_size' for the forest node corresponding to the processed allocno.
Referenced by first_common_ancestor_node(), form_allocno_hard_regs_nodes_forest(), and setup_left_conflict_sizes_p().
◆ processed_coalesced_allocno_bitmap
|
static |
Bitmap used to prevent a repeated allocno processing because of coalescing.
Referenced by coalesced_allocno_conflict_p(), and ira_sort_regnos_for_alter_reg().
◆ regno_coalesced_allocno_cost
|
static |
Usage cost and order number of coalesced allocno set to which given pseudo register belongs to.
Referenced by coalesced_pseudo_reg_freq_compare(), ira_sort_regnos_for_alter_reg(), and setup_coalesced_allocno_costs_and_nums().
◆ regno_coalesced_allocno_num
|
static |
◆ regno_max_ref_mode
|
static |
Widest width in which each pseudo reg is referred to (via subreg). It is used for sorting pseudo registers.
Referenced by coalesced_pseudo_reg_slot_compare(), and ira_sort_regnos_for_alter_reg().
◆ slot_coalesced_allocnos_live_ranges
|
static |
Array of live ranges of size IRA_ALLOCNOS_NUM. Live range for given slot contains live ranges of coalesced allocnos assigned to given slot.
Referenced by coalesce_spill_slots(), setup_slot_coalesced_allocno_live_ranges(), and slot_coalesced_allocno_live_ranges_intersect_p().
◆ sorted_allocnos
|
static |
All allocnos sorted according their priorities.
Referenced by color_allocnos(), fast_allocation(), improve_allocation(), ira_finish_assign(), ira_initiate_assign(), ira_reassign_conflict_allocnos(), and sort_bucket().
◆ sorted_copies
|
static |
An array used to sort copies.
Referenced by coalesce_allocnos(), form_threads_from_bucket(), form_threads_from_colorable_allocno(), form_threads_from_copies(), ira_finish_assign(), and ira_initiate_assign().
◆ uncolorable_allocno_bucket
|
static |
Bucket of allocnos that might be not colored currently without spilling.
Referenced by add_allocno_to_bucket(), color_allocnos(), delete_allocno_from_bucket(), push_allocno_to_stack(), push_allocnos_to_stack(), put_allocno_into_bucket(), and remove_allocno_from_bucket_and_push().
◆ uncolorable_allocnos_num
|
static |
The current number of allocnos in the uncolorable_bucket.
Referenced by add_allocno_to_bucket(), delete_allocno_from_bucket(), and push_allocnos_to_stack().
◆ update_cost_check
|
static |
The current value of update_costs_from_copies call count.
Referenced by initiate_cost_update(), queue_update_cost(), and start_update_cost().
◆ update_cost_queue
|
static |
The first element in a queue of allocnos whose copy costs need to be updated. Null if the queue is empty.
Referenced by get_next_update_cost(), queue_update_cost(), and start_update_cost().
◆ update_cost_queue_elems
|
static |
A pool of elements in the queue described by update_cost_queue. Elements are indexed by ALLOCNO_NUM.
Referenced by finish_cost_update(), get_next_update_cost(), initiate_cost_update(), and queue_update_cost().
◆ update_cost_queue_tail
|
static |
The last element in the queue described by update_cost_queue. Not valid if update_cost_queue is null.
Referenced by queue_update_cost().
◆ update_cost_record_pool
|
static |
This page contains functions used to choose hard registers for allocnos.
Pool for update cost records.
Referenced by finish_update_cost_records(), free_update_cost_record_list(), and get_update_cost_record().
