#include "config.h"#include "system.h"#include "coretypes.h"#include "backend.h"#include "target.h"#include "rtl.h"#include "tree.h"#include "df.h"#include "memmodel.h"#include "tm_p.h"#include "regs.h"#include "emit-rtl.h"#include "dumpfile.h"#include "calls.h"#include "function-abi.h"
Data Structures | |
| class | df_collection_rec |
| struct | df_scan_problem_data |
Variables | |
| static HARD_REG_SET | elim_reg_set |
| static bool | regs_ever_live [FIRST_PSEUDO_REGISTER] |
| static const unsigned int | copy_defs = 0x1 |
| static const unsigned int | copy_uses = 0x2 |
| static const unsigned int | copy_eq_uses = 0x4 |
| static const unsigned int | copy_mw = 0x8 |
| static const unsigned int | copy_all |
| static const struct df_problem | problem_SCAN |
| static bool | initialized = false |
Function Documentation
◆ df_add_refs_to_table()
|
static |
Add the refs in REF_VEC to the table in REF_INFO starting at OFFSET.
References df_d::changeable_flags, df, DF_NO_HARD_REGS, DF_REF_ID, DF_REF_NEXT_LOC, DF_REF_REGNO, ggc_alloc(), and offset.
Referenced by df_reorganize_refs_by_insn_bb().
◆ df_bb_refs_collect()
|
static |
Collect all artificial refs at the block level for BB and add them to COLLECTION_REC.
References bb_has_eh_pred(), df, df_canonize_collection_rec(), df_entry_block_defs_collect(), df_exit_block_uses_collect(), DF_REF_ARTIFICIAL, DF_REF_AT_TOP, df_ref_record(), DF_REF_REG_DEF, DF_REF_REG_USE, df_d::eh_block_artificial_uses, EH_RETURN_DATA_REGNO, ENTRY_BLOCK, df_d::entry_block_defs, EXECUTE_IF_SET_IN_BITMAP, EXIT_BLOCK, df_d::exit_block_uses, basic_block_def::flags, ggc_alloc(), hard_frame_pointer_rtx, i, basic_block_def::index, INVALID_REGNUM, NULL, NUM_FIXED_BLOCKS, regno_reg_rtx, and df_d::regular_block_artificial_uses.
Referenced by df_bb_refs_record(), and df_bb_verify().
◆ df_bb_refs_record()
Record all the refs within the basic block BB_INDEX and scan the instructions if SCAN_INSNS.
References BASIC_BLOCK_FOR_FN, cfun, copy_all, df, df_bb_refs_collect(), df_grow_bb_info(), df_insn_create_insn_record(), DF_INSN_INFO_GET, DF_INSN_INFO_LUID, df_insn_refs_collect(), df_refs_add_to_chains(), df_scan, df_set_bb_dirty(), FOR_BB_INSNS, gcc_assert, ggc_alloc(), df_insn_info::insn, INSN_P, df_insn_info::luid, and NULL.
Referenced by create_basic_block_structure(), and df_scan_blocks().
◆ df_bb_verify()
|
static |
Return true if all refs in the basic block are correct and complete. Due to df_ref_chain_verify, it will cause all refs that are verified to have DF_REF_MARK bit set.
References df_bb_refs_collect(), df_free_collection_rec(), df_get_artificial_defs(), df_get_artificial_uses(), df_insn_refs_verify(), df_refs_verify(), df_scan_get_bb_info(), FOR_BB_INSNS_REVERSE, gcc_assert, ggc_alloc(), basic_block_def::index, df_insn_info::insn, and INSN_P.
Referenced by df_scan_verify().
◆ df_canonize_collection_rec()
|
static |
Sort and remove duplicates from the COLLECTION_REC.
References df_sort_and_compress_mws(), df_sort_and_compress_refs(), and ggc_alloc().
Referenced by df_bb_refs_collect(), df_entry_block_defs_collect(), df_exit_block_uses_collect(), df_insn_refs_collect(), and df_notes_rescan().
◆ df_check_and_grow_ref_info()
|
static |
Check and grow the ref information if necessary. This routine guarantees total_size + BITMAP_ADDEND amount of entries in refs array. It updates ref_info->refs_size only and does not change ref_info->total_size.
References df_grow_ref_info(), and ggc_alloc().
Referenced by df_install_ref(), df_reorganize_refs_by_insn(), df_reorganize_refs_by_reg_by_insn(), and df_reorganize_refs_by_reg_by_reg().
◆ df_compute_regs_ever_live()
Compute "regs_ever_live" information from the underlying df information. Set the vector to all false if RESET.
References changed, df, df_hard_reg_used_p(), df_update_entry_exit_and_calls(), ggc_alloc(), i, df_d::redo_entry_and_exit, and regs_ever_live.
Referenced by df_analyze_1(), reginfo_init(), and rest_of_handle_df_initialize().
◆ df_count_refs()
|
static |
Count the number of refs. Include the defs if INCLUDE_DEFS. Include the uses if INCLUDE_USES. Include the eq_uses if INCLUDE_EQ_USES.
References df, DF_REG_DEF_COUNT, DF_REG_EQ_USE_COUNT, DF_REG_USE_COUNT, ggc_alloc(), and df_d::regs_inited.
Referenced by df_reorganize_refs_by_insn(), df_reorganize_refs_by_reg_by_insn(), and df_reorganize_refs_by_reg_by_reg().
◆ df_def_record_1()
|
static |
Process all the registers defined in the rtx pointed by LOC. Autoincrement/decrement definitions will be picked up by df_uses_record. Any change here has to be matched in df_find_hard_reg_defs_1.
References df_def_record_1(), DF_REF_BASE, DF_REF_PARTIAL, DF_REF_READ_WRITE, df_ref_record(), DF_REF_REG_DEF, DF_REF_REG_USE, DF_REF_REGULAR, DF_REF_STRICT_LOW_PART, DF_REF_SUBREG, DF_REF_ZERO_EXTRACT, gcc_assert, GET_CODE, ggc_alloc(), i, NULL, read_modify_subreg_p(), REG_P, REGNO, SUBREG_REG, XEXP, XVECEXP, and XVECLEN.
Referenced by df_def_record_1(), and df_defs_record().
◆ df_defs_record()
|
static |
Process all the registers defined in the pattern rtx, X. Any change here has to be matched in df_find_hard_reg_defs.
References COND_EXEC_CODE, df_def_record_1(), df_defs_record(), DF_REF_CONDITIONAL, DF_REF_MUST_CLOBBER, GET_CODE, ggc_alloc(), i, RTX_CODE, SET, SET_DEST, XEXP, XVECEXP, and XVECLEN.
Referenced by df_defs_record(), df_get_call_refs(), and df_insn_refs_collect().
◆ df_entry_block_bitmap_verify()
Returns true if the entry block has correct and complete df_ref set. If not it either aborts if ABORT_IF_FAIL is true or returns false.
References bitmap_equal_p(), df, df_bitmap_obstack, df_get_entry_block_def_set(), df_print_regset(), df_d::entry_block_defs, gcc_assert, and ggc_alloc().
Referenced by df_scan_verify().
◆ df_entry_block_defs_collect()
|
static |
Return the (conservative) set of hard registers that are defined on entry to the function. It uses df->entry_block_defs to determine which register reference to include.
References cfun, df_canonize_collection_rec(), DF_REF_ARTIFICIAL, df_ref_record(), DF_REF_REG_DEF, ENTRY_BLOCK_PTR_FOR_FN, EXECUTE_IF_SET_IN_BITMAP, ggc_alloc(), i, NULL, and regno_reg_rtx.
Referenced by df_bb_refs_collect(), and df_record_entry_block_defs().
◆ df_epilogue_uses_p()
Return true if REGNO is used by the epilogue.
References crtl, EPILOGUE_USES, and TEST_HARD_REG_BIT.
Referenced by df_get_exit_block_use_set(), and init_resource_info().
◆ df_exit_block_bitmap_verify()
Returns true if the exit block has correct and complete df_ref set. If not it either aborts if ABORT_IF_FAIL is true or returns false.
References bitmap_equal_p(), df, df_bitmap_obstack, df_get_exit_block_use_set(), df_print_regset(), df_d::exit_block_uses, gcc_assert, and ggc_alloc().
Referenced by df_scan_verify().
◆ df_exit_block_uses_collect()
|
static |
Return the refs of hard registers that are used in the exit block. It uses df->exit_block_uses to determine register to include.
References bb_has_eh_pred(), bitmap_bit_p, cfun, df_canonize_collection_rec(), DF_REF_ARTIFICIAL, df_ref_record(), DF_REF_REG_USE, EXECUTE_IF_SET_IN_BITMAP, EXIT_BLOCK_PTR_FOR_FN, fixed_regs, ggc_alloc(), i, NULL, regno_reg_rtx, and reload_completed.
Referenced by df_bb_refs_collect(), and df_record_exit_block_uses().
◆ df_find_hard_reg_defs()
|
static |
Set bits in *DEFS for hard registers defined in the pattern X. This has to match the logic in df_defs_record.
References COND_EXEC_CODE, defs, df_find_hard_reg_defs(), df_find_hard_reg_defs_1(), GET_CODE, ggc_alloc(), i, RTX_CODE, SET, SET_DEST, XEXP, XVECEXP, and XVECLEN.
Referenced by df_find_hard_reg_defs(), and df_get_call_refs().
◆ df_find_hard_reg_defs_1()
|
static |
Set bits in *DEFS for hard registers found in the rtx DST, which is the destination of a set or clobber. This has to match the logic in df_defs_record_1.
References defs, df_find_hard_reg_defs_1(), gcc_assert, GET_CODE, ggc_alloc(), HARD_REGISTER_P, i, REG_P, REGNO, SET_HARD_REG_BIT, SUBREG_REG, XEXP, XVECEXP, and XVECLEN.
Referenced by df_find_hard_reg_defs(), and df_find_hard_reg_defs_1().
◆ df_free_collection_rec()
|
static |
Free all of the refs and the mw_hardregs in COLLECTION_REC.
References df_free_ref(), df_scan, FOR_EACH_VEC_ELT, ggc_alloc(), df_scan_problem_data::mw_reg_pool, and object_allocator< T >::remove().
Referenced by df_bb_verify(), and df_insn_rescan().
◆ df_free_ref()
References DF_REF_ARTIFICIAL, DF_REF_BASE, DF_REF_CLASS, DF_REF_REGULAR, df_scan, df_scan_problem_data::ref_artificial_pool, df_scan_problem_data::ref_base_pool, df_scan_problem_data::ref_regular_pool, and object_allocator< T >::remove().
Referenced by df_free_collection_rec(), df_reg_chain_unlink(), and df_sort_and_compress_refs().
◆ df_get_call_refs()
|
static |
Get call's extra defs and uses (track caller-saved registers).
References bitmap_bit_p, CALL_INSN_FUNCTION_USAGE, CLEAR_HARD_REG_SET, crtl, df, df_defs_record(), df_find_hard_reg_defs(), DF_REF_BASE, DF_REF_CALL_STACK_USAGE, DF_REF_MAY_CLOBBER, df_ref_record(), DF_REF_REG_DEF, DF_REF_REG_USE, df_uses_record(), df_d::exit_block_uses, FAKE_CALL_P, GET_CODE, ggc_alloc(), global_regs, i, df_insn_info::insn, insn_callee_abi(), NULL, PATTERN(), refers_to_regno_p(), REG_P, REGNO, regno_reg_rtx, RTL_CONST_CALL_P, RTL_PURE_CALL_P, SIBLING_CALL_P, TEST_HARD_REG_BIT, and XEXP.
Referenced by df_insn_refs_collect().
◆ df_get_conditional_uses()
|
static |
For all DF_REF_CONDITIONAL defs, add a corresponding uses.
References DF_REF_BB, DF_REF_CLASS, DF_REF_CONDITIONAL, df_ref_create_structure(), DF_REF_FLAGS, DF_REF_FLAGS_IS_SET, DF_REF_INSN_INFO, DF_REF_LOC, DF_REF_REG, DF_REF_REG_USE, DF_REF_REGNO, FOR_EACH_VEC_ELT, and ggc_alloc().
Referenced by df_insn_refs_collect().
◆ df_get_eh_block_artificial_uses()
Get the artificial use set for an eh block.
References bitmap_clear(), bitmap_set_bit, fixed_regs, frame_pointer_needed, ggc_alloc(), HARD_FRAME_POINTER_IS_FRAME_POINTER, HARD_FRAME_POINTER_REGNUM, and reload_completed.
Referenced by df_scan_blocks(), and df_scan_verify().
◆ df_get_entry_block_def_set()
Set the bit for regs that are considered being defined at the entry.
References bitmap_clear(), bitmap_set_bit, crtl, current_function_decl, df_regs_ever_live_p(), df_scan, DF_SCAN_EMPTY_ENTRY_EXIT, epilogue_completed, fixed_regs, frame_pointer_needed, ggc_alloc(), global_regs, HARD_FRAME_POINTER_IS_FRAME_POINTER, HARD_FRAME_POINTER_REGNUM, i, INCOMING_REGNO, INCOMING_RETURN_ADDR_RTX, INVALID_REGNUM, LOCAL_REGNO, PIC_OFFSET_TABLE_REGNUM, r, REG_P, REGNO, reload_completed, rtx_for_static_chain(), and targetm.
Referenced by df_entry_block_bitmap_verify(), df_scan_blocks(), and df_update_entry_block_defs().
◆ df_get_exit_block_use_set()
Set the bit for regs that are considered being used at the exit.
References bitmap_clear(), bitmap_set_bit, crtl, df_epilogue_uses_p(), df_mark_reg(), df_regs_ever_live_p(), df_scan, DF_SCAN_EMPTY_ENTRY_EXIT, diddle_return_value(), EH_RETURN_DATA_REGNO, EH_RETURN_HANDLER_RTX, epilogue_completed, fixed_regs, frame_pointer_needed, ggc_alloc(), global_regs, HARD_FRAME_POINTER_IS_FRAME_POINTER, HARD_FRAME_POINTER_REGNUM, i, INVALID_REGNUM, LOCAL_REGNO, PIC_OFFSET_TABLE_REG_CALL_CLOBBERED, PIC_OFFSET_TABLE_REGNUM, REG_P, reload_completed, and targetm.
Referenced by df_exit_block_bitmap_verify(), df_scan_blocks(), and df_update_exit_block_uses().
◆ df_get_regular_block_artificial_uses()
Get the artificial use set for a regular (i.e. non-exit/non-entry) block.
References bitmap_clear(), bitmap_set_bit, fixed_regs, frame_pointer_needed, ggc_alloc(), HARD_FRAME_POINTER_IS_FRAME_POINTER, HARD_FRAME_POINTER_REGNUM, i, INVALID_REGNUM, PIC_OFFSET_TABLE_REGNUM, and reload_completed.
Referenced by df_scan_blocks(), and df_scan_verify().
◆ df_grow_insn_info()
Grow the ref information. If the current size is less than the number of instructions, grow to 25% more than the number of instructions.
References df, DF_INSN_SIZE, get_max_uid(), ggc_alloc(), df_d::insns, and df_d::insns_size.
Referenced by df_insn_create_insn_record(), df_live_local_compute(), df_live_verify_transfer_functions(), df_mir_local_compute(), df_recompute_luids(), and df_scan_alloc().
◆ df_grow_ref_info()
|
static |
◆ df_grow_reg_info()
First, grow the reg_info information. If the current size is less than the number of pseudos, grow to 25% more than the number of pseudos. Second, assure that all of the slots up to max_reg_num have been filled with reg_info structures.
References object_allocator< T >::allocate(), df_ref_info::begin, df_ref_info::count, df_d::def_info, df_d::def_regs, df, df_scan, df_d::eq_use_regs, ggc_alloc(), i, max_reg_num(), df_scan_problem_data::reg_pool, df_d::regs_inited, df_d::regs_size, df_d::use_info, and df_d::use_regs.
Referenced by df_insn_delete(), df_insn_rescan(), df_notes_rescan(), df_ref_change_reg_with_loc(), df_scan_alloc(), and regstat_init_n_sets_and_refs().
◆ df_hard_reg_init()
Initialize some platform specific structures.
References CLEAR_HARD_REG_SET, elim_reg_set, ggc_alloc(), i, initialized, and SET_HARD_REG_BIT.
Referenced by rest_of_handle_df_initialize().
◆ df_hard_reg_used_count()
A count of the number of times REG is actually used in the some instruction. There are a fair number of conditions that affect the setting of this array. See the comment in df.h for df->hard_regs_live_count for the conditions that this array is set.
References df, and df_d::hard_regs_live_count.
◆ df_hard_reg_used_p()
Return true if hard REG is actually used in the some instruction. There are a fair number of conditions that affect the setting of this array. See the comment in df.h for df->hard_regs_live_count for the conditions that this array is set.
References df, and df_d::hard_regs_live_count.
Referenced by df_compute_regs_ever_live().
◆ df_insn_change_bb()
| void df_insn_change_bb | ( | rtx_insn * | insn, |
| basic_block | new_bb ) |
Change all of the basic block references in INSN to use the insn's current basic block. This function is called from routines that move instructions from one block to another.
References BLOCK_FOR_INSN(), DEBUG_INSN_P, df, df_insn_rescan(), DF_INSN_UID_SAFE_GET, df_set_bb_dirty(), dump_file, ggc_alloc(), basic_block_def::index, df_insn_info::insn, INSN_P, INSN_UID(), NULL, and set_block_for_insn().
Referenced by reorder_insns(), and update_bb_for_insn_chain().
◆ df_insn_create_insn_record()
| struct df_insn_info * df_insn_create_insn_record | ( | rtx_insn * | insn | ) |
Create the insn record for INSN. If there was one there, zero it out.
References object_allocator< T >::allocate(), df_grow_insn_info(), DF_INSN_INFO_GET, df_insn_info_init_fields(), DF_INSN_INFO_SET, df_scan, ggc_alloc(), df_insn_info::insn, and df_scan_problem_data::insn_pool.
Referenced by df_bb_refs_record(), df_insn_rescan(), df_live_bb_local_compute(), df_mir_bb_local_compute(), df_notes_rescan(), and df_recompute_luids().
◆ df_insn_delete()
Delete all of the refs information from INSN, either right now or marked for later in deferred mode.
References bitmap_clear_bit(), bitmap_set_bit, BLOCK_FOR_INSN(), df_d::changeable_flags, df, DF_DEFER_INSN_RESCAN, df_grow_bb_info(), df_grow_reg_info(), df_insn_info_delete(), DF_INSN_UID_SAFE_GET, df_scan, df_set_bb_dirty(), dump_file, gcc_checking_assert, ggc_alloc(), INSN_P, INSN_UID(), df_d::insns_to_delete, df_d::insns_to_notes_rescan, df_d::insns_to_rescan, NONDEBUG_INSN_P, NULL, and reload_completed.
Referenced by delete_insn(), and set_insn_deleted().
◆ df_insn_info_delete()
Delete all of the refs information from the insn with UID. Internal helper for df_insn_delete, df_insn_rescan, and other df-scan routines that don't have to work in deferred mode and do not have to mark basic blocks for re-processing.
References bitmap_clear_bit(), df, df_insn_info_free_fields(), DF_INSN_UID_SAFE_GET, DF_INSN_UID_SET, df_scan, df_scan_problem_data::insn_pool, df_d::insns_to_delete, df_d::insns_to_notes_rescan, df_d::insns_to_rescan, NULL, and object_allocator< T >::remove().
Referenced by df_insn_delete(), df_insn_rescan_all(), df_process_deferred_rescans(), and df_scan_free_bb_info().
◆ df_insn_info_free_fields()
|
static |
Remove the contents of INSN_INFO (but don't free INSN_INFO itself).
References df_insn_info::defs, df_chain, df_mw_hardreg_chain_delete(), df_ref_chain_delete(), df_ref_chain_delete_du_chain(), df_insn_info::eq_uses, df_insn_info::mw_hardregs, and df_insn_info::uses.
Referenced by df_insn_info_delete(), and df_insn_rescan().
◆ df_insn_info_init_fields()
|
static |
Initialize INSN_INFO to describe INSN.
References ggc_alloc(), and df_insn_info::insn.
Referenced by df_insn_create_insn_record(), and df_insn_rescan().
◆ df_insn_refs_collect()
|
static |
Collect all refs in the INSN. This function is free of any side-effect - it will create and return a lists of df_ref's in the COLLECTION_REC without putting those refs into existing ref chains and reg chains.
References CALL_P, df_canonize_collection_rec(), df_defs_record(), df_get_call_refs(), df_get_conditional_uses(), DF_REF_BASE, DF_REF_CONDITIONAL, DF_REF_IN_NOTE, df_ref_record(), DF_REF_REG_USE, df_uses_record(), GET_CODE, ggc_alloc(), HARD_FRAME_POINTER_IS_FRAME_POINTER, HARD_FRAME_POINTER_REGNUM, df_insn_info::insn, NULL, PATTERN(), REG_NOTE_KIND, REG_NOTES, regno_reg_rtx, and XEXP.
Referenced by df_bb_refs_record(), df_insn_refs_verify(), and df_insn_rescan().
◆ df_insn_refs_verify()
|
static |
Return true if the existing insn refs information is complete and correct. Otherwise (i.e. if there's any missing or extra refs), return the correct df_ref chain in REFS_RETURN. If ABORT_IF_FAIL, leave the refs that are verified (already in the ref chain) as DF_REF_MARKED(). If it's false, then it's a per-insn verification mode instead of the whole function, so unmark everything. If ABORT_IF_FAIL is set, this function never returns false.
References DF_INSN_INFO_GET, df_insn_refs_collect(), DF_INSN_UID_DEFS, DF_INSN_UID_EQ_USES, DF_INSN_UID_MWS, DF_INSN_UID_USES, df_mws_verify(), df_refs_verify(), ggc_alloc(), df_insn_info::insn, and INSN_UID().
Referenced by df_bb_verify(), and df_insn_rescan().
◆ df_insn_rescan()
Rescan INSN. Return TRUE if the rescanning produced any changes.
References bitmap_clear_bit(), bitmap_set_bit, BLOCK_FOR_INSN(), df_d::changeable_flags, copy_all, DEBUG_INSN_P, df_insn_info::defs, df, DF_DEFER_INSN_RESCAN, df_free_collection_rec(), df_grow_bb_info(), df_grow_reg_info(), df_insn_create_insn_record(), df_insn_info_free_fields(), df_insn_info_init_fields(), DF_INSN_LUID, df_insn_refs_collect(), df_insn_refs_verify(), DF_INSN_UID_SAFE_GET, DF_NO_INSN_RESCAN, df_refs_add_to_chains(), df_scan, df_set_bb_dirty(), dump_file, df_insn_info::eq_uses, ggc_alloc(), df_insn_info::insn, INSN_P, INSN_UID(), df_d::insns_to_delete, df_d::insns_to_notes_rescan, df_d::insns_to_rescan, df_insn_info::mw_hardregs, NULL, and df_insn_info::uses.
Referenced by add_insn_after(), add_insn_before(), adjust_for_new_dest(), can_move_invariant_reg(), change_loop(), cleanup_subreg_operands(), combine_and_move_insns(), confirm_change_group(), copyprop_hardreg_forward_1(), dead_debug_global_replace_temp(), dead_debug_local_finish(), delete_trivially_dead_insns(), delete_unmarked_insns(), df_insn_change_bb(), df_insn_rescan_all(), df_notes_rescan(), df_process_deferred_rescans(), df_update_entry_exit_and_calls(), emit_insn_after_1(), make_more_copies(), match_asm_constraints_1(), peep2_update_life(), propagate_for_debug(), propagate_for_debug_subst(), remove_insn_scratches(), remove_scratches(), replace_ref(), resolve_clobber(), resolve_debug(), restore_operands(), try_combine(), and update_ld_motion_stores().
◆ df_insn_rescan_all()
Rescan all of the insns in the function. Note that the artificial uses and defs are not touched. This function will destroy def-use or use-def chains.
References bitmap_clear(), bitmap_copy(), cfun, df_d::changeable_flags, df, df_bitmap_obstack, df_clear_flags(), DF_DEFER_INSN_RESCAN, df_insn_info_delete(), df_insn_rescan(), DF_INSN_UID_SAFE_GET, DF_NO_INSN_RESCAN, df_set_flags(), EXECUTE_IF_SET_IN_BITMAP, FOR_BB_INSNS, FOR_EACH_BB_FN, ggc_alloc(), df_insn_info::insn, df_d::insns_to_delete, df_d::insns_to_notes_rescan, and df_d::insns_to_rescan.
Referenced by rest_of_handle_stack_regs().
◆ df_insn_rescan_debug_internal()
Same as df_insn_rescan, but don't mark the basic block as dirty.
References bitmap_clear_bit(), DEBUG_INSN_P, df_insn_info::defs, df, df_chain, DF_INSN_UID_SAFE_GET, df_mw_hardreg_chain_delete(), df_ref_chain_delete(), df_ref_chain_delete_du_chain(), dump_file, df_insn_info::eq_uses, gcc_assert, ggc_alloc(), df_insn_info::insn, INSN_UID(), INSN_VAR_LOCATION_LOC, df_d::insns_to_delete, df_d::insns_to_notes_rescan, df_d::insns_to_rescan, df_insn_info::mw_hardregs, df_insn_info::uses, and VAR_LOC_UNKNOWN_P.
Referenced by dead_debug_reset_uses(), df_note_bb_compute(), reload(), and reset_unmarked_insns_debug_uses().
◆ df_install_mws()
|
static |
This function takes the mws installs the entire group into the insn.
References count, DF_MWS_NEXT, ggc_alloc(), and i.
Referenced by df_refs_add_to_chains().
◆ df_install_ref()
|
static |
Add the new df_ref to appropriate reg_info/ref_info chains.
References df, df_check_and_grow_ref_info(), DF_HARD_REG_LIVE, DF_REF_FLAGS_IS_SET, DF_REF_ID, DF_REF_NEXT_REG, DF_REF_ORDER_NO_TABLE, DF_REF_PREV_REG, DF_REF_REGNO, gcc_assert, gcc_checking_assert, ggc_alloc(), df_d::hard_regs_live_count, and NULL.
Referenced by df_install_ref_incremental(), and df_install_refs().
◆ df_install_ref_incremental()
References df_d::analyze_subset, bitmap_bit_p, BLOCK_FOR_INSN(), df_d::blocks_to_analyze, DEBUG_INSN_P, df_d::def_info, df_d::def_regs, df, DF_INSN_DEFS, DF_INSN_EQ_USES, DF_INSN_USES, df_install_ref(), df_ref_compare(), df_ref_debug(), DF_REF_FLAGS, DF_REF_IN_NOTE, DF_REF_INSN, DF_REF_NEXT_LOC, DF_REF_ORDER_BY_INSN_WITH_NOTES, DF_REF_ORDER_BY_REG_WITH_NOTES, DF_REF_ORDER_NO_TABLE, DF_REF_ORDER_UNORDERED, DF_REF_ORDER_UNORDERED_WITH_NOTES, DF_REF_REG_DEF_P, DF_REF_REGNO, df_set_bb_dirty(), dump_file, df_d::eq_use_regs, ggc_alloc(), basic_block_def::index, df_d::use_info, and df_d::use_regs.
Referenced by df_ref_create_structure().
◆ df_install_refs()
|
static |
This function takes one of the groups of refs (defs, uses or eq_uses) and installs the entire group into the insn. It also adds each of these refs into the appropriate chains.
References df_d::analyze_subset, bitmap_bit_p, df_d::blocks_to_analyze, count, df, df_install_ref(), DF_REF_NEXT_LOC, DF_REF_ORDER_BY_INSN, DF_REF_ORDER_BY_INSN_WITH_NOTES, DF_REF_ORDER_BY_REG, DF_REF_ORDER_BY_REG_WITH_NOTES, DF_REF_ORDER_UNORDERED, DF_REF_ORDER_UNORDERED_WITH_NOTES, DF_REF_REGNO, FOR_EACH_VEC_ELT, ggc_alloc(), basic_block_def::index, and NULL.
Referenced by df_refs_add_to_chains().
◆ df_mark_reg()
Mark a register in SET. Hard registers in large modes get all of their component registers set as well.
References bitmap_set_range(), REG_NREGS, and REGNO.
Referenced by df_get_exit_block_use_set().
◆ df_maybe_reorganize_def_refs()
| void df_maybe_reorganize_def_refs | ( | enum df_ref_order | order | ) |
If the def refs in DF are not organized, reorganize them.
References df_d::def_info, df, DF_REF_ORDER_BY_INSN, DF_REF_ORDER_BY_INSN_WITH_NOTES, DF_REF_ORDER_BY_REG, DF_REF_ORDER_BY_REG_WITH_NOTES, DF_REF_ORDER_NO_TABLE, DF_REF_ORDER_UNORDERED, DF_REF_ORDER_UNORDERED_WITH_NOTES, df_reorganize_refs_by_insn(), df_reorganize_refs_by_reg(), free(), gcc_unreachable, NULL, df_ref_info::ref_order, df_ref_info::refs, and df_ref_info::refs_size.
Referenced by df_finish_pass(), df_rd_local_compute(), and df_set_blocks().
◆ df_maybe_reorganize_use_refs()
| void df_maybe_reorganize_use_refs | ( | enum df_ref_order | order | ) |
If the use refs in DF are not organized, reorganize them.
References df, DF_REF_ORDER_BY_INSN, DF_REF_ORDER_BY_INSN_WITH_NOTES, DF_REF_ORDER_BY_REG, DF_REF_ORDER_BY_REG_WITH_NOTES, DF_REF_ORDER_NO_TABLE, DF_REF_ORDER_UNORDERED, DF_REF_ORDER_UNORDERED_WITH_NOTES, df_reorganize_refs_by_insn(), df_reorganize_refs_by_reg(), free(), gcc_unreachable, NULL, df_ref_info::ref_order, df_ref_info::refs, df_ref_info::refs_size, and df_d::use_info.
Referenced by df_finish_pass(), and df_set_blocks().
◆ df_mw_compare()
|
static |
Compare MW1 and MW2 for sorting.
References ggc_alloc().
Referenced by df_mw_ptr_compare(), df_notes_rescan(), and df_sort_and_compress_mws().
◆ df_mw_equal_p()
|
static |
Return true if the contents of two df_ref's are identical. It ignores DF_REF_MARKER.
References ggc_alloc().
Referenced by df_mws_verify(), and df_sort_and_compress_mws().
◆ df_mw_hardreg_chain_delete()
|
static |
Delete the hardreg chain.
References DF_MWS_NEXT, df_scan, ggc_alloc(), df_scan_problem_data::mw_reg_pool, and object_allocator< T >::remove().
Referenced by df_insn_info_free_fields(), and df_insn_rescan_debug_internal().
◆ df_mw_hardreg_chain_delete_eq_uses()
|
static |
Delete the mw_hardregs that point into the eq_notes.
References DF_MWS_NEXT, DF_REF_IN_NOTE, df_scan, ggc_alloc(), df_insn_info::mw_hardregs, df_scan_problem_data::mw_reg_pool, and object_allocator< T >::remove().
Referenced by df_notes_rescan().
◆ df_mw_ptr_compare()
Like df_mw_compare, but compare two df_mw_hardreg** pointers R1 and R2.
References df_mw_compare().
Referenced by df_sort_and_compress_mws().
◆ df_mws_verify()
|
static |
Verify that NEW_REC and OLD_REC have exactly the same members.
References df_mw_equal_p(), DF_MWS_NEXT, FOR_EACH_VEC_ELT, gcc_assert, ggc_alloc(), and NULL.
Referenced by df_insn_refs_verify().
◆ df_notes_rescan()
Rescan only the REG_EQUIV/REG_EQUAL notes part of INSN.
References bitmap_bit_p, bitmap_clear_bit(), bitmap_set_bit, BLOCK_FOR_INSN(), df_d::changeable_flags, copy_eq_uses, df_insn_info::defs, df, df_canonize_collection_rec(), DF_DEFER_INSN_RESCAN, df_grow_bb_info(), df_grow_reg_info(), df_insn_create_insn_record(), df_insn_rescan(), DF_INSN_UID_SAFE_GET, df_mw_compare(), df_mw_hardreg_chain_delete_eq_uses(), DF_MWS_NEXT, DF_NO_INSN_RESCAN, df_ref_chain_delete(), DF_REF_IN_NOTE, DF_REF_REG_USE, df_refs_add_to_chains(), df_scan, df_uses_record(), df_insn_info::eq_uses, FOR_EACH_VEC_ELT, ggc_alloc(), i, df_insn_info::insn, INSN_UID(), df_d::insns_to_delete, df_d::insns_to_notes_rescan, df_d::insns_to_rescan, df_insn_info::mw_hardregs, NULL, REG_NOTE_KIND, REG_NOTES, df_insn_info::uses, and XEXP.
Referenced by add_store_equivs(), canonicalize_insn(), change_loop(), cse_extended_basic_block(), cse_insn(), df_process_deferred_rescans(), df_remove_dead_eq_notes(), remove_note(), remove_reg_equal_equiv_notes(), resolve_reg_notes(), and set_unique_reg_note().
◆ df_process_deferred_rescans()
Process all of the deferred rescans or deletions.
References bitmap_clear(), bitmap_copy(), df_d::changeable_flags, df, df_bitmap_obstack, df_clear_flags(), DF_DEFER_INSN_RESCAN, df_insn_info_delete(), df_insn_rescan(), DF_INSN_UID_SAFE_GET, DF_NO_INSN_RESCAN, df_notes_rescan(), df_set_flags(), df_update_entry_exit_and_calls(), dump_file, EXECUTE_IF_SET_IN_BITMAP, ggc_alloc(), df_insn_info::insn, df_d::insns_to_delete, df_d::insns_to_notes_rescan, df_d::insns_to_rescan, and df_d::redo_entry_and_exit.
Referenced by df_analyze_1(), df_finish_pass(), iv_analysis_loop_init(), and move_invariants().
◆ df_recompute_luids()
| void df_recompute_luids | ( | basic_block | bb | ) |
Recompute the luids for the insns in BB.
References df_grow_insn_info(), df_insn_create_insn_record(), DF_INSN_INFO_GET, DF_INSN_INFO_LUID, FOR_BB_INSNS, gcc_assert, df_insn_info::insn, INSN_P, and df_insn_info::luid.
Referenced by attempt_change(), df_lr_bb_local_compute(), merge_in_block(), and move_invariant_reg().
◆ df_record_entry_block_defs()
Record the (conservative) set of hard registers that are defined on entry to the function.
References BASIC_BLOCK_FOR_FN, cfun, copy_defs, df_entry_block_defs_collect(), df_refs_add_to_chains(), ENTRY_BLOCK, ggc_alloc(), and NULL.
Referenced by df_scan_blocks(), and df_update_entry_block_defs().
◆ df_record_exit_block_uses()
Record the set of hard registers that are used in the exit block. It uses df->exit_block_uses to determine which bit to include.
References BASIC_BLOCK_FOR_FN, cfun, copy_uses, df_exit_block_uses_collect(), df_refs_add_to_chains(), EXIT_BLOCK, ggc_alloc(), and NULL.
Referenced by df_scan_blocks(), and df_update_exit_block_uses().
◆ df_ref_chain_delete()
Delete all refs in the ref chain.
References DF_REF_NEXT_LOC, and df_reg_chain_unlink().
Referenced by df_insn_info_free_fields(), df_insn_rescan_debug_internal(), df_notes_rescan(), df_scan_free_bb_info(), df_update_entry_block_defs(), and df_update_exit_block_uses().
◆ df_ref_chain_delete_du_chain()
Delete all du chain (DF_REF_CHAIN()) of all refs in the ref chain.
References df_chain_unlink(), DF_REF_CHAIN, and DF_REF_NEXT_LOC.
Referenced by df_insn_info_free_fields(), df_insn_rescan_debug_internal(), df_scan_free_bb_info(), df_update_entry_block_defs(), and df_update_exit_block_uses().
◆ df_ref_change_reg_with_loc()
Change the regno of register LOC to NEW_REGNO and update the df information accordingly. Refs that do not match LOC are not changed which means that artificial refs are not changed since they have no loc. This call is to support the SET_REGNO macro.
References df, df_grow_reg_info(), df_ref_change_reg_with_loc_1(), DF_REG_DEF_GET, DF_REG_EQ_USE_GET, DF_REG_USE_GET, GET_MODE, ggc_alloc(), REGNO, and set_mode_and_regno().
◆ df_ref_change_reg_with_loc_1()
|
static |
Helper function for df_ref_change_reg_with_loc.
References df_insn_info::defs, DF_REF_BB, df_ref_compare(), DF_REF_FLAGS, DF_REF_IN_NOTE, DF_REF_INSN_INFO, DF_REF_INSN_UID, DF_REF_IS_ARTIFICIAL, DF_REF_LOC, DF_REF_NEXT_LOC, DF_REF_NEXT_REG, DF_REF_PREV_REG, DF_REF_REG, DF_REF_REG_DEF_P, DF_REF_REGNO, df_set_bb_dirty(), dump_file, df_insn_info::eq_uses, ggc_alloc(), NULL, regno_reg_rtx, and df_insn_info::uses.
Referenced by df_ref_change_reg_with_loc().
◆ df_ref_compare()
Compare REF1 and REF2 for sorting. This is only called from places where all of the refs are of the same type, in the same insn, and have the same bb. So these fields are not checked.
References DF_REF_ARTIFICIAL, DF_REF_CLASS, DF_REF_FLAGS, DF_REF_FLAGS_IS_SET, DF_REF_LOC, DF_REF_MW_HARDREG, DF_REF_ORDER, DF_REF_REG, DF_REF_REGNO, DF_REF_TYPE, and ggc_alloc().
Referenced by df_install_ref_incremental(), df_ref_change_reg_with_loc_1(), df_ref_ptr_compare(), and df_sort_and_compress_refs().
◆ df_ref_create_structure()
|
static |
Allocate a ref and initialize its fields.
References object_allocator< T >::allocate(), DEBUG_INSN_P, df, DF_HARD_REG_LIVE, df_install_ref_incremental(), DF_REF_ARTIFICIAL, DF_REF_BASE, DF_REF_CHAIN, DF_REF_CLASS, DF_REF_FLAGS, DF_REF_FLAGS_CLEAR, DF_REF_FLAGS_IS_SET, DF_REF_FLAGS_SET, DF_REF_ID, DF_REF_IN_NOTE, DF_REF_INSN_INFO, DF_REF_MAY_CLOBBER, DF_REF_NEXT_REG, DF_REF_ORDER, DF_REF_PREV_REG, DF_REF_REG, DF_REF_REG_DEF, DF_REF_REG_DEF_P, DF_REF_REGNO, DF_REF_REGULAR, DF_REF_TYPE, df_scan, elim_reg_set, gcc_checking_assert, gcc_unreachable, GET_CODE, ggc_alloc(), df_insn_info::insn, NULL, df_scan_problem_data::ref_artificial_pool, df_scan_problem_data::ref_base_pool, df_d::ref_order, df_scan_problem_data::ref_regular_pool, REGNO, SUBREG_REG, and TEST_HARD_REG_BIT.
Referenced by df_get_conditional_uses(), and df_ref_record().
◆ df_ref_equal_p()
Return true if the contents of two df_ref's are identical. It ignores DF_REF_MARKER.
References DF_REF_ARTIFICIAL, DF_REF_BASE, DF_REF_BB, DF_REF_CLASS, DF_REF_FLAGS, DF_REF_INSN_INFO, DF_REF_LOC, DF_REF_MW_HARDREG, DF_REF_REG, DF_REF_REG_MARKER, DF_REF_REGNO, DF_REF_REGULAR, DF_REF_TYPE, gcc_unreachable, and ggc_alloc().
Referenced by df_refs_verify(), and df_sort_and_compress_refs().
◆ df_ref_ptr_compare()
Like df_ref_compare, but compare two df_ref* pointers R1 and R2.
References df_ref_compare(), and ggc_alloc().
Referenced by df_sort_and_compress_refs().
◆ df_ref_record()
|
static |
Create new references of type DF_REF_TYPE for each part of register REG at address LOC within INSN of BB.
References object_allocator< T >::allocate(), df, df_ref_create_structure(), DF_REF_MW_HARDREG, DF_REF_PARTIAL, DF_REF_REG, df_scan, END_REGNO(), gcc_assert, gcc_checking_assert, GET_CODE, GET_MODE, ggc_alloc(), i, df_scan_problem_data::mw_reg_pool, NULL, ORIGINAL_REGNO, df_d::ref_order, REG_P, REGNO, regno_reg_rtx, SUBREG_BYTE, subreg_nregs(), SUBREG_REG, and subreg_regno_offset().
Referenced by df_bb_refs_collect(), df_def_record_1(), df_entry_block_defs_collect(), df_exit_block_uses_collect(), df_get_call_refs(), df_insn_refs_collect(), and df_uses_record().
◆ df_refs_add_to_chains()
|
static |
Add a chain of df_refs to appropriate ref chain/reg_info/ref_info chains and update other necessary information.
References copy_defs, copy_eq_uses, copy_mw, copy_uses, df_d::def_info, df_d::def_regs, df, DF_INSN_INFO_GET, df_install_mws(), df_install_refs(), df_scan_get_bb_info(), df_d::eq_use_regs, gcc_checking_assert, ggc_alloc(), basic_block_def::index, df_insn_info::insn, df_d::use_info, and df_d::use_regs.
Referenced by df_bb_refs_record(), df_insn_rescan(), df_notes_rescan(), df_record_entry_block_defs(), and df_record_exit_block_uses().
◆ df_refs_verify()
|
static |
Verify that NEW_REC and OLD_REC have exactly the same members.
References df_ref_equal_p(), DF_REF_IS_REG_MARKED, DF_REF_NEXT_LOC, DF_REF_REG_UNMARK, FOR_EACH_VEC_ELT, gcc_assert, ggc_alloc(), and NULL.
Referenced by df_bb_verify(), and df_insn_refs_verify().
◆ df_reg_chain_mark()
|
static |
Mark all refs in the reg chain. Verify that all of the registers are in the correct chain.
References count, df_chain, DF_REF_CHAIN, DF_REF_FLAGS, DF_REF_IN_NOTE, DF_REF_IS_REG_MARKED, DF_REF_NEXT_REG, DF_REF_PREV_REG, DF_REF_REG_DEF_P, DF_REF_REG_MARK, DF_REF_REGNO, gcc_assert, ggc_alloc(), and refs.
Referenced by df_scan_verify().
◆ df_reg_chain_unlink()
Unlink and delete REF at the reg_use, reg_eq_use or reg_def chain. Also delete the def-use or use-def chain if it exists.
References df_d::analyze_subset, bitmap_bit_p, df_d::blocks_to_analyze, df_d::def_info, df, df_chain, df_chain_unlink(), df_free_ref(), DF_HARD_REG_LIVE, DF_REF_BBNO, DF_REF_CHAIN, DF_REF_FLAGS, DF_REF_FLAGS_IS_SET, DF_REF_ID, DF_REF_IN_NOTE, DF_REF_NEXT_REG, DF_REF_ORDER_BY_INSN_WITH_NOTES, DF_REF_ORDER_BY_REG_WITH_NOTES, DF_REF_ORDER_UNORDERED_WITH_NOTES, DF_REF_PREV_REG, DF_REF_REG_DEF_P, DF_REF_REGNO, DF_REG_DEF_GET, DF_REG_EQ_USE_GET, DF_REG_USE_GET, gcc_assert, ggc_alloc(), df_d::hard_regs_live_count, NULL, df_ref_info::ref_order, df_ref_info::refs, refs, and df_d::use_info.
Referenced by df_ref_chain_delete().
◆ df_reg_chain_verify_unmarked()
Verify that all of the registers in the chain are unmarked.
References DF_REF_IS_REG_MARKED, DF_REF_NEXT_REG, gcc_assert, and refs.
Referenced by df_scan_verify().
◆ df_regs_ever_live_p()
Get the value of regs_ever_live[REGNO].
References regs_ever_live.
Referenced by check_new_reg_p(), df_get_entry_block_def_set(), df_get_exit_block_use_set(), df_scan_start_dump(), do_reload(), find_hard_regno_for_1(), finish_spills(), gen_call_used_regs_seq(), lra_constraints(), peep2_find_free_register(), reload_combine_recognize_pattern(), and requires_stack_frame_p().
◆ df_reorganize_refs_by_insn()
|
static |
Organize the refs by insn into the table in REF_INFO. If blocks_to_analyze is defined, use that set, otherwise the entire program. Include the defs if INCLUDE_DEFS. Include the uses if INCLUDE_USES. Include the eq_uses if INCLUDE_EQ_USES.
References BASIC_BLOCK_FOR_FN, df_d::blocks_to_analyze, cfun, df, df_check_and_grow_ref_info(), df_count_refs(), df_reorganize_refs_by_insn_bb(), EXECUTE_IF_SET_IN_BITMAP, FOR_ALL_BB_FN, ggc_alloc(), and offset.
Referenced by df_maybe_reorganize_def_refs(), and df_maybe_reorganize_use_refs().
◆ df_reorganize_refs_by_insn_bb()
|
static |
Count the number of refs in all of the insns of BB. Include the defs if INCLUDE_DEFS. Include the uses if INCLUDE_USES. Include the eq_uses if INCLUDE_EQ_USES.
References df_add_refs_to_table(), df_get_artificial_defs(), df_get_artificial_uses(), DF_INSN_UID_DEFS, DF_INSN_UID_EQ_USES, DF_INSN_UID_USES, FOR_BB_INSNS, ggc_alloc(), basic_block_def::index, df_insn_info::insn, INSN_P, INSN_UID(), and offset.
Referenced by df_reorganize_refs_by_insn().
◆ df_reorganize_refs_by_reg()
|
static |
Take build ref table for either the uses or defs from the reg-use or reg-def chains.
References df_d::analyze_subset, df, df_reorganize_refs_by_reg_by_insn(), df_reorganize_refs_by_reg_by_reg(), and ggc_alloc().
Referenced by df_maybe_reorganize_def_refs(), and df_maybe_reorganize_use_refs().
◆ df_reorganize_refs_by_reg_by_insn()
|
static |
Take build ref table for either the uses or defs from the reg-use or reg-def chains. This version processes the refs in insn order which is likely to be best if processing some segment of the function.
References BASIC_BLOCK_FOR_FN, df_d::blocks_to_analyze, cfun, df_d::changeable_flags, df, df_check_and_grow_ref_info(), df_count_refs(), DF_INSN_INFO_GET, DF_NO_HARD_REGS, DF_REF_ID, DF_REF_REGNO, EXECUTE_IF_SET_IN_BITMAP, FOR_BB_INSNS, FOR_EACH_ARTIFICIAL_DEF, FOR_EACH_ARTIFICIAL_USE, FOR_EACH_INSN_INFO_DEF, FOR_EACH_INSN_INFO_EQ_USE, FOR_EACH_INSN_INFO_USE, ggc_alloc(), df_insn_info::insn, INSN_P, offset, r, and df_d::regs_inited.
Referenced by df_reorganize_refs_by_reg().
◆ df_reorganize_refs_by_reg_by_reg()
|
static |
Take build ref table for either the uses or defs from the reg-use or reg-def chains. This version processes the refs in reg order which is likely to be best if processing the whole function.
References df_d::changeable_flags, count, df, df_check_and_grow_ref_info(), df_count_refs(), DF_NO_HARD_REGS, DF_REF_ID, DF_REF_NEXT_REG, DF_REG_DEF_CHAIN, DF_REG_EQ_USE_CHAIN, DF_REG_USE_CHAIN, gcc_checking_assert, ggc_alloc(), offset, and df_d::regs_inited.
Referenced by df_reorganize_refs_by_reg().
◆ df_scan_add_problem()
Create a new DATAFLOW instance and add it to an existing instance of DF. The returned structure is what is used to get at the solution.
References df_add_problem(), and problem_SCAN.
Referenced by rest_of_handle_df_initialize().
◆ df_scan_alloc()
Allocate the problem data for the scanning problem. This should be called when the problem is created or when the entire function is to be rescanned.
References BITMAP_ALLOC, bitmap_initialize(), bitmap_obstack_initialize(), cfun, df, df_grow_bb_info(), df_grow_insn_info(), df_grow_reg_info(), df_scan, df_scan_free_internal(), df_scan_get_bb_info(), df_d::eh_block_artificial_uses, df_d::entry_block_defs, df_d::exit_block_uses, FOR_ALL_BB_FN, ggc_alloc(), df_d::hardware_regs_used, basic_block_def::index, df_scan_problem_data::insn_bitmaps, df_scan_problem_data::insn_pool, df_d::insns_to_delete, df_d::insns_to_notes_rescan, df_d::insns_to_rescan, df_scan_problem_data::mw_reg_pool, NULL, df_scan_problem_data::ref_artificial_pool, df_scan_problem_data::ref_base_pool, df_scan_problem_data::ref_regular_pool, df_scan_problem_data::reg_bitmaps, df_scan_problem_data::reg_pool, and df_d::regular_block_artificial_uses.
Referenced by do_reload(), and rest_of_handle_df_initialize().
◆ df_scan_blocks()
Rescan all of the block_to_analyze or all of the blocks in the function if df_set_blocks if blocks_to_analyze is NULL;
References BASIC_BLOCK_FOR_FN, bitmap_ior_into(), cfun, df_d::def_info, df, df_bb_refs_record(), df_get_eh_block_artificial_uses(), df_get_entry_block_def_set(), df_get_exit_block_use_set(), df_get_regular_block_artificial_uses(), df_record_entry_block_defs(), df_record_exit_block_uses(), DF_REF_ORDER_NO_TABLE, df_set_bb_dirty(), df_d::eh_block_artificial_uses, ENTRY_BLOCK, df_d::entry_block_defs, EXIT_BLOCK, df_d::exit_block_uses, FOR_EACH_BB_FN, basic_block_def::index, df_ref_info::ref_order, df_d::regular_block_artificial_uses, and df_d::use_info.
Referenced by do_reload(), and rest_of_handle_df_initialize().
◆ df_scan_free()
Free all of the data associated with the scan problem.
References BITMAP_FREE, df_d::blocks_to_analyze, df, df_scan, df_scan_free_internal(), free(), and NULL.
◆ df_scan_free_bb_info()
|
static |
Free basic block info.
References df_insn_info_delete(), df_ref_chain_delete(), df_ref_chain_delete_du_chain(), df_scan_get_bb_info(), FOR_BB_INSNS, ggc_alloc(), basic_block_def::index, INSN_P, INSN_UID(), and NULL.
◆ df_scan_free_internal()
Internal function to shut down the scanning problem.
References df_ref_info::begin, bitmap_clear(), BITMAP_FREE, bitmap_obstack_release(), df_ref_info::count, df_d::def_info, df_d::def_regs, df, DF_INSN_SIZE, DF_REG_SIZE, df_scan, df_d::eh_block_artificial_uses, df_d::entry_block_defs, df_d::eq_use_regs, df_d::exit_block_uses, free(), ggc_alloc(), df_d::hardware_regs_used, df_scan_problem_data::insn_bitmaps, df_scan_problem_data::insn_pool, df_d::insns, df_d::insns_to_delete, df_d::insns_to_notes_rescan, df_d::insns_to_rescan, df_scan_problem_data::mw_reg_pool, NULL, df_scan_problem_data::ref_artificial_pool, df_scan_problem_data::ref_base_pool, df_scan_problem_data::ref_regular_pool, df_ref_info::refs, df_scan_problem_data::reg_bitmaps, df_scan_problem_data::reg_pool, df_d::regs_size, df_d::regular_block_artificial_uses, df_d::use_info, and df_d::use_regs.
Referenced by df_scan_alloc(), and df_scan_free().
◆ df_scan_start_block()
|
static |
Dump the bb_info for a given basic block.
References df_insn_debug(), df_refs_chain_dump(), df_scan_get_bb_info(), FOR_BB_INSNS, ggc_alloc(), basic_block_def::index, and INSN_P.
◆ df_scan_start_dump()
Dump the preamble for DF_SCAN dump.
References CALL_P, cfun, df, df_print_regset(), DF_REG_DEF_COUNT, DF_REG_EQ_USE_COUNT, DF_REG_USE_COUNT, df_regs_ever_live_p(), df_d::eh_block_artificial_uses, eh_edge_abi, df_d::entry_block_defs, df_d::exit_block_uses, FOR_BB_INSNS, FOR_EACH_BB_FN, ggc_alloc(), df_d::hardware_regs_used, i, INSN_P, reg_names, df_d::regs_inited, and df_d::regular_block_artificial_uses.
◆ df_scan_verify()
Return true if df_ref information for all insns in all blocks are correct and complete.
References bitmap_equal_p(), bitmap_ior_into(), cfun, df, df_bb_verify(), df_bitmap_obstack, df_entry_block_bitmap_verify(), df_exit_block_bitmap_verify(), df_get_eh_block_artificial_uses(), df_get_regular_block_artificial_uses(), df_reg_chain_mark(), df_reg_chain_verify_unmarked(), DF_REG_DEF_CHAIN, DF_REG_DEF_COUNT, DF_REG_EQ_USE_CHAIN, DF_REG_EQ_USE_COUNT, DF_REG_SIZE, DF_REG_USE_CHAIN, DF_REG_USE_COUNT, df_d::eh_block_artificial_uses, FOR_ALL_BB_FN, gcc_assert, i, and df_d::regular_block_artificial_uses.
Referenced by df_verify().
◆ df_set_regs_ever_live()
Set regs_ever_live[REGNO] to VALUE. If this cause regs_ever_live to change, schedule that change for the next update.
References df, df_d::redo_entry_and_exit, and regs_ever_live.
Referenced by assign_hard_regno(), assign_spill_hard_regs(), finish_spills(), ira_setup_eliminable_regset(), lra(), lra_constraints(), mark_home_live_1(), reload(), rename_chains(), spill_hard_reg(), and update_equiv_regs_prescan().
◆ df_sort_and_compress_mws()
|
static |
Sort and compress a set of refs.
References count, df_mw_compare(), df_mw_equal_p(), df_mw_ptr_compare(), df_scan, ggc_alloc(), i, df_scan_problem_data::mw_reg_pool, and object_allocator< T >::remove().
Referenced by df_canonize_collection_rec().
◆ df_sort_and_compress_refs()
Sort and compress a set of refs.
References count, df_free_ref(), df_ref_compare(), df_ref_equal_p(), df_ref_ptr_compare(), ggc_alloc(), and i.
Referenced by df_canonize_collection_rec().
◆ df_update_entry_block_defs()
Update the defs in the entry block.
References BASIC_BLOCK_FOR_FN, bitmap_copy(), bitmap_equal_p(), cfun, changed, df, df_bitmap_obstack, df_get_entry_block_def_set(), df_record_entry_block_defs(), df_ref_chain_delete(), df_ref_chain_delete_du_chain(), df_scan_get_bb_info(), df_set_bb_dirty(), ENTRY_BLOCK, df_d::entry_block_defs, gcc_assert, ggc_alloc(), NULL, and refs.
Referenced by df_update_entry_exit_and_calls(), and thread_prologue_and_epilogue_insns().
◆ df_update_entry_exit_and_calls()
Recompute the parts of scanning that are based on regs_ever_live because something changed in that array.
References CALL_P, cfun, df_insn_rescan(), df_update_entry_block_defs(), df_update_exit_block_uses(), FOR_BB_INSNS, FOR_EACH_BB_FN, and INSN_P.
Referenced by df_compute_regs_ever_live(), df_process_deferred_rescans(), thread_prologue_and_epilogue_insns(), and try_shrink_wrapping_separate().
◆ df_update_exit_block_uses()
Update the uses in the exit block.
References BASIC_BLOCK_FOR_FN, bitmap_copy(), bitmap_equal_p(), cfun, changed, df, df_bitmap_obstack, df_get_exit_block_use_set(), df_record_exit_block_uses(), df_ref_chain_delete(), df_ref_chain_delete_du_chain(), df_scan_get_bb_info(), df_set_bb_dirty(), EXIT_BLOCK, df_d::exit_block_uses, gcc_assert, ggc_alloc(), NULL, and refs.
Referenced by df_update_entry_exit_and_calls(), gen_call_used_regs_seq(), and thread_prologue_and_epilogue_insns().
◆ df_uses_create()
Create new refs under address LOC within INSN. This function is only used externally. REF_FLAGS must be either 0 or DF_REF_IN_NOTE, depending on whether LOC is inside PATTERN (INSN) or a note.
References BLOCK_FOR_INSN(), DF_INSN_INFO_GET, DF_REF_IN_NOTE, DF_REF_REG_USE, df_uses_record(), gcc_assert, ggc_alloc(), and NULL.
◆ df_uses_record()
|
static |
Process all the registers used in the rtx at address LOC.
References ASM_OPERANDS_INPUT, ASM_OPERANDS_INPUT_LENGTH, CASE_CONST_ANY, DEBUG_INSN_P, DF_REF_IN_NOTE, DF_REF_PARTIAL, DF_REF_PRE_POST_MODIFY, DF_REF_READ_WRITE, df_ref_record(), DF_REF_REG_DEF, DF_REF_REG_MEM_LOAD, DF_REF_REG_MEM_STORE, DF_REF_REG_USE, DF_REF_REGULAR, DF_REF_SIGN_EXTRACT, DF_REF_STRICT_LOW_PART, DF_REF_SUBREG, DF_REF_ZERO_EXTRACT, df_uses_record(), gcc_assert, gcc_unreachable, GET_CODE, GET_RTX_FORMAT, GET_RTX_LENGTH, ggc_alloc(), i, df_insn_info::insn, MEM_P, PAT_VAR_LOCATION_LOC, read_modify_subreg_p(), REG_P, RTX_CODE, SET, SET_DEST, SET_SRC, SUBREG_REG, XEXP, XVECEXP, and XVECLEN.
Referenced by df_get_call_refs(), df_insn_refs_collect(), df_notes_rescan(), df_uses_create(), and df_uses_record().
Variable Documentation
◆ copy_all
Referenced by df_bb_refs_record(), and df_insn_rescan().
◆ copy_defs
Flags used to tell df_refs_add_to_chains() which vectors it should copy.
Referenced by df_record_entry_block_defs(), and df_refs_add_to_chains().
◆ copy_eq_uses
Referenced by df_notes_rescan(), and df_refs_add_to_chains().
◆ copy_mw
Referenced by df_refs_add_to_chains().
◆ copy_uses
Referenced by df_record_exit_block_uses(), and df_refs_add_to_chains().
◆ elim_reg_set
|
static |
Scanning of rtl for dataflow analysis.
Copyright (C) 1999-2024 Free Software Foundation, Inc.
Originally contributed by Michael P. Hayes
(m.hayes@elec.canterbury.ac.nz, mhayes@redhat.com)
Major rewrite contributed by Danny Berlin (dberlin@dberlin.org)
and Kenneth Zadeck (zadeck@naturalbridge.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/>. The set of hard registers in eliminables[i].from.
Referenced by df_hard_reg_init(), and df_ref_create_structure().
◆ initialized
Referenced by df_hard_reg_init().
◆ problem_SCAN
|
static |
Referenced by df_scan_add_problem().
◆ regs_ever_live
|
static |
Indexed by hardware reg number, is true if that register is ever used in the current function. In df-scan.cc, this is set up to record the hard regs used explicitly. Reload adds in the hard regs used for holding pseudo regs. Final uses it to generate the code in the function prologue and epilogue to save and restore registers as needed.
Referenced by df_compute_regs_ever_live(), df_regs_ever_live_p(), and df_set_regs_ever_live().
