- Generated by
1.8.1.1
|
GCC Middle and Back End API Reference
|
Go to the source code of this file.
Data Structures | |
| struct | reload |
| struct | target_reload |
| struct | reg_equivs_s |
| struct | insn_chain |
Typedefs | |
| typedef struct reg_equivs_s | reg_equivs_t |
Variables | |
| struct reload | rld [MAX_RELOADS] |
| int | n_reloads |
| struct target_reload | default_target_reload |
| struct target_reload * | this_target_reload |
| vec< reg_equivs_t, va_gc > * | reg_equivs |
| int | n_earlyclobbers |
| rtx | reload_earlyclobbers [MAX_RECOG_OPERANDS] |
| int | reload_n_operands |
| int | reload_first_uid |
| int | num_not_at_initial_offset |
| struct insn_chain * | reload_insn_chain |
| typedef struct reg_equivs_s reg_equivs_t |
Register equivalences. Indexed by register number.
| enum reload_type |
Encode the usage of a reload. The following codes are supported:
RELOAD_FOR_INPUT reload of an input operand
RELOAD_FOR_OUTPUT likewise, for output
RELOAD_FOR_INSN a reload that must not conflict with anything
used in the insn, but may conflict with
something used before or after the insn
RELOAD_FOR_INPUT_ADDRESS reload for parts of the address of an object
that is an input reload
RELOAD_FOR_INPADDR_ADDRESS reload needed for RELOAD_FOR_INPUT_ADDRESS
RELOAD_FOR_OUTPUT_ADDRESS like RELOAD_FOR INPUT_ADDRESS, for output
RELOAD_FOR_OUTADDR_ADDRESS reload needed for RELOAD_FOR_OUTPUT_ADDRESS
RELOAD_FOR_OPERAND_ADDRESS reload for the address of a non-reloaded
operand; these don't conflict with
any other addresses.
RELOAD_FOR_OPADDR_ADDR reload needed for RELOAD_FOR_OPERAND_ADDRESS
reloads; usually secondary reloads
RELOAD_OTHER none of the above, usually multiple uses
RELOAD_FOR_OTHER_ADDRESS reload for part of the address of an input
that is marked RELOAD_OTHER.
This used to be "enum reload_when_needed" but some debuggers have trouble
with an enum tag and variable of the same name.
| void calculate_elim_costs_all_insns | ( | void | ) |
Called from the register allocator to estimate costs of eliminating invariant registers.
This function is called from the register allocator to set up estimates for the cost of eliminating pseudos which have REG_EQUIV equivalences to an invariant. The structure is similar to calculate_needs_all_insns.
References dump_file, eliminate_regs_1(), elimination_costs_in_insn(), free(), get_insns(), init_elim_table(), init_eliminable_invariants(), insn_chain::insn, ira_adjust_equiv_reg_cost(), max_regno, num_eliminable, num_eliminable_invariants, offsets_at, offsets_known_at, optimize_bb_for_speed_p(), reg_renumber, set_initial_elim_offsets(), set_initial_label_offsets(), set_label_offsets(), set_src_cost(), and update_eliminable_offsets().
Referenced by ira_costs().
| void cleanup_subreg_operands | ( | rtx | ) |
Replace (subreg (reg)) with the appropriate (reg) for any operands.
| void clear_secondary_mem | ( | void | ) |
Clear any secondary memory locations we've made.
References memset(), and secondary_memlocs.
Referenced by reload().
| void compute_use_by_pseudos | ( | HARD_REG_SET * | , |
| bitmap | |||
| ) |
Referenced by choose_reload_regs_init(), finish_spills(), and reload_combine().
Make a copy of any replacements being done into X and move those copies to locations in Y, a copy of X. We only look at the highest level of the RTL.
| void deallocate_reload_reg | ( | int | r | ) |
Deallocate the reload register used by reload number R.
Referenced by remove_address_replacements().
| void debug_reload | ( | void | ) |
References debug_reload_to_stream().
| void debug_reload_to_stream | ( | FILE * | ) |
Debugging support.
| int earlyclobber_operand_p | ( | rtx | ) |
Return 1 if X is an operand of an insn that is being earlyclobbered.
Scan X and replace any eliminable registers (such as fp) with a replacement (such as sp), plus an offset.
Referenced by based_loc_descr(), compute_frame_pointer_to_fb_displacement(), dbxout_parms(), dbxout_symbol(), delete_output_reload(), eliminate_regs_in_insn(), get_secondary_mem(), make_memloc(), reg_loc_descriptor(), reload(), reload_as_needed(), sdbout_parms(), sdbout_symbol(), and vt_initialize().
| bool elimination_target_reg_p | ( | rtx | ) |
Referenced by find_reloads().
| rtx find_equiv_reg | ( | rtx | goal, |
| rtx | insn, | ||
| enum reg_class | rclass, | ||
| int | other, | ||
| short * | reload_reg_p, | ||
| int | goalreg, | ||
| enum machine_mode | mode | ||
| ) |
Check the insns before INSN to see if there is a suitable register containing the same value as GOAL.
Check the insns before INSN to see if there is a suitable register containing the same value as GOAL. If OTHER is -1, look for a register in class RCLASS. Otherwise, just see if register number OTHER shares GOAL's value. Return an rtx for the register found, or zero if none is found. If RELOAD_REG_P is (short *)1, we reject any hard reg that appears in reload_reg_rtx because such a hard reg is also needed coming into this insn. If RELOAD_REG_P is any other nonzero value, it is a vector indexed by hard reg number and we reject any hard reg whose element in the vector is nonnegative as well as any that appears in reload_reg_rtx. If GOAL is zero, then GOALREG is a register number; we look for an equivalent for that register. MODE is the machine mode of the value we want an equivalence for. If GOAL is nonzero and not VOIDmode, then it must have mode MODE. This function is used by jump.c as well as in the reload pass. If GOAL is the sum of the stack pointer and a constant, we treat it as if it were a constant except that sp is required to be unchanging.
References end_hard_regno(), find_reg_note(), HOST_WIDE_INT, in_hard_reg_set_p(), replacement::mode, n_reloads, operand_subword(), push_operand(), refers_to_regno_for_reload_p(), reg_overlap_mentioned_for_reload_p(), reload_first_uid, rld, rtx_equal_p(), rtx_renumbered_equal_p(), SET, true_regnum(), volatile_insn_p(), and replacement::where.
Referenced by choose_reload_regs(), find_reloads(), and push_reload().
| int find_reloads | ( | rtx | insn, |
| int | replace, | ||
| int | ind_levels, | ||
| int | live_known, | ||
| short * | reload_reg_p | ||
| ) |
Search the body of INSN for values that need reloading and record them with push_reload. REPLACE nonzero means record also where the values occur so that subst_reloads can be used.
Main entry point of this file: search the body of INSN for values that need reloading and record them with push_reload. REPLACE nonzero means record also where the values occur so that subst_reloads can be used. IND_LEVELS says how many levels of indirection are supported by this machine; a value of zero means that a memory reference is not a valid memory address. LIVE_KNOWN says we have valid information about which hard regs are live at each point in the program; this is true when we are called from global_alloc but false when stupid register allocation has been done. RELOAD_REG_P if nonzero is a vector indexed by hard reg number which is nonnegative if the reg has been commandeered for reloading into. It is copied into STATIC_RELOAD_REG_P and referenced from there by various subroutines. Return TRUE if some operands need to be changed, because of swapping commutative operands, reg_equiv_address substitution, or whatever.
References add_reg_note(), alternative_allows_const_pool_ref(), recog_data_d::alternative_enabled_p, base_reg_class(), cc0_rtx, combine_reloads(), recog_data_d::constraints, constraints, decompose(), recog_data_d::dup_loc, recog_data_d::dup_num, dup_replacements(), elimination_target_reg_p(), emit_insn_after(), emit_insn_before(), decomposition::end, error_for_asm(), extract_insn(), find_dummy_reload(), find_equiv_reg(), find_reg_note(), find_reloads(), find_reloads_address(), find_reloads_toplev(), force_const_mem(), gen_clobber(), gen_rtx_SUBREG(), get_address_mode(), hard_regs_live_known, immune_p(), reload::in, reload::in_reg, reload::inc, reload::inmode, insn_code_number, insn_data, recog_data_d::is_operator, label_is_jump_target_p(), len, memcpy(), memset(), reload::mode, n_alternatives(), recog_data_d::n_alternatives, recog_data_d::n_dups, n_earlyclobbers, recog_data_d::n_operands, n_reloads, n_replacements, nr, reload::nregs, num_not_at_initial_offset, offset, offsettable_memref_p(), offsettable_nonstrict_memref_p(), recog_data_d::operand, insn_data_d::operand, recog_data_d::operand_loc, recog_data_d::operand_mode, operands_match_p(), reload::opnum, reload::outmode, output_reloadnum, push_reload(), reload::rclass, recog_data, reg_alternate_class(), reg_class_subset_p(), reg_fits_class_p(), reg_mentioned_p(), reg_preferred_class(), reg_referenced_p(), reg_renumber, reload::reg_rtx, reg_set_p(), register_move_cost(), reject(), reload_earlyclobbers, RELOAD_FOR_INPADDR_ADDRESS, RELOAD_FOR_INPUT, RELOAD_FOR_INPUT_ADDRESS, RELOAD_FOR_INSN, RELOAD_FOR_OPADDR_ADDR, RELOAD_FOR_OPERAND_ADDRESS, RELOAD_FOR_OTHER_ADDRESS, RELOAD_FOR_OUTADDR_ADDRESS, RELOAD_FOR_OUTPUT, RELOAD_FOR_OUTPUT_ADDRESS, reload_n_operands, RELOAD_OTHER, replace_reloads, replacements, rld, rtx_equal_p(), RTX_UNARY, secondary_memlocs_elim, secondary_memlocs_elim_used, SET, set_unique_reg_note(), simplify_subreg_regno(), skip_alternative(), small_register_class_p(), static_reload_reg_p, insn_operand_data::strict_low, subreg_regno_offset(), targetm, this_insn, this_insn_is_asm, transfer_replacements(), type(), replacement::what, and reload::when_needed.
Referenced by calculate_needs_all_insns(), find_reloads(), and reload_as_needed().
If LOC was scheduled to be replaced by something, return the replacement. Otherwise, return *LOC.
Compute the sum of X and Y, making canonicalizations assumed in an address, namely: sum constant integers, surround the sum of two constants with a CONST, put the constant as the second operand, and group the constant on the outermost sum.
| rtx get_secondary_mem | ( | rtx | x, |
| enum machine_mode | mode, | ||
| int | opnum, | ||
| enum reload_type | type | ||
| ) |
Return a memory location that will be used to copy X in mode MODE. If we haven't already made a location for this mode in this insn, call find_reloads_address on the location being returned.
References assign_stack_local(), copy_rtx(), eliminate_regs(), find_reloads_address(), mode_for_size(), RELOAD_FOR_INPUT, RELOAD_FOR_INPUT_ADDRESS, RELOAD_FOR_OUTPUT, RELOAD_FOR_OUTPUT_ADDRESS, RELOAD_OTHER, secondary_memlocs, secondary_memlocs_elim, secondary_memlocs_elim_used, and strict_memory_address_addr_space_p().
Referenced by choose_reload_regs(), gen_reload(), push_reload(), and push_secondary_reload().
| void grow_reg_equivs | ( | void | ) |
Allocate or grow the reg_equiv tables, initializing new entries to 0.
Grow (or allocate) the REG_EQUIVS array from its current size (which may be zero elements) to MAX_REG_NUM elements. Initialize all new fields to NULL and update REG_EQUIVS_SIZE.
References max_reg_num(), max_regno, memset(), vec_safe_length(), and vec_safe_reserve().
Referenced by emit_move_list(), fix_reg_equiv_init(), init_eliminable_invariants(), ira(), reload(), and update_equiv_regs().
| void init_caller_save | ( | void | ) |
Functions in caller-save.c:
Initialize for caller-save.
Initialize for caller-save. Look at all the hard registers that are used by a call and for which reginfo.c has not already excluded from being used across a call. Ensure that we can find a mode to save the register and that there is a simple insn to save and restore the register. This latter check avoids problems that would occur if we tried to save the MQ register of some machines directly into memory.
References base_reg_class(), gen_rtx_MEM(), gen_rtx_REG(), HOST_BITS_PER_INT, offset, reg_save_code(), restinsn, restpat, saveinsn, savepat, test_mem, and test_reg.
Referenced by ira().
| void init_reload | ( | void | ) |
Functions in reload1.c:
Initialize the reload pass once per compilation.
Initialize the reload pass. This is called at the beginning of compilation and may be called again if the target is reinitialized.
References gen_rtx_MEM(), gen_rtx_REG(), plus_constant(), reload_obstack, and reload_startobj.
Referenced by backend_init_target().
| void init_save_areas | ( | void | ) |
Initialize save areas by showing that we haven't allocated any yet.
References regno_save_mem, and save_slots_num.
Referenced by reload().
| void mark_home_live | ( | int | ) |
Mark the slots in regs_ever_live for the hard regs used by pseudo-reg number REGNO.
Referenced by allocno_reload_assign(), and reload().
| int memory_move_cost | ( | enum | machine_mode, |
| reg_class_t | , | ||
| bool | |||
| ) |
| int memory_move_secondary_cost | ( | enum machine_mode | mode, |
| reg_class_t | rclass, | ||
| bool | in | ||
| ) |
Compute extra cost of moving registers to/from memory due to reloads. Only needed if secondary reloads are required for memory moves.
References memory_move_secondary_cost(), register_move_cost(), and secondary_reload_class().
Referenced by default_memory_move_cost(), and memory_move_secondary_cost().
Change any replacements being done to *X to be done to *Y
|
read |
Allocate a new insn_chain structure.
Allocate an empty insn_chain structure.
References insn_chain::dead_or_set, insn_chain::is_caller_save_insn, insn_chain::live_throughout, insn_chain::need_elim, insn_chain::need_operand_change, insn_chain::need_reload, insn_chain::next, reload_obstack, and unused_insn_chains.
Referenced by build_insn_chain(), and insert_one_insn().
Like rtx_equal_p except that it allows a REG and a SUBREG to match if they are the same hard reg, and has special hacks for autoincrement and autodecrement.
| int push_reload | ( | rtx | in, |
| rtx | out, | ||
| rtx * | inloc, | ||
| rtx * | outloc, | ||
| enum reg_class | rclass, | ||
| enum machine_mode | inmode, | ||
| enum machine_mode | outmode, | ||
| int | strict_low, | ||
| int | optional, | ||
| int | opnum, | ||
| enum reload_type | type | ||
| ) |
Record one reload that needs to be performed.
Record one reload that needs to be performed. IN is an rtx saying where the data are to be found before this instruction. OUT says where they must be stored after the instruction. (IN is zero for data not read, and OUT is zero for data not written.) INLOC and OUTLOC point to the places in the instructions where IN and OUT were found. If IN and OUT are both nonzero, it means the same register must be used to reload both IN and OUT. RCLASS is a register class required for the reloaded data. INMODE is the machine mode that the instruction requires for the reg that replaces IN and OUTMODE is likewise for OUT. If IN is zero, then OUT's location and mode should be passed as INLOC and INMODE. STRICT_LOW is the 1 if there is a containing STRICT_LOW_PART rtx. OPTIONAL nonzero means this reload does not need to be performed: it can be discarded if that is more convenient. OPNUM and TYPE say what the purpose of this reload is. The return value is the reload-number for this reload. If both IN and OUT are nonzero, in some rare cases we might want to make two separate reloads. (Actually we never do this now.) Therefore, the reload-number for OUT is stored in output_reloadnum when we return; the return value applies to IN. Usually (presently always), when IN and OUT are nonzero, the two reload-numbers are equal, but the caller should be careful to distinguish them.
References bitmap_bit_p(), can_reload_into(), earlyclobber_operand_p(), end_hard_regno(), error_for_asm(), find_dummy_reload(), find_equiv_reg(), find_inc_amount(), find_reusable_reload(), find_valid_class(), find_valid_class_1(), gen_rtx_REG(), get_secondary_mem(), hard_reg_set_here_p(), hard_regs_live_known, reload::in, in_hard_reg_set_p(), reload::in_reg, reload::inc, reload::inmode, replacement::mode, n_reloads, n_replacements, reload::nocombine, reload::opnum, reload::optional, reload::out, reload::out_reg, reload::outmode, output_reloadnum, push_reload(), push_secondary_reload(), reload::rclass, refers_to_regno_for_reload_p(), reg_class_subset_p(), reg_mentioned_p(), reg_or_subregno(), reg_overlap_mentioned_for_reload_p(), reg_renumber, reload::reg_rtx, RELOAD_FOR_OUTPUT, reload_inner_reg_of_subreg(), RELOAD_OTHER, remove_address_replacements(), replace_equiv_address_nv(), replace_reloads, replacements, rld, rtx_equal_p(), reload::secondary_in_icode, reload::secondary_in_reload, reload::secondary_out_icode, reload::secondary_out_reload, reload::secondary_p, secondary_reload_class(), sets_cc0_p(), static_reload_reg_p, subreg_lowpart_p(), subreg_regno(), subreg_regno_offset(), targetm, this_insn, this_insn_is_asm, type(), replacement::what, reload::when_needed, replacement::where, and word_mode.
Referenced by find_reloads(), find_reloads_address(), find_reloads_address_1(), find_reloads_address_part(), find_reloads_subreg_address(), and push_reload().
| int register_move_cost | ( | enum | machine_mode, |
| reg_class_t | , | ||
| reg_class_t | |||
| ) |
| int regno_clobbered_p | ( | unsigned int | regno, |
| rtx | insn, | ||
| enum machine_mode | mode, | ||
| int | sets | ||
| ) |
Return 1 if register REGNO is the subject of a clobber in insn INSN.
Return 1 if register REGNO is the subject of a clobber in insn INSN. If SETS is 1, also consider SETs. If SETS is 2, enable checking REG_INC. REGNO must refer to a hard register.
References replacement::mode, reg_inc_found_and_valid_p(), and SET.
Referenced by choose_reload_regs(), emit_output_reload_insns(), find_reloads_address(), and find_reloads_address_1().
The reload pass itself.
Referenced by do_reload().
Compute the actual register we should reload to, in case we're reloading to/from a register that is wider than a word.
| int remove_address_replacements | ( | rtx | in_rtx | ) |
IN_RTX is the value loaded by a reload that we now decided to inherit, or a subpart of it. If we have any replacements registered for IN_RTX, cancel the reloads that were supposed to load them. Return nonzero if we canceled any reloads.
Return 1 if altering OP will not modify the value of CLOBBER.
| void save_call_clobbered_regs | ( | void | ) |
Find the places where hard regs are live across calls and save them.
References insn_chain::block, copy_rtx(), find_reg_note(), hard_regs_saved, insert_one_insn(), insert_restore(), insert_save(), insn_chain::insn, insn_chain::is_caller_save_insn, last, insn_chain::live_throughout, mark_referenced_regs(), mark_reg_as_referenced, mark_set_regs(), n_regs_saved, insn_chain::next, note_stores(), insn_chain::prev, referenced_regs, reg_renumber, regno_reg_rtx, reload_insn_chain, and replace_reg_with_saved_mem.
Referenced by reload().
| enum reg_class scratch_reload_class | ( | enum | insn_code | ) |
| reg_class_t secondary_reload_class | ( | bool | in_p, |
| reg_class_t | rclass, | ||
| enum machine_mode | mode, | ||
| rtx | x | ||
| ) |
Functions from reload.c:
If a secondary reload is needed, return its class. If both an intermediate register and a scratch register is needed, we return the class of the intermediate register.
References secondary_reload_info::icode, secondary_reload_info::prev_sri, scratch_reload_class(), and targetm.
Referenced by choose_reload_regs(), emit_output_reload_insns(), memory_move_secondary_cost(), and push_reload().
| void setup_save_areas | ( | void | ) |
Allocate save areas for any hard registers that might need saving.
Allocate save areas for any hard registers that might need saving.
We take a conservative approach here and look for call-clobbered hard
registers that are assigned to pseudos that cross calls. This may
overestimate slightly (especially if some of these registers are later
used as spill registers), but it should not be significant.
For IRA we use priority coloring to decrease stack slots needed for
saving hard registers through calls. We build conflicts for them
to do coloring.
Future work:
In the fallback case we should iterate backwards across all possible
modes for the save, choosing the largest available one instead of
falling back to the smallest mode immediately. (eg TF -> DF -> SF).
We do not try to use "move multiple" instructions that exist
on some machines (such as the 68k moveml). It could be a win to try
and use them when possible. The hard part is doing it in a way that is
machine independent since they might be saving non-consecutive
registers. (imagine caller-saving d0,d1,a0,a1 on the 68k)
References assign_stack_local_1(), saved_hard_reg::call_freq, dump_file, find_reg_note(), finish_saved_hard_regs(), saved_hard_reg::first_p, free(), get_frame_alias_set(), saved_hard_reg::hard_regno, initiate_saved_hard_regs(), insn_chain::insn, insn_chain::live_throughout, mark_set_regs(), memcpy(), memset(), new_saved_hard_reg(), insn_chain::next, saved_hard_reg::next, note_stores(), saved_hard_reg::num, reg_renumber, regno_reg_rtx, regno_save_mem, reload_insn_chain, save_slots, save_slots_num, saved_hard_reg_compare_func(), saved_regs_num, set_mem_alias_set(), saved_hard_reg::slot, and used_regs.
Referenced by reload().
| void subst_reloads | ( | rtx | ) |
Substitute into the current INSN the registers into which we have reloaded the things that need reloading.
| void transfer_replacements | ( | int | , |
| int | |||
| ) |
Transfer all replacements that used to be in reload FROM to be in reload TO.
| struct target_reload default_target_reload |
@verbatim Reload pseudo regs into hard regs for insns that require hard regs.
Copyright (C) 1987-2013 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/.
This file contains the reload pass of the compiler, which is run after register allocation has been done. It checks that each insn is valid (operands required to be in registers really are in registers of the proper class) and fixes up invalid ones by copying values temporarily into registers for the insns that need them. The results of register allocation are described by the vector reg_renumber; the insns still contain pseudo regs, but reg_renumber can be used to find which hard reg, if any, a pseudo reg is in. The technique we always use is to free up a few hard regs that are called ``reload regs'', and for each place where a pseudo reg must be in a hard reg, copy it temporarily into one of the reload regs. Reload regs are allocated locally for every instruction that needs reloads. When there are pseudos which are allocated to a register that has been chosen as a reload reg, such pseudos must be ``spilled''. This means that they go to other hard regs, or to stack slots if no other available hard regs can be found. Spilling can invalidate more insns, requiring additional need for reloads, so we must keep checking until the process stabilizes. For machines with different classes of registers, we must keep track of the register class needed for each reload, and make sure that we allocate enough reload registers of each class. The file reload.c contains the code that checks one insn for validity and reports the reloads that it needs. This file is in charge of scanning the entire rtl code, accumulating the reload needs, spilling, assigning reload registers to use for fixing up each insn, and generating the new insns to copy values into the reload registers.
| int n_earlyclobbers |
All the "earlyclobber" operands of the current insn are recorded here.
Referenced by choose_reload_regs(), earlyclobber_operand_p(), and find_reloads().
| int n_reloads |
All reloads of the current insn are recorded here. See reload.h for comments.
Referenced by calculate_needs_all_insns(), choose_reload_regs(), choose_reload_regs_init(), clear_reload_reg_in_use(), combine_reloads(), conflicts_with_override(), copy_reloads(), debug_reload_to_stream(), delete_address_reloads_1(), delete_output_reload(), emit_reload_insns(), find_equiv_reg(), find_reload_regs(), find_reloads(), find_reusable_reload(), forget_marked_reloads(), forget_old_reloads_1(), push_reload(), push_secondary_reload(), reload_as_needed(), reload_reg_free_for_value_p(), reload_reg_reaches_end_p(), reloads_unique_chain_p(), and remove_address_replacements().
| int num_not_at_initial_offset |
Record the number of pending eliminations that have an offset not equal to their initial offset. If nonzero, we use a new copy of each replacement result in any insns encountered.
Referenced by emit_input_reload_insns(), find_reloads(), find_reloads_address(), find_reloads_address_1(), find_reloads_toplev(), set_initial_elim_offsets(), set_offsets_for_label(), subst_reg_equivs(), and update_eliminable_offsets().
| vec<reg_equivs_t, va_gc>* reg_equivs |
Referenced by do_reload(), emit_move_list(), and fix_reg_equiv_init().
| rtx reload_earlyclobbers[MAX_RECOG_OPERANDS] |
Referenced by choose_reload_regs(), earlyclobber_operand_p(), and find_reloads().
| int reload_first_uid |
First uid used by insns created by reload in this function. Used in find_equiv_reg.
Referenced by delete_address_reloads_1(), find_equiv_reg(), and reload().
| struct insn_chain* reload_insn_chain |
A chain of insn_chain structures to describe all non-note insns in a function.
List of insn_chain instructions, one for every insn that reload needs to examine.
Referenced by build_insn_chain(), delete_caller_save_insns(), insert_one_insn(), print_insn_chains(), save_call_clobbered_regs(), and setup_save_areas().
| int reload_n_operands |
Save the number of operands.
Referenced by choose_reload_regs_init(), emit_reload_insns(), find_reloads(), reload_reg_free_p(), and reload_reg_reaches_end_p().
| struct reload rld[MAX_RELOADS] |
Referenced by allocate_reload_reg(), choose_reload_regs(), choose_reload_regs_init(), clear_reload_reg_in_use(), combine_reloads(), copy_reloads(), curr_insn_transform(), deallocate_reload_reg(), debug_reload_to_stream(), delete_address_reloads_1(), delete_output_reload(), do_input_reload(), do_output_reload(), emit_input_reload_insns(), emit_output_reload_insns(), emit_reload_insns(), failed_reload(), find_dummy_reload(), find_equiv_reg(), find_reg(), find_reload_regs(), find_reloads(), find_reloads_address_1(), find_replacement(), find_reusable_reload(), gen_reload_chain_without_interm_reg_p(), push_reload(), push_secondary_reload(), reload_as_needed(), reload_reg_class_lower(), reload_reg_free_for_value_p(), reload_reg_reaches_end_p(), reloads_conflict(), reloads_unique_chain_p(), remove_address_replacements(), set_reload_reg(), and subst_reloads().
| struct target_reload* this_target_reload |
1.8.1.1