#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 "emit-rtl.h"#include "recog.h"#include "cfgrtl.h"#include "profile.h"#include "expr.h"#include "tree-pass.h"#include "dbgcnt.h"#include "intl.h"#include "gcse-common.h"#include "gcse.h"#include "regs.h"#include "function-abi.h"
Data Structures | |
| struct | expr |
| struct | expr_hasher |
| struct | occr |
| struct | unoccr |
| struct | modifies_mem |
Macros | |
| #define | INSN_CUID(INSN) |
Variables | ||
| struct { | ||
| int moves_inserted | ||
| int copies_inserted | ||
| int insns_deleted | ||
| } | stats | |
| static hash_table< expr_hasher > * | expr_table | |
| static struct obstack | expr_obstack | |
| static struct obstack | occr_obstack | |
| static struct obstack | unoccr_obstack | |
| static int * | reg_avail_info | |
| static struct modifies_mem * | modifies_mem_list | |
| static struct obstack | modifies_mem_obstack | |
| static struct modifies_mem * | modifies_mem_obstack_bottom | |
| static int * | uid_cuid | |
| static bitmap | modify_mem_list_set | |
| static bitmap | blocks_with_calls | |
| static vec< rtx_insn * > * | modify_mem_list | |
| static vec< modify_pair > * | canon_modify_mem_list | |
| static sbitmap * | transp | |
| static int | mems_conflict_p | |
Macro Definition Documentation
◆ INSN_CUID
| #define INSN_CUID | ( | INSN | ) |
Referenced by hash_scan_set(), load_killed_in_block_p(), oprs_unchanged_p(), record_last_reg_set_info(), and record_last_reg_set_info_regno().
Function Documentation
◆ alloc_mem()
|
static |
Helpers for memory allocation/freeing.
Allocate memory for the CUID mapping array and register/memory tracking tables.
References BITMAP_ALLOC, blocks_with_calls, canon_modify_mem_list, cfun, expr_obstack, expr_table, FOR_BB_INSNS, FOR_EACH_BB_FN, gcc_obstack_init, get_max_uid(), i, occr::insn, INSN_P, INSN_UID(), last_basic_block_for_fn, MAX, modifies_mem_obstack, modifies_mem_obstack_bottom, modify_mem_list, modify_mem_list_set, NULL, occr_obstack, uid_cuid, and unoccr_obstack.
Referenced by gcse_after_reload_main().
◆ bb_has_well_behaved_predecessors()
|
static |
Return true if the predecessors of BB are "well behaved".
References BB_END, cfun, EDGE_COUNT, FOR_EACH_EDGE, NULL, basic_block_def::preds, single_pred_p(), and tablejump_p().
Referenced by eliminate_partially_redundant_loads().
◆ compute_expr_transp()
| int compute_expr_transp | ( | expr ** | slot, |
| FILE * | dump_file ) |
This helper is called via htab_traverse.
References expr::bitmap_index, blocks_with_calls, canon_modify_mem_list, compute_transp(), expr::expr, modify_mem_list_set, and transp.
Referenced by gcse_after_reload_main().
◆ compute_hash_table()
|
static |
Create hash table of memory expressions available at end of basic blocks. Basically you should think of this hash table as the representation of AVAIL_OUT. This is the set of expressions that is generated in a basic block and not killed before the end of the same basic block. Notice that this is really a local computation.
References cfun, FOR_BB_INSNS, FOR_EACH_BB_FN, GET_CODE, hash_scan_set(), modifies_mem::insn, INSN_P, PATTERN(), record_opr_changes(), reset_opr_set_tables(), and SET.
Referenced by gcse_after_reload_main(), one_code_hoisting_pass(), one_cprop_pass(), and one_pre_gcse_pass().
◆ delete_redundant_insns()
|
static |
References delete_redundant_insns_1(), dump_file, expr_table, and NULL.
Referenced by gcse_after_reload_main().
◆ delete_redundant_insns_1()
| int delete_redundant_insns_1 | ( | expr ** | slot, |
| void * | data ) |
Go over the expression hash table and delete insns that were marked for later deletion.
This helper is called via htab_traverse.
References dbg_cnt(), delete_insn(), occr::deleted_p, dump_file, exprs, occr::insn, occr::next, NULL, and print_rtl_single().
Referenced by delete_redundant_insns().
◆ dump_expr_hash_table_entry()
| int dump_expr_hash_table_entry | ( | expr ** | slot, |
| FILE * | file ) |
Dump all expressions and occurrences that are currently in the expression hash table to FILE.
This helper is called via htab_traverse.
References exprs, occr::insn, occr::next, print_rtl(), and print_rtl_single().
Referenced by dump_hash_table().
◆ dump_hash_table()
|
static |
References dump_expr_hash_table_entry(), expr_table, fmt_size_t, and HOST_SIZE_T_PRINT_DEC.
Referenced by gcse_after_reload_main().
◆ eliminate_partially_redundant_load()
|
static |
The work horses of this pass.
This handles the case where several stores feed a partially redundant load. It checks if the redundancy elimination is possible and if it's worth it. Redundancy elimination is possible if, 1) None of the operands of an insn have been modified since the start of the current basic block. 2) In any predecessor of the current basic block, the same expression is generated. See the function body for the heuristics that determine if eliminating a redundancy is also worth doing, assuming it is possible.
References expr::avail_occr, BB_END, BB_HEAD, expr::bitmap_index, BLOCK_FOR_INSN(), cfun, constrain_operands(), copy_insn(), copy_rtx(), delete_insn(), occr::deleted_p, dump_file, EDGE_CRITICAL_P, extract_insn(), FOR_EACH_EDGE, gcc_assert, gen_move_insn(), get_avail_load_store_reg(), get_bb_avail_insn(), get_preferred_alternatives(), insert_insn_on_edge(), occr::insn, unoccr::insn, profile_count::max_count, occr::next, unoccr::next, NEXT_INSN(), NULL, NULL_RTX, optimize_bb_for_size_p(), PATTERN(), unoccr::pred, basic_block_def::preds, PREV_INSN(), print_rtl(), print_rtl_single(), profile_info, PROFILE_READ, profile_status_for_fn, reg_changed_after_insn_p(), reg_killed_on_edge(), reg_set_between_p(), reg_used_between_p(), reg_used_on_edge(), REGNO, SET_DEST, set_noop_p(), targetm, profile_count::to_gcov_type(), unoccr_obstack, and profile_count::zero().
Referenced by eliminate_partially_redundant_loads().
◆ eliminate_partially_redundant_loads()
|
static |
Performing the redundancy elimination as described before.
References bb_has_well_behaved_predecessors(), cfun, commit_edge_insertions(), eliminate_partially_redundant_load(), ENTRY_BLOCK_PTR_FOR_FN, EXIT_BLOCK_PTR_FOR_FN, expr, FOR_BB_BETWEEN, FOR_BB_INSNS, general_operand(), GET_CODE, GET_MODE, unoccr::insn, INSN_P, lookup_expr_in_table(), may_trap_p(), MEM_P, MEM_VOLATILE_P, basic_block_def::next_bb, NONJUMP_INSN_P, NULL, oprs_unchanged_p(), optimize_bb_for_size_p(), PATTERN(), record_opr_changes(), REG_P, reset_opr_set_tables(), SET, SET_DEST, SET_SRC, and side_effects_p().
Referenced by gcse_after_reload_main().
◆ find_mem_conflicts()
DEST is the output of an instruction. If it is a memory reference, and possibly conflicts with the load found in DATA, then set mems_conflict_p to a nonzero value.
References GET_CODE, GET_MODE, MEM_P, mems_conflict_p, true_dependence(), and XEXP.
Referenced by load_killed_in_block_p().
◆ free_mem()
|
static |
Free memory allocated by alloc_mem.
References BITMAP_FREE, blocks_with_calls, canon_modify_mem_list, EXECUTE_IF_SET_IN_BITMAP, expr_obstack, expr_table, free(), i, modifies_mem_obstack, modify_mem_list, modify_mem_list_set, NULL, occr_obstack, uid_cuid, and unoccr_obstack.
Referenced by gcse_after_reload_main().
◆ gcse_after_reload_main()
|
static |
Main entry point of the GCSE after reload - clean some redundant loads due to spilling.
References _, alloc_mem(), bitmap_vector_ones(), cfun, compute_expr_transp(), compute_hash_table(), delete_redundant_insns(), df_analyze(), dump_file, dump_hash_table(), eliminate_partially_redundant_loads(), end_alias_analysis(), expr_table, free_mem(), gcse_or_cprop_is_too_expensive(), init_alias_analysis(), last_basic_block_for_fn, NULL, sbitmap_vector_alloc(), sbitmap_vector_free(), statistics_counter_event(), and transp.
Referenced by rest_of_handle_gcse2().
◆ get_avail_load_store_reg()
Return the loaded/stored register of a load/store instruction.
References gcc_assert, modifies_mem::insn, PATTERN(), REG_P, SET_DEST, and SET_SRC.
Referenced by eliminate_partially_redundant_load(), and get_bb_avail_insn().
◆ get_bb_avail_insn()
|
static |
Search for the occurrences of expression in BB.
References BB_END, BB_HEAD, bitmap_bit_p, BLOCK_FOR_INSN(), get_avail_load_store_reg(), get_bb_avail_insn(), basic_block_def::index, occr::insn, occr::next, NEXT_INSN(), NULL, PREV_INSN(), reg_killed_on_edge(), reg_set_between_p(), single_pred(), single_pred_edge(), single_pred_p(), and transp.
Referenced by eliminate_partially_redundant_load(), and get_bb_avail_insn().
◆ hash_expr()
|
static |
Hash expression X. DO_NOT_RECORD_P is a boolean indicating if a volatile operand is found or if the expression contains something we don't want to insert in the table.
Hash table support.
References GET_MODE, hash_rtx(), and NULL.
Referenced by insert_expr_in_table(), and lookup_expr_in_table().
◆ hash_scan_set()
|
static |
Scan the pattern of INSN and add an entry to the hash TABLE. After reload we are interested in loads/stores only.
References can_copy_p(), FLOAT_MODE_P, general_operand(), GET_MODE, insert_expr_in_table(), modifies_mem::insn, INSN_CUID, JUMP_P, load_killed_in_block_p(), MEM_P, oprs_unchanged_p(), PATTERN(), REG_P, REGNO, SET_DEST, set_noop_p(), SET_SRC, and XEXP.
Referenced by compute_hash_table().
◆ insert_expr_in_table()
Insert expression X in INSN in the hash TABLE. If it is already present, record it as the last occurrence in INSN's basic block.
References expr::avail_occr, expr::bitmap_index, BLOCK_FOR_INSN(), occr::deleted_p, expr::expr, expr_obstack, expr_table, expr::hash, hash_expr(), occr::insn, occr::next, NULL, and occr_obstack.
Referenced by hash_scan_set().
◆ load_killed_in_block_p()
Return nonzero if the expression in X (a memory reference) is killed in the current basic block before (if AFTER_INSN is false) or after (if AFTER_INSN is true) the insn with the CUID in UID_LIMIT. This function assumes that the modifies_mem table is flushed when the hash table construction or redundancy elimination phases start processing a new basic block.
References CALL_P, find_mem_conflicts(), modifies_mem::insn, INSN_CUID, mems_conflict_p, modifies_mem_list, modifies_mem::next, and note_stores().
Referenced by hash_scan_set(), and oprs_unchanged_p().
◆ lookup_expr_in_table()
Lookup pattern PAT in the expression hash table. The result is a pointer to the table entry, or NULL if not found.
References expr::avail_occr, expr::expr, expr_obstack, expr_table, expr::hash, hash_expr(), and NULL.
Referenced by eliminate_partially_redundant_loads().
◆ make_pass_gcse2()
| rtl_opt_pass * make_pass_gcse2 | ( | gcc::context * | ctxt | ) |
◆ oprs_unchanged_p()
Support for hash table construction and transformations.
Return nonzero if the operands of expression X are unchanged 1) from the start of INSN's basic block up to but not including INSN if AFTER_INSN is false, or 2) from INSN to the end of INSN's basic block if AFTER_INSN is true.
References CASE_CONST_ANY, gcc_assert, GET_CODE, GET_RTX_FORMAT, GET_RTX_LENGTH, i, occr::insn, INSN_CUID, load_killed_in_block_p(), oprs_unchanged_p(), reg_changed_after_insn_p(), REGNO, XEXP, XVECEXP, and XVECLEN.
Referenced by eliminate_partially_redundant_loads(), hash_scan_set(), and oprs_unchanged_p().
◆ record_last_mem_set_info()
|
static |
Record memory modification information for INSN. We do not actually care about the memory location(s) that are set, or even how they are set (consider a CALL_INSN). We merely need to record which insns modify memory.
References blocks_with_calls, canon_modify_mem_list, modifies_mem::insn, modifies_mem_list, modifies_mem_obstack, modify_mem_list, modify_mem_list_set, modifies_mem::next, and record_last_mem_set_info_common().
Referenced by record_last_set_info(), and record_opr_changes().
◆ record_last_reg_set_info()
Record register first/last/block set information for REGNO in INSN.
References END_REGNO(), modifies_mem::insn, INSN_CUID, and REGNO.
Referenced by record_last_set_info(), and record_opr_changes().
◆ record_last_reg_set_info_regno()
|
inlinestatic |
References modifies_mem::insn, and INSN_CUID.
Referenced by record_last_set_info(), and record_opr_changes().
◆ record_last_set_info()
Called from compute_hash_table via note_stores to handle one SET or CLOBBER in an insn. DATA is really the instruction in which the SET is taking place.
References GET_CODE, GET_MODE, MEM_P, push_operand(), record_last_mem_set_info(), record_last_reg_set_info(), record_last_reg_set_info_regno(), REG_P, and SUBREG_REG.
Referenced by record_opr_changes().
◆ record_opr_changes()
|
static |
Record things set by INSN. This data is used by oprs_unchanged_p.
References CALL_P, can_throw_external(), EXECUTE_IF_SET_IN_HARD_REG_SET, function_abi::full_and_partial_reg_clobbers(), modifies_mem::insn, insn_callee_abi(), note_stores(), record_last_mem_set_info(), record_last_reg_set_info(), record_last_reg_set_info_regno(), record_last_set_info(), REG_NOTE_KIND, REG_NOTES, RTL_CONST_OR_PURE_CALL_P, RTL_LOOPING_CONST_OR_PURE_CALL_P, and XEXP.
Referenced by compute_hash_table(), and eliminate_partially_redundant_loads().
◆ reg_changed_after_insn_p()
Return true if register X is recorded as being set by an instruction whose CUID is greater than the one given.
References END_REGNO(), and REGNO.
Referenced by eliminate_partially_redundant_load(), and oprs_unchanged_p().
◆ reg_killed_on_edge()
Helpers for eliminate_partially_redundant_load.
Check if register REG is killed in any insn waiting to be inserted on edge E. This function is required to check that our data flow analysis is still valid prior to commit_edge_insertions.
References modifies_mem::insn, INSN_P, NEXT_INSN(), and reg_set_p().
Referenced by eliminate_partially_redundant_load(), and get_bb_avail_insn().
◆ reg_used_on_edge()
Similar to above - check if register REG is used in any insn waiting to be inserted on edge E. Assumes no such insn can be a CALL_INSN; if so call reg_used_between_p with PREV(insn),NEXT(insn) instead of calling reg_overlap_mentioned_p.
References modifies_mem::insn, INSN_P, NEXT_INSN(), PATTERN(), and reg_overlap_mentioned_p().
Referenced by eliminate_partially_redundant_load().
◆ reset_opr_set_tables()
|
static |
Reset tables used to keep track of what's still available since the start of the block.
References modifies_mem_list, modifies_mem_obstack, modifies_mem_obstack_bottom, and NULL.
Referenced by compute_hash_table(), and eliminate_partially_redundant_loads().
◆ rest_of_handle_gcse2()
|
static |
References gcse_after_reload_main(), get_insns(), and rebuild_jump_labels().
Variable Documentation
◆ blocks_with_calls
|
static |
Bitmap of blocks which have calls.
Referenced by alloc_mem(), compute_expr_transp(), free_mem(), and record_last_mem_set_info().
◆ canon_modify_mem_list
|
static |
Vector indexed by block # with a canonicalized list of insns that modify memory in the block.
Referenced by alloc_mem(), compute_expr_transp(), free_mem(), and record_last_mem_set_info().
◆ copies_inserted
| int copies_inserted |
◆ expr_obstack
|
static |
Referenced by alloc_mem(), free_mem(), insert_expr_in_table(), and lookup_expr_in_table().
◆ expr_table
|
static |
The table itself.
Referenced by alloc_mem(), delete_redundant_insns(), dump_hash_table(), free_mem(), gcse_after_reload_main(), insert_expr_in_table(), and lookup_expr_in_table().
◆ insns_deleted
| int insns_deleted |
◆ mems_conflict_p
|
static |
Used for communication between find_mem_conflicts and load_killed_in_block_p. Nonzero if find_mem_conflicts finds a conflict between two memory references. This is a bit of a hack to work around the limitations of note_stores.
Referenced by find_mem_conflicts(), and load_killed_in_block_p().
◆ modifies_mem_list
|
static |
Referenced by load_killed_in_block_p(), record_last_mem_set_info(), and reset_opr_set_tables().
◆ modifies_mem_obstack
|
static |
The modifies_mem structs also go on an obstack, only this obstack is freed each time after completing the analysis or transformations on a basic block. So we allocate a dummy modifies_mem_obstack_bottom object on the obstack to keep track of the bottom of the obstack.
Referenced by alloc_mem(), free_mem(), record_last_mem_set_info(), and reset_opr_set_tables().
◆ modifies_mem_obstack_bottom
|
static |
Referenced by alloc_mem(), and reset_opr_set_tables().
◆ modify_mem_list
Vector indexed by block # with a list of all the insns that modify memory within the block.
Referenced by alloc_mem(), free_mem(), and record_last_mem_set_info().
◆ modify_mem_list_set
|
static |
Bitmap of blocks which have memory stores.
Referenced by alloc_mem(), compute_expr_transp(), free_mem(), and record_last_mem_set_info().
◆ moves_inserted
| int moves_inserted |
◆ occr_obstack
|
static |
Referenced by alloc_mem(), free_mem(), and insert_expr_in_table().
◆ reg_avail_info
|
static |
Array where each element is the CUID if the insn that last set the hard register with the number of the element, since the start of the current basic block. This array is used during the building of the hash table (step 1) to determine if a reg is killed before the end of a basic block. It is also used when eliminating partial redundancies (step 2) to see if a reg was modified since the start of a basic block.
◆ [struct]
| struct { ... } stats |
Post reload partially redundant load elimination Copyright (C) 2004-2024 Free Software Foundation, Inc. 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 following code implements gcse after reload, the purpose of this
pass is to cleanup redundant loads generated by reload and other
optimizations that come after gcse. It searches for simple inter-block
redundancies and tries to eliminate them by adding moves and loads
in cold places.
Perform partially redundant load elimination, try to eliminate redundant
loads created by the reload pass. We try to look for full or partial
redundant loads fed by one or more loads/stores in predecessor BBs,
and try adding loads to make them fully redundant. We also check if
it's worth adding loads to be able to delete the redundant load.
Algorithm:
1. Build available expressions hash table:
For each load/store instruction, if the loaded/stored memory didn't
change until the end of the basic block add this memory expression to
the hash table.
2. Perform Redundancy elimination:
For each load instruction do the following:
perform partial redundancy elimination, check if it's worth adding
loads to make the load fully redundant. If so add loads and
register copies and delete the load.
3. Delete instructions made redundant in step 2.
Future enhancement:
If the loaded register is used/defined between load and some store,
look for some other free register between load and all its stores,
and replace the load with a copy from this register to the loaded
register.
Keep statistics of this pass.
Referenced by compute_branch_probabilities(), def_target_insn(), ggc_print_common_statistics(), handle_overloaded_gen(), handle_overloaded_gen(), and vect_validate_multiplication().
◆ transp
|
static |
Vector of simple bitmaps indexed by block number. Each component sbitmap indicates which expressions are transparent through the block.
Referenced by compute_expr_transp(), gcse_after_reload_main(), and get_bb_avail_insn().
◆ uid_cuid
|
static |
Mapping of insn UIDs to CUIDs. CUIDs are like UIDs except they increase monotonically in each basic block, have no gaps, and only apply to real insns.
Referenced by alloc_mem(), and free_mem().
◆ unoccr_obstack
|
static |
Referenced by alloc_mem(), eliminate_partially_redundant_load(), and free_mem().
