118334Speter/* Search an insn for pseudo regs that must be in hard regs and are not. 290285Sobrien Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 3169699Skan 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, 4169699Skan Inc. 518334Speter 690285SobrienThis file is part of GCC. 718334Speter 890285SobrienGCC is free software; you can redistribute it and/or modify it under 990285Sobrienthe terms of the GNU General Public License as published by the Free 1090285SobrienSoftware Foundation; either version 2, or (at your option) any later 1190285Sobrienversion. 1218334Speter 1390285SobrienGCC is distributed in the hope that it will be useful, but WITHOUT ANY 1490285SobrienWARRANTY; without even the implied warranty of MERCHANTABILITY or 1590285SobrienFITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 1690285Sobrienfor more details. 1718334Speter 1818334SpeterYou should have received a copy of the GNU General Public License 1990285Sobrienalong with GCC; see the file COPYING. If not, write to the Free 20169699SkanSoftware Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 21169699Skan02110-1301, USA. */ 2218334Speter 2318334Speter/* This file contains subroutines used only from the file reload1.c. 2418334Speter It knows how to scan one insn for operands and values 2518334Speter that need to be copied into registers to make valid code. 2618334Speter It also finds other operands and values which are valid 2718334Speter but for which equivalent values in registers exist and 2818334Speter ought to be used instead. 2918334Speter 3018334Speter Before processing the first insn of the function, call `init_reload'. 31169699Skan init_reload actually has to be called earlier anyway. 3218334Speter 3318334Speter To scan an insn, call `find_reloads'. This does two things: 3418334Speter 1. sets up tables describing which values must be reloaded 3518334Speter for this insn, and what kind of hard regs they must be reloaded into; 3618334Speter 2. optionally record the locations where those values appear in 3718334Speter the data, so they can be replaced properly later. 3818334Speter This is done only if the second arg to `find_reloads' is nonzero. 3918334Speter 4018334Speter The third arg to `find_reloads' specifies the number of levels 4118334Speter of indirect addressing supported by the machine. If it is zero, 4218334Speter indirect addressing is not valid. If it is one, (MEM (REG n)) 4318334Speter is valid even if (REG n) did not get a hard register; if it is two, 4418334Speter (MEM (MEM (REG n))) is also valid even if (REG n) did not get a 4518334Speter hard register, and similarly for higher values. 4618334Speter 4718334Speter Then you must choose the hard regs to reload those pseudo regs into, 4818334Speter and generate appropriate load insns before this insn and perhaps 4918334Speter also store insns after this insn. Set up the array `reload_reg_rtx' 5018334Speter to contain the REG rtx's for the registers you used. In some 5118334Speter cases `find_reloads' will return a nonzero value in `reload_reg_rtx' 5218334Speter for certain reloads. Then that tells you which register to use, 5318334Speter so you do not need to allocate one. But you still do need to add extra 5418334Speter instructions to copy the value into and out of that register. 5518334Speter 5618334Speter Finally you must call `subst_reloads' to substitute the reload reg rtx's 5718334Speter into the locations already recorded. 5818334Speter 5918334SpeterNOTE SIDE EFFECTS: 6018334Speter 6118334Speter find_reloads can alter the operands of the instruction it is called on. 6218334Speter 6318334Speter 1. Two operands of any sort may be interchanged, if they are in a 6418334Speter commutative instruction. 6518334Speter This happens only if find_reloads thinks the instruction will compile 6618334Speter better that way. 6718334Speter 6818334Speter 2. Pseudo-registers that are equivalent to constants are replaced 6918334Speter with those constants if they are not in hard registers. 7018334Speter 7118334Speter1 happens every time find_reloads is called. 7218334Speter2 happens only when REPLACE is 1, which is only when 7318334Speteractually doing the reloads, not when just counting them. 7418334Speter 7518334SpeterUsing a reload register for several reloads in one insn: 7618334Speter 7718334SpeterWhen an insn has reloads, it is considered as having three parts: 7818334Speterthe input reloads, the insn itself after reloading, and the output reloads. 7918334SpeterReloads of values used in memory addresses are often needed for only one part. 8018334Speter 8118334SpeterWhen this is so, reload_when_needed records which part needs the reload. 8218334SpeterTwo reloads for different parts of the insn can share the same reload 8318334Speterregister. 8418334Speter 8518334SpeterWhen a reload is used for addresses in multiple parts, or when it is 8618334Speteran ordinary operand, it is classified as RELOAD_OTHER, and cannot share 8718334Spetera register with any other reload. */ 8818334Speter 8918334Speter#define REG_OK_STRICT 9018334Speter 9118334Speter#include "config.h" 9250605Sobrien#include "system.h" 93132727Skan#include "coretypes.h" 94132727Skan#include "tm.h" 9518334Speter#include "rtl.h" 9690285Sobrien#include "tm_p.h" 9718334Speter#include "insn-config.h" 9890285Sobrien#include "expr.h" 9990285Sobrien#include "optabs.h" 10018334Speter#include "recog.h" 10118334Speter#include "reload.h" 10218334Speter#include "regs.h" 103169699Skan#include "addresses.h" 10418334Speter#include "hard-reg-set.h" 10518334Speter#include "flags.h" 10618334Speter#include "real.h" 10718334Speter#include "output.h" 10890285Sobrien#include "function.h" 10950605Sobrien#include "toplev.h" 110132727Skan#include "params.h" 111169699Skan#include "target.h" 11218334Speter 113169699Skan/* True if X is a constant that can be forced into the constant pool. */ 114169699Skan#define CONST_POOL_OK_P(X) \ 115169699Skan (CONSTANT_P (X) \ 116169699Skan && GET_CODE (X) != HIGH \ 117169699Skan && !targetm.cannot_force_const_mem (X)) 11850605Sobrien 119169699Skan/* True if C is a non-empty register class that has too few registers 120169699Skan to be safely used as a reload target class. */ 121169699Skan#define SMALL_REGISTER_CLASS_P(C) \ 122169699Skan (reg_class_size [(C)] == 1 \ 123169699Skan || (reg_class_size [(C)] >= 1 && CLASS_LIKELY_SPILLED_P (C))) 124169699Skan 12518334Speter 12690285Sobrien/* All reloads of the current insn are recorded here. See reload.h for 12790285Sobrien comments. */ 12818334Speterint n_reloads; 12990285Sobrienstruct reload rld[MAX_RELOADS]; 13018334Speter 13118334Speter/* All the "earlyclobber" operands of the current insn 13218334Speter are recorded here. */ 13318334Speterint n_earlyclobbers; 13418334Speterrtx reload_earlyclobbers[MAX_RECOG_OPERANDS]; 13518334Speter 13618334Speterint reload_n_operands; 13718334Speter 13818334Speter/* Replacing reloads. 13918334Speter 14018334Speter If `replace_reloads' is nonzero, then as each reload is recorded 14118334Speter an entry is made for it in the table `replacements'. 14218334Speter Then later `subst_reloads' can look through that table and 14318334Speter perform all the replacements needed. */ 14418334Speter 14518334Speter/* Nonzero means record the places to replace. */ 14618334Speterstatic int replace_reloads; 14718334Speter 14818334Speter/* Each replacement is recorded with a structure like this. */ 14918334Speterstruct replacement 15018334Speter{ 15118334Speter rtx *where; /* Location to store in */ 15218334Speter rtx *subreg_loc; /* Location of SUBREG if WHERE is inside 15318334Speter a SUBREG; 0 otherwise. */ 15418334Speter int what; /* which reload this is for */ 15518334Speter enum machine_mode mode; /* mode it must have */ 15618334Speter}; 15718334Speter 15818334Speterstatic struct replacement replacements[MAX_RECOG_OPERANDS * ((MAX_REGS_PER_ADDRESS * 2) + 1)]; 15918334Speter 16018334Speter/* Number of replacements currently recorded. */ 16118334Speterstatic int n_replacements; 16218334Speter 16318334Speter/* Used to track what is modified by an operand. */ 16418334Speterstruct decomposition 16518334Speter{ 16650605Sobrien int reg_flag; /* Nonzero if referencing a register. */ 16750605Sobrien int safe; /* Nonzero if this can't conflict with anything. */ 16850605Sobrien rtx base; /* Base address for MEM. */ 16950605Sobrien HOST_WIDE_INT start; /* Starting offset or register number. */ 17018334Speter HOST_WIDE_INT end; /* Ending offset or register number. */ 17118334Speter}; 17218334Speter 17318334Speter#ifdef SECONDARY_MEMORY_NEEDED 17418334Speter 17518334Speter/* Save MEMs needed to copy from one class of registers to another. One MEM 17690285Sobrien is used per mode, but normally only one or two modes are ever used. 17718334Speter 17890285Sobrien We keep two versions, before and after register elimination. The one 17918334Speter after register elimination is record separately for each operand. This 18018334Speter is done in case the address is not valid to be sure that we separately 18118334Speter reload each. */ 18218334Speter 18318334Speterstatic rtx secondary_memlocs[NUM_MACHINE_MODES]; 18418334Speterstatic rtx secondary_memlocs_elim[NUM_MACHINE_MODES][MAX_RECOG_OPERANDS]; 185132727Skanstatic int secondary_memlocs_elim_used = 0; 18618334Speter#endif 18718334Speter 18818334Speter/* The instruction we are doing reloads for; 18918334Speter so we can test whether a register dies in it. */ 19018334Speterstatic rtx this_insn; 19118334Speter 19218334Speter/* Nonzero if this instruction is a user-specified asm with operands. */ 19318334Speterstatic int this_insn_is_asm; 19418334Speter 19518334Speter/* If hard_regs_live_known is nonzero, 19618334Speter we can tell which hard regs are currently live, 19718334Speter at least enough to succeed in choosing dummy reloads. */ 19818334Speterstatic int hard_regs_live_known; 19918334Speter 20018334Speter/* Indexed by hard reg number, 20150605Sobrien element is nonnegative if hard reg has been spilled. 20218334Speter This vector is passed to `find_reloads' as an argument 20318334Speter and is not changed here. */ 20418334Speterstatic short *static_reload_reg_p; 20518334Speter 20618334Speter/* Set to 1 in subst_reg_equivs if it changes anything. */ 20718334Speterstatic int subst_reg_equivs_changed; 20818334Speter 20918334Speter/* On return from push_reload, holds the reload-number for the OUT 21018334Speter operand, which can be different for that from the input operand. */ 21118334Speterstatic int output_reloadnum; 21218334Speter 21318334Speter /* Compare two RTX's. */ 21418334Speter#define MATCHES(x, y) \ 215169699Skan (x == y || (x != 0 && (REG_P (x) \ 216169699Skan ? REG_P (y) && REGNO (x) == REGNO (y) \ 21718334Speter : rtx_equal_p (x, y) && ! side_effects_p (x)))) 21818334Speter 21918334Speter /* Indicates if two reloads purposes are for similar enough things that we 22018334Speter can merge their reloads. */ 22118334Speter#define MERGABLE_RELOADS(when1, when2, op1, op2) \ 22218334Speter ((when1) == RELOAD_OTHER || (when2) == RELOAD_OTHER \ 22318334Speter || ((when1) == (when2) && (op1) == (op2)) \ 22418334Speter || ((when1) == RELOAD_FOR_INPUT && (when2) == RELOAD_FOR_INPUT) \ 22518334Speter || ((when1) == RELOAD_FOR_OPERAND_ADDRESS \ 22618334Speter && (when2) == RELOAD_FOR_OPERAND_ADDRESS) \ 22718334Speter || ((when1) == RELOAD_FOR_OTHER_ADDRESS \ 22818334Speter && (when2) == RELOAD_FOR_OTHER_ADDRESS)) 22918334Speter 23018334Speter /* Nonzero if these two reload purposes produce RELOAD_OTHER when merged. */ 23118334Speter#define MERGE_TO_OTHER(when1, when2, op1, op2) \ 23218334Speter ((when1) != (when2) \ 23318334Speter || ! ((op1) == (op2) \ 23418334Speter || (when1) == RELOAD_FOR_INPUT \ 23518334Speter || (when1) == RELOAD_FOR_OPERAND_ADDRESS \ 23618334Speter || (when1) == RELOAD_FOR_OTHER_ADDRESS)) 23718334Speter 23850605Sobrien /* If we are going to reload an address, compute the reload type to 23950605Sobrien use. */ 24050605Sobrien#define ADDR_TYPE(type) \ 24150605Sobrien ((type) == RELOAD_FOR_INPUT_ADDRESS \ 24250605Sobrien ? RELOAD_FOR_INPADDR_ADDRESS \ 24350605Sobrien : ((type) == RELOAD_FOR_OUTPUT_ADDRESS \ 24450605Sobrien ? RELOAD_FOR_OUTADDR_ADDRESS \ 24550605Sobrien : (type))) 24650605Sobrien 247132727Skanstatic int push_secondary_reload (int, rtx, int, int, enum reg_class, 248132727Skan enum machine_mode, enum reload_type, 249169699Skan enum insn_code *, secondary_reload_info *); 250169699Skanstatic enum reg_class find_valid_class (enum machine_mode, enum machine_mode, 251169699Skan int, unsigned int); 252132727Skanstatic int reload_inner_reg_of_subreg (rtx, enum machine_mode, int); 253132727Skanstatic void push_replacement (rtx *, int, enum machine_mode); 254132727Skanstatic void dup_replacements (rtx *, rtx *); 255132727Skanstatic void combine_reloads (void); 256132727Skanstatic int find_reusable_reload (rtx *, rtx, enum reg_class, 257132727Skan enum reload_type, int, int); 258132727Skanstatic rtx find_dummy_reload (rtx, rtx, rtx *, rtx *, enum machine_mode, 259132727Skan enum machine_mode, enum reg_class, int, int); 260132727Skanstatic int hard_reg_set_here_p (unsigned int, unsigned int, rtx); 261132727Skanstatic struct decomposition decompose (rtx); 262132727Skanstatic int immune_p (rtx, rtx, struct decomposition); 263132727Skanstatic int alternative_allows_memconst (const char *, int); 264132727Skanstatic rtx find_reloads_toplev (rtx, int, enum reload_type, int, int, rtx, 265132727Skan int *); 266132727Skanstatic rtx make_memloc (rtx, int); 267132727Skanstatic int maybe_memory_address_p (enum machine_mode, rtx, rtx *); 268132727Skanstatic int find_reloads_address (enum machine_mode, rtx *, rtx, rtx *, 269132727Skan int, enum reload_type, int, rtx); 270132727Skanstatic rtx subst_reg_equivs (rtx, rtx); 271132727Skanstatic rtx subst_indexed_address (rtx); 272132727Skanstatic void update_auto_inc_notes (rtx, int, int); 273169699Skanstatic int find_reloads_address_1 (enum machine_mode, rtx, int, 274169699Skan enum rtx_code, enum rtx_code, rtx *, 275132727Skan int, enum reload_type,int, rtx); 276132727Skanstatic void find_reloads_address_part (rtx, rtx *, enum reg_class, 277132727Skan enum machine_mode, int, 278132727Skan enum reload_type, int); 279132727Skanstatic rtx find_reloads_subreg_address (rtx, int, int, enum reload_type, 280132727Skan int, rtx); 281132727Skanstatic void copy_replacements_1 (rtx *, rtx *, int); 282132727Skanstatic int find_inc_amount (rtx, rtx); 283169699Skanstatic int refers_to_mem_for_reload_p (rtx); 284169699Skanstatic int refers_to_regno_for_reload_p (unsigned int, unsigned int, 285169699Skan rtx, rtx *); 286169699Skan 287169699Skan/* Add NEW to reg_equiv_alt_mem_list[REGNO] if it's not present in the 288169699Skan list yet. */ 289169699Skan 290169699Skanstatic void 291169699Skanpush_reg_equiv_alt_mem (int regno, rtx mem) 292169699Skan{ 293169699Skan rtx it; 294169699Skan 295169699Skan for (it = reg_equiv_alt_mem_list [regno]; it; it = XEXP (it, 1)) 296169699Skan if (rtx_equal_p (XEXP (it, 0), mem)) 297169699Skan return; 298169699Skan 299169699Skan reg_equiv_alt_mem_list [regno] 300169699Skan = alloc_EXPR_LIST (REG_EQUIV, mem, 301169699Skan reg_equiv_alt_mem_list [regno]); 302169699Skan} 30318334Speter 30418334Speter/* Determine if any secondary reloads are needed for loading (if IN_P is 305117404Skan nonzero) or storing (if IN_P is zero) X to or from a reload register of 30618334Speter register class RELOAD_CLASS in mode RELOAD_MODE. If secondary reloads 30718334Speter are needed, push them. 30818334Speter 30918334Speter Return the reload number of the secondary reload we made, or -1 if 31018334Speter we didn't need one. *PICODE is set to the insn_code to use if we do 31118334Speter need a secondary reload. */ 31218334Speter 31318334Speterstatic int 314132727Skanpush_secondary_reload (int in_p, rtx x, int opnum, int optional, 315132727Skan enum reg_class reload_class, 316132727Skan enum machine_mode reload_mode, enum reload_type type, 317169699Skan enum insn_code *picode, secondary_reload_info *prev_sri) 31818334Speter{ 31918334Speter enum reg_class class = NO_REGS; 320169699Skan enum reg_class scratch_class; 32118334Speter enum machine_mode mode = reload_mode; 32218334Speter enum insn_code icode = CODE_FOR_nothing; 32318334Speter enum insn_code t_icode = CODE_FOR_nothing; 32418334Speter enum reload_type secondary_type; 32518334Speter int s_reload, t_reload = -1; 326169699Skan const char *scratch_constraint; 327169699Skan char letter; 328169699Skan secondary_reload_info sri; 32918334Speter 33050605Sobrien if (type == RELOAD_FOR_INPUT_ADDRESS 33150605Sobrien || type == RELOAD_FOR_OUTPUT_ADDRESS 33250605Sobrien || type == RELOAD_FOR_INPADDR_ADDRESS 33350605Sobrien || type == RELOAD_FOR_OUTADDR_ADDRESS) 33418334Speter secondary_type = type; 33518334Speter else 33618334Speter secondary_type = in_p ? RELOAD_FOR_INPUT_ADDRESS : RELOAD_FOR_OUTPUT_ADDRESS; 33718334Speter 33818334Speter *picode = CODE_FOR_nothing; 33918334Speter 34018334Speter /* If X is a paradoxical SUBREG, use the inner value to determine both the 34118334Speter mode and object being reloaded. */ 34218334Speter if (GET_CODE (x) == SUBREG 34318334Speter && (GET_MODE_SIZE (GET_MODE (x)) 34418334Speter > GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))) 34518334Speter { 34618334Speter x = SUBREG_REG (x); 34718334Speter reload_mode = GET_MODE (x); 34818334Speter } 34918334Speter 35018334Speter /* If X is a pseudo-register that has an equivalent MEM (actually, if it 35118334Speter is still a pseudo-register by now, it *must* have an equivalent MEM 35218334Speter but we don't want to assume that), use that equivalent when seeing if 35318334Speter a secondary reload is needed since whether or not a reload is needed 35418334Speter might be sensitive to the form of the MEM. */ 35518334Speter 356169699Skan if (REG_P (x) && REGNO (x) >= FIRST_PSEUDO_REGISTER 35718334Speter && reg_equiv_mem[REGNO (x)] != 0) 35818334Speter x = reg_equiv_mem[REGNO (x)]; 35918334Speter 360169699Skan sri.icode = CODE_FOR_nothing; 361169699Skan sri.prev_sri = prev_sri; 362169699Skan class = targetm.secondary_reload (in_p, x, reload_class, reload_mode, &sri); 363169699Skan icode = sri.icode; 36418334Speter 36518334Speter /* If we don't need any secondary registers, done. */ 366169699Skan if (class == NO_REGS && icode == CODE_FOR_nothing) 36718334Speter return -1; 36818334Speter 369169699Skan if (class != NO_REGS) 370169699Skan t_reload = push_secondary_reload (in_p, x, opnum, optional, class, 371169699Skan reload_mode, type, &t_icode, &sri); 37218334Speter 373169699Skan /* If we will be using an insn, the secondary reload is for a 374169699Skan scratch register. */ 37518334Speter 37618334Speter if (icode != CODE_FOR_nothing) 37718334Speter { 378117404Skan /* If IN_P is nonzero, the reload register will be the output in 37918334Speter operand 0. If IN_P is zero, the reload register will be the input 38018334Speter in operand 1. Outputs should have an initial "=", which we must 38118334Speter skip. */ 38218334Speter 383169699Skan /* ??? It would be useful to be able to handle only two, or more than 384169699Skan three, operands, but for now we can only handle the case of having 385169699Skan exactly three: output, input and one temp/scratch. */ 386169699Skan gcc_assert (insn_data[(int) icode].n_operands == 3); 38718334Speter 388169699Skan /* ??? We currently have no way to represent a reload that needs 389169699Skan an icode to reload from an intermediate tertiary reload register. 390169699Skan We should probably have a new field in struct reload to tag a 391169699Skan chain of scratch operand reloads onto. */ 392169699Skan gcc_assert (class == NO_REGS); 39390285Sobrien 394169699Skan scratch_constraint = insn_data[(int) icode].operand[2].constraint; 395169699Skan gcc_assert (*scratch_constraint == '='); 396169699Skan scratch_constraint++; 397169699Skan if (*scratch_constraint == '&') 398169699Skan scratch_constraint++; 399169699Skan letter = *scratch_constraint; 400169699Skan scratch_class = (letter == 'r' ? GENERAL_REGS 401169699Skan : REG_CLASS_FROM_CONSTRAINT ((unsigned char) letter, 402169699Skan scratch_constraint)); 40390285Sobrien 404169699Skan class = scratch_class; 405169699Skan mode = insn_data[(int) icode].operand[2].mode; 40618334Speter } 40718334Speter 40818334Speter /* This case isn't valid, so fail. Reload is allowed to use the same 40918334Speter register for RELOAD_FOR_INPUT_ADDRESS and RELOAD_FOR_INPUT reloads, but 41018334Speter in the case of a secondary register, we actually need two different 41118334Speter registers for correct code. We fail here to prevent the possibility of 41218334Speter silently generating incorrect code later. 41318334Speter 41418334Speter The convention is that secondary input reloads are valid only if the 41518334Speter secondary_class is different from class. If you have such a case, you 41618334Speter can not use secondary reloads, you must work around the problem some 41718334Speter other way. 41818334Speter 41990285Sobrien Allow this when a reload_in/out pattern is being used. I.e. assume 42090285Sobrien that the generated code handles this case. */ 42118334Speter 422169699Skan gcc_assert (!in_p || class != reload_class || icode != CODE_FOR_nothing 423169699Skan || t_icode != CODE_FOR_nothing); 42418334Speter 42518334Speter /* See if we can reuse an existing secondary reload. */ 42618334Speter for (s_reload = 0; s_reload < n_reloads; s_reload++) 42790285Sobrien if (rld[s_reload].secondary_p 42890285Sobrien && (reg_class_subset_p (class, rld[s_reload].class) 42990285Sobrien || reg_class_subset_p (rld[s_reload].class, class)) 43090285Sobrien && ((in_p && rld[s_reload].inmode == mode) 43190285Sobrien || (! in_p && rld[s_reload].outmode == mode)) 43290285Sobrien && ((in_p && rld[s_reload].secondary_in_reload == t_reload) 43390285Sobrien || (! in_p && rld[s_reload].secondary_out_reload == t_reload)) 43490285Sobrien && ((in_p && rld[s_reload].secondary_in_icode == t_icode) 43590285Sobrien || (! in_p && rld[s_reload].secondary_out_icode == t_icode)) 436169699Skan && (SMALL_REGISTER_CLASS_P (class) || SMALL_REGISTER_CLASSES) 43790285Sobrien && MERGABLE_RELOADS (secondary_type, rld[s_reload].when_needed, 43890285Sobrien opnum, rld[s_reload].opnum)) 43918334Speter { 44018334Speter if (in_p) 44190285Sobrien rld[s_reload].inmode = mode; 44218334Speter if (! in_p) 44390285Sobrien rld[s_reload].outmode = mode; 44418334Speter 44590285Sobrien if (reg_class_subset_p (class, rld[s_reload].class)) 44690285Sobrien rld[s_reload].class = class; 44718334Speter 44890285Sobrien rld[s_reload].opnum = MIN (rld[s_reload].opnum, opnum); 44990285Sobrien rld[s_reload].optional &= optional; 45090285Sobrien rld[s_reload].secondary_p = 1; 45190285Sobrien if (MERGE_TO_OTHER (secondary_type, rld[s_reload].when_needed, 45290285Sobrien opnum, rld[s_reload].opnum)) 45390285Sobrien rld[s_reload].when_needed = RELOAD_OTHER; 45418334Speter } 45518334Speter 45618334Speter if (s_reload == n_reloads) 45718334Speter { 45850605Sobrien#ifdef SECONDARY_MEMORY_NEEDED 45950605Sobrien /* If we need a memory location to copy between the two reload regs, 46050605Sobrien set it up now. Note that we do the input case before making 46190285Sobrien the reload and the output case after. This is due to the 46250605Sobrien way reloads are output. */ 46350605Sobrien 46450605Sobrien if (in_p && icode == CODE_FOR_nothing 46550605Sobrien && SECONDARY_MEMORY_NEEDED (class, reload_class, mode)) 46670639Sobrien { 46770639Sobrien get_secondary_mem (x, reload_mode, opnum, type); 46870639Sobrien 46970639Sobrien /* We may have just added new reloads. Make sure we add 47070639Sobrien the new reload at the end. */ 47170639Sobrien s_reload = n_reloads; 47270639Sobrien } 47350605Sobrien#endif 47450605Sobrien 47518334Speter /* We need to make a new secondary reload for this register class. */ 47690285Sobrien rld[s_reload].in = rld[s_reload].out = 0; 47790285Sobrien rld[s_reload].class = class; 47818334Speter 47990285Sobrien rld[s_reload].inmode = in_p ? mode : VOIDmode; 48090285Sobrien rld[s_reload].outmode = ! in_p ? mode : VOIDmode; 48190285Sobrien rld[s_reload].reg_rtx = 0; 48290285Sobrien rld[s_reload].optional = optional; 48390285Sobrien rld[s_reload].inc = 0; 48418334Speter /* Maybe we could combine these, but it seems too tricky. */ 48590285Sobrien rld[s_reload].nocombine = 1; 48690285Sobrien rld[s_reload].in_reg = 0; 48790285Sobrien rld[s_reload].out_reg = 0; 48890285Sobrien rld[s_reload].opnum = opnum; 48990285Sobrien rld[s_reload].when_needed = secondary_type; 49090285Sobrien rld[s_reload].secondary_in_reload = in_p ? t_reload : -1; 49190285Sobrien rld[s_reload].secondary_out_reload = ! in_p ? t_reload : -1; 49290285Sobrien rld[s_reload].secondary_in_icode = in_p ? t_icode : CODE_FOR_nothing; 49390285Sobrien rld[s_reload].secondary_out_icode 49418334Speter = ! in_p ? t_icode : CODE_FOR_nothing; 49590285Sobrien rld[s_reload].secondary_p = 1; 49618334Speter 49718334Speter n_reloads++; 49818334Speter 49918334Speter#ifdef SECONDARY_MEMORY_NEEDED 50018334Speter if (! in_p && icode == CODE_FOR_nothing 50150605Sobrien && SECONDARY_MEMORY_NEEDED (reload_class, class, mode)) 50250605Sobrien get_secondary_mem (x, mode, opnum, type); 50318334Speter#endif 50418334Speter } 50518334Speter 50618334Speter *picode = icode; 50718334Speter return s_reload; 50818334Speter} 509169699Skan 510169699Skan/* If a secondary reload is needed, return its class. If both an intermediate 511169699Skan register and a scratch register is needed, we return the class of the 512169699Skan intermediate register. */ 513169699Skanenum reg_class 514169699Skansecondary_reload_class (bool in_p, enum reg_class class, 515169699Skan enum machine_mode mode, rtx x) 516169699Skan{ 517169699Skan enum insn_code icode; 518169699Skan secondary_reload_info sri; 519169699Skan 520169699Skan sri.icode = CODE_FOR_nothing; 521169699Skan sri.prev_sri = NULL; 522169699Skan class = targetm.secondary_reload (in_p, x, class, mode, &sri); 523169699Skan icode = sri.icode; 524169699Skan 525169699Skan /* If there are no secondary reloads at all, we return NO_REGS. 526169699Skan If an intermediate register is needed, we return its class. */ 527169699Skan if (icode == CODE_FOR_nothing || class != NO_REGS) 528169699Skan return class; 529169699Skan 530169699Skan /* No intermediate register is needed, but we have a special reload 531169699Skan pattern, which we assume for now needs a scratch register. */ 532169699Skan return scratch_reload_class (icode); 533169699Skan} 534169699Skan 535169699Skan/* ICODE is the insn_code of a reload pattern. Check that it has exactly 536169699Skan three operands, verify that operand 2 is an output operand, and return 537169699Skan its register class. 538169699Skan ??? We'd like to be able to handle any pattern with at least 2 operands, 539169699Skan for zero or more scratch registers, but that needs more infrastructure. */ 540169699Skanenum reg_class 541169699Skanscratch_reload_class (enum insn_code icode) 542169699Skan{ 543169699Skan const char *scratch_constraint; 544169699Skan char scratch_letter; 545169699Skan enum reg_class class; 546169699Skan 547169699Skan gcc_assert (insn_data[(int) icode].n_operands == 3); 548169699Skan scratch_constraint = insn_data[(int) icode].operand[2].constraint; 549169699Skan gcc_assert (*scratch_constraint == '='); 550169699Skan scratch_constraint++; 551169699Skan if (*scratch_constraint == '&') 552169699Skan scratch_constraint++; 553169699Skan scratch_letter = *scratch_constraint; 554169699Skan if (scratch_letter == 'r') 555169699Skan return GENERAL_REGS; 556169699Skan class = REG_CLASS_FROM_CONSTRAINT ((unsigned char) scratch_letter, 557169699Skan scratch_constraint); 558169699Skan gcc_assert (class != NO_REGS); 559169699Skan return class; 560169699Skan} 56118334Speter 56218334Speter#ifdef SECONDARY_MEMORY_NEEDED 56318334Speter 56490285Sobrien/* Return a memory location that will be used to copy X in mode MODE. 56518334Speter If we haven't already made a location for this mode in this insn, 56618334Speter call find_reloads_address on the location being returned. */ 56718334Speter 56818334Speterrtx 569132727Skanget_secondary_mem (rtx x ATTRIBUTE_UNUSED, enum machine_mode mode, 570132727Skan int opnum, enum reload_type type) 57118334Speter{ 57218334Speter rtx loc; 57318334Speter int mem_valid; 57418334Speter 57518334Speter /* By default, if MODE is narrower than a word, widen it to a word. 57618334Speter This is required because most machines that require these memory 57718334Speter locations do not support short load and stores from all registers 57818334Speter (e.g., FP registers). */ 57918334Speter 58018334Speter#ifdef SECONDARY_MEMORY_NEEDED_MODE 58118334Speter mode = SECONDARY_MEMORY_NEEDED_MODE (mode); 58218334Speter#else 58390285Sobrien if (GET_MODE_BITSIZE (mode) < BITS_PER_WORD && INTEGRAL_MODE_P (mode)) 58418334Speter mode = mode_for_size (BITS_PER_WORD, GET_MODE_CLASS (mode), 0); 58518334Speter#endif 58618334Speter 58718334Speter /* If we already have made a MEM for this operand in MODE, return it. */ 58818334Speter if (secondary_memlocs_elim[(int) mode][opnum] != 0) 58918334Speter return secondary_memlocs_elim[(int) mode][opnum]; 59018334Speter 59190285Sobrien /* If this is the first time we've tried to get a MEM for this mode, 59218334Speter allocate a new one. `something_changed' in reload will get set 59318334Speter by noticing that the frame size has changed. */ 59418334Speter 59518334Speter if (secondary_memlocs[(int) mode] == 0) 59618334Speter { 59718334Speter#ifdef SECONDARY_MEMORY_NEEDED_RTX 59818334Speter secondary_memlocs[(int) mode] = SECONDARY_MEMORY_NEEDED_RTX (mode); 59918334Speter#else 60018334Speter secondary_memlocs[(int) mode] 60118334Speter = assign_stack_local (mode, GET_MODE_SIZE (mode), 0); 60218334Speter#endif 60318334Speter } 60418334Speter 60518334Speter /* Get a version of the address doing any eliminations needed. If that 60618334Speter didn't give us a new MEM, make a new one if it isn't valid. */ 60718334Speter 60818334Speter loc = eliminate_regs (secondary_memlocs[(int) mode], VOIDmode, NULL_RTX); 60918334Speter mem_valid = strict_memory_address_p (mode, XEXP (loc, 0)); 61018334Speter 61118334Speter if (! mem_valid && loc == secondary_memlocs[(int) mode]) 61218334Speter loc = copy_rtx (loc); 61318334Speter 61418334Speter /* The only time the call below will do anything is if the stack 61518334Speter offset is too large. In that case IND_LEVELS doesn't matter, so we 61618334Speter can just pass a zero. Adjust the type to be the address of the 61718334Speter corresponding object. If the address was valid, save the eliminated 61818334Speter address. If it wasn't valid, we need to make a reload each time, so 61918334Speter don't save it. */ 62018334Speter 62118334Speter if (! mem_valid) 62218334Speter { 62318334Speter type = (type == RELOAD_FOR_INPUT ? RELOAD_FOR_INPUT_ADDRESS 62418334Speter : type == RELOAD_FOR_OUTPUT ? RELOAD_FOR_OUTPUT_ADDRESS 62518334Speter : RELOAD_OTHER); 62618334Speter 627117404Skan find_reloads_address (mode, &loc, XEXP (loc, 0), &XEXP (loc, 0), 62850605Sobrien opnum, type, 0, 0); 62918334Speter } 63018334Speter 63118334Speter secondary_memlocs_elim[(int) mode][opnum] = loc; 632132727Skan if (secondary_memlocs_elim_used <= (int)mode) 633132727Skan secondary_memlocs_elim_used = (int)mode + 1; 63418334Speter return loc; 63518334Speter} 63618334Speter 63718334Speter/* Clear any secondary memory locations we've made. */ 63818334Speter 63918334Spetervoid 640132727Skanclear_secondary_mem (void) 64118334Speter{ 642132727Skan memset (secondary_memlocs, 0, sizeof secondary_memlocs); 64318334Speter} 64418334Speter#endif /* SECONDARY_MEMORY_NEEDED */ 64518334Speter 64650605Sobrien 647169699Skan/* Find the largest class which has at least one register valid in 648169699Skan mode INNER, and which for every such register, that register number 649169699Skan plus N is also valid in OUTER (if in range) and is cheap to move 650169699Skan into REGNO. Such a class must exist. */ 651169699Skan 65250605Sobrienstatic enum reg_class 653169699Skanfind_valid_class (enum machine_mode outer ATTRIBUTE_UNUSED, 654169699Skan enum machine_mode inner ATTRIBUTE_UNUSED, int n, 655132727Skan unsigned int dest_regno ATTRIBUTE_UNUSED) 65650605Sobrien{ 657102798Skan int best_cost = -1; 65850605Sobrien int class; 65950605Sobrien int regno; 66090285Sobrien enum reg_class best_class = NO_REGS; 661132727Skan enum reg_class dest_class ATTRIBUTE_UNUSED = REGNO_REG_CLASS (dest_regno); 66290285Sobrien unsigned int best_size = 0; 663102798Skan int cost; 66450605Sobrien 66550605Sobrien for (class = 1; class < N_REG_CLASSES; class++) 66650605Sobrien { 66750605Sobrien int bad = 0; 668169699Skan int good = 0; 669169699Skan for (regno = 0; regno < FIRST_PSEUDO_REGISTER - n && ! bad; regno++) 670169699Skan if (TEST_HARD_REG_BIT (reg_class_contents[class], regno)) 671169699Skan { 672169699Skan if (HARD_REGNO_MODE_OK (regno, inner)) 673169699Skan { 674169699Skan good = 1; 675169699Skan if (! TEST_HARD_REG_BIT (reg_class_contents[class], regno + n) 676169699Skan || ! HARD_REGNO_MODE_OK (regno + n, outer)) 677169699Skan bad = 1; 678169699Skan } 679169699Skan } 68050605Sobrien 681169699Skan if (bad || !good) 682102798Skan continue; 683169699Skan cost = REGISTER_MOVE_COST (outer, class, dest_class); 684102798Skan 685102798Skan if ((reg_class_size[class] > best_size 686102798Skan && (best_cost < 0 || best_cost >= cost)) 687102798Skan || best_cost > cost) 688102798Skan { 689102798Skan best_class = class; 690102798Skan best_size = reg_class_size[class]; 691169699Skan best_cost = REGISTER_MOVE_COST (outer, class, dest_class); 692102798Skan } 69350605Sobrien } 69450605Sobrien 695169699Skan gcc_assert (best_size != 0); 69650605Sobrien 69750605Sobrien return best_class; 69850605Sobrien} 69950605Sobrien 70052557Sobrien/* Return the number of a previously made reload that can be combined with 70152557Sobrien a new one, or n_reloads if none of the existing reloads can be used. 70252557Sobrien OUT, CLASS, TYPE and OPNUM are the same arguments as passed to 70352557Sobrien push_reload, they determine the kind of the new reload that we try to 70452557Sobrien combine. P_IN points to the corresponding value of IN, which can be 70552557Sobrien modified by this function. 70652557Sobrien DONT_SHARE is nonzero if we can't share any input-only reload for IN. */ 70790285Sobrien 70852557Sobrienstatic int 709132727Skanfind_reusable_reload (rtx *p_in, rtx out, enum reg_class class, 710132727Skan enum reload_type type, int opnum, int dont_share) 71152557Sobrien{ 71252557Sobrien rtx in = *p_in; 71352557Sobrien int i; 71452557Sobrien /* We can't merge two reloads if the output of either one is 71552557Sobrien earlyclobbered. */ 71652557Sobrien 71752557Sobrien if (earlyclobber_operand_p (out)) 71852557Sobrien return n_reloads; 71952557Sobrien 72052557Sobrien /* We can use an existing reload if the class is right 72152557Sobrien and at least one of IN and OUT is a match 72252557Sobrien and the other is at worst neutral. 72390285Sobrien (A zero compared against anything is neutral.) 72452557Sobrien 72552557Sobrien If SMALL_REGISTER_CLASSES, don't use existing reloads unless they are 72652557Sobrien for the same thing since that can cause us to need more reload registers 72752557Sobrien than we otherwise would. */ 72890285Sobrien 72952557Sobrien for (i = 0; i < n_reloads; i++) 73090285Sobrien if ((reg_class_subset_p (class, rld[i].class) 73190285Sobrien || reg_class_subset_p (rld[i].class, class)) 73252557Sobrien /* If the existing reload has a register, it must fit our class. */ 73390285Sobrien && (rld[i].reg_rtx == 0 73452557Sobrien || TEST_HARD_REG_BIT (reg_class_contents[(int) class], 73590285Sobrien true_regnum (rld[i].reg_rtx))) 73690285Sobrien && ((in != 0 && MATCHES (rld[i].in, in) && ! dont_share 73790285Sobrien && (out == 0 || rld[i].out == 0 || MATCHES (rld[i].out, out))) 73890285Sobrien || (out != 0 && MATCHES (rld[i].out, out) 73990285Sobrien && (in == 0 || rld[i].in == 0 || MATCHES (rld[i].in, in)))) 74090285Sobrien && (rld[i].out == 0 || ! earlyclobber_operand_p (rld[i].out)) 741169699Skan && (SMALL_REGISTER_CLASS_P (class) || SMALL_REGISTER_CLASSES) 74290285Sobrien && MERGABLE_RELOADS (type, rld[i].when_needed, opnum, rld[i].opnum)) 74352557Sobrien return i; 74452557Sobrien 74552557Sobrien /* Reloading a plain reg for input can match a reload to postincrement 74652557Sobrien that reg, since the postincrement's value is the right value. 74752557Sobrien Likewise, it can match a preincrement reload, since we regard 74852557Sobrien the preincrementation as happening before any ref in this insn 74952557Sobrien to that register. */ 75052557Sobrien for (i = 0; i < n_reloads; i++) 75190285Sobrien if ((reg_class_subset_p (class, rld[i].class) 75290285Sobrien || reg_class_subset_p (rld[i].class, class)) 75352557Sobrien /* If the existing reload has a register, it must fit our 75452557Sobrien class. */ 75590285Sobrien && (rld[i].reg_rtx == 0 75652557Sobrien || TEST_HARD_REG_BIT (reg_class_contents[(int) class], 75790285Sobrien true_regnum (rld[i].reg_rtx))) 75890285Sobrien && out == 0 && rld[i].out == 0 && rld[i].in != 0 759169699Skan && ((REG_P (in) 760169699Skan && GET_RTX_CLASS (GET_CODE (rld[i].in)) == RTX_AUTOINC 76190285Sobrien && MATCHES (XEXP (rld[i].in, 0), in)) 762169699Skan || (REG_P (rld[i].in) 763169699Skan && GET_RTX_CLASS (GET_CODE (in)) == RTX_AUTOINC 76490285Sobrien && MATCHES (XEXP (in, 0), rld[i].in))) 76590285Sobrien && (rld[i].out == 0 || ! earlyclobber_operand_p (rld[i].out)) 766169699Skan && (SMALL_REGISTER_CLASS_P (class) || SMALL_REGISTER_CLASSES) 76790285Sobrien && MERGABLE_RELOADS (type, rld[i].when_needed, 76890285Sobrien opnum, rld[i].opnum)) 76952557Sobrien { 77052557Sobrien /* Make sure reload_in ultimately has the increment, 77152557Sobrien not the plain register. */ 772169699Skan if (REG_P (in)) 77390285Sobrien *p_in = rld[i].in; 77452557Sobrien return i; 77552557Sobrien } 77652557Sobrien return n_reloads; 77752557Sobrien} 77852557Sobrien 77990285Sobrien/* Return nonzero if X is a SUBREG which will require reloading of its 78090285Sobrien SUBREG_REG expression. */ 78190285Sobrien 78290285Sobrienstatic int 783132727Skanreload_inner_reg_of_subreg (rtx x, enum machine_mode mode, int output) 78490285Sobrien{ 78590285Sobrien rtx inner; 78690285Sobrien 78790285Sobrien /* Only SUBREGs are problematical. */ 78890285Sobrien if (GET_CODE (x) != SUBREG) 78990285Sobrien return 0; 79090285Sobrien 79190285Sobrien inner = SUBREG_REG (x); 79290285Sobrien 79390285Sobrien /* If INNER is a constant or PLUS, then INNER must be reloaded. */ 79490285Sobrien if (CONSTANT_P (inner) || GET_CODE (inner) == PLUS) 79590285Sobrien return 1; 79690285Sobrien 79790285Sobrien /* If INNER is not a hard register, then INNER will not need to 79890285Sobrien be reloaded. */ 799169699Skan if (!REG_P (inner) 80090285Sobrien || REGNO (inner) >= FIRST_PSEUDO_REGISTER) 80190285Sobrien return 0; 80290285Sobrien 80390285Sobrien /* If INNER is not ok for MODE, then INNER will need reloading. */ 80490285Sobrien if (! HARD_REGNO_MODE_OK (subreg_regno (x), mode)) 80590285Sobrien return 1; 80690285Sobrien 80790285Sobrien /* If the outer part is a word or smaller, INNER larger than a 80890285Sobrien word and the number of regs for INNER is not the same as the 80990285Sobrien number of words in INNER, then INNER will need reloading. */ 81090285Sobrien return (GET_MODE_SIZE (mode) <= UNITS_PER_WORD 811107605Sobrien && output 81290285Sobrien && GET_MODE_SIZE (GET_MODE (inner)) > UNITS_PER_WORD 81390285Sobrien && ((GET_MODE_SIZE (GET_MODE (inner)) / UNITS_PER_WORD) 814169699Skan != (int) hard_regno_nregs[REGNO (inner)][GET_MODE (inner)])); 81590285Sobrien} 81690285Sobrien 817132727Skan/* Return nonzero if IN can be reloaded into REGNO with mode MODE without 818132727Skan requiring an extra reload register. The caller has already found that 819132727Skan IN contains some reference to REGNO, so check that we can produce the 820132727Skan new value in a single step. E.g. if we have 821132727Skan (set (reg r13) (plus (reg r13) (const int 1))), and there is an 822132727Skan instruction that adds one to a register, this should succeed. 823132727Skan However, if we have something like 824132727Skan (set (reg r13) (plus (reg r13) (const int 999))), and the constant 999 825132727Skan needs to be loaded into a register first, we need a separate reload 826132727Skan register. 827132727Skan Such PLUS reloads are generated by find_reload_address_part. 828132727Skan The out-of-range PLUS expressions are usually introduced in the instruction 829132727Skan patterns by register elimination and substituting pseudos without a home 830132727Skan by their function-invariant equivalences. */ 831132727Skanstatic int 832132727Skancan_reload_into (rtx in, int regno, enum machine_mode mode) 833132727Skan{ 834132727Skan rtx dst, test_insn; 835132727Skan int r = 0; 836132727Skan struct recog_data save_recog_data; 837132727Skan 838132727Skan /* For matching constraints, we often get notional input reloads where 839132727Skan we want to use the original register as the reload register. I.e. 840132727Skan technically this is a non-optional input-output reload, but IN is 841132727Skan already a valid register, and has been chosen as the reload register. 842132727Skan Speed this up, since it trivially works. */ 843169699Skan if (REG_P (in)) 844132727Skan return 1; 845132727Skan 846132727Skan /* To test MEMs properly, we'd have to take into account all the reloads 847132727Skan that are already scheduled, which can become quite complicated. 848132727Skan And since we've already handled address reloads for this MEM, it 849132727Skan should always succeed anyway. */ 850169699Skan if (MEM_P (in)) 851132727Skan return 1; 852132727Skan 853132727Skan /* If we can make a simple SET insn that does the job, everything should 854132727Skan be fine. */ 855132727Skan dst = gen_rtx_REG (mode, regno); 856132727Skan test_insn = make_insn_raw (gen_rtx_SET (VOIDmode, dst, in)); 857132727Skan save_recog_data = recog_data; 858132727Skan if (recog_memoized (test_insn) >= 0) 859132727Skan { 860132727Skan extract_insn (test_insn); 861132727Skan r = constrain_operands (1); 862132727Skan } 863132727Skan recog_data = save_recog_data; 864132727Skan return r; 865132727Skan} 866132727Skan 86718334Speter/* Record one reload that needs to be performed. 86818334Speter IN is an rtx saying where the data are to be found before this instruction. 86918334Speter OUT says where they must be stored after the instruction. 87018334Speter (IN is zero for data not read, and OUT is zero for data not written.) 87118334Speter INLOC and OUTLOC point to the places in the instructions where 87218334Speter IN and OUT were found. 873117404Skan If IN and OUT are both nonzero, it means the same register must be used 87418334Speter to reload both IN and OUT. 87518334Speter 87618334Speter CLASS is a register class required for the reloaded data. 87718334Speter INMODE is the machine mode that the instruction requires 87818334Speter for the reg that replaces IN and OUTMODE is likewise for OUT. 87918334Speter 88018334Speter If IN is zero, then OUT's location and mode should be passed as 88118334Speter INLOC and INMODE. 88218334Speter 88318334Speter STRICT_LOW is the 1 if there is a containing STRICT_LOW_PART rtx. 88418334Speter 88518334Speter OPTIONAL nonzero means this reload does not need to be performed: 88618334Speter it can be discarded if that is more convenient. 88718334Speter 88818334Speter OPNUM and TYPE say what the purpose of this reload is. 88918334Speter 89018334Speter The return value is the reload-number for this reload. 89118334Speter 89218334Speter If both IN and OUT are nonzero, in some rare cases we might 89318334Speter want to make two separate reloads. (Actually we never do this now.) 89418334Speter Therefore, the reload-number for OUT is stored in 89518334Speter output_reloadnum when we return; the return value applies to IN. 89618334Speter Usually (presently always), when IN and OUT are nonzero, 89718334Speter the two reload-numbers are equal, but the caller should be careful to 89818334Speter distinguish them. */ 89918334Speter 90090285Sobrienint 901132727Skanpush_reload (rtx in, rtx out, rtx *inloc, rtx *outloc, 902132727Skan enum reg_class class, enum machine_mode inmode, 903132727Skan enum machine_mode outmode, int strict_low, int optional, 904132727Skan int opnum, enum reload_type type) 90518334Speter{ 90690285Sobrien int i; 90718334Speter int dont_share = 0; 90818334Speter int dont_remove_subreg = 0; 90918334Speter rtx *in_subreg_loc = 0, *out_subreg_loc = 0; 91018334Speter int secondary_in_reload = -1, secondary_out_reload = -1; 91118334Speter enum insn_code secondary_in_icode = CODE_FOR_nothing; 91218334Speter enum insn_code secondary_out_icode = CODE_FOR_nothing; 91318334Speter 91418334Speter /* INMODE and/or OUTMODE could be VOIDmode if no mode 91518334Speter has been specified for the operand. In that case, 91618334Speter use the operand's mode as the mode to reload. */ 91718334Speter if (inmode == VOIDmode && in != 0) 91818334Speter inmode = GET_MODE (in); 91918334Speter if (outmode == VOIDmode && out != 0) 92018334Speter outmode = GET_MODE (out); 92118334Speter 92290285Sobrien /* If IN is a pseudo register everywhere-equivalent to a constant, and 92318334Speter it is not in a hard register, reload straight from the constant, 92418334Speter since we want to get rid of such pseudo registers. 92518334Speter Often this is done earlier, but not always in find_reloads_address. */ 926169699Skan if (in != 0 && REG_P (in)) 92718334Speter { 92890285Sobrien int regno = REGNO (in); 92918334Speter 93018334Speter if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0 93118334Speter && reg_equiv_constant[regno] != 0) 93218334Speter in = reg_equiv_constant[regno]; 93318334Speter } 93418334Speter 93518334Speter /* Likewise for OUT. Of course, OUT will never be equivalent to 93618334Speter an actual constant, but it might be equivalent to a memory location 93718334Speter (in the case of a parameter). */ 938169699Skan if (out != 0 && REG_P (out)) 93918334Speter { 94090285Sobrien int regno = REGNO (out); 94118334Speter 94218334Speter if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0 94318334Speter && reg_equiv_constant[regno] != 0) 94418334Speter out = reg_equiv_constant[regno]; 94518334Speter } 94618334Speter 94718334Speter /* If we have a read-write operand with an address side-effect, 94818334Speter change either IN or OUT so the side-effect happens only once. */ 949169699Skan if (in != 0 && out != 0 && MEM_P (in) && rtx_equal_p (in, out)) 95090285Sobrien switch (GET_CODE (XEXP (in, 0))) 95190285Sobrien { 95290285Sobrien case POST_INC: case POST_DEC: case POST_MODIFY: 95390285Sobrien in = replace_equiv_address_nv (in, XEXP (XEXP (in, 0), 0)); 95490285Sobrien break; 95518334Speter 95690285Sobrien case PRE_INC: case PRE_DEC: case PRE_MODIFY: 95790285Sobrien out = replace_equiv_address_nv (out, XEXP (XEXP (out, 0), 0)); 95890285Sobrien break; 95990285Sobrien 96090285Sobrien default: 96190285Sobrien break; 96290285Sobrien } 96390285Sobrien 96418334Speter /* If we are reloading a (SUBREG constant ...), really reload just the 96518334Speter inside expression in its own mode. Similarly for (SUBREG (PLUS ...)). 96618334Speter If we have (SUBREG:M1 (MEM:M2 ...) ...) (or an inner REG that is still 96718334Speter a pseudo and hence will become a MEM) with M1 wider than M2 and the 96818334Speter register is a pseudo, also reload the inside expression. 96918334Speter For machines that extend byte loads, do this for any SUBREG of a pseudo 97018334Speter where both M1 and M2 are a word or smaller, M1 is wider than M2, and 97118334Speter M2 is an integral mode that gets extended when loaded. 97218334Speter Similar issue for (SUBREG:M1 (REG:M2 ...) ...) for a hard register R where 97318334Speter either M1 is not valid for R or M2 is wider than a word but we only 97418334Speter need one word to store an M2-sized quantity in R. 97518334Speter (However, if OUT is nonzero, we need to reload the reg *and* 97618334Speter the subreg, so do nothing here, and let following statement handle it.) 97718334Speter 97818334Speter Note that the case of (SUBREG (CONST_INT...)...) is handled elsewhere; 97918334Speter we can't handle it here because CONST_INT does not indicate a mode. 98018334Speter 98118334Speter Similarly, we must reload the inside expression if we have a 98218334Speter STRICT_LOW_PART (presumably, in == out in the cas). 98318334Speter 98418334Speter Also reload the inner expression if it does not require a secondary 98518334Speter reload but the SUBREG does. 98618334Speter 98718334Speter Finally, reload the inner expression if it is a register that is in 98818334Speter the class whose registers cannot be referenced in a different size 98990285Sobrien and M1 is not the same size as M2. If subreg_lowpart_p is false, we 99018334Speter cannot reload just the inside since we might end up with the wrong 99152557Sobrien register class. But if it is inside a STRICT_LOW_PART, we have 99252557Sobrien no choice, so we hope we do get the right register class there. */ 99318334Speter 99452557Sobrien if (in != 0 && GET_CODE (in) == SUBREG 99590285Sobrien && (subreg_lowpart_p (in) || strict_low) 996117404Skan#ifdef CANNOT_CHANGE_MODE_CLASS 997117404Skan && !CANNOT_CHANGE_MODE_CLASS (GET_MODE (SUBREG_REG (in)), inmode, class) 99818334Speter#endif 99918334Speter && (CONSTANT_P (SUBREG_REG (in)) 100018334Speter || GET_CODE (SUBREG_REG (in)) == PLUS 100118334Speter || strict_low 1002169699Skan || (((REG_P (SUBREG_REG (in)) 100318334Speter && REGNO (SUBREG_REG (in)) >= FIRST_PSEUDO_REGISTER) 1004169699Skan || MEM_P (SUBREG_REG (in))) 100518334Speter && ((GET_MODE_SIZE (inmode) 100618334Speter > GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))) 100718334Speter#ifdef LOAD_EXTEND_OP 100818334Speter || (GET_MODE_SIZE (inmode) <= UNITS_PER_WORD 100918334Speter && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))) 101018334Speter <= UNITS_PER_WORD) 101118334Speter && (GET_MODE_SIZE (inmode) 101218334Speter > GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))) 101318334Speter && INTEGRAL_MODE_P (GET_MODE (SUBREG_REG (in))) 1014169699Skan && LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (in))) != UNKNOWN) 101518334Speter#endif 101650605Sobrien#ifdef WORD_REGISTER_OPERATIONS 101750605Sobrien || ((GET_MODE_SIZE (inmode) 101850605Sobrien < GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))) 101950605Sobrien && ((GET_MODE_SIZE (inmode) - 1) / UNITS_PER_WORD == 102050605Sobrien ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))) - 1) 102150605Sobrien / UNITS_PER_WORD))) 102250605Sobrien#endif 102318334Speter )) 1024169699Skan || (REG_P (SUBREG_REG (in)) 102518334Speter && REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER 102618334Speter /* The case where out is nonzero 102718334Speter is handled differently in the following statement. */ 102890285Sobrien && (out == 0 || subreg_lowpart_p (in)) 102918334Speter && ((GET_MODE_SIZE (inmode) <= UNITS_PER_WORD 103018334Speter && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))) 103118334Speter > UNITS_PER_WORD) 103218334Speter && ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))) 103318334Speter / UNITS_PER_WORD) 1034169699Skan != (int) hard_regno_nregs[REGNO (SUBREG_REG (in))] 1035169699Skan [GET_MODE (SUBREG_REG (in))])) 103690285Sobrien || ! HARD_REGNO_MODE_OK (subreg_regno (in), inmode))) 1037169699Skan || (secondary_reload_class (1, class, inmode, in) != NO_REGS 1038169699Skan && (secondary_reload_class (1, class, GET_MODE (SUBREG_REG (in)), 1039169699Skan SUBREG_REG (in)) 104018334Speter == NO_REGS)) 1041117404Skan#ifdef CANNOT_CHANGE_MODE_CLASS 1042169699Skan || (REG_P (SUBREG_REG (in)) 104318334Speter && REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER 1044117404Skan && REG_CANNOT_CHANGE_MODE_P 1045117404Skan (REGNO (SUBREG_REG (in)), GET_MODE (SUBREG_REG (in)), inmode)) 104618334Speter#endif 104718334Speter )) 104818334Speter { 104918334Speter in_subreg_loc = inloc; 105018334Speter inloc = &SUBREG_REG (in); 105118334Speter in = *inloc; 105250605Sobrien#if ! defined (LOAD_EXTEND_OP) && ! defined (WORD_REGISTER_OPERATIONS) 1053169699Skan if (MEM_P (in)) 105418334Speter /* This is supposed to happen only for paradoxical subregs made by 105518334Speter combine.c. (SUBREG (MEM)) isn't supposed to occur other ways. */ 1056169699Skan gcc_assert (GET_MODE_SIZE (GET_MODE (in)) <= GET_MODE_SIZE (inmode)); 105718334Speter#endif 105818334Speter inmode = GET_MODE (in); 105918334Speter } 106018334Speter 106118334Speter /* Similar issue for (SUBREG:M1 (REG:M2 ...) ...) for a hard register R where 106218334Speter either M1 is not valid for R or M2 is wider than a word but we only 106318334Speter need one word to store an M2-sized quantity in R. 106418334Speter 106518334Speter However, we must reload the inner reg *as well as* the subreg in 106618334Speter that case. */ 106718334Speter 106850605Sobrien /* Similar issue for (SUBREG constant ...) if it was not handled by the 106990285Sobrien code above. This can happen if SUBREG_BYTE != 0. */ 107050605Sobrien 1071107605Sobrien if (in != 0 && reload_inner_reg_of_subreg (in, inmode, 0)) 107218334Speter { 107390285Sobrien enum reg_class in_class = class; 107490285Sobrien 1075169699Skan if (REG_P (SUBREG_REG (in))) 107690285Sobrien in_class 1077169699Skan = find_valid_class (inmode, GET_MODE (SUBREG_REG (in)), 107890285Sobrien subreg_regno_offset (REGNO (SUBREG_REG (in)), 107990285Sobrien GET_MODE (SUBREG_REG (in)), 108090285Sobrien SUBREG_BYTE (in), 1081102798Skan GET_MODE (in)), 1082102798Skan REGNO (SUBREG_REG (in))); 108390285Sobrien 108418334Speter /* This relies on the fact that emit_reload_insns outputs the 108518334Speter instructions for input reloads of type RELOAD_OTHER in the same 108618334Speter order as the reloads. Thus if the outer reload is also of type 108718334Speter RELOAD_OTHER, we are guaranteed that this inner reload will be 108818334Speter output before the outer reload. */ 108990285Sobrien push_reload (SUBREG_REG (in), NULL_RTX, &SUBREG_REG (in), (rtx *) 0, 109090285Sobrien in_class, VOIDmode, VOIDmode, 0, 0, opnum, type); 109118334Speter dont_remove_subreg = 1; 109218334Speter } 109318334Speter 109418334Speter /* Similarly for paradoxical and problematical SUBREGs on the output. 109518334Speter Note that there is no reason we need worry about the previous value 109618334Speter of SUBREG_REG (out); even if wider than out, 109718334Speter storing in a subreg is entitled to clobber it all 109818334Speter (except in the case of STRICT_LOW_PART, 109918334Speter and in that case the constraint should label it input-output.) */ 110052557Sobrien if (out != 0 && GET_CODE (out) == SUBREG 110190285Sobrien && (subreg_lowpart_p (out) || strict_low) 1102117404Skan#ifdef CANNOT_CHANGE_MODE_CLASS 1103117404Skan && !CANNOT_CHANGE_MODE_CLASS (GET_MODE (SUBREG_REG (out)), outmode, class) 110418334Speter#endif 110518334Speter && (CONSTANT_P (SUBREG_REG (out)) 110618334Speter || strict_low 1107169699Skan || (((REG_P (SUBREG_REG (out)) 110818334Speter && REGNO (SUBREG_REG (out)) >= FIRST_PSEUDO_REGISTER) 1109169699Skan || MEM_P (SUBREG_REG (out))) 111018334Speter && ((GET_MODE_SIZE (outmode) 111150605Sobrien > GET_MODE_SIZE (GET_MODE (SUBREG_REG (out)))) 111250605Sobrien#ifdef WORD_REGISTER_OPERATIONS 111350605Sobrien || ((GET_MODE_SIZE (outmode) 111450605Sobrien < GET_MODE_SIZE (GET_MODE (SUBREG_REG (out)))) 111550605Sobrien && ((GET_MODE_SIZE (outmode) - 1) / UNITS_PER_WORD == 111650605Sobrien ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (out))) - 1) 111750605Sobrien / UNITS_PER_WORD))) 111850605Sobrien#endif 111990285Sobrien )) 1120169699Skan || (REG_P (SUBREG_REG (out)) 112118334Speter && REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER 112218334Speter && ((GET_MODE_SIZE (outmode) <= UNITS_PER_WORD 112318334Speter && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (out))) 112418334Speter > UNITS_PER_WORD) 112518334Speter && ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (out))) 112618334Speter / UNITS_PER_WORD) 1127169699Skan != (int) hard_regno_nregs[REGNO (SUBREG_REG (out))] 1128169699Skan [GET_MODE (SUBREG_REG (out))])) 112990285Sobrien || ! HARD_REGNO_MODE_OK (subreg_regno (out), outmode))) 1130169699Skan || (secondary_reload_class (0, class, outmode, out) != NO_REGS 1131169699Skan && (secondary_reload_class (0, class, GET_MODE (SUBREG_REG (out)), 1132169699Skan SUBREG_REG (out)) 113318334Speter == NO_REGS)) 1134117404Skan#ifdef CANNOT_CHANGE_MODE_CLASS 1135169699Skan || (REG_P (SUBREG_REG (out)) 113618334Speter && REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER 1137117404Skan && REG_CANNOT_CHANGE_MODE_P (REGNO (SUBREG_REG (out)), 1138132727Skan GET_MODE (SUBREG_REG (out)), 1139117404Skan outmode)) 114018334Speter#endif 114118334Speter )) 114218334Speter { 114318334Speter out_subreg_loc = outloc; 114418334Speter outloc = &SUBREG_REG (out); 114590285Sobrien out = *outloc; 114650605Sobrien#if ! defined (LOAD_EXTEND_OP) && ! defined (WORD_REGISTER_OPERATIONS) 1147169699Skan gcc_assert (!MEM_P (out) 1148169699Skan || GET_MODE_SIZE (GET_MODE (out)) 1149169699Skan <= GET_MODE_SIZE (outmode)); 115018334Speter#endif 115118334Speter outmode = GET_MODE (out); 115218334Speter } 115318334Speter 115418334Speter /* Similar issue for (SUBREG:M1 (REG:M2 ...) ...) for a hard register R where 115518334Speter either M1 is not valid for R or M2 is wider than a word but we only 115618334Speter need one word to store an M2-sized quantity in R. 115718334Speter 115818334Speter However, we must reload the inner reg *as well as* the subreg in 115918334Speter that case. In this case, the inner reg is an in-out reload. */ 116018334Speter 1161107605Sobrien if (out != 0 && reload_inner_reg_of_subreg (out, outmode, 1)) 116218334Speter { 116318334Speter /* This relies on the fact that emit_reload_insns outputs the 116418334Speter instructions for output reloads of type RELOAD_OTHER in reverse 116518334Speter order of the reloads. Thus if the outer reload is also of type 116618334Speter RELOAD_OTHER, we are guaranteed that this inner reload will be 116718334Speter output after the outer reload. */ 116818334Speter dont_remove_subreg = 1; 116918334Speter push_reload (SUBREG_REG (out), SUBREG_REG (out), &SUBREG_REG (out), 117050605Sobrien &SUBREG_REG (out), 1171169699Skan find_valid_class (outmode, GET_MODE (SUBREG_REG (out)), 117290285Sobrien subreg_regno_offset (REGNO (SUBREG_REG (out)), 117390285Sobrien GET_MODE (SUBREG_REG (out)), 117490285Sobrien SUBREG_BYTE (out), 1175102798Skan GET_MODE (out)), 1176102798Skan REGNO (SUBREG_REG (out))), 117750605Sobrien VOIDmode, VOIDmode, 0, 0, 117818334Speter opnum, RELOAD_OTHER); 117918334Speter } 118018334Speter 118118334Speter /* If IN appears in OUT, we can't share any input-only reload for IN. */ 1182169699Skan if (in != 0 && out != 0 && MEM_P (out) 1183171835Skan && (REG_P (in) || MEM_P (in) || GET_CODE (in) == PLUS) 118418334Speter && reg_overlap_mentioned_for_reload_p (in, XEXP (out, 0))) 118518334Speter dont_share = 1; 118618334Speter 118718334Speter /* If IN is a SUBREG of a hard register, make a new REG. This 118818334Speter simplifies some of the cases below. */ 118918334Speter 1190169699Skan if (in != 0 && GET_CODE (in) == SUBREG && REG_P (SUBREG_REG (in)) 119118334Speter && REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER 119218334Speter && ! dont_remove_subreg) 119390285Sobrien in = gen_rtx_REG (GET_MODE (in), subreg_regno (in)); 119418334Speter 119518334Speter /* Similarly for OUT. */ 119618334Speter if (out != 0 && GET_CODE (out) == SUBREG 1197169699Skan && REG_P (SUBREG_REG (out)) 119818334Speter && REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER 119918334Speter && ! dont_remove_subreg) 120090285Sobrien out = gen_rtx_REG (GET_MODE (out), subreg_regno (out)); 120118334Speter 120218334Speter /* Narrow down the class of register wanted if that is 120318334Speter desirable on this machine for efficiency. */ 1204169699Skan { 1205169699Skan enum reg_class preferred_class = class; 120618334Speter 1207169699Skan if (in != 0) 1208169699Skan preferred_class = PREFERRED_RELOAD_CLASS (in, class); 1209169699Skan 121018334Speter /* Output reloads may need analogous treatment, different in detail. */ 121118334Speter#ifdef PREFERRED_OUTPUT_RELOAD_CLASS 1212169699Skan if (out != 0) 1213169699Skan preferred_class = PREFERRED_OUTPUT_RELOAD_CLASS (out, preferred_class); 121418334Speter#endif 121518334Speter 1216169699Skan /* Discard what the target said if we cannot do it. */ 1217169699Skan if (preferred_class != NO_REGS 1218169699Skan || (optional && type == RELOAD_FOR_OUTPUT)) 1219169699Skan class = preferred_class; 1220169699Skan } 1221169699Skan 122218334Speter /* Make sure we use a class that can handle the actual pseudo 122318334Speter inside any subreg. For example, on the 386, QImode regs 122418334Speter can appear within SImode subregs. Although GENERAL_REGS 122518334Speter can handle SImode, QImode needs a smaller class. */ 122618334Speter#ifdef LIMIT_RELOAD_CLASS 122718334Speter if (in_subreg_loc) 122818334Speter class = LIMIT_RELOAD_CLASS (inmode, class); 122918334Speter else if (in != 0 && GET_CODE (in) == SUBREG) 123018334Speter class = LIMIT_RELOAD_CLASS (GET_MODE (SUBREG_REG (in)), class); 123118334Speter 123218334Speter if (out_subreg_loc) 123318334Speter class = LIMIT_RELOAD_CLASS (outmode, class); 123418334Speter if (out != 0 && GET_CODE (out) == SUBREG) 123518334Speter class = LIMIT_RELOAD_CLASS (GET_MODE (SUBREG_REG (out)), class); 123618334Speter#endif 123718334Speter 123818334Speter /* Verify that this class is at least possible for the mode that 123918334Speter is specified. */ 124018334Speter if (this_insn_is_asm) 124118334Speter { 124218334Speter enum machine_mode mode; 124318334Speter if (GET_MODE_SIZE (inmode) > GET_MODE_SIZE (outmode)) 124418334Speter mode = inmode; 124518334Speter else 124618334Speter mode = outmode; 124718334Speter if (mode == VOIDmode) 124818334Speter { 1249169699Skan error_for_asm (this_insn, "cannot reload integer constant " 1250169699Skan "operand in %<asm%>"); 125118334Speter mode = word_mode; 125218334Speter if (in != 0) 125318334Speter inmode = word_mode; 125418334Speter if (out != 0) 125518334Speter outmode = word_mode; 125618334Speter } 125718334Speter for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) 125818334Speter if (HARD_REGNO_MODE_OK (i, mode) 125918334Speter && TEST_HARD_REG_BIT (reg_class_contents[(int) class], i)) 126018334Speter { 1261169699Skan int nregs = hard_regno_nregs[i][mode]; 126218334Speter 126318334Speter int j; 126418334Speter for (j = 1; j < nregs; j++) 126518334Speter if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class], i + j)) 126618334Speter break; 126718334Speter if (j == nregs) 126818334Speter break; 126918334Speter } 127018334Speter if (i == FIRST_PSEUDO_REGISTER) 127118334Speter { 1272169699Skan error_for_asm (this_insn, "impossible register constraint " 1273169699Skan "in %<asm%>"); 1274169699Skan /* Avoid further trouble with this insn. */ 1275169699Skan PATTERN (this_insn) = gen_rtx_USE (VOIDmode, const0_rtx); 1276169699Skan /* We used to continue here setting class to ALL_REGS, but it triggers 1277169699Skan sanity check on i386 for: 1278169699Skan void foo(long double d) 1279169699Skan { 1280169699Skan asm("" :: "a" (d)); 1281169699Skan } 1282169699Skan Returning zero here ought to be safe as we take care in 1283169699Skan find_reloads to not process the reloads when instruction was 1284169699Skan replaced by USE. */ 1285169699Skan 1286169699Skan return 0; 128718334Speter } 128818334Speter } 128918334Speter 129052557Sobrien /* Optional output reloads are always OK even if we have no register class, 129152557Sobrien since the function of these reloads is only to have spill_reg_store etc. 129252557Sobrien set, so that the storing insn can be deleted later. */ 1293169699Skan gcc_assert (class != NO_REGS 1294169699Skan || (optional != 0 && type == RELOAD_FOR_OUTPUT)); 129518334Speter 129652557Sobrien i = find_reusable_reload (&in, out, class, type, opnum, dont_share); 129718334Speter 129818334Speter if (i == n_reloads) 129918334Speter { 130018334Speter /* See if we need a secondary reload register to move between CLASS 130118334Speter and IN or CLASS and OUT. Get the icode and push any required reloads 130218334Speter needed for each of them if so. */ 130318334Speter 130418334Speter if (in != 0) 130518334Speter secondary_in_reload 130618334Speter = push_secondary_reload (1, in, opnum, optional, class, inmode, type, 1307169699Skan &secondary_in_icode, NULL); 130818334Speter if (out != 0 && GET_CODE (out) != SCRATCH) 130918334Speter secondary_out_reload 131018334Speter = push_secondary_reload (0, out, opnum, optional, class, outmode, 1311169699Skan type, &secondary_out_icode, NULL); 131218334Speter 131318334Speter /* We found no existing reload suitable for re-use. 131418334Speter So add an additional reload. */ 131518334Speter 131650605Sobrien#ifdef SECONDARY_MEMORY_NEEDED 1317117404Skan /* If a memory location is needed for the copy, make one. */ 1318169699Skan if (in != 0 1319169699Skan && (REG_P (in) 1320169699Skan || (GET_CODE (in) == SUBREG && REG_P (SUBREG_REG (in)))) 1321117404Skan && reg_or_subregno (in) < FIRST_PSEUDO_REGISTER 1322117404Skan && SECONDARY_MEMORY_NEEDED (REGNO_REG_CLASS (reg_or_subregno (in)), 1323117404Skan class, inmode)) 1324117404Skan get_secondary_mem (in, inmode, opnum, type); 132550605Sobrien#endif 132650605Sobrien 132718334Speter i = n_reloads; 132890285Sobrien rld[i].in = in; 132990285Sobrien rld[i].out = out; 133090285Sobrien rld[i].class = class; 133190285Sobrien rld[i].inmode = inmode; 133290285Sobrien rld[i].outmode = outmode; 133390285Sobrien rld[i].reg_rtx = 0; 133490285Sobrien rld[i].optional = optional; 133590285Sobrien rld[i].inc = 0; 133690285Sobrien rld[i].nocombine = 0; 133790285Sobrien rld[i].in_reg = inloc ? *inloc : 0; 133890285Sobrien rld[i].out_reg = outloc ? *outloc : 0; 133990285Sobrien rld[i].opnum = opnum; 134090285Sobrien rld[i].when_needed = type; 134190285Sobrien rld[i].secondary_in_reload = secondary_in_reload; 134290285Sobrien rld[i].secondary_out_reload = secondary_out_reload; 134390285Sobrien rld[i].secondary_in_icode = secondary_in_icode; 134490285Sobrien rld[i].secondary_out_icode = secondary_out_icode; 134590285Sobrien rld[i].secondary_p = 0; 134618334Speter 134718334Speter n_reloads++; 134818334Speter 134918334Speter#ifdef SECONDARY_MEMORY_NEEDED 1350169699Skan if (out != 0 1351169699Skan && (REG_P (out) 1352169699Skan || (GET_CODE (out) == SUBREG && REG_P (SUBREG_REG (out)))) 1353117404Skan && reg_or_subregno (out) < FIRST_PSEUDO_REGISTER 1354117404Skan && SECONDARY_MEMORY_NEEDED (class, 1355117404Skan REGNO_REG_CLASS (reg_or_subregno (out)), 1356117404Skan outmode)) 1357117404Skan get_secondary_mem (out, outmode, opnum, type); 135818334Speter#endif 135918334Speter } 136018334Speter else 136118334Speter { 136218334Speter /* We are reusing an existing reload, 136318334Speter but we may have additional information for it. 136418334Speter For example, we may now have both IN and OUT 136518334Speter while the old one may have just one of them. */ 136618334Speter 136750605Sobrien /* The modes can be different. If they are, we want to reload in 136850605Sobrien the larger mode, so that the value is valid for both modes. */ 136950605Sobrien if (inmode != VOIDmode 137090285Sobrien && GET_MODE_SIZE (inmode) > GET_MODE_SIZE (rld[i].inmode)) 137190285Sobrien rld[i].inmode = inmode; 137250605Sobrien if (outmode != VOIDmode 137390285Sobrien && GET_MODE_SIZE (outmode) > GET_MODE_SIZE (rld[i].outmode)) 137490285Sobrien rld[i].outmode = outmode; 137518334Speter if (in != 0) 137652557Sobrien { 137752557Sobrien rtx in_reg = inloc ? *inloc : 0; 137852557Sobrien /* If we merge reloads for two distinct rtl expressions that 137952557Sobrien are identical in content, there might be duplicate address 138052557Sobrien reloads. Remove the extra set now, so that if we later find 138152557Sobrien that we can inherit this reload, we can get rid of the 138252557Sobrien address reloads altogether. 138352557Sobrien 138452557Sobrien Do not do this if both reloads are optional since the result 138552557Sobrien would be an optional reload which could potentially leave 138652557Sobrien unresolved address replacements. 138752557Sobrien 138852557Sobrien It is not sufficient to call transfer_replacements since 138952557Sobrien choose_reload_regs will remove the replacements for address 139052557Sobrien reloads of inherited reloads which results in the same 139152557Sobrien problem. */ 139290285Sobrien if (rld[i].in != in && rtx_equal_p (in, rld[i].in) 139390285Sobrien && ! (rld[i].optional && optional)) 139452557Sobrien { 139552557Sobrien /* We must keep the address reload with the lower operand 139652557Sobrien number alive. */ 139790285Sobrien if (opnum > rld[i].opnum) 139852557Sobrien { 139952557Sobrien remove_address_replacements (in); 140090285Sobrien in = rld[i].in; 140190285Sobrien in_reg = rld[i].in_reg; 140252557Sobrien } 140352557Sobrien else 140490285Sobrien remove_address_replacements (rld[i].in); 140552557Sobrien } 140690285Sobrien rld[i].in = in; 140790285Sobrien rld[i].in_reg = in_reg; 140852557Sobrien } 140918334Speter if (out != 0) 141052557Sobrien { 141190285Sobrien rld[i].out = out; 141290285Sobrien rld[i].out_reg = outloc ? *outloc : 0; 141352557Sobrien } 141490285Sobrien if (reg_class_subset_p (class, rld[i].class)) 141590285Sobrien rld[i].class = class; 141690285Sobrien rld[i].optional &= optional; 141790285Sobrien if (MERGE_TO_OTHER (type, rld[i].when_needed, 141890285Sobrien opnum, rld[i].opnum)) 141990285Sobrien rld[i].when_needed = RELOAD_OTHER; 142090285Sobrien rld[i].opnum = MIN (rld[i].opnum, opnum); 142118334Speter } 142218334Speter 142390285Sobrien /* If the ostensible rtx being reloaded differs from the rtx found 142418334Speter in the location to substitute, this reload is not safe to combine 142518334Speter because we cannot reliably tell whether it appears in the insn. */ 142618334Speter 142718334Speter if (in != 0 && in != *inloc) 142890285Sobrien rld[i].nocombine = 1; 142918334Speter 143018334Speter#if 0 143118334Speter /* This was replaced by changes in find_reloads_address_1 and the new 143218334Speter function inc_for_reload, which go with a new meaning of reload_inc. */ 143318334Speter 143418334Speter /* If this is an IN/OUT reload in an insn that sets the CC, 143518334Speter it must be for an autoincrement. It doesn't work to store 143618334Speter the incremented value after the insn because that would clobber the CC. 143718334Speter So we must do the increment of the value reloaded from, 143818334Speter increment it, store it back, then decrement again. */ 143918334Speter if (out != 0 && sets_cc0_p (PATTERN (this_insn))) 144018334Speter { 144118334Speter out = 0; 144290285Sobrien rld[i].out = 0; 144390285Sobrien rld[i].inc = find_inc_amount (PATTERN (this_insn), in); 144418334Speter /* If we did not find a nonzero amount-to-increment-by, 144518334Speter that contradicts the belief that IN is being incremented 144618334Speter in an address in this insn. */ 1447169699Skan gcc_assert (rld[i].inc != 0); 144818334Speter } 144918334Speter#endif 145018334Speter 145118334Speter /* If we will replace IN and OUT with the reload-reg, 145218334Speter record where they are located so that substitution need 145318334Speter not do a tree walk. */ 145418334Speter 145518334Speter if (replace_reloads) 145618334Speter { 145718334Speter if (inloc != 0) 145818334Speter { 145990285Sobrien struct replacement *r = &replacements[n_replacements++]; 146018334Speter r->what = i; 146118334Speter r->subreg_loc = in_subreg_loc; 146218334Speter r->where = inloc; 146318334Speter r->mode = inmode; 146418334Speter } 146518334Speter if (outloc != 0 && outloc != inloc) 146618334Speter { 146790285Sobrien struct replacement *r = &replacements[n_replacements++]; 146818334Speter r->what = i; 146918334Speter r->where = outloc; 147018334Speter r->subreg_loc = out_subreg_loc; 147118334Speter r->mode = outmode; 147218334Speter } 147318334Speter } 147418334Speter 147518334Speter /* If this reload is just being introduced and it has both 147618334Speter an incoming quantity and an outgoing quantity that are 147718334Speter supposed to be made to match, see if either one of the two 147818334Speter can serve as the place to reload into. 147918334Speter 148090285Sobrien If one of them is acceptable, set rld[i].reg_rtx 148118334Speter to that one. */ 148218334Speter 148390285Sobrien if (in != 0 && out != 0 && in != out && rld[i].reg_rtx == 0) 148418334Speter { 148590285Sobrien rld[i].reg_rtx = find_dummy_reload (in, out, inloc, outloc, 148690285Sobrien inmode, outmode, 148790285Sobrien rld[i].class, i, 148890285Sobrien earlyclobber_operand_p (out)); 148918334Speter 149018334Speter /* If the outgoing register already contains the same value 149118334Speter as the incoming one, we can dispense with loading it. 149218334Speter The easiest way to tell the caller that is to give a phony 149318334Speter value for the incoming operand (same as outgoing one). */ 149490285Sobrien if (rld[i].reg_rtx == out 1495169699Skan && (REG_P (in) || CONSTANT_P (in)) 149618334Speter && 0 != find_equiv_reg (in, this_insn, 0, REGNO (out), 149718334Speter static_reload_reg_p, i, inmode)) 149890285Sobrien rld[i].in = out; 149918334Speter } 150018334Speter 150118334Speter /* If this is an input reload and the operand contains a register that 150218334Speter dies in this insn and is used nowhere else, see if it is the right class 150318334Speter to be used for this reload. Use it if so. (This occurs most commonly 150418334Speter in the case of paradoxical SUBREGs and in-out reloads). We cannot do 150518334Speter this if it is also an output reload that mentions the register unless 150618334Speter the output is a SUBREG that clobbers an entire register. 150718334Speter 150818334Speter Note that the operand might be one of the spill regs, if it is a 150918334Speter pseudo reg and we are in a block where spilling has not taken place. 151018334Speter But if there is no spilling in this block, that is OK. 151118334Speter An explicitly used hard reg cannot be a spill reg. */ 151218334Speter 1513169699Skan if (rld[i].reg_rtx == 0 && in != 0 && hard_regs_live_known) 151418334Speter { 151518334Speter rtx note; 151618334Speter int regno; 151790285Sobrien enum machine_mode rel_mode = inmode; 151818334Speter 151990285Sobrien if (out && GET_MODE_SIZE (outmode) > GET_MODE_SIZE (inmode)) 152090285Sobrien rel_mode = outmode; 152190285Sobrien 152218334Speter for (note = REG_NOTES (this_insn); note; note = XEXP (note, 1)) 152318334Speter if (REG_NOTE_KIND (note) == REG_DEAD 1524169699Skan && REG_P (XEXP (note, 0)) 152518334Speter && (regno = REGNO (XEXP (note, 0))) < FIRST_PSEUDO_REGISTER 152618334Speter && reg_mentioned_p (XEXP (note, 0), in) 1527169699Skan /* Check that we don't use a hardreg for an uninitialized 1528169699Skan pseudo. See also find_dummy_reload(). */ 1529169699Skan && (ORIGINAL_REGNO (XEXP (note, 0)) < FIRST_PSEUDO_REGISTER 1530169699Skan || ! bitmap_bit_p (ENTRY_BLOCK_PTR->il.rtl->global_live_at_end, 1531169699Skan ORIGINAL_REGNO (XEXP (note, 0)))) 153218334Speter && ! refers_to_regno_for_reload_p (regno, 153318334Speter (regno 1534169699Skan + hard_regno_nregs[regno] 1535169699Skan [rel_mode]), 153618334Speter PATTERN (this_insn), inloc) 153718334Speter /* If this is also an output reload, IN cannot be used as 153818334Speter the reload register if it is set in this insn unless IN 153918334Speter is also OUT. */ 154018334Speter && (out == 0 || in == out 154118334Speter || ! hard_reg_set_here_p (regno, 154218334Speter (regno 1543169699Skan + hard_regno_nregs[regno] 1544169699Skan [rel_mode]), 154518334Speter PATTERN (this_insn))) 154618334Speter /* ??? Why is this code so different from the previous? 154718334Speter Is there any simple coherent way to describe the two together? 154818334Speter What's going on here. */ 154918334Speter && (in != out 155018334Speter || (GET_CODE (in) == SUBREG 155118334Speter && (((GET_MODE_SIZE (GET_MODE (in)) + (UNITS_PER_WORD - 1)) 155218334Speter / UNITS_PER_WORD) 155318334Speter == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))) 155418334Speter + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))) 155518334Speter /* Make sure the operand fits in the reg that dies. */ 155690285Sobrien && (GET_MODE_SIZE (rel_mode) 155790285Sobrien <= GET_MODE_SIZE (GET_MODE (XEXP (note, 0)))) 155818334Speter && HARD_REGNO_MODE_OK (regno, inmode) 155970639Sobrien && HARD_REGNO_MODE_OK (regno, outmode)) 156018334Speter { 156170639Sobrien unsigned int offs; 1562169699Skan unsigned int nregs = MAX (hard_regno_nregs[regno][inmode], 1563169699Skan hard_regno_nregs[regno][outmode]); 156470639Sobrien 156570639Sobrien for (offs = 0; offs < nregs; offs++) 156670639Sobrien if (fixed_regs[regno + offs] 156770639Sobrien || ! TEST_HARD_REG_BIT (reg_class_contents[(int) class], 156870639Sobrien regno + offs)) 156970639Sobrien break; 157070639Sobrien 1571132727Skan if (offs == nregs 1572132727Skan && (! (refers_to_regno_for_reload_p 1573169699Skan (regno, (regno + hard_regno_nregs[regno][inmode]), 1574132727Skan in, (rtx *)0)) 1575132727Skan || can_reload_into (in, regno, inmode))) 157670639Sobrien { 157790285Sobrien rld[i].reg_rtx = gen_rtx_REG (rel_mode, regno); 157870639Sobrien break; 157970639Sobrien } 158018334Speter } 158118334Speter } 158218334Speter 158318334Speter if (out) 158418334Speter output_reloadnum = i; 158518334Speter 158618334Speter return i; 158718334Speter} 158818334Speter 158918334Speter/* Record an additional place we must replace a value 159018334Speter for which we have already recorded a reload. 159118334Speter RELOADNUM is the value returned by push_reload 159218334Speter when the reload was recorded. 159318334Speter This is used in insn patterns that use match_dup. */ 159418334Speter 159518334Speterstatic void 1596132727Skanpush_replacement (rtx *loc, int reloadnum, enum machine_mode mode) 159718334Speter{ 159818334Speter if (replace_reloads) 159918334Speter { 160090285Sobrien struct replacement *r = &replacements[n_replacements++]; 160118334Speter r->what = reloadnum; 160218334Speter r->where = loc; 160318334Speter r->subreg_loc = 0; 160418334Speter r->mode = mode; 160518334Speter } 160618334Speter} 1607117404Skan 1608117404Skan/* Duplicate any replacement we have recorded to apply at 1609117404Skan location ORIG_LOC to also be performed at DUP_LOC. 1610117404Skan This is used in insn patterns that use match_dup. */ 1611117404Skan 1612117404Skanstatic void 1613132727Skandup_replacements (rtx *dup_loc, rtx *orig_loc) 1614117404Skan{ 1615117404Skan int i, n = n_replacements; 1616117404Skan 1617117404Skan for (i = 0; i < n; i++) 1618117404Skan { 1619117404Skan struct replacement *r = &replacements[i]; 1620117404Skan if (r->where == orig_loc) 1621117404Skan push_replacement (dup_loc, r->what, r->mode); 1622117404Skan } 1623117404Skan} 162418334Speter 162518334Speter/* Transfer all replacements that used to be in reload FROM to be in 162618334Speter reload TO. */ 162718334Speter 162818334Spetervoid 1629132727Skantransfer_replacements (int to, int from) 163018334Speter{ 163118334Speter int i; 163218334Speter 163318334Speter for (i = 0; i < n_replacements; i++) 163418334Speter if (replacements[i].what == from) 163518334Speter replacements[i].what = to; 163618334Speter} 163718334Speter 163852557Sobrien/* IN_RTX is the value loaded by a reload that we now decided to inherit, 163952557Sobrien or a subpart of it. If we have any replacements registered for IN_RTX, 164052557Sobrien cancel the reloads that were supposed to load them. 1641117404Skan Return nonzero if we canceled any reloads. */ 164252557Sobrienint 1643132727Skanremove_address_replacements (rtx in_rtx) 164450605Sobrien{ 164550605Sobrien int i, j; 164652557Sobrien char reload_flags[MAX_RELOADS]; 164752557Sobrien int something_changed = 0; 164850605Sobrien 164990285Sobrien memset (reload_flags, 0, sizeof reload_flags); 165050605Sobrien for (i = 0, j = 0; i < n_replacements; i++) 165150605Sobrien { 165252557Sobrien if (loc_mentioned_in_p (replacements[i].where, in_rtx)) 165352557Sobrien reload_flags[replacements[i].what] |= 1; 165452557Sobrien else 165552557Sobrien { 165652557Sobrien replacements[j++] = replacements[i]; 165752557Sobrien reload_flags[replacements[i].what] |= 2; 165852557Sobrien } 165950605Sobrien } 166052557Sobrien /* Note that the following store must be done before the recursive calls. */ 166152557Sobrien n_replacements = j; 166252557Sobrien 166352557Sobrien for (i = n_reloads - 1; i >= 0; i--) 166452557Sobrien { 166552557Sobrien if (reload_flags[i] == 1) 166652557Sobrien { 166752557Sobrien deallocate_reload_reg (i); 166890285Sobrien remove_address_replacements (rld[i].in); 166990285Sobrien rld[i].in = 0; 167052557Sobrien something_changed = 1; 167152557Sobrien } 167252557Sobrien } 167352557Sobrien return something_changed; 167450605Sobrien} 167550605Sobrien 167618334Speter/* If there is only one output reload, and it is not for an earlyclobber 167718334Speter operand, try to combine it with a (logically unrelated) input reload 167818334Speter to reduce the number of reload registers needed. 167918334Speter 168018334Speter This is safe if the input reload does not appear in 168118334Speter the value being output-reloaded, because this implies 168218334Speter it is not needed any more once the original insn completes. 168318334Speter 168418334Speter If that doesn't work, see we can use any of the registers that 168518334Speter die in this insn as a reload register. We can if it is of the right 168618334Speter class and does not appear in the value being output-reloaded. */ 168718334Speter 168818334Speterstatic void 1689132727Skancombine_reloads (void) 169018334Speter{ 169118334Speter int i; 169218334Speter int output_reload = -1; 169318334Speter int secondary_out = -1; 169418334Speter rtx note; 169518334Speter 169618334Speter /* Find the output reload; return unless there is exactly one 169718334Speter and that one is mandatory. */ 169818334Speter 169918334Speter for (i = 0; i < n_reloads; i++) 170090285Sobrien if (rld[i].out != 0) 170118334Speter { 170218334Speter if (output_reload >= 0) 170318334Speter return; 170418334Speter output_reload = i; 170518334Speter } 170618334Speter 170790285Sobrien if (output_reload < 0 || rld[output_reload].optional) 170818334Speter return; 170918334Speter 171018334Speter /* An input-output reload isn't combinable. */ 171118334Speter 171290285Sobrien if (rld[output_reload].in != 0) 171318334Speter return; 171418334Speter 171518334Speter /* If this reload is for an earlyclobber operand, we can't do anything. */ 171690285Sobrien if (earlyclobber_operand_p (rld[output_reload].out)) 171718334Speter return; 171818334Speter 171990285Sobrien /* If there is a reload for part of the address of this operand, we would 172090285Sobrien need to chnage it to RELOAD_FOR_OTHER_ADDRESS. But that would extend 172190285Sobrien its life to the point where doing this combine would not lower the 172290285Sobrien number of spill registers needed. */ 172390285Sobrien for (i = 0; i < n_reloads; i++) 172490285Sobrien if ((rld[i].when_needed == RELOAD_FOR_OUTPUT_ADDRESS 172590285Sobrien || rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS) 172690285Sobrien && rld[i].opnum == rld[output_reload].opnum) 172790285Sobrien return; 172890285Sobrien 172918334Speter /* Check each input reload; can we combine it? */ 173018334Speter 173118334Speter for (i = 0; i < n_reloads; i++) 173290285Sobrien if (rld[i].in && ! rld[i].optional && ! rld[i].nocombine 173318334Speter /* Life span of this reload must not extend past main insn. */ 173490285Sobrien && rld[i].when_needed != RELOAD_FOR_OUTPUT_ADDRESS 173590285Sobrien && rld[i].when_needed != RELOAD_FOR_OUTADDR_ADDRESS 173690285Sobrien && rld[i].when_needed != RELOAD_OTHER 173790285Sobrien && (CLASS_MAX_NREGS (rld[i].class, rld[i].inmode) 173890285Sobrien == CLASS_MAX_NREGS (rld[output_reload].class, 173990285Sobrien rld[output_reload].outmode)) 174090285Sobrien && rld[i].inc == 0 174190285Sobrien && rld[i].reg_rtx == 0 174218334Speter#ifdef SECONDARY_MEMORY_NEEDED 174318334Speter /* Don't combine two reloads with different secondary 174418334Speter memory locations. */ 174590285Sobrien && (secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[i].opnum] == 0 174690285Sobrien || secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[output_reload].opnum] == 0 174790285Sobrien || rtx_equal_p (secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[i].opnum], 174890285Sobrien secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[output_reload].opnum])) 174918334Speter#endif 175050605Sobrien && (SMALL_REGISTER_CLASSES 175190285Sobrien ? (rld[i].class == rld[output_reload].class) 175290285Sobrien : (reg_class_subset_p (rld[i].class, 175390285Sobrien rld[output_reload].class) 175490285Sobrien || reg_class_subset_p (rld[output_reload].class, 175590285Sobrien rld[i].class))) 175690285Sobrien && (MATCHES (rld[i].in, rld[output_reload].out) 175718334Speter /* Args reversed because the first arg seems to be 175818334Speter the one that we imagine being modified 175918334Speter while the second is the one that might be affected. */ 176090285Sobrien || (! reg_overlap_mentioned_for_reload_p (rld[output_reload].out, 176190285Sobrien rld[i].in) 176218334Speter /* However, if the input is a register that appears inside 176318334Speter the output, then we also can't share. 176418334Speter Imagine (set (mem (reg 69)) (plus (reg 69) ...)). 176518334Speter If the same reload reg is used for both reg 69 and the 176618334Speter result to be stored in memory, then that result 176718334Speter will clobber the address of the memory ref. */ 1768169699Skan && ! (REG_P (rld[i].in) 176990285Sobrien && reg_overlap_mentioned_for_reload_p (rld[i].in, 177090285Sobrien rld[output_reload].out)))) 1771107605Sobrien && ! reload_inner_reg_of_subreg (rld[i].in, rld[i].inmode, 1772107605Sobrien rld[i].when_needed != RELOAD_FOR_INPUT) 177390285Sobrien && (reg_class_size[(int) rld[i].class] 177450605Sobrien || SMALL_REGISTER_CLASSES) 177518334Speter /* We will allow making things slightly worse by combining an 177618334Speter input and an output, but no worse than that. */ 177790285Sobrien && (rld[i].when_needed == RELOAD_FOR_INPUT 177890285Sobrien || rld[i].when_needed == RELOAD_FOR_OUTPUT)) 177918334Speter { 178018334Speter int j; 178118334Speter 178218334Speter /* We have found a reload to combine with! */ 178390285Sobrien rld[i].out = rld[output_reload].out; 178490285Sobrien rld[i].out_reg = rld[output_reload].out_reg; 178590285Sobrien rld[i].outmode = rld[output_reload].outmode; 178618334Speter /* Mark the old output reload as inoperative. */ 178790285Sobrien rld[output_reload].out = 0; 178818334Speter /* The combined reload is needed for the entire insn. */ 178990285Sobrien rld[i].when_needed = RELOAD_OTHER; 179050605Sobrien /* If the output reload had a secondary reload, copy it. */ 179190285Sobrien if (rld[output_reload].secondary_out_reload != -1) 179218334Speter { 179390285Sobrien rld[i].secondary_out_reload 179490285Sobrien = rld[output_reload].secondary_out_reload; 179590285Sobrien rld[i].secondary_out_icode 179690285Sobrien = rld[output_reload].secondary_out_icode; 179718334Speter } 179818334Speter 179918334Speter#ifdef SECONDARY_MEMORY_NEEDED 180018334Speter /* Copy any secondary MEM. */ 180190285Sobrien if (secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[output_reload].opnum] != 0) 180290285Sobrien secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[i].opnum] 180390285Sobrien = secondary_memlocs_elim[(int) rld[output_reload].outmode][rld[output_reload].opnum]; 180418334Speter#endif 180550605Sobrien /* If required, minimize the register class. */ 180690285Sobrien if (reg_class_subset_p (rld[output_reload].class, 180790285Sobrien rld[i].class)) 180890285Sobrien rld[i].class = rld[output_reload].class; 180918334Speter 181018334Speter /* Transfer all replacements from the old reload to the combined. */ 181118334Speter for (j = 0; j < n_replacements; j++) 181218334Speter if (replacements[j].what == output_reload) 181318334Speter replacements[j].what = i; 181418334Speter 181518334Speter return; 181618334Speter } 181718334Speter 181818334Speter /* If this insn has only one operand that is modified or written (assumed 181918334Speter to be the first), it must be the one corresponding to this reload. It 182018334Speter is safe to use anything that dies in this insn for that output provided 182118334Speter that it does not occur in the output (we already know it isn't an 182218334Speter earlyclobber. If this is an asm insn, give up. */ 182318334Speter 182418334Speter if (INSN_CODE (this_insn) == -1) 182518334Speter return; 182618334Speter 182790285Sobrien for (i = 1; i < insn_data[INSN_CODE (this_insn)].n_operands; i++) 182890285Sobrien if (insn_data[INSN_CODE (this_insn)].operand[i].constraint[0] == '=' 182990285Sobrien || insn_data[INSN_CODE (this_insn)].operand[i].constraint[0] == '+') 183018334Speter return; 183118334Speter 183218334Speter /* See if some hard register that dies in this insn and is not used in 183318334Speter the output is the right class. Only works if the register we pick 183418334Speter up can fully hold our output reload. */ 183518334Speter for (note = REG_NOTES (this_insn); note; note = XEXP (note, 1)) 183618334Speter if (REG_NOTE_KIND (note) == REG_DEAD 1837169699Skan && REG_P (XEXP (note, 0)) 183818334Speter && ! reg_overlap_mentioned_for_reload_p (XEXP (note, 0), 183990285Sobrien rld[output_reload].out) 184018334Speter && REGNO (XEXP (note, 0)) < FIRST_PSEUDO_REGISTER 184190285Sobrien && HARD_REGNO_MODE_OK (REGNO (XEXP (note, 0)), rld[output_reload].outmode) 184290285Sobrien && TEST_HARD_REG_BIT (reg_class_contents[(int) rld[output_reload].class], 184318334Speter REGNO (XEXP (note, 0))) 1844169699Skan && (hard_regno_nregs[REGNO (XEXP (note, 0))][rld[output_reload].outmode] 1845169699Skan <= hard_regno_nregs[REGNO (XEXP (note, 0))][GET_MODE (XEXP (note, 0))]) 184618334Speter /* Ensure that a secondary or tertiary reload for this output 184718334Speter won't want this register. */ 184890285Sobrien && ((secondary_out = rld[output_reload].secondary_out_reload) == -1 184990285Sobrien || (! (TEST_HARD_REG_BIT 185090285Sobrien (reg_class_contents[(int) rld[secondary_out].class], 185190285Sobrien REGNO (XEXP (note, 0)))) 185290285Sobrien && ((secondary_out = rld[secondary_out].secondary_out_reload) == -1 185318334Speter || ! (TEST_HARD_REG_BIT 185490285Sobrien (reg_class_contents[(int) rld[secondary_out].class], 185518334Speter REGNO (XEXP (note, 0))))))) 1856169699Skan && ! fixed_regs[REGNO (XEXP (note, 0))] 1857169699Skan /* Check that we don't use a hardreg for an uninitialized 1858169699Skan pseudo. See also find_dummy_reload(). */ 1859169699Skan && (ORIGINAL_REGNO (XEXP (note, 0)) < FIRST_PSEUDO_REGISTER 1860169699Skan || ! bitmap_bit_p (ENTRY_BLOCK_PTR->il.rtl->global_live_at_end, 1861169699Skan ORIGINAL_REGNO (XEXP (note, 0))))) 186218334Speter { 186390285Sobrien rld[output_reload].reg_rtx 186490285Sobrien = gen_rtx_REG (rld[output_reload].outmode, 186550605Sobrien REGNO (XEXP (note, 0))); 186618334Speter return; 186718334Speter } 186818334Speter} 186918334Speter 187018334Speter/* Try to find a reload register for an in-out reload (expressions IN and OUT). 187118334Speter See if one of IN and OUT is a register that may be used; 187218334Speter this is desirable since a spill-register won't be needed. 187318334Speter If so, return the register rtx that proves acceptable. 187418334Speter 187518334Speter INLOC and OUTLOC are locations where IN and OUT appear in the insn. 187618334Speter CLASS is the register class required for the reload. 187718334Speter 187818334Speter If FOR_REAL is >= 0, it is the number of the reload, 187918334Speter and in some cases when it can be discovered that OUT doesn't need 188090285Sobrien to be computed, clear out rld[FOR_REAL].out. 188118334Speter 188218334Speter If FOR_REAL is -1, this should not be done, because this call 188350605Sobrien is just to see if a register can be found, not to find and install it. 188418334Speter 1885117404Skan EARLYCLOBBER is nonzero if OUT is an earlyclobber operand. This 188650605Sobrien puts an additional constraint on being able to use IN for OUT since 188750605Sobrien IN must not appear elsewhere in the insn (it is assumed that IN itself 188850605Sobrien is safe from the earlyclobber). */ 188950605Sobrien 189018334Speterstatic rtx 1891132727Skanfind_dummy_reload (rtx real_in, rtx real_out, rtx *inloc, rtx *outloc, 1892132727Skan enum machine_mode inmode, enum machine_mode outmode, 1893132727Skan enum reg_class class, int for_real, int earlyclobber) 189418334Speter{ 189518334Speter rtx in = real_in; 189618334Speter rtx out = real_out; 189718334Speter int in_offset = 0; 189818334Speter int out_offset = 0; 189918334Speter rtx value = 0; 190018334Speter 190118334Speter /* If operands exceed a word, we can't use either of them 190218334Speter unless they have the same size. */ 190318334Speter if (GET_MODE_SIZE (outmode) != GET_MODE_SIZE (inmode) 190418334Speter && (GET_MODE_SIZE (outmode) > UNITS_PER_WORD 190518334Speter || GET_MODE_SIZE (inmode) > UNITS_PER_WORD)) 190618334Speter return 0; 190718334Speter 190890285Sobrien /* Note that {in,out}_offset are needed only when 'in' or 'out' 190990285Sobrien respectively refers to a hard register. */ 191090285Sobrien 191118334Speter /* Find the inside of any subregs. */ 191218334Speter while (GET_CODE (out) == SUBREG) 191318334Speter { 1914169699Skan if (REG_P (SUBREG_REG (out)) 191590285Sobrien && REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER) 191690285Sobrien out_offset += subreg_regno_offset (REGNO (SUBREG_REG (out)), 191790285Sobrien GET_MODE (SUBREG_REG (out)), 191890285Sobrien SUBREG_BYTE (out), 191990285Sobrien GET_MODE (out)); 192018334Speter out = SUBREG_REG (out); 192118334Speter } 192218334Speter while (GET_CODE (in) == SUBREG) 192318334Speter { 1924169699Skan if (REG_P (SUBREG_REG (in)) 192590285Sobrien && REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER) 192690285Sobrien in_offset += subreg_regno_offset (REGNO (SUBREG_REG (in)), 192790285Sobrien GET_MODE (SUBREG_REG (in)), 192890285Sobrien SUBREG_BYTE (in), 192990285Sobrien GET_MODE (in)); 193018334Speter in = SUBREG_REG (in); 193118334Speter } 193218334Speter 193318334Speter /* Narrow down the reg class, the same way push_reload will; 193418334Speter otherwise we might find a dummy now, but push_reload won't. */ 1935169699Skan { 1936169699Skan enum reg_class preferred_class = PREFERRED_RELOAD_CLASS (in, class); 1937169699Skan if (preferred_class != NO_REGS) 1938169699Skan class = preferred_class; 1939169699Skan } 194018334Speter 194118334Speter /* See if OUT will do. */ 1942169699Skan if (REG_P (out) 194318334Speter && REGNO (out) < FIRST_PSEUDO_REGISTER) 194418334Speter { 194590285Sobrien unsigned int regno = REGNO (out) + out_offset; 1946169699Skan unsigned int nwords = hard_regno_nregs[regno][outmode]; 194718334Speter rtx saved_rtx; 194818334Speter 194918334Speter /* When we consider whether the insn uses OUT, 195018334Speter ignore references within IN. They don't prevent us 195118334Speter from copying IN into OUT, because those refs would 195218334Speter move into the insn that reloads IN. 195318334Speter 195418334Speter However, we only ignore IN in its role as this reload. 195518334Speter If the insn uses IN elsewhere and it contains OUT, 195618334Speter that counts. We can't be sure it's the "same" operand 195718334Speter so it might not go through this reload. */ 195818334Speter saved_rtx = *inloc; 195918334Speter *inloc = const0_rtx; 196018334Speter 196118334Speter if (regno < FIRST_PSEUDO_REGISTER 196296288Sobrien && HARD_REGNO_MODE_OK (regno, outmode) 196318334Speter && ! refers_to_regno_for_reload_p (regno, regno + nwords, 196418334Speter PATTERN (this_insn), outloc)) 196518334Speter { 196690285Sobrien unsigned int i; 196790285Sobrien 196818334Speter for (i = 0; i < nwords; i++) 196918334Speter if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class], 197018334Speter regno + i)) 197118334Speter break; 197218334Speter 197318334Speter if (i == nwords) 197418334Speter { 1975169699Skan if (REG_P (real_out)) 197618334Speter value = real_out; 197718334Speter else 197850605Sobrien value = gen_rtx_REG (outmode, regno); 197918334Speter } 198018334Speter } 198118334Speter 198218334Speter *inloc = saved_rtx; 198318334Speter } 198418334Speter 198518334Speter /* Consider using IN if OUT was not acceptable 198618334Speter or if OUT dies in this insn (like the quotient in a divmod insn). 198718334Speter We can't use IN unless it is dies in this insn, 198818334Speter which means we must know accurately which hard regs are live. 198950605Sobrien Also, the result can't go in IN if IN is used within OUT, 199050605Sobrien or if OUT is an earlyclobber and IN appears elsewhere in the insn. */ 199118334Speter if (hard_regs_live_known 1992169699Skan && REG_P (in) 199318334Speter && REGNO (in) < FIRST_PSEUDO_REGISTER 199418334Speter && (value == 0 199518334Speter || find_reg_note (this_insn, REG_UNUSED, real_out)) 199618334Speter && find_reg_note (this_insn, REG_DEAD, real_in) 199718334Speter && !fixed_regs[REGNO (in)] 199818334Speter && HARD_REGNO_MODE_OK (REGNO (in), 199918334Speter /* The only case where out and real_out might 200018334Speter have different modes is where real_out 200118334Speter is a subreg, and in that case, out 200218334Speter has a real mode. */ 200318334Speter (GET_MODE (out) != VOIDmode 2004169699Skan ? GET_MODE (out) : outmode)) 2005169699Skan /* But only do all this if we can be sure, that this input 2006169699Skan operand doesn't correspond with an uninitialized pseudoreg. 2007169699Skan global can assign some hardreg to it, which is the same as 2008169699Skan a different pseudo also currently live (as it can ignore the 2009169699Skan conflict). So we never must introduce writes to such hardregs, 2010169699Skan as they would clobber the other live pseudo using the same. 2011169699Skan See also PR20973. */ 2012169699Skan && (ORIGINAL_REGNO (in) < FIRST_PSEUDO_REGISTER 2013169699Skan || ! bitmap_bit_p (ENTRY_BLOCK_PTR->il.rtl->global_live_at_end, 2014169699Skan ORIGINAL_REGNO (in)))) 201518334Speter { 201690285Sobrien unsigned int regno = REGNO (in) + in_offset; 2017169699Skan unsigned int nwords = hard_regno_nregs[regno][inmode]; 201818334Speter 201990285Sobrien if (! refers_to_regno_for_reload_p (regno, regno + nwords, out, (rtx*) 0) 202018334Speter && ! hard_reg_set_here_p (regno, regno + nwords, 202150605Sobrien PATTERN (this_insn)) 202250605Sobrien && (! earlyclobber 202350605Sobrien || ! refers_to_regno_for_reload_p (regno, regno + nwords, 202450605Sobrien PATTERN (this_insn), inloc))) 202518334Speter { 202690285Sobrien unsigned int i; 202790285Sobrien 202818334Speter for (i = 0; i < nwords; i++) 202918334Speter if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class], 203018334Speter regno + i)) 203118334Speter break; 203218334Speter 203318334Speter if (i == nwords) 203418334Speter { 203518334Speter /* If we were going to use OUT as the reload reg 203618334Speter and changed our mind, it means OUT is a dummy that 203718334Speter dies here. So don't bother copying value to it. */ 203818334Speter if (for_real >= 0 && value == real_out) 203990285Sobrien rld[for_real].out = 0; 2040169699Skan if (REG_P (real_in)) 204118334Speter value = real_in; 204218334Speter else 204350605Sobrien value = gen_rtx_REG (inmode, regno); 204418334Speter } 204518334Speter } 204618334Speter } 204718334Speter 204818334Speter return value; 204918334Speter} 205018334Speter 205118334Speter/* This page contains subroutines used mainly for determining 205218334Speter whether the IN or an OUT of a reload can serve as the 205318334Speter reload register. */ 205418334Speter 205518334Speter/* Return 1 if X is an operand of an insn that is being earlyclobbered. */ 205618334Speter 205770639Sobrienint 2058132727Skanearlyclobber_operand_p (rtx x) 205918334Speter{ 206018334Speter int i; 206118334Speter 206218334Speter for (i = 0; i < n_earlyclobbers; i++) 206318334Speter if (reload_earlyclobbers[i] == x) 206418334Speter return 1; 206518334Speter 206618334Speter return 0; 206718334Speter} 206818334Speter 206918334Speter/* Return 1 if expression X alters a hard reg in the range 207018334Speter from BEG_REGNO (inclusive) to END_REGNO (exclusive), 207118334Speter either explicitly or in the guise of a pseudo-reg allocated to REGNO. 207218334Speter X should be the body of an instruction. */ 207318334Speter 207418334Speterstatic int 2075132727Skanhard_reg_set_here_p (unsigned int beg_regno, unsigned int end_regno, rtx x) 207618334Speter{ 207718334Speter if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER) 207818334Speter { 207990285Sobrien rtx op0 = SET_DEST (x); 208090285Sobrien 208118334Speter while (GET_CODE (op0) == SUBREG) 208218334Speter op0 = SUBREG_REG (op0); 2083169699Skan if (REG_P (op0)) 208418334Speter { 208590285Sobrien unsigned int r = REGNO (op0); 208690285Sobrien 208718334Speter /* See if this reg overlaps range under consideration. */ 208818334Speter if (r < end_regno 2089169699Skan && r + hard_regno_nregs[r][GET_MODE (op0)] > beg_regno) 209018334Speter return 1; 209118334Speter } 209218334Speter } 209318334Speter else if (GET_CODE (x) == PARALLEL) 209418334Speter { 209590285Sobrien int i = XVECLEN (x, 0) - 1; 209690285Sobrien 209718334Speter for (; i >= 0; i--) 209818334Speter if (hard_reg_set_here_p (beg_regno, end_regno, XVECEXP (x, 0, i))) 209918334Speter return 1; 210018334Speter } 210118334Speter 210218334Speter return 0; 210318334Speter} 210418334Speter 210518334Speter/* Return 1 if ADDR is a valid memory address for mode MODE, 210618334Speter and check that each pseudo reg has the proper kind of 210718334Speter hard reg. */ 210818334Speter 210918334Speterint 2110132727Skanstrict_memory_address_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx addr) 211118334Speter{ 211218334Speter GO_IF_LEGITIMATE_ADDRESS (mode, addr, win); 211318334Speter return 0; 211418334Speter 211518334Speter win: 211618334Speter return 1; 211718334Speter} 211818334Speter 211918334Speter/* Like rtx_equal_p except that it allows a REG and a SUBREG to match 212018334Speter if they are the same hard reg, and has special hacks for 212118334Speter autoincrement and autodecrement. 212218334Speter This is specifically intended for find_reloads to use 212318334Speter in determining whether two operands match. 212418334Speter X is the operand whose number is the lower of the two. 212518334Speter 212618334Speter The value is 2 if Y contains a pre-increment that matches 212718334Speter a non-incrementing address in X. */ 212818334Speter 212918334Speter/* ??? To be completely correct, we should arrange to pass 213018334Speter for X the output operand and for Y the input operand. 213118334Speter For now, we assume that the output operand has the lower number 213218334Speter because that is natural in (SET output (... input ...)). */ 213318334Speter 213418334Speterint 2135132727Skanoperands_match_p (rtx x, rtx y) 213618334Speter{ 213790285Sobrien int i; 213890285Sobrien RTX_CODE code = GET_CODE (x); 213990285Sobrien const char *fmt; 214018334Speter int success_2; 214190285Sobrien 214218334Speter if (x == y) 214318334Speter return 1; 2144169699Skan if ((code == REG || (code == SUBREG && REG_P (SUBREG_REG (x)))) 2145169699Skan && (REG_P (y) || (GET_CODE (y) == SUBREG 2146169699Skan && REG_P (SUBREG_REG (y))))) 214718334Speter { 214890285Sobrien int j; 214918334Speter 215018334Speter if (code == SUBREG) 215118334Speter { 215218334Speter i = REGNO (SUBREG_REG (x)); 215318334Speter if (i >= FIRST_PSEUDO_REGISTER) 215418334Speter goto slow; 215590285Sobrien i += subreg_regno_offset (REGNO (SUBREG_REG (x)), 215690285Sobrien GET_MODE (SUBREG_REG (x)), 215790285Sobrien SUBREG_BYTE (x), 215890285Sobrien GET_MODE (x)); 215918334Speter } 216018334Speter else 216118334Speter i = REGNO (x); 216218334Speter 216318334Speter if (GET_CODE (y) == SUBREG) 216418334Speter { 216518334Speter j = REGNO (SUBREG_REG (y)); 216618334Speter if (j >= FIRST_PSEUDO_REGISTER) 216718334Speter goto slow; 216890285Sobrien j += subreg_regno_offset (REGNO (SUBREG_REG (y)), 216990285Sobrien GET_MODE (SUBREG_REG (y)), 217090285Sobrien SUBREG_BYTE (y), 217190285Sobrien GET_MODE (y)); 217218334Speter } 217318334Speter else 217418334Speter j = REGNO (y); 217518334Speter 217618334Speter /* On a WORDS_BIG_ENDIAN machine, point to the last register of a 2177146906Skan multiple hard register group of scalar integer registers, so that 2178146906Skan for example (reg:DI 0) and (reg:SI 1) will be considered the same 2179146906Skan register. */ 218018334Speter if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD 2181146906Skan && SCALAR_INT_MODE_P (GET_MODE (x)) 218218334Speter && i < FIRST_PSEUDO_REGISTER) 2183169699Skan i += hard_regno_nregs[i][GET_MODE (x)] - 1; 218418334Speter if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (y)) > UNITS_PER_WORD 2185146906Skan && SCALAR_INT_MODE_P (GET_MODE (y)) 218618334Speter && j < FIRST_PSEUDO_REGISTER) 2187169699Skan j += hard_regno_nregs[j][GET_MODE (y)] - 1; 218818334Speter 218918334Speter return i == j; 219018334Speter } 219118334Speter /* If two operands must match, because they are really a single 219218334Speter operand of an assembler insn, then two postincrements are invalid 219318334Speter because the assembler insn would increment only once. 2194117404Skan On the other hand, a postincrement matches ordinary indexing 219518334Speter if the postincrement is the output operand. */ 219690285Sobrien if (code == POST_DEC || code == POST_INC || code == POST_MODIFY) 219718334Speter return operands_match_p (XEXP (x, 0), y); 219818334Speter /* Two preincrements are invalid 219918334Speter because the assembler insn would increment only once. 2200117404Skan On the other hand, a preincrement matches ordinary indexing 220118334Speter if the preincrement is the input operand. 220218334Speter In this case, return 2, since some callers need to do special 220318334Speter things when this happens. */ 220490285Sobrien if (GET_CODE (y) == PRE_DEC || GET_CODE (y) == PRE_INC 220590285Sobrien || GET_CODE (y) == PRE_MODIFY) 220618334Speter return operands_match_p (x, XEXP (y, 0)) ? 2 : 0; 220718334Speter 220818334Speter slow: 220918334Speter 2210169699Skan /* Now we have disposed of all the cases in which different rtx codes 2211169699Skan can match. */ 221218334Speter if (code != GET_CODE (y)) 221318334Speter return 0; 221418334Speter 221518334Speter /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. */ 221618334Speter if (GET_MODE (x) != GET_MODE (y)) 221718334Speter return 0; 221818334Speter 2219169699Skan switch (code) 2220169699Skan { 2221169699Skan case CONST_INT: 2222169699Skan case CONST_DOUBLE: 2223169699Skan return 0; 2224169699Skan 2225169699Skan case LABEL_REF: 2226169699Skan return XEXP (x, 0) == XEXP (y, 0); 2227169699Skan case SYMBOL_REF: 2228169699Skan return XSTR (x, 0) == XSTR (y, 0); 2229169699Skan 2230169699Skan default: 2231169699Skan break; 2232169699Skan } 2233169699Skan 223418334Speter /* Compare the elements. If any pair of corresponding elements 223518334Speter fail to match, return 0 for the whole things. */ 223618334Speter 223718334Speter success_2 = 0; 223818334Speter fmt = GET_RTX_FORMAT (code); 223918334Speter for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 224018334Speter { 224152557Sobrien int val, j; 224218334Speter switch (fmt[i]) 224318334Speter { 224418334Speter case 'w': 224518334Speter if (XWINT (x, i) != XWINT (y, i)) 224618334Speter return 0; 224718334Speter break; 224818334Speter 224918334Speter case 'i': 225018334Speter if (XINT (x, i) != XINT (y, i)) 225118334Speter return 0; 225218334Speter break; 225318334Speter 225418334Speter case 'e': 225518334Speter val = operands_match_p (XEXP (x, i), XEXP (y, i)); 225618334Speter if (val == 0) 225718334Speter return 0; 225818334Speter /* If any subexpression returns 2, 225918334Speter we should return 2 if we are successful. */ 226018334Speter if (val == 2) 226118334Speter success_2 = 1; 226218334Speter break; 226318334Speter 226418334Speter case '0': 226518334Speter break; 226618334Speter 226752557Sobrien case 'E': 226852557Sobrien if (XVECLEN (x, i) != XVECLEN (y, i)) 226952557Sobrien return 0; 227052557Sobrien for (j = XVECLEN (x, i) - 1; j >= 0; --j) 227152557Sobrien { 227252557Sobrien val = operands_match_p (XVECEXP (x, i, j), XVECEXP (y, i, j)); 227352557Sobrien if (val == 0) 227452557Sobrien return 0; 227552557Sobrien if (val == 2) 227652557Sobrien success_2 = 1; 227752557Sobrien } 227852557Sobrien break; 227952557Sobrien 228018334Speter /* It is believed that rtx's at this level will never 228118334Speter contain anything but integers and other rtx's, 228218334Speter except for within LABEL_REFs and SYMBOL_REFs. */ 228318334Speter default: 2284169699Skan gcc_unreachable (); 228518334Speter } 228618334Speter } 228718334Speter return 1 + success_2; 228818334Speter} 228918334Speter 229018334Speter/* Describe the range of registers or memory referenced by X. 229190285Sobrien If X is a register, set REG_FLAG and put the first register 229218334Speter number into START and the last plus one into END. 229390285Sobrien If X is a memory reference, put a base address into BASE 229418334Speter and a range of integer offsets into START and END. 229590285Sobrien If X is pushing on the stack, we can assume it causes no trouble, 229618334Speter so we set the SAFE field. */ 229718334Speter 229818334Speterstatic struct decomposition 2299132727Skandecompose (rtx x) 230018334Speter{ 230118334Speter struct decomposition val; 230218334Speter int all_const = 0; 230318334Speter 2304169699Skan memset (&val, 0, sizeof (val)); 230518334Speter 2306169699Skan switch (GET_CODE (x)) 230718334Speter { 2308169699Skan case MEM: 2309169699Skan { 2310169699Skan rtx base = NULL_RTX, offset = 0; 2311169699Skan rtx addr = XEXP (x, 0); 2312169699Skan 2313169699Skan if (GET_CODE (addr) == PRE_DEC || GET_CODE (addr) == PRE_INC 2314169699Skan || GET_CODE (addr) == POST_DEC || GET_CODE (addr) == POST_INC) 2315169699Skan { 2316169699Skan val.base = XEXP (addr, 0); 2317169699Skan val.start = -GET_MODE_SIZE (GET_MODE (x)); 2318169699Skan val.end = GET_MODE_SIZE (GET_MODE (x)); 2319169699Skan val.safe = REGNO (val.base) == STACK_POINTER_REGNUM; 2320169699Skan return val; 2321169699Skan } 2322169699Skan 2323169699Skan if (GET_CODE (addr) == PRE_MODIFY || GET_CODE (addr) == POST_MODIFY) 2324169699Skan { 2325169699Skan if (GET_CODE (XEXP (addr, 1)) == PLUS 2326169699Skan && XEXP (addr, 0) == XEXP (XEXP (addr, 1), 0) 2327169699Skan && CONSTANT_P (XEXP (XEXP (addr, 1), 1))) 2328169699Skan { 2329169699Skan val.base = XEXP (addr, 0); 2330169699Skan val.start = -INTVAL (XEXP (XEXP (addr, 1), 1)); 2331169699Skan val.end = INTVAL (XEXP (XEXP (addr, 1), 1)); 2332169699Skan val.safe = REGNO (val.base) == STACK_POINTER_REGNUM; 2333169699Skan return val; 2334169699Skan } 2335169699Skan } 2336169699Skan 2337169699Skan if (GET_CODE (addr) == CONST) 2338169699Skan { 2339169699Skan addr = XEXP (addr, 0); 2340169699Skan all_const = 1; 2341169699Skan } 2342169699Skan if (GET_CODE (addr) == PLUS) 2343169699Skan { 2344169699Skan if (CONSTANT_P (XEXP (addr, 0))) 2345169699Skan { 2346169699Skan base = XEXP (addr, 1); 2347169699Skan offset = XEXP (addr, 0); 2348169699Skan } 2349169699Skan else if (CONSTANT_P (XEXP (addr, 1))) 2350169699Skan { 2351169699Skan base = XEXP (addr, 0); 2352169699Skan offset = XEXP (addr, 1); 2353169699Skan } 2354169699Skan } 2355169699Skan 2356169699Skan if (offset == 0) 2357169699Skan { 2358169699Skan base = addr; 2359169699Skan offset = const0_rtx; 2360169699Skan } 2361169699Skan if (GET_CODE (offset) == CONST) 2362169699Skan offset = XEXP (offset, 0); 2363169699Skan if (GET_CODE (offset) == PLUS) 2364169699Skan { 2365169699Skan if (GET_CODE (XEXP (offset, 0)) == CONST_INT) 2366169699Skan { 2367169699Skan base = gen_rtx_PLUS (GET_MODE (base), base, XEXP (offset, 1)); 2368169699Skan offset = XEXP (offset, 0); 2369169699Skan } 2370169699Skan else if (GET_CODE (XEXP (offset, 1)) == CONST_INT) 2371169699Skan { 2372169699Skan base = gen_rtx_PLUS (GET_MODE (base), base, XEXP (offset, 0)); 2373169699Skan offset = XEXP (offset, 1); 2374169699Skan } 2375169699Skan else 2376169699Skan { 2377169699Skan base = gen_rtx_PLUS (GET_MODE (base), base, offset); 2378169699Skan offset = const0_rtx; 2379169699Skan } 2380169699Skan } 2381169699Skan else if (GET_CODE (offset) != CONST_INT) 2382169699Skan { 2383169699Skan base = gen_rtx_PLUS (GET_MODE (base), base, offset); 2384169699Skan offset = const0_rtx; 2385169699Skan } 2386169699Skan 2387169699Skan if (all_const && GET_CODE (base) == PLUS) 2388169699Skan base = gen_rtx_CONST (GET_MODE (base), base); 2389169699Skan 2390169699Skan gcc_assert (GET_CODE (offset) == CONST_INT); 2391169699Skan 2392169699Skan val.start = INTVAL (offset); 2393169699Skan val.end = val.start + GET_MODE_SIZE (GET_MODE (x)); 2394169699Skan val.base = base; 2395169699Skan } 2396169699Skan break; 2397169699Skan 2398169699Skan case REG: 239918334Speter val.reg_flag = 1; 240090285Sobrien val.start = true_regnum (x); 2401169699Skan if (val.start < 0 || val.start >= FIRST_PSEUDO_REGISTER) 240218334Speter { 240318334Speter /* A pseudo with no hard reg. */ 240418334Speter val.start = REGNO (x); 240518334Speter val.end = val.start + 1; 240618334Speter } 240718334Speter else 240818334Speter /* A hard reg. */ 2409169699Skan val.end = val.start + hard_regno_nregs[val.start][GET_MODE (x)]; 2410169699Skan break; 2411169699Skan 2412169699Skan case SUBREG: 2413169699Skan if (!REG_P (SUBREG_REG (x))) 241418334Speter /* This could be more precise, but it's good enough. */ 241518334Speter return decompose (SUBREG_REG (x)); 241618334Speter val.reg_flag = 1; 241790285Sobrien val.start = true_regnum (x); 2418169699Skan if (val.start < 0 || val.start >= FIRST_PSEUDO_REGISTER) 241918334Speter return decompose (SUBREG_REG (x)); 242018334Speter else 242118334Speter /* A hard reg. */ 2422169699Skan val.end = val.start + hard_regno_nregs[val.start][GET_MODE (x)]; 2423169699Skan break; 2424169699Skan 2425169699Skan case SCRATCH: 2426169699Skan /* This hasn't been assigned yet, so it can't conflict yet. */ 2427169699Skan val.safe = 1; 2428169699Skan break; 2429169699Skan 2430169699Skan default: 2431169699Skan gcc_assert (CONSTANT_P (x)); 2432169699Skan val.safe = 1; 2433169699Skan break; 243418334Speter } 243518334Speter return val; 243618334Speter} 243718334Speter 243818334Speter/* Return 1 if altering Y will not modify the value of X. 243918334Speter Y is also described by YDATA, which should be decompose (Y). */ 244018334Speter 244118334Speterstatic int 2442132727Skanimmune_p (rtx x, rtx y, struct decomposition ydata) 244318334Speter{ 244418334Speter struct decomposition xdata; 244518334Speter 244618334Speter if (ydata.reg_flag) 244790285Sobrien return !refers_to_regno_for_reload_p (ydata.start, ydata.end, x, (rtx*) 0); 244818334Speter if (ydata.safe) 244918334Speter return 1; 245018334Speter 2451169699Skan gcc_assert (MEM_P (y)); 245218334Speter /* If Y is memory and X is not, Y can't affect X. */ 2453169699Skan if (!MEM_P (x)) 245418334Speter return 1; 245518334Speter 245690285Sobrien xdata = decompose (x); 245718334Speter 245818334Speter if (! rtx_equal_p (xdata.base, ydata.base)) 245918334Speter { 246018334Speter /* If bases are distinct symbolic constants, there is no overlap. */ 246118334Speter if (CONSTANT_P (xdata.base) && CONSTANT_P (ydata.base)) 246218334Speter return 1; 246318334Speter /* Constants and stack slots never overlap. */ 246418334Speter if (CONSTANT_P (xdata.base) 246518334Speter && (ydata.base == frame_pointer_rtx 246618334Speter || ydata.base == hard_frame_pointer_rtx 246718334Speter || ydata.base == stack_pointer_rtx)) 246818334Speter return 1; 246918334Speter if (CONSTANT_P (ydata.base) 247018334Speter && (xdata.base == frame_pointer_rtx 247118334Speter || xdata.base == hard_frame_pointer_rtx 247218334Speter || xdata.base == stack_pointer_rtx)) 247318334Speter return 1; 247418334Speter /* If either base is variable, we don't know anything. */ 247518334Speter return 0; 247618334Speter } 247718334Speter 247818334Speter return (xdata.start >= ydata.end || ydata.start >= xdata.end); 247918334Speter} 248018334Speter 248118334Speter/* Similar, but calls decompose. */ 248218334Speter 248318334Speterint 2484132727Skansafe_from_earlyclobber (rtx op, rtx clobber) 248518334Speter{ 248618334Speter struct decomposition early_data; 248718334Speter 248818334Speter early_data = decompose (clobber); 248918334Speter return immune_p (op, clobber, early_data); 249018334Speter} 249118334Speter 249218334Speter/* Main entry point of this file: search the body of INSN 249318334Speter for values that need reloading and record them with push_reload. 249418334Speter REPLACE nonzero means record also where the values occur 249518334Speter so that subst_reloads can be used. 249618334Speter 249718334Speter IND_LEVELS says how many levels of indirection are supported by this 249818334Speter machine; a value of zero means that a memory reference is not a valid 249918334Speter memory address. 250018334Speter 250118334Speter LIVE_KNOWN says we have valid information about which hard 250218334Speter regs are live at each point in the program; this is true when 250318334Speter we are called from global_alloc but false when stupid register 250418334Speter allocation has been done. 250518334Speter 250618334Speter RELOAD_REG_P if nonzero is a vector indexed by hard reg number 250718334Speter which is nonnegative if the reg has been commandeered for reloading into. 250818334Speter It is copied into STATIC_RELOAD_REG_P and referenced from there 250952557Sobrien by various subroutines. 251018334Speter 251152557Sobrien Return TRUE if some operands need to be changed, because of swapping 251252557Sobrien commutative operands, reg_equiv_address substitution, or whatever. */ 251352557Sobrien 251452557Sobrienint 2515132727Skanfind_reloads (rtx insn, int replace, int ind_levels, int live_known, 2516132727Skan short *reload_reg_p) 251718334Speter{ 251890285Sobrien int insn_code_number; 251990285Sobrien int i, j; 252018334Speter int noperands; 252118334Speter /* These start out as the constraints for the insn 252218334Speter and they are chewed up as we consider alternatives. */ 252318334Speter char *constraints[MAX_RECOG_OPERANDS]; 252418334Speter /* These are the preferred classes for an operand, or NO_REGS if it isn't 252518334Speter a register. */ 252618334Speter enum reg_class preferred_class[MAX_RECOG_OPERANDS]; 252718334Speter char pref_or_nothing[MAX_RECOG_OPERANDS]; 2528169699Skan /* Nonzero for a MEM operand whose entire address needs a reload. 2529169699Skan May be -1 to indicate the entire address may or may not need a reload. */ 253018334Speter int address_reloaded[MAX_RECOG_OPERANDS]; 2531169699Skan /* Nonzero for an address operand that needs to be completely reloaded. 2532169699Skan May be -1 to indicate the entire operand may or may not need a reload. */ 2533117404Skan int address_operand_reloaded[MAX_RECOG_OPERANDS]; 253418334Speter /* Value of enum reload_type to use for operand. */ 253518334Speter enum reload_type operand_type[MAX_RECOG_OPERANDS]; 253618334Speter /* Value of enum reload_type to use within address of operand. */ 253718334Speter enum reload_type address_type[MAX_RECOG_OPERANDS]; 253818334Speter /* Save the usage of each operand. */ 253918334Speter enum reload_usage { RELOAD_READ, RELOAD_READ_WRITE, RELOAD_WRITE } modified[MAX_RECOG_OPERANDS]; 254018334Speter int no_input_reloads = 0, no_output_reloads = 0; 254118334Speter int n_alternatives; 254218334Speter int this_alternative[MAX_RECOG_OPERANDS]; 254390285Sobrien char this_alternative_match_win[MAX_RECOG_OPERANDS]; 254418334Speter char this_alternative_win[MAX_RECOG_OPERANDS]; 254518334Speter char this_alternative_offmemok[MAX_RECOG_OPERANDS]; 254618334Speter char this_alternative_earlyclobber[MAX_RECOG_OPERANDS]; 254718334Speter int this_alternative_matches[MAX_RECOG_OPERANDS]; 254818334Speter int swapped; 254918334Speter int goal_alternative[MAX_RECOG_OPERANDS]; 255018334Speter int this_alternative_number; 255190285Sobrien int goal_alternative_number = 0; 255218334Speter int operand_reloadnum[MAX_RECOG_OPERANDS]; 255318334Speter int goal_alternative_matches[MAX_RECOG_OPERANDS]; 255418334Speter int goal_alternative_matched[MAX_RECOG_OPERANDS]; 255590285Sobrien char goal_alternative_match_win[MAX_RECOG_OPERANDS]; 255618334Speter char goal_alternative_win[MAX_RECOG_OPERANDS]; 255718334Speter char goal_alternative_offmemok[MAX_RECOG_OPERANDS]; 255818334Speter char goal_alternative_earlyclobber[MAX_RECOG_OPERANDS]; 255918334Speter int goal_alternative_swapped; 256018334Speter int best; 256118334Speter int commutative; 256218334Speter char operands_match[MAX_RECOG_OPERANDS][MAX_RECOG_OPERANDS]; 256318334Speter rtx substed_operand[MAX_RECOG_OPERANDS]; 256418334Speter rtx body = PATTERN (insn); 256518334Speter rtx set = single_set (insn); 256690285Sobrien int goal_earlyclobber = 0, this_earlyclobber; 256718334Speter enum machine_mode operand_mode[MAX_RECOG_OPERANDS]; 256852557Sobrien int retval = 0; 256918334Speter 257018334Speter this_insn = insn; 257118334Speter n_reloads = 0; 257218334Speter n_replacements = 0; 257318334Speter n_earlyclobbers = 0; 257418334Speter replace_reloads = replace; 257518334Speter hard_regs_live_known = live_known; 257618334Speter static_reload_reg_p = reload_reg_p; 257718334Speter 257818334Speter /* JUMP_INSNs and CALL_INSNs are not allowed to have any output reloads; 257918334Speter neither are insns that SET cc0. Insns that use CC0 are not allowed 258018334Speter to have any input reloads. */ 2581169699Skan if (JUMP_P (insn) || CALL_P (insn)) 258218334Speter no_output_reloads = 1; 258318334Speter 258418334Speter#ifdef HAVE_cc0 258518334Speter if (reg_referenced_p (cc0_rtx, PATTERN (insn))) 258618334Speter no_input_reloads = 1; 258718334Speter if (reg_set_p (cc0_rtx, PATTERN (insn))) 258818334Speter no_output_reloads = 1; 258918334Speter#endif 259090285Sobrien 259118334Speter#ifdef SECONDARY_MEMORY_NEEDED 259218334Speter /* The eliminated forms of any secondary memory locations are per-insn, so 259318334Speter clear them out here. */ 259418334Speter 2595132727Skan if (secondary_memlocs_elim_used) 2596132727Skan { 2597132727Skan memset (secondary_memlocs_elim, 0, 2598132727Skan sizeof (secondary_memlocs_elim[0]) * secondary_memlocs_elim_used); 2599132727Skan secondary_memlocs_elim_used = 0; 2600132727Skan } 260118334Speter#endif 260218334Speter 260352557Sobrien /* Dispose quickly of (set (reg..) (reg..)) if both have hard regs and it 260452557Sobrien is cheap to move between them. If it is not, there may not be an insn 260552557Sobrien to do the copy, so we may need a reload. */ 260652557Sobrien if (GET_CODE (body) == SET 2607169699Skan && REG_P (SET_DEST (body)) 260852557Sobrien && REGNO (SET_DEST (body)) < FIRST_PSEUDO_REGISTER 2609169699Skan && REG_P (SET_SRC (body)) 261052557Sobrien && REGNO (SET_SRC (body)) < FIRST_PSEUDO_REGISTER 261190285Sobrien && REGISTER_MOVE_COST (GET_MODE (SET_SRC (body)), 261290285Sobrien REGNO_REG_CLASS (REGNO (SET_SRC (body))), 261352557Sobrien REGNO_REG_CLASS (REGNO (SET_DEST (body)))) == 2) 261452557Sobrien return 0; 261518334Speter 261652557Sobrien extract_insn (insn); 261718334Speter 261890285Sobrien noperands = reload_n_operands = recog_data.n_operands; 261990285Sobrien n_alternatives = recog_data.n_alternatives; 262018334Speter 262152557Sobrien /* Just return "no reloads" if insn has no operands with constraints. */ 262252557Sobrien if (noperands == 0 || n_alternatives == 0) 262352557Sobrien return 0; 262418334Speter 262552557Sobrien insn_code_number = INSN_CODE (insn); 262652557Sobrien this_insn_is_asm = insn_code_number < 0; 262718334Speter 262890285Sobrien memcpy (operand_mode, recog_data.operand_mode, 262990285Sobrien noperands * sizeof (enum machine_mode)); 263090285Sobrien memcpy (constraints, recog_data.constraints, noperands * sizeof (char *)); 263118334Speter 263218334Speter commutative = -1; 263318334Speter 263418334Speter /* If we will need to know, later, whether some pair of operands 263518334Speter are the same, we must compare them now and save the result. 263618334Speter Reloading the base and index registers will clobber them 263718334Speter and afterward they will fail to match. */ 263818334Speter 263918334Speter for (i = 0; i < noperands; i++) 264018334Speter { 264190285Sobrien char *p; 264290285Sobrien int c; 264318334Speter 264490285Sobrien substed_operand[i] = recog_data.operand[i]; 264518334Speter p = constraints[i]; 264618334Speter 264718334Speter modified[i] = RELOAD_READ; 264818334Speter 264990285Sobrien /* Scan this operand's constraint to see if it is an output operand, 265018334Speter an in-out operand, is commutative, or should match another. */ 265118334Speter 2652132727Skan while ((c = *p)) 265318334Speter { 2654132727Skan p += CONSTRAINT_LEN (c, p); 2655169699Skan switch (c) 265618334Speter { 2657169699Skan case '=': 2658169699Skan modified[i] = RELOAD_WRITE; 2659169699Skan break; 2660169699Skan case '+': 2661169699Skan modified[i] = RELOAD_READ_WRITE; 2662169699Skan break; 2663169699Skan case '%': 2664169699Skan { 2665169699Skan /* The last operand should not be marked commutative. */ 2666169699Skan gcc_assert (i != noperands - 1); 266752557Sobrien 2668169699Skan /* We currently only support one commutative pair of 2669169699Skan operands. Some existing asm code currently uses more 2670169699Skan than one pair. Previously, that would usually work, 2671169699Skan but sometimes it would crash the compiler. We 2672169699Skan continue supporting that case as well as we can by 2673169699Skan silently ignoring all but the first pair. In the 2674169699Skan future we may handle it correctly. */ 2675169699Skan if (commutative < 0) 2676169699Skan commutative = i; 2677169699Skan else 2678169699Skan gcc_assert (this_insn_is_asm); 2679169699Skan } 2680169699Skan break; 2681169699Skan /* Use of ISDIGIT is tempting here, but it may get expensive because 2682169699Skan of locale support we don't want. */ 2683169699Skan case '0': case '1': case '2': case '3': case '4': 2684169699Skan case '5': case '6': case '7': case '8': case '9': 2685169699Skan { 2686169699Skan c = strtoul (p - 1, &p, 10); 268790285Sobrien 2688169699Skan operands_match[c][i] 2689169699Skan = operands_match_p (recog_data.operand[c], 2690169699Skan recog_data.operand[i]); 269118334Speter 2692169699Skan /* An operand may not match itself. */ 2693169699Skan gcc_assert (c != i); 269418334Speter 2695169699Skan /* If C can be commuted with C+1, and C might need to match I, 2696169699Skan then C+1 might also need to match I. */ 2697169699Skan if (commutative >= 0) 2698169699Skan { 2699169699Skan if (c == commutative || c == commutative + 1) 2700169699Skan { 2701169699Skan int other = c + (c == commutative ? 1 : -1); 2702169699Skan operands_match[other][i] 2703169699Skan = operands_match_p (recog_data.operand[other], 2704169699Skan recog_data.operand[i]); 2705169699Skan } 2706169699Skan if (i == commutative || i == commutative + 1) 2707169699Skan { 2708169699Skan int other = i + (i == commutative ? 1 : -1); 2709169699Skan operands_match[c][other] 2710169699Skan = operands_match_p (recog_data.operand[c], 2711169699Skan recog_data.operand[other]); 2712169699Skan } 2713169699Skan /* Note that C is supposed to be less than I. 2714169699Skan No need to consider altering both C and I because in 2715169699Skan that case we would alter one into the other. */ 2716169699Skan } 2717169699Skan } 271818334Speter } 271918334Speter } 272018334Speter } 272118334Speter 272218334Speter /* Examine each operand that is a memory reference or memory address 272318334Speter and reload parts of the addresses into index registers. 272418334Speter Also here any references to pseudo regs that didn't get hard regs 272518334Speter but are equivalent to constants get replaced in the insn itself 272690285Sobrien with those constants. Nobody will ever see them again. 272718334Speter 272818334Speter Finally, set up the preferred classes of each operand. */ 272918334Speter 273018334Speter for (i = 0; i < noperands; i++) 273118334Speter { 273290285Sobrien RTX_CODE code = GET_CODE (recog_data.operand[i]); 273318334Speter 273418334Speter address_reloaded[i] = 0; 2735117404Skan address_operand_reloaded[i] = 0; 273618334Speter operand_type[i] = (modified[i] == RELOAD_READ ? RELOAD_FOR_INPUT 273718334Speter : modified[i] == RELOAD_WRITE ? RELOAD_FOR_OUTPUT 273818334Speter : RELOAD_OTHER); 273918334Speter address_type[i] 274018334Speter = (modified[i] == RELOAD_READ ? RELOAD_FOR_INPUT_ADDRESS 274118334Speter : modified[i] == RELOAD_WRITE ? RELOAD_FOR_OUTPUT_ADDRESS 274218334Speter : RELOAD_OTHER); 274318334Speter 274418334Speter if (*constraints[i] == 0) 274518334Speter /* Ignore things like match_operator operands. */ 274618334Speter ; 2747117404Skan else if (constraints[i][0] == 'p' 2748132727Skan || EXTRA_ADDRESS_CONSTRAINT (constraints[i][0], constraints[i])) 274918334Speter { 2750117404Skan address_operand_reloaded[i] 2751117404Skan = find_reloads_address (recog_data.operand_mode[i], (rtx*) 0, 2752117404Skan recog_data.operand[i], 2753117404Skan recog_data.operand_loc[i], 2754117404Skan i, operand_type[i], ind_levels, insn); 275550605Sobrien 275690285Sobrien /* If we now have a simple operand where we used to have a 275750605Sobrien PLUS or MULT, re-recognize and try again. */ 2758169699Skan if ((OBJECT_P (*recog_data.operand_loc[i]) 275990285Sobrien || GET_CODE (*recog_data.operand_loc[i]) == SUBREG) 276090285Sobrien && (GET_CODE (recog_data.operand[i]) == MULT 276190285Sobrien || GET_CODE (recog_data.operand[i]) == PLUS)) 276250605Sobrien { 276350605Sobrien INSN_CODE (insn) = -1; 276452557Sobrien retval = find_reloads (insn, replace, ind_levels, live_known, 276552557Sobrien reload_reg_p); 276652557Sobrien return retval; 276750605Sobrien } 276850605Sobrien 276990285Sobrien recog_data.operand[i] = *recog_data.operand_loc[i]; 277090285Sobrien substed_operand[i] = recog_data.operand[i]; 2771117404Skan 2772117404Skan /* Address operands are reloaded in their existing mode, 2773117404Skan no matter what is specified in the machine description. */ 2774117404Skan operand_mode[i] = GET_MODE (recog_data.operand[i]); 277518334Speter } 277618334Speter else if (code == MEM) 277718334Speter { 277852557Sobrien address_reloaded[i] 277990285Sobrien = find_reloads_address (GET_MODE (recog_data.operand[i]), 278090285Sobrien recog_data.operand_loc[i], 278190285Sobrien XEXP (recog_data.operand[i], 0), 278290285Sobrien &XEXP (recog_data.operand[i], 0), 278352557Sobrien i, address_type[i], ind_levels, insn); 278490285Sobrien recog_data.operand[i] = *recog_data.operand_loc[i]; 278590285Sobrien substed_operand[i] = recog_data.operand[i]; 278618334Speter } 278718334Speter else if (code == SUBREG) 278850605Sobrien { 278990285Sobrien rtx reg = SUBREG_REG (recog_data.operand[i]); 279050605Sobrien rtx op 279190285Sobrien = find_reloads_toplev (recog_data.operand[i], i, address_type[i], 279250605Sobrien ind_levels, 279350605Sobrien set != 0 279490285Sobrien && &SET_DEST (set) == recog_data.operand_loc[i], 279590285Sobrien insn, 279690285Sobrien &address_reloaded[i]); 279750605Sobrien 279850605Sobrien /* If we made a MEM to load (a part of) the stackslot of a pseudo 279950605Sobrien that didn't get a hard register, emit a USE with a REG_EQUAL 280050605Sobrien note in front so that we might inherit a previous, possibly 280150605Sobrien wider reload. */ 280290285Sobrien 280352557Sobrien if (replace 2804169699Skan && MEM_P (op) 2805169699Skan && REG_P (reg) 280650605Sobrien && (GET_MODE_SIZE (GET_MODE (reg)) 280750605Sobrien >= GET_MODE_SIZE (GET_MODE (op)))) 280890285Sobrien set_unique_reg_note (emit_insn_before (gen_rtx_USE (VOIDmode, reg), 280990285Sobrien insn), 281090285Sobrien REG_EQUAL, reg_equiv_memory_loc[REGNO (reg)]); 281150605Sobrien 281290285Sobrien substed_operand[i] = recog_data.operand[i] = op; 281350605Sobrien } 2814169699Skan else if (code == PLUS || GET_RTX_CLASS (code) == RTX_UNARY) 281550605Sobrien /* We can get a PLUS as an "operand" as a result of register 281650605Sobrien elimination. See eliminate_regs and gen_reload. We handle 281750605Sobrien a unary operator by reloading the operand. */ 281890285Sobrien substed_operand[i] = recog_data.operand[i] 281990285Sobrien = find_reloads_toplev (recog_data.operand[i], i, address_type[i], 282090285Sobrien ind_levels, 0, insn, 282190285Sobrien &address_reloaded[i]); 282218334Speter else if (code == REG) 282318334Speter { 282418334Speter /* This is equivalent to calling find_reloads_toplev. 282518334Speter The code is duplicated for speed. 282618334Speter When we find a pseudo always equivalent to a constant, 282718334Speter we replace it by the constant. We must be sure, however, 282818334Speter that we don't try to replace it in the insn in which it 282990285Sobrien is being set. */ 283090285Sobrien int regno = REGNO (recog_data.operand[i]); 283118334Speter if (reg_equiv_constant[regno] != 0 283290285Sobrien && (set == 0 || &SET_DEST (set) != recog_data.operand_loc[i])) 283350605Sobrien { 283450605Sobrien /* Record the existing mode so that the check if constants are 283590285Sobrien allowed will work when operand_mode isn't specified. */ 283650605Sobrien 283750605Sobrien if (operand_mode[i] == VOIDmode) 283890285Sobrien operand_mode[i] = GET_MODE (recog_data.operand[i]); 283950605Sobrien 284090285Sobrien substed_operand[i] = recog_data.operand[i] 284190285Sobrien = reg_equiv_constant[regno]; 284250605Sobrien } 284352557Sobrien if (reg_equiv_memory_loc[regno] != 0 284452557Sobrien && (reg_equiv_address[regno] != 0 || num_not_at_initial_offset)) 284552557Sobrien /* We need not give a valid is_set_dest argument since the case 284652557Sobrien of a constant equivalence was checked above. */ 284790285Sobrien substed_operand[i] = recog_data.operand[i] 284890285Sobrien = find_reloads_toplev (recog_data.operand[i], i, address_type[i], 284990285Sobrien ind_levels, 0, insn, 285090285Sobrien &address_reloaded[i]); 285118334Speter } 285218334Speter /* If the operand is still a register (we didn't replace it with an 285318334Speter equivalent), get the preferred class to reload it into. */ 285490285Sobrien code = GET_CODE (recog_data.operand[i]); 285518334Speter preferred_class[i] 285690285Sobrien = ((code == REG && REGNO (recog_data.operand[i]) 285790285Sobrien >= FIRST_PSEUDO_REGISTER) 285890285Sobrien ? reg_preferred_class (REGNO (recog_data.operand[i])) 285990285Sobrien : NO_REGS); 286018334Speter pref_or_nothing[i] 286190285Sobrien = (code == REG 286290285Sobrien && REGNO (recog_data.operand[i]) >= FIRST_PSEUDO_REGISTER 286390285Sobrien && reg_alternate_class (REGNO (recog_data.operand[i])) == NO_REGS); 286418334Speter } 286518334Speter 286618334Speter /* If this is simply a copy from operand 1 to operand 0, merge the 286718334Speter preferred classes for the operands. */ 286890285Sobrien if (set != 0 && noperands >= 2 && recog_data.operand[0] == SET_DEST (set) 286990285Sobrien && recog_data.operand[1] == SET_SRC (set)) 287018334Speter { 287118334Speter preferred_class[0] = preferred_class[1] 287218334Speter = reg_class_subunion[(int) preferred_class[0]][(int) preferred_class[1]]; 287318334Speter pref_or_nothing[0] |= pref_or_nothing[1]; 287418334Speter pref_or_nothing[1] |= pref_or_nothing[0]; 287518334Speter } 287618334Speter 287718334Speter /* Now see what we need for pseudo-regs that didn't get hard regs 287818334Speter or got the wrong kind of hard reg. For this, we must consider 287918334Speter all the operands together against the register constraints. */ 288018334Speter 288150605Sobrien best = MAX_RECOG_OPERANDS * 2 + 600; 288218334Speter 288318334Speter swapped = 0; 288418334Speter goal_alternative_swapped = 0; 288518334Speter try_swapped: 288618334Speter 288718334Speter /* The constraints are made of several alternatives. 288818334Speter Each operand's constraint looks like foo,bar,... with commas 288918334Speter separating the alternatives. The first alternatives for all 289018334Speter operands go together, the second alternatives go together, etc. 289118334Speter 289218334Speter First loop over alternatives. */ 289318334Speter 289418334Speter for (this_alternative_number = 0; 289518334Speter this_alternative_number < n_alternatives; 289618334Speter this_alternative_number++) 289718334Speter { 289818334Speter /* Loop over operands for one constraint alternative. */ 289918334Speter /* LOSERS counts those that don't fit this alternative 290018334Speter and would require loading. */ 290118334Speter int losers = 0; 290218334Speter /* BAD is set to 1 if it some operand can't fit this alternative 290318334Speter even after reloading. */ 290418334Speter int bad = 0; 290518334Speter /* REJECT is a count of how undesirable this alternative says it is 290618334Speter if any reloading is required. If the alternative matches exactly 290718334Speter then REJECT is ignored, but otherwise it gets this much 290890285Sobrien counted against it in addition to the reloading needed. Each 290918334Speter ? counts three times here since we want the disparaging caused by 291018334Speter a bad register class to only count 1/3 as much. */ 291118334Speter int reject = 0; 291218334Speter 291318334Speter this_earlyclobber = 0; 291418334Speter 291518334Speter for (i = 0; i < noperands; i++) 291618334Speter { 291790285Sobrien char *p = constraints[i]; 2918132727Skan char *end; 2919132727Skan int len; 292090285Sobrien int win = 0; 292190285Sobrien int did_match = 0; 292290285Sobrien /* 0 => this operand can be reloaded somehow for this alternative. */ 292318334Speter int badop = 1; 292418334Speter /* 0 => this operand can be reloaded if the alternative allows regs. */ 292518334Speter int winreg = 0; 292618334Speter int c; 2927132727Skan int m; 292890285Sobrien rtx operand = recog_data.operand[i]; 292918334Speter int offset = 0; 293018334Speter /* Nonzero means this is a MEM that must be reloaded into a reg 293118334Speter regardless of what the constraint says. */ 293218334Speter int force_reload = 0; 293318334Speter int offmemok = 0; 293418334Speter /* Nonzero if a constant forced into memory would be OK for this 293518334Speter operand. */ 293618334Speter int constmemok = 0; 293718334Speter int earlyclobber = 0; 293818334Speter 293950605Sobrien /* If the predicate accepts a unary operator, it means that 294090285Sobrien we need to reload the operand, but do not do this for 294150605Sobrien match_operator and friends. */ 2942169699Skan if (UNARY_P (operand) && *p != 0) 294350605Sobrien operand = XEXP (operand, 0); 294450605Sobrien 294518334Speter /* If the operand is a SUBREG, extract 294618334Speter the REG or MEM (or maybe even a constant) within. 294718334Speter (Constants can occur as a result of reg_equiv_constant.) */ 294818334Speter 294918334Speter while (GET_CODE (operand) == SUBREG) 295018334Speter { 295190285Sobrien /* Offset only matters when operand is a REG and 295290285Sobrien it is a hard reg. This is because it is passed 295390285Sobrien to reg_fits_class_p if it is a REG and all pseudos 295490285Sobrien return 0 from that function. */ 2955169699Skan if (REG_P (SUBREG_REG (operand)) 295690285Sobrien && REGNO (SUBREG_REG (operand)) < FIRST_PSEUDO_REGISTER) 295790285Sobrien { 2958117404Skan if (!subreg_offset_representable_p 2959117404Skan (REGNO (SUBREG_REG (operand)), 2960117404Skan GET_MODE (SUBREG_REG (operand)), 2961117404Skan SUBREG_BYTE (operand), 2962117404Skan GET_MODE (operand))) 2963117404Skan force_reload = 1; 296490285Sobrien offset += subreg_regno_offset (REGNO (SUBREG_REG (operand)), 296590285Sobrien GET_MODE (SUBREG_REG (operand)), 296690285Sobrien SUBREG_BYTE (operand), 296790285Sobrien GET_MODE (operand)); 296890285Sobrien } 296918334Speter operand = SUBREG_REG (operand); 297050605Sobrien /* Force reload if this is a constant or PLUS or if there may 297118334Speter be a problem accessing OPERAND in the outer mode. */ 297218334Speter if (CONSTANT_P (operand) 297318334Speter || GET_CODE (operand) == PLUS 297418334Speter /* We must force a reload of paradoxical SUBREGs 297518334Speter of a MEM because the alignment of the inner value 297618334Speter may not be enough to do the outer reference. On 297718334Speter big-endian machines, it may also reference outside 297818334Speter the object. 297918334Speter 298018334Speter On machines that extend byte operations and we have a 298118334Speter SUBREG where both the inner and outer modes are no wider 298218334Speter than a word and the inner mode is narrower, is integral, 298318334Speter and gets extended when loaded from memory, combine.c has 298418334Speter made assumptions about the behavior of the machine in such 298518334Speter register access. If the data is, in fact, in memory we 298618334Speter must always load using the size assumed to be in the 298790285Sobrien register and let the insn do the different-sized 298850605Sobrien accesses. 298950605Sobrien 299090285Sobrien This is doubly true if WORD_REGISTER_OPERATIONS. In 299150605Sobrien this case eliminate_regs has left non-paradoxical 2992132727Skan subregs for push_reload to see. Make sure it does 299350605Sobrien by forcing the reload. 299450605Sobrien 299550605Sobrien ??? When is it right at this stage to have a subreg 2996132727Skan of a mem that is _not_ to be handled specially? IMO 299750605Sobrien those should have been reduced to just a mem. */ 2998169699Skan || ((MEM_P (operand) 2999169699Skan || (REG_P (operand) 300018334Speter && REGNO (operand) >= FIRST_PSEUDO_REGISTER)) 300150605Sobrien#ifndef WORD_REGISTER_OPERATIONS 300218334Speter && (((GET_MODE_BITSIZE (GET_MODE (operand)) 300318334Speter < BIGGEST_ALIGNMENT) 300418334Speter && (GET_MODE_SIZE (operand_mode[i]) 300518334Speter > GET_MODE_SIZE (GET_MODE (operand)))) 3006132727Skan || BYTES_BIG_ENDIAN 300718334Speter#ifdef LOAD_EXTEND_OP 300818334Speter || (GET_MODE_SIZE (operand_mode[i]) <= UNITS_PER_WORD 300918334Speter && (GET_MODE_SIZE (GET_MODE (operand)) 301018334Speter <= UNITS_PER_WORD) 301118334Speter && (GET_MODE_SIZE (operand_mode[i]) 301218334Speter > GET_MODE_SIZE (GET_MODE (operand))) 301318334Speter && INTEGRAL_MODE_P (GET_MODE (operand)) 3014169699Skan && LOAD_EXTEND_OP (GET_MODE (operand)) != UNKNOWN) 301518334Speter#endif 301650605Sobrien ) 301750605Sobrien#endif 301850605Sobrien ) 301990285Sobrien ) 302018334Speter force_reload = 1; 302118334Speter } 302218334Speter 302318334Speter this_alternative[i] = (int) NO_REGS; 302418334Speter this_alternative_win[i] = 0; 302590285Sobrien this_alternative_match_win[i] = 0; 302618334Speter this_alternative_offmemok[i] = 0; 302718334Speter this_alternative_earlyclobber[i] = 0; 302818334Speter this_alternative_matches[i] = -1; 302918334Speter 303018334Speter /* An empty constraint or empty alternative 303118334Speter allows anything which matched the pattern. */ 303218334Speter if (*p == 0 || *p == ',') 303318334Speter win = 1, badop = 0; 303418334Speter 303518334Speter /* Scan this alternative's specs for this operand; 303618334Speter set WIN if the operand fits any letter in this alternative. 303718334Speter Otherwise, clear BADOP if this operand could 303818334Speter fit some letter after reloads, 303918334Speter or set WINREG if this operand could fit after reloads 304018334Speter provided the constraint allows some registers. */ 304118334Speter 3042132727Skan do 3043132727Skan switch ((c = *p, len = CONSTRAINT_LEN (c, p)), c) 304418334Speter { 3045132727Skan case '\0': 3046132727Skan len = 0; 3047132727Skan break; 3048132727Skan case ',': 3049132727Skan c = '\0'; 3050132727Skan break; 3051132727Skan 305290285Sobrien case '=': case '+': case '*': 305318334Speter break; 305418334Speter 305518334Speter case '%': 3056132727Skan /* We only support one commutative marker, the first 3057132727Skan one. We already set commutative above. */ 305818334Speter break; 305918334Speter 306018334Speter case '?': 306150605Sobrien reject += 6; 306218334Speter break; 306318334Speter 306418334Speter case '!': 306550605Sobrien reject = 600; 306618334Speter break; 306718334Speter 306818334Speter case '#': 306918334Speter /* Ignore rest of this alternative as far as 307018334Speter reloading is concerned. */ 3071132727Skan do 307290285Sobrien p++; 3073132727Skan while (*p && *p != ','); 3074132727Skan len = 0; 307518334Speter break; 307618334Speter 307790285Sobrien case '0': case '1': case '2': case '3': case '4': 307890285Sobrien case '5': case '6': case '7': case '8': case '9': 3079132727Skan m = strtoul (p, &end, 10); 3080132727Skan p = end; 3081132727Skan len = 0; 308290285Sobrien 3083132727Skan this_alternative_matches[i] = m; 308418334Speter /* We are supposed to match a previous operand. 308518334Speter If we do, we win if that one did. 308618334Speter If we do not, count both of the operands as losers. 308718334Speter (This is too conservative, since most of the time 308818334Speter only a single reload insn will be needed to make 308918334Speter the two operands win. As a result, this alternative 309018334Speter may be rejected when it is actually desirable.) */ 3091132727Skan if ((swapped && (m != commutative || i != commutative + 1)) 309218334Speter /* If we are matching as if two operands were swapped, 309318334Speter also pretend that operands_match had been computed 309418334Speter with swapped. 309518334Speter But if I is the second of those and C is the first, 309618334Speter don't exchange them, because operands_match is valid 309718334Speter only on one side of its diagonal. */ 309818334Speter ? (operands_match 3099132727Skan [(m == commutative || m == commutative + 1) 3100132727Skan ? 2 * commutative + 1 - m : m] 310190285Sobrien [(i == commutative || i == commutative + 1) 310290285Sobrien ? 2 * commutative + 1 - i : i]) 3103132727Skan : operands_match[m][i]) 310450605Sobrien { 310550605Sobrien /* If we are matching a non-offsettable address where an 310650605Sobrien offsettable address was expected, then we must reject 310750605Sobrien this combination, because we can't reload it. */ 3108132727Skan if (this_alternative_offmemok[m] 3109169699Skan && MEM_P (recog_data.operand[m]) 3110132727Skan && this_alternative[m] == (int) NO_REGS 3111132727Skan && ! this_alternative_win[m]) 311250605Sobrien bad = 1; 311350605Sobrien 3114132727Skan did_match = this_alternative_win[m]; 311550605Sobrien } 311618334Speter else 311718334Speter { 311818334Speter /* Operands don't match. */ 311918334Speter rtx value; 3120146906Skan int loc1, loc2; 312118334Speter /* Retroactively mark the operand we had to match 312218334Speter as a loser, if it wasn't already. */ 3123132727Skan if (this_alternative_win[m]) 312418334Speter losers++; 3125132727Skan this_alternative_win[m] = 0; 3126132727Skan if (this_alternative[m] == (int) NO_REGS) 312718334Speter bad = 1; 312818334Speter /* But count the pair only once in the total badness of 3129146906Skan this alternative, if the pair can be a dummy reload. 3130146906Skan The pointers in operand_loc are not swapped; swap 3131146906Skan them by hand if necessary. */ 3132146906Skan if (swapped && i == commutative) 3133146906Skan loc1 = commutative + 1; 3134146906Skan else if (swapped && i == commutative + 1) 3135146906Skan loc1 = commutative; 3136146906Skan else 3137146906Skan loc1 = i; 3138146906Skan if (swapped && m == commutative) 3139146906Skan loc2 = commutative + 1; 3140146906Skan else if (swapped && m == commutative + 1) 3141146906Skan loc2 = commutative; 3142146906Skan else 3143146906Skan loc2 = m; 314418334Speter value 314590285Sobrien = find_dummy_reload (recog_data.operand[i], 3146132727Skan recog_data.operand[m], 3147146906Skan recog_data.operand_loc[loc1], 3148146906Skan recog_data.operand_loc[loc2], 3149132727Skan operand_mode[i], operand_mode[m], 3150132727Skan this_alternative[m], -1, 3151132727Skan this_alternative_earlyclobber[m]); 315218334Speter 315318334Speter if (value != 0) 315418334Speter losers--; 315518334Speter } 315618334Speter /* This can be fixed with reloads if the operand 315718334Speter we are supposed to match can be fixed with reloads. */ 315818334Speter badop = 0; 3159132727Skan this_alternative[i] = this_alternative[m]; 316018334Speter 316118334Speter /* If we have to reload this operand and some previous 316218334Speter operand also had to match the same thing as this 316318334Speter operand, we don't know how to do that. So reject this 316418334Speter alternative. */ 316590285Sobrien if (! did_match || force_reload) 316618334Speter for (j = 0; j < i; j++) 316718334Speter if (this_alternative_matches[j] 316818334Speter == this_alternative_matches[i]) 316918334Speter badop = 1; 317018334Speter break; 317118334Speter 317218334Speter case 'p': 317318334Speter /* All necessary reloads for an address_operand 317418334Speter were handled in find_reloads_address. */ 3175169699Skan this_alternative[i] 3176169699Skan = (int) base_reg_class (VOIDmode, ADDRESS, SCRATCH); 317718334Speter win = 1; 317896288Sobrien badop = 0; 317918334Speter break; 318018334Speter 318118334Speter case 'm': 318218334Speter if (force_reload) 318318334Speter break; 3184169699Skan if (MEM_P (operand) 3185169699Skan || (REG_P (operand) 318618334Speter && REGNO (operand) >= FIRST_PSEUDO_REGISTER 318718334Speter && reg_renumber[REGNO (operand)] < 0)) 318818334Speter win = 1; 3189169699Skan if (CONST_POOL_OK_P (operand)) 319018334Speter badop = 0; 319118334Speter constmemok = 1; 319218334Speter break; 319318334Speter 319418334Speter case '<': 3195169699Skan if (MEM_P (operand) 319618334Speter && ! address_reloaded[i] 319718334Speter && (GET_CODE (XEXP (operand, 0)) == PRE_DEC 319818334Speter || GET_CODE (XEXP (operand, 0)) == POST_DEC)) 319918334Speter win = 1; 320018334Speter break; 320118334Speter 320218334Speter case '>': 3203169699Skan if (MEM_P (operand) 320418334Speter && ! address_reloaded[i] 320518334Speter && (GET_CODE (XEXP (operand, 0)) == PRE_INC 320618334Speter || GET_CODE (XEXP (operand, 0)) == POST_INC)) 320718334Speter win = 1; 320818334Speter break; 320918334Speter 321018334Speter /* Memory operand whose address is not offsettable. */ 321118334Speter case 'V': 321218334Speter if (force_reload) 321318334Speter break; 3214169699Skan if (MEM_P (operand) 321518334Speter && ! (ind_levels ? offsettable_memref_p (operand) 321618334Speter : offsettable_nonstrict_memref_p (operand)) 321718334Speter /* Certain mem addresses will become offsettable 321818334Speter after they themselves are reloaded. This is important; 321918334Speter we don't want our own handling of unoffsettables 322018334Speter to override the handling of reg_equiv_address. */ 3221169699Skan && !(REG_P (XEXP (operand, 0)) 322218334Speter && (ind_levels == 0 322318334Speter || reg_equiv_address[REGNO (XEXP (operand, 0))] != 0))) 322418334Speter win = 1; 322518334Speter break; 322618334Speter 322718334Speter /* Memory operand whose address is offsettable. */ 322818334Speter case 'o': 322918334Speter if (force_reload) 323018334Speter break; 3231169699Skan if ((MEM_P (operand) 323218334Speter /* If IND_LEVELS, find_reloads_address won't reload a 323318334Speter pseudo that didn't get a hard reg, so we have to 323418334Speter reject that case. */ 323552557Sobrien && ((ind_levels ? offsettable_memref_p (operand) 323652557Sobrien : offsettable_nonstrict_memref_p (operand)) 323752557Sobrien /* A reloaded address is offsettable because it is now 323852557Sobrien just a simple register indirect. */ 3239169699Skan || address_reloaded[i] == 1)) 3240169699Skan || (REG_P (operand) 324118334Speter && REGNO (operand) >= FIRST_PSEUDO_REGISTER 324218334Speter && reg_renumber[REGNO (operand)] < 0 324318334Speter /* If reg_equiv_address is nonzero, we will be 324418334Speter loading it into a register; hence it will be 324518334Speter offsettable, but we cannot say that reg_equiv_mem 324618334Speter is offsettable without checking. */ 324718334Speter && ((reg_equiv_mem[REGNO (operand)] != 0 324818334Speter && offsettable_memref_p (reg_equiv_mem[REGNO (operand)])) 324918334Speter || (reg_equiv_address[REGNO (operand)] != 0)))) 325018334Speter win = 1; 3251169699Skan if (CONST_POOL_OK_P (operand) 3252169699Skan || MEM_P (operand)) 325318334Speter badop = 0; 325418334Speter constmemok = 1; 325518334Speter offmemok = 1; 325618334Speter break; 325718334Speter 325818334Speter case '&': 325918334Speter /* Output operand that is stored before the need for the 326018334Speter input operands (and their index registers) is over. */ 326118334Speter earlyclobber = 1, this_earlyclobber = 1; 326218334Speter break; 326318334Speter 326418334Speter case 'E': 326518334Speter case 'F': 3266117404Skan if (GET_CODE (operand) == CONST_DOUBLE 3267117404Skan || (GET_CODE (operand) == CONST_VECTOR 3268117404Skan && (GET_MODE_CLASS (GET_MODE (operand)) 3269117404Skan == MODE_VECTOR_FLOAT))) 327018334Speter win = 1; 327118334Speter break; 327218334Speter 327318334Speter case 'G': 327418334Speter case 'H': 327518334Speter if (GET_CODE (operand) == CONST_DOUBLE 3276132727Skan && CONST_DOUBLE_OK_FOR_CONSTRAINT_P (operand, c, p)) 327718334Speter win = 1; 327818334Speter break; 327918334Speter 328018334Speter case 's': 328118334Speter if (GET_CODE (operand) == CONST_INT 328218334Speter || (GET_CODE (operand) == CONST_DOUBLE 328318334Speter && GET_MODE (operand) == VOIDmode)) 328418334Speter break; 328518334Speter case 'i': 328618334Speter if (CONSTANT_P (operand) 3287169699Skan && (! flag_pic || LEGITIMATE_PIC_OPERAND_P (operand))) 328818334Speter win = 1; 328918334Speter break; 329018334Speter 329118334Speter case 'n': 329218334Speter if (GET_CODE (operand) == CONST_INT 329318334Speter || (GET_CODE (operand) == CONST_DOUBLE 329418334Speter && GET_MODE (operand) == VOIDmode)) 329518334Speter win = 1; 329618334Speter break; 329718334Speter 329818334Speter case 'I': 329918334Speter case 'J': 330018334Speter case 'K': 330118334Speter case 'L': 330218334Speter case 'M': 330318334Speter case 'N': 330418334Speter case 'O': 330518334Speter case 'P': 330618334Speter if (GET_CODE (operand) == CONST_INT 3307132727Skan && CONST_OK_FOR_CONSTRAINT_P (INTVAL (operand), c, p)) 330818334Speter win = 1; 330918334Speter break; 331018334Speter 331118334Speter case 'X': 3312169699Skan force_reload = 0; 331318334Speter win = 1; 331418334Speter break; 331518334Speter 331618334Speter case 'g': 331718334Speter if (! force_reload 331818334Speter /* A PLUS is never a valid operand, but reload can make 331918334Speter it from a register when eliminating registers. */ 332018334Speter && GET_CODE (operand) != PLUS 332118334Speter /* A SCRATCH is not a valid operand. */ 332218334Speter && GET_CODE (operand) != SCRATCH 332390285Sobrien && (! CONSTANT_P (operand) 332490285Sobrien || ! flag_pic 332518334Speter || LEGITIMATE_PIC_OPERAND_P (operand)) 332618334Speter && (GENERAL_REGS == ALL_REGS 3327169699Skan || !REG_P (operand) 332818334Speter || (REGNO (operand) >= FIRST_PSEUDO_REGISTER 332918334Speter && reg_renumber[REGNO (operand)] < 0))) 333018334Speter win = 1; 333190285Sobrien /* Drop through into 'r' case. */ 333218334Speter 333318334Speter case 'r': 333418334Speter this_alternative[i] 333518334Speter = (int) reg_class_subunion[this_alternative[i]][(int) GENERAL_REGS]; 333618334Speter goto reg; 333718334Speter 333890285Sobrien default: 3339132727Skan if (REG_CLASS_FROM_CONSTRAINT (c, p) == NO_REGS) 334090285Sobrien { 3341132727Skan#ifdef EXTRA_CONSTRAINT_STR 3342132727Skan if (EXTRA_MEMORY_CONSTRAINT (c, p)) 3343117404Skan { 3344117404Skan if (force_reload) 3345117404Skan break; 3346132727Skan if (EXTRA_CONSTRAINT_STR (operand, c, p)) 3347117404Skan win = 1; 3348117404Skan /* If the address was already reloaded, 3349117404Skan we win as well. */ 3350169699Skan else if (MEM_P (operand) 3351169699Skan && address_reloaded[i] == 1) 3352117404Skan win = 1; 3353117404Skan /* Likewise if the address will be reloaded because 3354117404Skan reg_equiv_address is nonzero. For reg_equiv_mem 3355117404Skan we have to check. */ 3356169699Skan else if (REG_P (operand) 3357132727Skan && REGNO (operand) >= FIRST_PSEUDO_REGISTER 3358132727Skan && reg_renumber[REGNO (operand)] < 0 3359132727Skan && ((reg_equiv_mem[REGNO (operand)] != 0 3360132727Skan && EXTRA_CONSTRAINT_STR (reg_equiv_mem[REGNO (operand)], c, p)) 3361132727Skan || (reg_equiv_address[REGNO (operand)] != 0))) 3362117404Skan win = 1; 3363117404Skan 3364117404Skan /* If we didn't already win, we can reload 3365117404Skan constants via force_const_mem, and other 3366117404Skan MEMs by reloading the address like for 'o'. */ 3367169699Skan if (CONST_POOL_OK_P (operand) 3368169699Skan || MEM_P (operand)) 3369117404Skan badop = 0; 3370117404Skan constmemok = 1; 3371117404Skan offmemok = 1; 3372117404Skan break; 3373117404Skan } 3374132727Skan if (EXTRA_ADDRESS_CONSTRAINT (c, p)) 3375117404Skan { 3376132727Skan if (EXTRA_CONSTRAINT_STR (operand, c, p)) 3377117404Skan win = 1; 3378117404Skan 3379117404Skan /* If we didn't already win, we can reload 3380117404Skan the address into a base register. */ 3381169699Skan this_alternative[i] 3382169699Skan = (int) base_reg_class (VOIDmode, ADDRESS, SCRATCH); 3383117404Skan badop = 0; 3384117404Skan break; 3385117404Skan } 3386117404Skan 3387132727Skan if (EXTRA_CONSTRAINT_STR (operand, c, p)) 338890285Sobrien win = 1; 338918334Speter#endif 339090285Sobrien break; 339190285Sobrien } 339290285Sobrien 339318334Speter this_alternative[i] 3394132727Skan = (int) (reg_class_subunion 3395132727Skan [this_alternative[i]] 3396132727Skan [(int) REG_CLASS_FROM_CONSTRAINT (c, p)]); 339718334Speter reg: 339818334Speter if (GET_MODE (operand) == BLKmode) 339918334Speter break; 340018334Speter winreg = 1; 3401169699Skan if (REG_P (operand) 340218334Speter && reg_fits_class_p (operand, this_alternative[i], 340390285Sobrien offset, GET_MODE (recog_data.operand[i]))) 340418334Speter win = 1; 340518334Speter break; 340618334Speter } 3407132727Skan while ((p += len), c); 340818334Speter 340918334Speter constraints[i] = p; 341018334Speter 341118334Speter /* If this operand could be handled with a reg, 341218334Speter and some reg is allowed, then this operand can be handled. */ 341318334Speter if (winreg && this_alternative[i] != (int) NO_REGS) 341418334Speter badop = 0; 341518334Speter 341618334Speter /* Record which operands fit this alternative. */ 341718334Speter this_alternative_earlyclobber[i] = earlyclobber; 341818334Speter if (win && ! force_reload) 341918334Speter this_alternative_win[i] = 1; 342090285Sobrien else if (did_match && ! force_reload) 342190285Sobrien this_alternative_match_win[i] = 1; 342218334Speter else 342318334Speter { 342418334Speter int const_to_mem = 0; 342518334Speter 342618334Speter this_alternative_offmemok[i] = offmemok; 342718334Speter losers++; 342818334Speter if (badop) 342918334Speter bad = 1; 343018334Speter /* Alternative loses if it has no regs for a reg operand. */ 3431169699Skan if (REG_P (operand) 343218334Speter && this_alternative[i] == (int) NO_REGS 343318334Speter && this_alternative_matches[i] < 0) 343418334Speter bad = 1; 343518334Speter 343618334Speter /* If this is a constant that is reloaded into the desired 343718334Speter class by copying it to memory first, count that as another 343818334Speter reload. This is consistent with other code and is 343918334Speter required to avoid choosing another alternative when 344018334Speter the constant is moved into memory by this function on 344190285Sobrien an early reload pass. Note that the test here is 344218334Speter precisely the same as in the code below that calls 344318334Speter force_const_mem. */ 3444169699Skan if (CONST_POOL_OK_P (operand) 344550605Sobrien && ((PREFERRED_RELOAD_CLASS (operand, 344690285Sobrien (enum reg_class) this_alternative[i]) 344750605Sobrien == NO_REGS) 344850605Sobrien || no_input_reloads) 344918334Speter && operand_mode[i] != VOIDmode) 345018334Speter { 345118334Speter const_to_mem = 1; 345218334Speter if (this_alternative[i] != (int) NO_REGS) 345318334Speter losers++; 345418334Speter } 345518334Speter 345650605Sobrien /* Alternative loses if it requires a type of reload not 345750605Sobrien permitted for this insn. We can always reload SCRATCH 345850605Sobrien and objects with a REG_UNUSED note. */ 3459169699Skan if (GET_CODE (operand) != SCRATCH 346090285Sobrien && modified[i] != RELOAD_READ && no_output_reloads 346190285Sobrien && ! find_reg_note (insn, REG_UNUSED, operand)) 346250605Sobrien bad = 1; 346350605Sobrien else if (modified[i] != RELOAD_WRITE && no_input_reloads 346450605Sobrien && ! const_to_mem) 346550605Sobrien bad = 1; 346650605Sobrien 3467169699Skan /* If we can't reload this value at all, reject this 3468169699Skan alternative. Note that we could also lose due to 3469169699Skan LIMIT_RELOAD_CLASS, but we don't check that 3470169699Skan here. */ 3471169699Skan 3472169699Skan if (! CONSTANT_P (operand) 3473169699Skan && (enum reg_class) this_alternative[i] != NO_REGS) 3474169699Skan { 3475169699Skan if (PREFERRED_RELOAD_CLASS 3476169699Skan (operand, (enum reg_class) this_alternative[i]) 3477169699Skan == NO_REGS) 3478169699Skan reject = 600; 3479169699Skan 3480169699Skan#ifdef PREFERRED_OUTPUT_RELOAD_CLASS 3481169699Skan if (operand_type[i] == RELOAD_FOR_OUTPUT 3482169699Skan && PREFERRED_OUTPUT_RELOAD_CLASS 3483169699Skan (operand, (enum reg_class) this_alternative[i]) 3484169699Skan == NO_REGS) 3485169699Skan reject = 600; 3486132727Skan#endif 3487169699Skan } 3488132727Skan 348918334Speter /* We prefer to reload pseudos over reloading other things, 349018334Speter since such reloads may be able to be eliminated later. 349118334Speter If we are reloading a SCRATCH, we won't be generating any 349290285Sobrien insns, just using a register, so it is also preferred. 349318334Speter So bump REJECT in other cases. Don't do this in the 349418334Speter case where we are forcing a constant into memory and 349518334Speter it will then win since we don't want to have a different 349618334Speter alternative match then. */ 3497169699Skan if (! (REG_P (operand) 349818334Speter && REGNO (operand) >= FIRST_PSEUDO_REGISTER) 349918334Speter && GET_CODE (operand) != SCRATCH 350018334Speter && ! (const_to_mem && constmemok)) 350150605Sobrien reject += 2; 350250605Sobrien 350350605Sobrien /* Input reloads can be inherited more often than output 350450605Sobrien reloads can be removed, so penalize output reloads. */ 350550605Sobrien if (operand_type[i] != RELOAD_FOR_INPUT 350650605Sobrien && GET_CODE (operand) != SCRATCH) 350718334Speter reject++; 350818334Speter } 350918334Speter 351090285Sobrien /* If this operand is a pseudo register that didn't get a hard 351118334Speter reg and this alternative accepts some register, see if the 351218334Speter class that we want is a subset of the preferred class for this 351318334Speter register. If not, but it intersects that class, use the 351418334Speter preferred class instead. If it does not intersect the preferred 351518334Speter class, show that usage of this alternative should be discouraged; 351618334Speter it will be discouraged more still if the register is `preferred 351718334Speter or nothing'. We do this because it increases the chance of 351818334Speter reusing our spill register in a later insn and avoiding a pair 351918334Speter of memory stores and loads. 352018334Speter 352118334Speter Don't bother with this if this alternative will accept this 352218334Speter operand. 352318334Speter 352418334Speter Don't do this for a multiword operand, since it is only a 352518334Speter small win and has the risk of requiring more spill registers, 352618334Speter which could cause a large loss. 352718334Speter 352818334Speter Don't do this if the preferred class has only one register 352918334Speter because we might otherwise exhaust the class. */ 353018334Speter 353190285Sobrien if (! win && ! did_match 353290285Sobrien && this_alternative[i] != (int) NO_REGS 353318334Speter && GET_MODE_SIZE (operand_mode[i]) <= UNITS_PER_WORD 3534169699Skan && reg_class_size [(int) preferred_class[i]] > 0 3535169699Skan && ! SMALL_REGISTER_CLASS_P (preferred_class[i])) 353618334Speter { 353718334Speter if (! reg_class_subset_p (this_alternative[i], 353818334Speter preferred_class[i])) 353918334Speter { 354018334Speter /* Since we don't have a way of forming the intersection, 354118334Speter we just do something special if the preferred class 354290285Sobrien is a subset of the class we have; that's the most 354318334Speter common case anyway. */ 354418334Speter if (reg_class_subset_p (preferred_class[i], 354518334Speter this_alternative[i])) 354618334Speter this_alternative[i] = (int) preferred_class[i]; 354718334Speter else 354850605Sobrien reject += (2 + 2 * pref_or_nothing[i]); 354918334Speter } 355018334Speter } 355118334Speter } 355218334Speter 355318334Speter /* Now see if any output operands that are marked "earlyclobber" 355418334Speter in this alternative conflict with any input operands 355518334Speter or any memory addresses. */ 355618334Speter 355718334Speter for (i = 0; i < noperands; i++) 355818334Speter if (this_alternative_earlyclobber[i] 355990285Sobrien && (this_alternative_win[i] || this_alternative_match_win[i])) 356018334Speter { 356190285Sobrien struct decomposition early_data; 356218334Speter 356390285Sobrien early_data = decompose (recog_data.operand[i]); 356418334Speter 3565169699Skan gcc_assert (modified[i] != RELOAD_READ); 356690285Sobrien 356718334Speter if (this_alternative[i] == NO_REGS) 356818334Speter { 356918334Speter this_alternative_earlyclobber[i] = 0; 3570169699Skan gcc_assert (this_insn_is_asm); 3571169699Skan error_for_asm (this_insn, 3572169699Skan "%<&%> constraint used with no register class"); 357318334Speter } 357418334Speter 357518334Speter for (j = 0; j < noperands; j++) 357618334Speter /* Is this an input operand or a memory ref? */ 3577169699Skan if ((MEM_P (recog_data.operand[j]) 357818334Speter || modified[j] != RELOAD_WRITE) 357918334Speter && j != i 358018334Speter /* Ignore things like match_operator operands. */ 358190285Sobrien && *recog_data.constraints[j] != 0 358218334Speter /* Don't count an input operand that is constrained to match 358318334Speter the early clobber operand. */ 358418334Speter && ! (this_alternative_matches[j] == i 358590285Sobrien && rtx_equal_p (recog_data.operand[i], 358690285Sobrien recog_data.operand[j])) 358718334Speter /* Is it altered by storing the earlyclobber operand? */ 358890285Sobrien && !immune_p (recog_data.operand[j], recog_data.operand[i], 358990285Sobrien early_data)) 359018334Speter { 3591169699Skan /* If the output is in a non-empty few-regs class, 359218334Speter it's costly to reload it, so reload the input instead. */ 3593169699Skan if (SMALL_REGISTER_CLASS_P (this_alternative[i]) 3594169699Skan && (REG_P (recog_data.operand[j]) 359590285Sobrien || GET_CODE (recog_data.operand[j]) == SUBREG)) 359618334Speter { 359718334Speter losers++; 359818334Speter this_alternative_win[j] = 0; 359990285Sobrien this_alternative_match_win[j] = 0; 360018334Speter } 360118334Speter else 360218334Speter break; 360318334Speter } 360418334Speter /* If an earlyclobber operand conflicts with something, 360518334Speter it must be reloaded, so request this and count the cost. */ 360618334Speter if (j != noperands) 360718334Speter { 360818334Speter losers++; 360918334Speter this_alternative_win[i] = 0; 361090285Sobrien this_alternative_match_win[j] = 0; 361118334Speter for (j = 0; j < noperands; j++) 361218334Speter if (this_alternative_matches[j] == i 361390285Sobrien && this_alternative_match_win[j]) 361418334Speter { 361518334Speter this_alternative_win[j] = 0; 361690285Sobrien this_alternative_match_win[j] = 0; 361718334Speter losers++; 361818334Speter } 361918334Speter } 362018334Speter } 362118334Speter 362218334Speter /* If one alternative accepts all the operands, no reload required, 362318334Speter choose that alternative; don't consider the remaining ones. */ 362418334Speter if (losers == 0) 362518334Speter { 362618334Speter /* Unswap these so that they are never swapped at `finish'. */ 362718334Speter if (commutative >= 0) 362818334Speter { 362990285Sobrien recog_data.operand[commutative] = substed_operand[commutative]; 363090285Sobrien recog_data.operand[commutative + 1] 363118334Speter = substed_operand[commutative + 1]; 363218334Speter } 363318334Speter for (i = 0; i < noperands; i++) 363418334Speter { 363590285Sobrien goal_alternative_win[i] = this_alternative_win[i]; 363690285Sobrien goal_alternative_match_win[i] = this_alternative_match_win[i]; 363718334Speter goal_alternative[i] = this_alternative[i]; 363818334Speter goal_alternative_offmemok[i] = this_alternative_offmemok[i]; 363918334Speter goal_alternative_matches[i] = this_alternative_matches[i]; 364018334Speter goal_alternative_earlyclobber[i] 364118334Speter = this_alternative_earlyclobber[i]; 364218334Speter } 364318334Speter goal_alternative_number = this_alternative_number; 364418334Speter goal_alternative_swapped = swapped; 364518334Speter goal_earlyclobber = this_earlyclobber; 364618334Speter goto finish; 364718334Speter } 364818334Speter 364918334Speter /* REJECT, set by the ! and ? constraint characters and when a register 365018334Speter would be reloaded into a non-preferred class, discourages the use of 365150605Sobrien this alternative for a reload goal. REJECT is incremented by six 365250605Sobrien for each ? and two for each non-preferred class. */ 365350605Sobrien losers = losers * 6 + reject; 365418334Speter 365518334Speter /* If this alternative can be made to work by reloading, 365618334Speter and it needs less reloading than the others checked so far, 365718334Speter record it as the chosen goal for reloading. */ 365818334Speter if (! bad && best > losers) 365918334Speter { 366018334Speter for (i = 0; i < noperands; i++) 366118334Speter { 366218334Speter goal_alternative[i] = this_alternative[i]; 366318334Speter goal_alternative_win[i] = this_alternative_win[i]; 366490285Sobrien goal_alternative_match_win[i] = this_alternative_match_win[i]; 366518334Speter goal_alternative_offmemok[i] = this_alternative_offmemok[i]; 366618334Speter goal_alternative_matches[i] = this_alternative_matches[i]; 366718334Speter goal_alternative_earlyclobber[i] 366818334Speter = this_alternative_earlyclobber[i]; 366918334Speter } 367018334Speter goal_alternative_swapped = swapped; 367118334Speter best = losers; 367218334Speter goal_alternative_number = this_alternative_number; 367318334Speter goal_earlyclobber = this_earlyclobber; 367418334Speter } 367518334Speter } 367618334Speter 367718334Speter /* If insn is commutative (it's safe to exchange a certain pair of operands) 367818334Speter then we need to try each alternative twice, 367918334Speter the second time matching those two operands 368018334Speter as if we had exchanged them. 368118334Speter To do this, really exchange them in operands. 368218334Speter 368318334Speter If we have just tried the alternatives the second time, 368418334Speter return operands to normal and drop through. */ 368518334Speter 368618334Speter if (commutative >= 0) 368718334Speter { 368818334Speter swapped = !swapped; 368918334Speter if (swapped) 369018334Speter { 369190285Sobrien enum reg_class tclass; 369290285Sobrien int t; 369318334Speter 369490285Sobrien recog_data.operand[commutative] = substed_operand[commutative + 1]; 369590285Sobrien recog_data.operand[commutative + 1] = substed_operand[commutative]; 369690285Sobrien /* Swap the duplicates too. */ 369790285Sobrien for (i = 0; i < recog_data.n_dups; i++) 369890285Sobrien if (recog_data.dup_num[i] == commutative 369990285Sobrien || recog_data.dup_num[i] == commutative + 1) 370090285Sobrien *recog_data.dup_loc[i] 370190285Sobrien = recog_data.operand[(int) recog_data.dup_num[i]]; 370218334Speter 370318334Speter tclass = preferred_class[commutative]; 370418334Speter preferred_class[commutative] = preferred_class[commutative + 1]; 370518334Speter preferred_class[commutative + 1] = tclass; 370618334Speter 370718334Speter t = pref_or_nothing[commutative]; 370818334Speter pref_or_nothing[commutative] = pref_or_nothing[commutative + 1]; 370918334Speter pref_or_nothing[commutative + 1] = t; 371018334Speter 3711169699Skan t = address_reloaded[commutative]; 3712169699Skan address_reloaded[commutative] = address_reloaded[commutative + 1]; 3713169699Skan address_reloaded[commutative + 1] = t; 3714169699Skan 371590285Sobrien memcpy (constraints, recog_data.constraints, 371690285Sobrien noperands * sizeof (char *)); 371718334Speter goto try_swapped; 371818334Speter } 371918334Speter else 372018334Speter { 372190285Sobrien recog_data.operand[commutative] = substed_operand[commutative]; 372290285Sobrien recog_data.operand[commutative + 1] 372390285Sobrien = substed_operand[commutative + 1]; 372490285Sobrien /* Unswap the duplicates too. */ 372590285Sobrien for (i = 0; i < recog_data.n_dups; i++) 372690285Sobrien if (recog_data.dup_num[i] == commutative 372790285Sobrien || recog_data.dup_num[i] == commutative + 1) 372890285Sobrien *recog_data.dup_loc[i] 372990285Sobrien = recog_data.operand[(int) recog_data.dup_num[i]]; 373018334Speter } 373118334Speter } 373218334Speter 373318334Speter /* The operands don't meet the constraints. 373418334Speter goal_alternative describes the alternative 373518334Speter that we could reach by reloading the fewest operands. 373618334Speter Reload so as to fit it. */ 373718334Speter 373850605Sobrien if (best == MAX_RECOG_OPERANDS * 2 + 600) 373918334Speter { 374018334Speter /* No alternative works with reloads?? */ 374118334Speter if (insn_code_number >= 0) 374290285Sobrien fatal_insn ("unable to generate reloads for:", insn); 3743169699Skan error_for_asm (insn, "inconsistent operand constraints in an %<asm%>"); 374418334Speter /* Avoid further trouble with this insn. */ 374550605Sobrien PATTERN (insn) = gen_rtx_USE (VOIDmode, const0_rtx); 374618334Speter n_reloads = 0; 374752557Sobrien return 0; 374818334Speter } 374918334Speter 375018334Speter /* Jump to `finish' from above if all operands are valid already. 375118334Speter In that case, goal_alternative_win is all 1. */ 375218334Speter finish: 375318334Speter 375418334Speter /* Right now, for any pair of operands I and J that are required to match, 375518334Speter with I < J, 375618334Speter goal_alternative_matches[J] is I. 375718334Speter Set up goal_alternative_matched as the inverse function: 375818334Speter goal_alternative_matched[I] = J. */ 375918334Speter 376018334Speter for (i = 0; i < noperands; i++) 376118334Speter goal_alternative_matched[i] = -1; 3762117404Skan 376318334Speter for (i = 0; i < noperands; i++) 376418334Speter if (! goal_alternative_win[i] 376518334Speter && goal_alternative_matches[i] >= 0) 376618334Speter goal_alternative_matched[goal_alternative_matches[i]] = i; 376718334Speter 376890285Sobrien for (i = 0; i < noperands; i++) 376990285Sobrien goal_alternative_win[i] |= goal_alternative_match_win[i]; 377090285Sobrien 377118334Speter /* If the best alternative is with operands 1 and 2 swapped, 377218334Speter consider them swapped before reporting the reloads. Update the 377318334Speter operand numbers of any reloads already pushed. */ 377418334Speter 377518334Speter if (goal_alternative_swapped) 377618334Speter { 377790285Sobrien rtx tem; 377818334Speter 377918334Speter tem = substed_operand[commutative]; 378018334Speter substed_operand[commutative] = substed_operand[commutative + 1]; 378118334Speter substed_operand[commutative + 1] = tem; 378290285Sobrien tem = recog_data.operand[commutative]; 378390285Sobrien recog_data.operand[commutative] = recog_data.operand[commutative + 1]; 378490285Sobrien recog_data.operand[commutative + 1] = tem; 378590285Sobrien tem = *recog_data.operand_loc[commutative]; 378690285Sobrien *recog_data.operand_loc[commutative] 378790285Sobrien = *recog_data.operand_loc[commutative + 1]; 378890285Sobrien *recog_data.operand_loc[commutative + 1] = tem; 378918334Speter 379018334Speter for (i = 0; i < n_reloads; i++) 379118334Speter { 379290285Sobrien if (rld[i].opnum == commutative) 379390285Sobrien rld[i].opnum = commutative + 1; 379490285Sobrien else if (rld[i].opnum == commutative + 1) 379590285Sobrien rld[i].opnum = commutative; 379618334Speter } 379718334Speter } 379818334Speter 379918334Speter for (i = 0; i < noperands; i++) 380018334Speter { 380118334Speter operand_reloadnum[i] = -1; 380218334Speter 380318334Speter /* If this is an earlyclobber operand, we need to widen the scope. 380418334Speter The reload must remain valid from the start of the insn being 380518334Speter reloaded until after the operand is stored into its destination. 380618334Speter We approximate this with RELOAD_OTHER even though we know that we 380718334Speter do not conflict with RELOAD_FOR_INPUT_ADDRESS reloads. 380818334Speter 380918334Speter One special case that is worth checking is when we have an 381018334Speter output that is earlyclobber but isn't used past the insn (typically 381190285Sobrien a SCRATCH). In this case, we only need have the reload live 381218334Speter through the insn itself, but not for any of our input or output 381390285Sobrien reloads. 381450605Sobrien But we must not accidentally narrow the scope of an existing 381550605Sobrien RELOAD_OTHER reload - leave these alone. 381618334Speter 381718334Speter In any case, anything needed to address this operand can remain 381818334Speter however they were previously categorized. */ 381918334Speter 382050605Sobrien if (goal_alternative_earlyclobber[i] && operand_type[i] != RELOAD_OTHER) 382118334Speter operand_type[i] 382290285Sobrien = (find_reg_note (insn, REG_UNUSED, recog_data.operand[i]) 382318334Speter ? RELOAD_FOR_INSN : RELOAD_OTHER); 382418334Speter } 382518334Speter 382618334Speter /* Any constants that aren't allowed and can't be reloaded 382718334Speter into registers are here changed into memory references. */ 382818334Speter for (i = 0; i < noperands; i++) 382918334Speter if (! goal_alternative_win[i] 3830169699Skan && CONST_POOL_OK_P (recog_data.operand[i]) 383190285Sobrien && ((PREFERRED_RELOAD_CLASS (recog_data.operand[i], 383290285Sobrien (enum reg_class) goal_alternative[i]) 383350605Sobrien == NO_REGS) 383450605Sobrien || no_input_reloads) 383518334Speter && operand_mode[i] != VOIDmode) 383618334Speter { 383790285Sobrien substed_operand[i] = recog_data.operand[i] 383818334Speter = find_reloads_toplev (force_const_mem (operand_mode[i], 383990285Sobrien recog_data.operand[i]), 384090285Sobrien i, address_type[i], ind_levels, 0, insn, 384190285Sobrien NULL); 384290285Sobrien if (alternative_allows_memconst (recog_data.constraints[i], 384318334Speter goal_alternative_number)) 384418334Speter goal_alternative_win[i] = 1; 384518334Speter } 384618334Speter 3847169699Skan /* Likewise any invalid constants appearing as operand of a PLUS 3848169699Skan that is to be reloaded. */ 3849169699Skan for (i = 0; i < noperands; i++) 3850169699Skan if (! goal_alternative_win[i] 3851169699Skan && GET_CODE (recog_data.operand[i]) == PLUS 3852169699Skan && CONST_POOL_OK_P (XEXP (recog_data.operand[i], 1)) 3853169699Skan && (PREFERRED_RELOAD_CLASS (XEXP (recog_data.operand[i], 1), 3854169699Skan (enum reg_class) goal_alternative[i]) 3855169699Skan == NO_REGS) 3856169699Skan && operand_mode[i] != VOIDmode) 3857169699Skan { 3858169699Skan rtx tem = force_const_mem (operand_mode[i], 3859169699Skan XEXP (recog_data.operand[i], 1)); 3860169699Skan tem = gen_rtx_PLUS (operand_mode[i], 3861169699Skan XEXP (recog_data.operand[i], 0), tem); 3862169699Skan 3863169699Skan substed_operand[i] = recog_data.operand[i] 3864169699Skan = find_reloads_toplev (tem, i, address_type[i], 3865169699Skan ind_levels, 0, insn, NULL); 3866169699Skan } 3867169699Skan 386818334Speter /* Record the values of the earlyclobber operands for the caller. */ 386918334Speter if (goal_earlyclobber) 387018334Speter for (i = 0; i < noperands; i++) 387118334Speter if (goal_alternative_earlyclobber[i]) 387290285Sobrien reload_earlyclobbers[n_earlyclobbers++] = recog_data.operand[i]; 387318334Speter 387418334Speter /* Now record reloads for all the operands that need them. */ 387518334Speter for (i = 0; i < noperands; i++) 387618334Speter if (! goal_alternative_win[i]) 387718334Speter { 387818334Speter /* Operands that match previous ones have already been handled. */ 387918334Speter if (goal_alternative_matches[i] >= 0) 388018334Speter ; 388118334Speter /* Handle an operand with a nonoffsettable address 388218334Speter appearing where an offsettable address will do 388318334Speter by reloading the address into a base register. 388418334Speter 388518334Speter ??? We can also do this when the operand is a register and 388618334Speter reg_equiv_mem is not offsettable, but this is a bit tricky, 388718334Speter so we don't bother with it. It may not be worth doing. */ 388818334Speter else if (goal_alternative_matched[i] == -1 388918334Speter && goal_alternative_offmemok[i] 3890169699Skan && MEM_P (recog_data.operand[i])) 389118334Speter { 3892169699Skan /* If the address to be reloaded is a VOIDmode constant, 3893169699Skan use Pmode as mode of the reload register, as would have 3894169699Skan been done by find_reloads_address. */ 3895169699Skan enum machine_mode address_mode; 3896169699Skan address_mode = GET_MODE (XEXP (recog_data.operand[i], 0)); 3897169699Skan if (address_mode == VOIDmode) 3898169699Skan address_mode = Pmode; 3899169699Skan 390018334Speter operand_reloadnum[i] 390190285Sobrien = push_reload (XEXP (recog_data.operand[i], 0), NULL_RTX, 390290285Sobrien &XEXP (recog_data.operand[i], 0), (rtx*) 0, 3903169699Skan base_reg_class (VOIDmode, MEM, SCRATCH), 3904169699Skan address_mode, 390518334Speter VOIDmode, 0, 0, i, RELOAD_FOR_INPUT); 390690285Sobrien rld[operand_reloadnum[i]].inc 390790285Sobrien = GET_MODE_SIZE (GET_MODE (recog_data.operand[i])); 390818334Speter 390918334Speter /* If this operand is an output, we will have made any 391018334Speter reloads for its address as RELOAD_FOR_OUTPUT_ADDRESS, but 391118334Speter now we are treating part of the operand as an input, so 391218334Speter we must change these to RELOAD_FOR_INPUT_ADDRESS. */ 391318334Speter 391418334Speter if (modified[i] == RELOAD_WRITE) 391550605Sobrien { 391650605Sobrien for (j = 0; j < n_reloads; j++) 391750605Sobrien { 391890285Sobrien if (rld[j].opnum == i) 391950605Sobrien { 392090285Sobrien if (rld[j].when_needed == RELOAD_FOR_OUTPUT_ADDRESS) 392190285Sobrien rld[j].when_needed = RELOAD_FOR_INPUT_ADDRESS; 392290285Sobrien else if (rld[j].when_needed 392350605Sobrien == RELOAD_FOR_OUTADDR_ADDRESS) 392490285Sobrien rld[j].when_needed = RELOAD_FOR_INPADDR_ADDRESS; 392550605Sobrien } 392650605Sobrien } 392750605Sobrien } 392818334Speter } 392918334Speter else if (goal_alternative_matched[i] == -1) 393050605Sobrien { 393150605Sobrien operand_reloadnum[i] 393250605Sobrien = push_reload ((modified[i] != RELOAD_WRITE 393390285Sobrien ? recog_data.operand[i] : 0), 393490285Sobrien (modified[i] != RELOAD_READ 393590285Sobrien ? recog_data.operand[i] : 0), 393650605Sobrien (modified[i] != RELOAD_WRITE 393790285Sobrien ? recog_data.operand_loc[i] : 0), 393850605Sobrien (modified[i] != RELOAD_READ 393990285Sobrien ? recog_data.operand_loc[i] : 0), 394050605Sobrien (enum reg_class) goal_alternative[i], 394150605Sobrien (modified[i] == RELOAD_WRITE 394250605Sobrien ? VOIDmode : operand_mode[i]), 394350605Sobrien (modified[i] == RELOAD_READ 394450605Sobrien ? VOIDmode : operand_mode[i]), 394550605Sobrien (insn_code_number < 0 ? 0 394690285Sobrien : insn_data[insn_code_number].operand[i].strict_low), 394750605Sobrien 0, i, operand_type[i]); 394850605Sobrien } 394918334Speter /* In a matching pair of operands, one must be input only 395018334Speter and the other must be output only. 395118334Speter Pass the input operand as IN and the other as OUT. */ 395218334Speter else if (modified[i] == RELOAD_READ 395318334Speter && modified[goal_alternative_matched[i]] == RELOAD_WRITE) 395418334Speter { 395518334Speter operand_reloadnum[i] 395690285Sobrien = push_reload (recog_data.operand[i], 395790285Sobrien recog_data.operand[goal_alternative_matched[i]], 395890285Sobrien recog_data.operand_loc[i], 395990285Sobrien recog_data.operand_loc[goal_alternative_matched[i]], 396018334Speter (enum reg_class) goal_alternative[i], 396118334Speter operand_mode[i], 396218334Speter operand_mode[goal_alternative_matched[i]], 396318334Speter 0, 0, i, RELOAD_OTHER); 396418334Speter operand_reloadnum[goal_alternative_matched[i]] = output_reloadnum; 396518334Speter } 396618334Speter else if (modified[i] == RELOAD_WRITE 396718334Speter && modified[goal_alternative_matched[i]] == RELOAD_READ) 396818334Speter { 396918334Speter operand_reloadnum[goal_alternative_matched[i]] 397090285Sobrien = push_reload (recog_data.operand[goal_alternative_matched[i]], 397190285Sobrien recog_data.operand[i], 397290285Sobrien recog_data.operand_loc[goal_alternative_matched[i]], 397390285Sobrien recog_data.operand_loc[i], 397418334Speter (enum reg_class) goal_alternative[i], 397518334Speter operand_mode[goal_alternative_matched[i]], 397618334Speter operand_mode[i], 397718334Speter 0, 0, i, RELOAD_OTHER); 397818334Speter operand_reloadnum[i] = output_reloadnum; 397918334Speter } 398018334Speter else 398118334Speter { 3982169699Skan gcc_assert (insn_code_number < 0); 3983169699Skan error_for_asm (insn, "inconsistent operand constraints " 3984169699Skan "in an %<asm%>"); 398518334Speter /* Avoid further trouble with this insn. */ 398650605Sobrien PATTERN (insn) = gen_rtx_USE (VOIDmode, const0_rtx); 398718334Speter n_reloads = 0; 398852557Sobrien return 0; 398918334Speter } 399018334Speter } 399118334Speter else if (goal_alternative_matched[i] < 0 399218334Speter && goal_alternative_matches[i] < 0 3993169699Skan && address_operand_reloaded[i] != 1 399418334Speter && optimize) 399518334Speter { 399690285Sobrien /* For each non-matching operand that's a MEM or a pseudo-register 399718334Speter that didn't get a hard register, make an optional reload. 399818334Speter This may get done even if the insn needs no reloads otherwise. */ 399918334Speter 400090285Sobrien rtx operand = recog_data.operand[i]; 400118334Speter 400218334Speter while (GET_CODE (operand) == SUBREG) 400390285Sobrien operand = SUBREG_REG (operand); 4004169699Skan if ((MEM_P (operand) 4005169699Skan || (REG_P (operand) 400618334Speter && REGNO (operand) >= FIRST_PSEUDO_REGISTER)) 400752557Sobrien /* If this is only for an output, the optional reload would not 400852557Sobrien actually cause us to use a register now, just note that 400952557Sobrien something is stored here. */ 401052557Sobrien && ((enum reg_class) goal_alternative[i] != NO_REGS 401152557Sobrien || modified[i] == RELOAD_WRITE) 401218334Speter && ! no_input_reloads 401352557Sobrien /* An optional output reload might allow to delete INSN later. 401452557Sobrien We mustn't make in-out reloads on insns that are not permitted 401552557Sobrien output reloads. 401652557Sobrien If this is an asm, we can't delete it; we must not even call 401752557Sobrien push_reload for an optional output reload in this case, 401852557Sobrien because we can't be sure that the constraint allows a register, 401952557Sobrien and push_reload verifies the constraints for asms. */ 402018334Speter && (modified[i] == RELOAD_READ 402152557Sobrien || (! no_output_reloads && ! this_insn_is_asm))) 402218334Speter operand_reloadnum[i] 402390285Sobrien = push_reload ((modified[i] != RELOAD_WRITE 402490285Sobrien ? recog_data.operand[i] : 0), 402590285Sobrien (modified[i] != RELOAD_READ 402690285Sobrien ? recog_data.operand[i] : 0), 402718334Speter (modified[i] != RELOAD_WRITE 402890285Sobrien ? recog_data.operand_loc[i] : 0), 402918334Speter (modified[i] != RELOAD_READ 403090285Sobrien ? recog_data.operand_loc[i] : 0), 403118334Speter (enum reg_class) goal_alternative[i], 403218334Speter (modified[i] == RELOAD_WRITE 403318334Speter ? VOIDmode : operand_mode[i]), 403418334Speter (modified[i] == RELOAD_READ 403518334Speter ? VOIDmode : operand_mode[i]), 403618334Speter (insn_code_number < 0 ? 0 403790285Sobrien : insn_data[insn_code_number].operand[i].strict_low), 403818334Speter 1, i, operand_type[i]); 403952557Sobrien /* If a memory reference remains (either as a MEM or a pseudo that 404052557Sobrien did not get a hard register), yet we can't make an optional 404152557Sobrien reload, check if this is actually a pseudo register reference; 404252557Sobrien we then need to emit a USE and/or a CLOBBER so that reload 404352557Sobrien inheritance will do the right thing. */ 404452557Sobrien else if (replace 4045169699Skan && (MEM_P (operand) 4046169699Skan || (REG_P (operand) 404752557Sobrien && REGNO (operand) >= FIRST_PSEUDO_REGISTER 404852557Sobrien && reg_renumber [REGNO (operand)] < 0))) 404952557Sobrien { 405090285Sobrien operand = *recog_data.operand_loc[i]; 405152557Sobrien 405252557Sobrien while (GET_CODE (operand) == SUBREG) 405390285Sobrien operand = SUBREG_REG (operand); 4054169699Skan if (REG_P (operand)) 405552557Sobrien { 405652557Sobrien if (modified[i] != RELOAD_WRITE) 405790285Sobrien /* We mark the USE with QImode so that we recognize 405890285Sobrien it as one that can be safely deleted at the end 405990285Sobrien of reload. */ 406090285Sobrien PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode, operand), 406190285Sobrien insn), QImode); 406252557Sobrien if (modified[i] != RELOAD_READ) 406352557Sobrien emit_insn_after (gen_rtx_CLOBBER (VOIDmode, operand), insn); 406452557Sobrien } 406552557Sobrien } 406618334Speter } 406718334Speter else if (goal_alternative_matches[i] >= 0 406818334Speter && goal_alternative_win[goal_alternative_matches[i]] 406918334Speter && modified[i] == RELOAD_READ 407018334Speter && modified[goal_alternative_matches[i]] == RELOAD_WRITE 407118334Speter && ! no_input_reloads && ! no_output_reloads 407218334Speter && optimize) 407318334Speter { 407418334Speter /* Similarly, make an optional reload for a pair of matching 407518334Speter objects that are in MEM or a pseudo that didn't get a hard reg. */ 407618334Speter 407790285Sobrien rtx operand = recog_data.operand[i]; 407818334Speter 407918334Speter while (GET_CODE (operand) == SUBREG) 408090285Sobrien operand = SUBREG_REG (operand); 4081169699Skan if ((MEM_P (operand) 4082169699Skan || (REG_P (operand) 408318334Speter && REGNO (operand) >= FIRST_PSEUDO_REGISTER)) 408418334Speter && ((enum reg_class) goal_alternative[goal_alternative_matches[i]] 408518334Speter != NO_REGS)) 408618334Speter operand_reloadnum[i] = operand_reloadnum[goal_alternative_matches[i]] 408790285Sobrien = push_reload (recog_data.operand[goal_alternative_matches[i]], 408890285Sobrien recog_data.operand[i], 408990285Sobrien recog_data.operand_loc[goal_alternative_matches[i]], 409090285Sobrien recog_data.operand_loc[i], 409118334Speter (enum reg_class) goal_alternative[goal_alternative_matches[i]], 409218334Speter operand_mode[goal_alternative_matches[i]], 409318334Speter operand_mode[i], 409418334Speter 0, 1, goal_alternative_matches[i], RELOAD_OTHER); 409518334Speter } 409690285Sobrien 409752557Sobrien /* Perform whatever substitutions on the operands we are supposed 409852557Sobrien to make due to commutativity or replacement of registers 409952557Sobrien with equivalent constants or memory slots. */ 410052557Sobrien 410152557Sobrien for (i = 0; i < noperands; i++) 410252557Sobrien { 410352557Sobrien /* We only do this on the last pass through reload, because it is 410490285Sobrien possible for some data (like reg_equiv_address) to be changed during 4105169699Skan later passes. Moreover, we lose the opportunity to get a useful 410690285Sobrien reload_{in,out}_reg when we do these replacements. */ 410752557Sobrien 410852557Sobrien if (replace) 410952557Sobrien { 411052557Sobrien rtx substitution = substed_operand[i]; 411152557Sobrien 411290285Sobrien *recog_data.operand_loc[i] = substitution; 411352557Sobrien 411452557Sobrien /* If we're replacing an operand with a LABEL_REF, we need 411552557Sobrien to make sure that there's a REG_LABEL note attached to 411652557Sobrien this instruction. */ 4117169699Skan if (!JUMP_P (insn) 411852557Sobrien && GET_CODE (substitution) == LABEL_REF 411952557Sobrien && !find_reg_note (insn, REG_LABEL, XEXP (substitution, 0))) 412090285Sobrien REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_LABEL, 412152557Sobrien XEXP (substitution, 0), 412252557Sobrien REG_NOTES (insn)); 412352557Sobrien } 412452557Sobrien else 412590285Sobrien retval |= (substed_operand[i] != *recog_data.operand_loc[i]); 412652557Sobrien } 412752557Sobrien 412818334Speter /* If this insn pattern contains any MATCH_DUP's, make sure that 412918334Speter they will be substituted if the operands they match are substituted. 413018334Speter Also do now any substitutions we already did on the operands. 413118334Speter 413218334Speter Don't do this if we aren't making replacements because we might be 413318334Speter propagating things allocated by frame pointer elimination into places 413418334Speter it doesn't expect. */ 413518334Speter 413618334Speter if (insn_code_number >= 0 && replace) 413790285Sobrien for (i = insn_data[insn_code_number].n_dups - 1; i >= 0; i--) 413818334Speter { 413990285Sobrien int opno = recog_data.dup_num[i]; 414090285Sobrien *recog_data.dup_loc[i] = *recog_data.operand_loc[opno]; 4141117404Skan dup_replacements (recog_data.dup_loc[i], recog_data.operand_loc[opno]); 414218334Speter } 414318334Speter 414418334Speter#if 0 414518334Speter /* This loses because reloading of prior insns can invalidate the equivalence 414618334Speter (or at least find_equiv_reg isn't smart enough to find it any more), 414718334Speter causing this insn to need more reload regs than it needed before. 414818334Speter It may be too late to make the reload regs available. 414918334Speter Now this optimization is done safely in choose_reload_regs. */ 415018334Speter 415118334Speter /* For each reload of a reg into some other class of reg, 415218334Speter search for an existing equivalent reg (same value now) in the right class. 415318334Speter We can use it as long as we don't need to change its contents. */ 415418334Speter for (i = 0; i < n_reloads; i++) 415590285Sobrien if (rld[i].reg_rtx == 0 415690285Sobrien && rld[i].in != 0 4157169699Skan && REG_P (rld[i].in) 415890285Sobrien && rld[i].out == 0) 415918334Speter { 416090285Sobrien rld[i].reg_rtx 416190285Sobrien = find_equiv_reg (rld[i].in, insn, rld[i].class, -1, 416290285Sobrien static_reload_reg_p, 0, rld[i].inmode); 416318334Speter /* Prevent generation of insn to load the value 416418334Speter because the one we found already has the value. */ 416590285Sobrien if (rld[i].reg_rtx) 416690285Sobrien rld[i].in = rld[i].reg_rtx; 416718334Speter } 416818334Speter#endif 416918334Speter 4170169699Skan /* If we detected error and replaced asm instruction by USE, forget about the 4171169699Skan reloads. */ 4172169699Skan if (GET_CODE (PATTERN (insn)) == USE 4173169699Skan && GET_CODE (XEXP (PATTERN (insn), 0)) == CONST_INT) 4174169699Skan n_reloads = 0; 4175169699Skan 417618334Speter /* Perhaps an output reload can be combined with another 417718334Speter to reduce needs by one. */ 417818334Speter if (!goal_earlyclobber) 417918334Speter combine_reloads (); 418018334Speter 418118334Speter /* If we have a pair of reloads for parts of an address, they are reloading 418218334Speter the same object, the operands themselves were not reloaded, and they 418318334Speter are for two operands that are supposed to match, merge the reloads and 418450605Sobrien change the type of the surviving reload to RELOAD_FOR_OPERAND_ADDRESS. */ 418518334Speter 418618334Speter for (i = 0; i < n_reloads; i++) 418718334Speter { 418818334Speter int k; 418918334Speter 419018334Speter for (j = i + 1; j < n_reloads; j++) 419190285Sobrien if ((rld[i].when_needed == RELOAD_FOR_INPUT_ADDRESS 419290285Sobrien || rld[i].when_needed == RELOAD_FOR_OUTPUT_ADDRESS 419390285Sobrien || rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS 419490285Sobrien || rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS) 419590285Sobrien && (rld[j].when_needed == RELOAD_FOR_INPUT_ADDRESS 419690285Sobrien || rld[j].when_needed == RELOAD_FOR_OUTPUT_ADDRESS 419790285Sobrien || rld[j].when_needed == RELOAD_FOR_INPADDR_ADDRESS 419890285Sobrien || rld[j].when_needed == RELOAD_FOR_OUTADDR_ADDRESS) 419990285Sobrien && rtx_equal_p (rld[i].in, rld[j].in) 420090285Sobrien && (operand_reloadnum[rld[i].opnum] < 0 420190285Sobrien || rld[operand_reloadnum[rld[i].opnum]].optional) 420290285Sobrien && (operand_reloadnum[rld[j].opnum] < 0 420390285Sobrien || rld[operand_reloadnum[rld[j].opnum]].optional) 420490285Sobrien && (goal_alternative_matches[rld[i].opnum] == rld[j].opnum 420590285Sobrien || (goal_alternative_matches[rld[j].opnum] 420690285Sobrien == rld[i].opnum))) 420718334Speter { 420818334Speter for (k = 0; k < n_replacements; k++) 420918334Speter if (replacements[k].what == j) 421018334Speter replacements[k].what = i; 421118334Speter 421290285Sobrien if (rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS 421390285Sobrien || rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS) 421490285Sobrien rld[i].when_needed = RELOAD_FOR_OPADDR_ADDR; 421550605Sobrien else 421690285Sobrien rld[i].when_needed = RELOAD_FOR_OPERAND_ADDRESS; 421790285Sobrien rld[j].in = 0; 421818334Speter } 421918334Speter } 422018334Speter 422190285Sobrien /* Scan all the reloads and update their type. 422218334Speter If a reload is for the address of an operand and we didn't reload 422318334Speter that operand, change the type. Similarly, change the operand number 422418334Speter of a reload when two operands match. If a reload is optional, treat it 422518334Speter as though the operand isn't reloaded. 422618334Speter 422718334Speter ??? This latter case is somewhat odd because if we do the optional 422818334Speter reload, it means the object is hanging around. Thus we need only 422918334Speter do the address reload if the optional reload was NOT done. 423018334Speter 423118334Speter Change secondary reloads to be the address type of their operand, not 423218334Speter the normal type. 423318334Speter 423418334Speter If an operand's reload is now RELOAD_OTHER, change any 423518334Speter RELOAD_FOR_INPUT_ADDRESS reloads of that operand to 423618334Speter RELOAD_FOR_OTHER_ADDRESS. */ 423718334Speter 423818334Speter for (i = 0; i < n_reloads; i++) 423918334Speter { 424090285Sobrien if (rld[i].secondary_p 424190285Sobrien && rld[i].when_needed == operand_type[rld[i].opnum]) 424290285Sobrien rld[i].when_needed = address_type[rld[i].opnum]; 424318334Speter 424490285Sobrien if ((rld[i].when_needed == RELOAD_FOR_INPUT_ADDRESS 424590285Sobrien || rld[i].when_needed == RELOAD_FOR_OUTPUT_ADDRESS 424690285Sobrien || rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS 424790285Sobrien || rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS) 424890285Sobrien && (operand_reloadnum[rld[i].opnum] < 0 424990285Sobrien || rld[operand_reloadnum[rld[i].opnum]].optional)) 425018334Speter { 425118334Speter /* If we have a secondary reload to go along with this reload, 425250605Sobrien change its type to RELOAD_FOR_OPADDR_ADDR. */ 425318334Speter 425490285Sobrien if ((rld[i].when_needed == RELOAD_FOR_INPUT_ADDRESS 425590285Sobrien || rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS) 425690285Sobrien && rld[i].secondary_in_reload != -1) 425718334Speter { 425890285Sobrien int secondary_in_reload = rld[i].secondary_in_reload; 425918334Speter 426090285Sobrien rld[secondary_in_reload].when_needed = RELOAD_FOR_OPADDR_ADDR; 426118334Speter 426250605Sobrien /* If there's a tertiary reload we have to change it also. */ 426318334Speter if (secondary_in_reload > 0 426490285Sobrien && rld[secondary_in_reload].secondary_in_reload != -1) 426590285Sobrien rld[rld[secondary_in_reload].secondary_in_reload].when_needed 426618334Speter = RELOAD_FOR_OPADDR_ADDR; 426718334Speter } 426818334Speter 426990285Sobrien if ((rld[i].when_needed == RELOAD_FOR_OUTPUT_ADDRESS 427090285Sobrien || rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS) 427190285Sobrien && rld[i].secondary_out_reload != -1) 427218334Speter { 427390285Sobrien int secondary_out_reload = rld[i].secondary_out_reload; 427418334Speter 427590285Sobrien rld[secondary_out_reload].when_needed = RELOAD_FOR_OPADDR_ADDR; 427618334Speter 427750605Sobrien /* If there's a tertiary reload we have to change it also. */ 427818334Speter if (secondary_out_reload 427990285Sobrien && rld[secondary_out_reload].secondary_out_reload != -1) 428090285Sobrien rld[rld[secondary_out_reload].secondary_out_reload].when_needed 428118334Speter = RELOAD_FOR_OPADDR_ADDR; 428218334Speter } 428350605Sobrien 428490285Sobrien if (rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS 428590285Sobrien || rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS) 428690285Sobrien rld[i].when_needed = RELOAD_FOR_OPADDR_ADDR; 428752557Sobrien else 428890285Sobrien rld[i].when_needed = RELOAD_FOR_OPERAND_ADDRESS; 428918334Speter } 429018334Speter 429190285Sobrien if ((rld[i].when_needed == RELOAD_FOR_INPUT_ADDRESS 429290285Sobrien || rld[i].when_needed == RELOAD_FOR_INPADDR_ADDRESS) 429390285Sobrien && operand_reloadnum[rld[i].opnum] >= 0 429490285Sobrien && (rld[operand_reloadnum[rld[i].opnum]].when_needed 429518334Speter == RELOAD_OTHER)) 429690285Sobrien rld[i].when_needed = RELOAD_FOR_OTHER_ADDRESS; 429718334Speter 429890285Sobrien if (goal_alternative_matches[rld[i].opnum] >= 0) 429990285Sobrien rld[i].opnum = goal_alternative_matches[rld[i].opnum]; 430018334Speter } 430118334Speter 430250605Sobrien /* Scan all the reloads, and check for RELOAD_FOR_OPERAND_ADDRESS reloads. 430350605Sobrien If we have more than one, then convert all RELOAD_FOR_OPADDR_ADDR 430450605Sobrien reloads to RELOAD_FOR_OPERAND_ADDRESS reloads. 430550605Sobrien 430650605Sobrien choose_reload_regs assumes that RELOAD_FOR_OPADDR_ADDR reloads never 430750605Sobrien conflict with RELOAD_FOR_OPERAND_ADDRESS reloads. This is true for a 430850605Sobrien single pair of RELOAD_FOR_OPADDR_ADDR/RELOAD_FOR_OPERAND_ADDRESS reloads. 430950605Sobrien However, if there is more than one RELOAD_FOR_OPERAND_ADDRESS reload, 431050605Sobrien then a RELOAD_FOR_OPADDR_ADDR reload conflicts with all 431150605Sobrien RELOAD_FOR_OPERAND_ADDRESS reloads other than the one that uses it. 431250605Sobrien This is complicated by the fact that a single operand can have more 431350605Sobrien than one RELOAD_FOR_OPERAND_ADDRESS reload. It is very difficult to fix 431450605Sobrien choose_reload_regs without affecting code quality, and cases that 431550605Sobrien actually fail are extremely rare, so it turns out to be better to fix 431650605Sobrien the problem here by not generating cases that choose_reload_regs will 431750605Sobrien fail for. */ 431852557Sobrien /* There is a similar problem with RELOAD_FOR_INPUT_ADDRESS / 431950605Sobrien RELOAD_FOR_OUTPUT_ADDRESS when there is more than one of a kind for 432050605Sobrien a single operand. 432150605Sobrien We can reduce the register pressure by exploiting that a 432250605Sobrien RELOAD_FOR_X_ADDR_ADDR that precedes all RELOAD_FOR_X_ADDRESS reloads 432352557Sobrien does not conflict with any of them, if it is only used for the first of 432452557Sobrien the RELOAD_FOR_X_ADDRESS reloads. */ 432550605Sobrien { 432650605Sobrien int first_op_addr_num = -2; 432750605Sobrien int first_inpaddr_num[MAX_RECOG_OPERANDS]; 432850605Sobrien int first_outpaddr_num[MAX_RECOG_OPERANDS]; 432990285Sobrien int need_change = 0; 433050605Sobrien /* We use last_op_addr_reload and the contents of the above arrays 433150605Sobrien first as flags - -2 means no instance encountered, -1 means exactly 433250605Sobrien one instance encountered. 433350605Sobrien If more than one instance has been encountered, we store the reload 433450605Sobrien number of the first reload of the kind in question; reload numbers 433550605Sobrien are known to be non-negative. */ 433650605Sobrien for (i = 0; i < noperands; i++) 433750605Sobrien first_inpaddr_num[i] = first_outpaddr_num[i] = -2; 433850605Sobrien for (i = n_reloads - 1; i >= 0; i--) 433950605Sobrien { 434090285Sobrien switch (rld[i].when_needed) 434150605Sobrien { 434250605Sobrien case RELOAD_FOR_OPERAND_ADDRESS: 434352557Sobrien if (++first_op_addr_num >= 0) 434450605Sobrien { 434552557Sobrien first_op_addr_num = i; 434650605Sobrien need_change = 1; 434750605Sobrien } 434850605Sobrien break; 434950605Sobrien case RELOAD_FOR_INPUT_ADDRESS: 435090285Sobrien if (++first_inpaddr_num[rld[i].opnum] >= 0) 435150605Sobrien { 435290285Sobrien first_inpaddr_num[rld[i].opnum] = i; 435350605Sobrien need_change = 1; 435450605Sobrien } 435550605Sobrien break; 435650605Sobrien case RELOAD_FOR_OUTPUT_ADDRESS: 435790285Sobrien if (++first_outpaddr_num[rld[i].opnum] >= 0) 435850605Sobrien { 435990285Sobrien first_outpaddr_num[rld[i].opnum] = i; 436050605Sobrien need_change = 1; 436150605Sobrien } 436250605Sobrien break; 436350605Sobrien default: 436450605Sobrien break; 436550605Sobrien } 436650605Sobrien } 436750605Sobrien 436850605Sobrien if (need_change) 436950605Sobrien { 437050605Sobrien for (i = 0; i < n_reloads; i++) 437150605Sobrien { 437290285Sobrien int first_num; 437390285Sobrien enum reload_type type; 437450605Sobrien 437590285Sobrien switch (rld[i].when_needed) 437650605Sobrien { 437750605Sobrien case RELOAD_FOR_OPADDR_ADDR: 437850605Sobrien first_num = first_op_addr_num; 437950605Sobrien type = RELOAD_FOR_OPERAND_ADDRESS; 438050605Sobrien break; 438150605Sobrien case RELOAD_FOR_INPADDR_ADDRESS: 438290285Sobrien first_num = first_inpaddr_num[rld[i].opnum]; 438350605Sobrien type = RELOAD_FOR_INPUT_ADDRESS; 438450605Sobrien break; 438550605Sobrien case RELOAD_FOR_OUTADDR_ADDRESS: 438690285Sobrien first_num = first_outpaddr_num[rld[i].opnum]; 438750605Sobrien type = RELOAD_FOR_OUTPUT_ADDRESS; 438850605Sobrien break; 438950605Sobrien default: 439050605Sobrien continue; 439150605Sobrien } 439252557Sobrien if (first_num < 0) 439352557Sobrien continue; 439452557Sobrien else if (i > first_num) 439590285Sobrien rld[i].when_needed = type; 439652557Sobrien else 439752557Sobrien { 439852557Sobrien /* Check if the only TYPE reload that uses reload I is 439952557Sobrien reload FIRST_NUM. */ 440052557Sobrien for (j = n_reloads - 1; j > first_num; j--) 440152557Sobrien { 440290285Sobrien if (rld[j].when_needed == type 440390285Sobrien && (rld[i].secondary_p 440490285Sobrien ? rld[j].secondary_in_reload == i 440590285Sobrien : reg_mentioned_p (rld[i].in, rld[j].in))) 440652557Sobrien { 440790285Sobrien rld[i].when_needed = type; 440852557Sobrien break; 440952557Sobrien } 441052557Sobrien } 441152557Sobrien } 441250605Sobrien } 441350605Sobrien } 441450605Sobrien } 441550605Sobrien 441618334Speter /* See if we have any reloads that are now allowed to be merged 441718334Speter because we've changed when the reload is needed to 441818334Speter RELOAD_FOR_OPERAND_ADDRESS or RELOAD_FOR_OTHER_ADDRESS. Only 441918334Speter check for the most common cases. */ 442018334Speter 442118334Speter for (i = 0; i < n_reloads; i++) 442290285Sobrien if (rld[i].in != 0 && rld[i].out == 0 442390285Sobrien && (rld[i].when_needed == RELOAD_FOR_OPERAND_ADDRESS 442490285Sobrien || rld[i].when_needed == RELOAD_FOR_OPADDR_ADDR 442590285Sobrien || rld[i].when_needed == RELOAD_FOR_OTHER_ADDRESS)) 442618334Speter for (j = 0; j < n_reloads; j++) 442790285Sobrien if (i != j && rld[j].in != 0 && rld[j].out == 0 442890285Sobrien && rld[j].when_needed == rld[i].when_needed 442990285Sobrien && MATCHES (rld[i].in, rld[j].in) 443090285Sobrien && rld[i].class == rld[j].class 443190285Sobrien && !rld[i].nocombine && !rld[j].nocombine 443290285Sobrien && rld[i].reg_rtx == rld[j].reg_rtx) 443318334Speter { 443490285Sobrien rld[i].opnum = MIN (rld[i].opnum, rld[j].opnum); 443518334Speter transfer_replacements (i, j); 443690285Sobrien rld[j].in = 0; 443718334Speter } 443818334Speter 443990285Sobrien#ifdef HAVE_cc0 444090285Sobrien /* If we made any reloads for addresses, see if they violate a 444190285Sobrien "no input reloads" requirement for this insn. But loads that we 444290285Sobrien do after the insn (such as for output addresses) are fine. */ 444390285Sobrien if (no_input_reloads) 444490285Sobrien for (i = 0; i < n_reloads; i++) 4445169699Skan gcc_assert (rld[i].in == 0 4446169699Skan || rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS 4447169699Skan || rld[i].when_needed == RELOAD_FOR_OUTPUT_ADDRESS); 444890285Sobrien#endif 444950605Sobrien 445090285Sobrien /* Compute reload_mode and reload_nregs. */ 445150605Sobrien for (i = 0; i < n_reloads; i++) 445250605Sobrien { 445390285Sobrien rld[i].mode 445490285Sobrien = (rld[i].inmode == VOIDmode 445590285Sobrien || (GET_MODE_SIZE (rld[i].outmode) 445690285Sobrien > GET_MODE_SIZE (rld[i].inmode))) 445790285Sobrien ? rld[i].outmode : rld[i].inmode; 445850605Sobrien 445990285Sobrien rld[i].nregs = CLASS_MAX_NREGS (rld[i].class, rld[i].mode); 446050605Sobrien } 446150605Sobrien 446290285Sobrien /* Special case a simple move with an input reload and a 446390285Sobrien destination of a hard reg, if the hard reg is ok, use it. */ 446490285Sobrien for (i = 0; i < n_reloads; i++) 446590285Sobrien if (rld[i].when_needed == RELOAD_FOR_INPUT 446690285Sobrien && GET_CODE (PATTERN (insn)) == SET 4467169699Skan && REG_P (SET_DEST (PATTERN (insn))) 4468132727Skan && SET_SRC (PATTERN (insn)) == rld[i].in) 446990285Sobrien { 4470132727Skan rtx dest = SET_DEST (PATTERN (insn)); 447190285Sobrien unsigned int regno = REGNO (dest); 447250605Sobrien 4473132727Skan if (regno < FIRST_PSEUDO_REGISTER 4474132727Skan && TEST_HARD_REG_BIT (reg_class_contents[rld[i].class], regno) 4475132727Skan && HARD_REGNO_MODE_OK (regno, rld[i].mode)) 4476132727Skan { 4477169699Skan int nr = hard_regno_nregs[regno][rld[i].mode]; 4478132727Skan int ok = 1, nri; 4479132727Skan 4480132727Skan for (nri = 1; nri < nr; nri ++) 4481132727Skan if (! TEST_HARD_REG_BIT (reg_class_contents[rld[i].class], regno + nri)) 4482132727Skan ok = 0; 4483132727Skan 4484132727Skan if (ok) 4485132727Skan rld[i].reg_rtx = dest; 4486132727Skan } 448790285Sobrien } 448850605Sobrien 448952557Sobrien return retval; 449018334Speter} 449118334Speter 449218334Speter/* Return 1 if alternative number ALTNUM in constraint-string CONSTRAINT 449318334Speter accepts a memory operand with constant address. */ 449418334Speter 449518334Speterstatic int 4496132727Skanalternative_allows_memconst (const char *constraint, int altnum) 449718334Speter{ 449890285Sobrien int c; 449918334Speter /* Skip alternatives before the one requested. */ 450018334Speter while (altnum > 0) 450118334Speter { 450218334Speter while (*constraint++ != ','); 450318334Speter altnum--; 450418334Speter } 450518334Speter /* Scan the requested alternative for 'm' or 'o'. 450618334Speter If one of them is present, this alternative accepts memory constants. */ 4507132727Skan for (; (c = *constraint) && c != ',' && c != '#'; 4508132727Skan constraint += CONSTRAINT_LEN (c, constraint)) 4509132727Skan if (c == 'm' || c == 'o' || EXTRA_MEMORY_CONSTRAINT (c, constraint)) 451018334Speter return 1; 451118334Speter return 0; 451218334Speter} 451318334Speter 451418334Speter/* Scan X for memory references and scan the addresses for reloading. 451518334Speter Also checks for references to "constant" regs that we want to eliminate 451618334Speter and replaces them with the values they stand for. 451718334Speter We may alter X destructively if it contains a reference to such. 451818334Speter If X is just a constant reg, we return the equivalent value 451918334Speter instead of X. 452018334Speter 452118334Speter IND_LEVELS says how many levels of indirect addressing this machine 452218334Speter supports. 452318334Speter 452418334Speter OPNUM and TYPE identify the purpose of the reload. 452518334Speter 452618334Speter IS_SET_DEST is true if X is the destination of a SET, which is not 452752557Sobrien appropriate to be replaced by a constant. 452818334Speter 452952557Sobrien INSN, if nonzero, is the insn in which we do the reload. It is used 453052557Sobrien to determine if we may generate output reloads, and where to put USEs 453190285Sobrien for pseudos that we have to replace with stack slots. 453252557Sobrien 453390285Sobrien ADDRESS_RELOADED. If nonzero, is a pointer to where we put the 453490285Sobrien result of find_reloads_address. */ 453590285Sobrien 453618334Speterstatic rtx 4537132727Skanfind_reloads_toplev (rtx x, int opnum, enum reload_type type, 4538132727Skan int ind_levels, int is_set_dest, rtx insn, 4539132727Skan int *address_reloaded) 454018334Speter{ 454190285Sobrien RTX_CODE code = GET_CODE (x); 454218334Speter 454390285Sobrien const char *fmt = GET_RTX_FORMAT (code); 454490285Sobrien int i; 454552557Sobrien int copied; 454618334Speter 454718334Speter if (code == REG) 454818334Speter { 454918334Speter /* This code is duplicated for speed in find_reloads. */ 455090285Sobrien int regno = REGNO (x); 455118334Speter if (reg_equiv_constant[regno] != 0 && !is_set_dest) 455218334Speter x = reg_equiv_constant[regno]; 455318334Speter#if 0 455490285Sobrien /* This creates (subreg (mem...)) which would cause an unnecessary 455590285Sobrien reload of the mem. */ 455618334Speter else if (reg_equiv_mem[regno] != 0) 455718334Speter x = reg_equiv_mem[regno]; 455818334Speter#endif 455952557Sobrien else if (reg_equiv_memory_loc[regno] 456052557Sobrien && (reg_equiv_address[regno] != 0 || num_not_at_initial_offset)) 456118334Speter { 456252557Sobrien rtx mem = make_memloc (x, regno); 456352557Sobrien if (reg_equiv_address[regno] 456452557Sobrien || ! rtx_equal_p (mem, reg_equiv_mem[regno])) 456552557Sobrien { 456652557Sobrien /* If this is not a toplevel operand, find_reloads doesn't see 456752557Sobrien this substitution. We have to emit a USE of the pseudo so 456852557Sobrien that delete_output_reload can see it. */ 456990285Sobrien if (replace_reloads && recog_data.operand[opnum] != x) 457090285Sobrien /* We mark the USE with QImode so that we recognize it 457190285Sobrien as one that can be safely deleted at the end of 457290285Sobrien reload. */ 457390285Sobrien PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode, x), insn), 457490285Sobrien QImode); 457552557Sobrien x = mem; 457690285Sobrien i = find_reloads_address (GET_MODE (x), &x, XEXP (x, 0), &XEXP (x, 0), 457790285Sobrien opnum, type, ind_levels, insn); 4578169699Skan if (x != mem) 4579169699Skan push_reg_equiv_alt_mem (regno, x); 458090285Sobrien if (address_reloaded) 458190285Sobrien *address_reloaded = i; 458252557Sobrien } 458318334Speter } 458418334Speter return x; 458518334Speter } 458618334Speter if (code == MEM) 458718334Speter { 458818334Speter rtx tem = x; 458990285Sobrien 459090285Sobrien i = find_reloads_address (GET_MODE (x), &tem, XEXP (x, 0), &XEXP (x, 0), 459190285Sobrien opnum, type, ind_levels, insn); 459290285Sobrien if (address_reloaded) 459390285Sobrien *address_reloaded = i; 459490285Sobrien 459518334Speter return tem; 459618334Speter } 459718334Speter 4598169699Skan if (code == SUBREG && REG_P (SUBREG_REG (x))) 459918334Speter { 4600169699Skan /* Check for SUBREG containing a REG that's equivalent to a 4601169699Skan constant. If the constant has a known value, truncate it 4602169699Skan right now. Similarly if we are extracting a single-word of a 4603169699Skan multi-word constant. If the constant is symbolic, allow it 4604169699Skan to be substituted normally. push_reload will strip the 4605169699Skan subreg later. The constant must not be VOIDmode, because we 4606169699Skan will lose the mode of the register (this should never happen 4607169699Skan because one of the cases above should handle it). */ 460818334Speter 460990285Sobrien int regno = REGNO (SUBREG_REG (x)); 461018334Speter rtx tem; 461118334Speter 461218334Speter if (subreg_lowpart_p (x) 4613169699Skan && regno >= FIRST_PSEUDO_REGISTER 4614169699Skan && reg_renumber[regno] < 0 461518334Speter && reg_equiv_constant[regno] != 0 461618334Speter && (tem = gen_lowpart_common (GET_MODE (x), 461718334Speter reg_equiv_constant[regno])) != 0) 461818334Speter return tem; 461918334Speter 4620169699Skan if (regno >= FIRST_PSEUDO_REGISTER 4621169699Skan && reg_renumber[regno] < 0 4622107605Sobrien && reg_equiv_constant[regno] != 0) 462350605Sobrien { 4624107605Sobrien tem = 4625107605Sobrien simplify_gen_subreg (GET_MODE (x), reg_equiv_constant[regno], 4626107605Sobrien GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x)); 4627169699Skan gcc_assert (tem); 462850605Sobrien return tem; 462950605Sobrien } 463050605Sobrien 463118334Speter /* If the subreg contains a reg that will be converted to a mem, 463218334Speter convert the subreg to a narrower memref now. 463318334Speter Otherwise, we would get (subreg (mem ...) ...), 463418334Speter which would force reload of the mem. 463518334Speter 463618334Speter We also need to do this if there is an equivalent MEM that is 463718334Speter not offsettable. In that case, alter_subreg would produce an 463818334Speter invalid address on big-endian machines. 463918334Speter 464018334Speter For machines that extend byte loads, we must not reload using 464118334Speter a wider mode if we have a paradoxical SUBREG. find_reloads will 464218334Speter force a reload in that case. So we should not do anything here. */ 464318334Speter 4644169699Skan if (regno >= FIRST_PSEUDO_REGISTER 464518334Speter#ifdef LOAD_EXTEND_OP 464618334Speter && (GET_MODE_SIZE (GET_MODE (x)) 464718334Speter <= GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))) 464818334Speter#endif 464918334Speter && (reg_equiv_address[regno] != 0 465018334Speter || (reg_equiv_mem[regno] != 0 465190285Sobrien && (! strict_memory_address_p (GET_MODE (x), 465218334Speter XEXP (reg_equiv_mem[regno], 0)) 465352557Sobrien || ! offsettable_memref_p (reg_equiv_mem[regno]) 465452557Sobrien || num_not_at_initial_offset)))) 465552557Sobrien x = find_reloads_subreg_address (x, 1, opnum, type, ind_levels, 465652557Sobrien insn); 465752557Sobrien } 465852557Sobrien 465952557Sobrien for (copied = 0, i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 466052557Sobrien { 466152557Sobrien if (fmt[i] == 'e') 466218334Speter { 466352557Sobrien rtx new_part = find_reloads_toplev (XEXP (x, i), opnum, type, 466490285Sobrien ind_levels, is_set_dest, insn, 466590285Sobrien address_reloaded); 466652557Sobrien /* If we have replaced a reg with it's equivalent memory loc - 466752557Sobrien that can still be handled here e.g. if it's in a paradoxical 466852557Sobrien subreg - we must make the change in a copy, rather than using 466952557Sobrien a destructive change. This way, find_reloads can still elect 467052557Sobrien not to do the change. */ 467152557Sobrien if (new_part != XEXP (x, i) && ! CONSTANT_P (new_part) && ! copied) 467218334Speter { 467352557Sobrien x = shallow_copy_rtx (x); 467452557Sobrien copied = 1; 467518334Speter } 467652557Sobrien XEXP (x, i) = new_part; 467718334Speter } 467818334Speter } 467918334Speter return x; 468018334Speter} 468118334Speter 468218334Speter/* Return a mem ref for the memory equivalent of reg REGNO. 468318334Speter This mem ref is not shared with anything. */ 468418334Speter 468518334Speterstatic rtx 4686132727Skanmake_memloc (rtx ad, int regno) 468718334Speter{ 468818334Speter /* We must rerun eliminate_regs, in case the elimination 468918334Speter offsets have changed. */ 469052557Sobrien rtx tem 469152557Sobrien = XEXP (eliminate_regs (reg_equiv_memory_loc[regno], 0, NULL_RTX), 0); 469218334Speter 469318334Speter /* If TEM might contain a pseudo, we must copy it to avoid 469418334Speter modifying it when we do the substitution for the reload. */ 469590285Sobrien if (rtx_varies_p (tem, 0)) 469618334Speter tem = copy_rtx (tem); 469718334Speter 469890285Sobrien tem = replace_equiv_address_nv (reg_equiv_memory_loc[regno], tem); 469990285Sobrien tem = adjust_address_nv (tem, GET_MODE (ad), 0); 470090285Sobrien 470190285Sobrien /* Copy the result if it's still the same as the equivalence, to avoid 470290285Sobrien modifying it when we do the substitution for the reload. */ 470390285Sobrien if (tem == reg_equiv_memory_loc[regno]) 470490285Sobrien tem = copy_rtx (tem); 470518334Speter return tem; 470618334Speter} 470718334Speter 4708117404Skan/* Returns true if AD could be turned into a valid memory reference 4709132727Skan to mode MODE by reloading the part pointed to by PART into a 4710117404Skan register. */ 4711117404Skan 4712117404Skanstatic int 4713132727Skanmaybe_memory_address_p (enum machine_mode mode, rtx ad, rtx *part) 4714117404Skan{ 4715117404Skan int retv; 4716117404Skan rtx tem = *part; 4717117404Skan rtx reg = gen_rtx_REG (GET_MODE (tem), max_reg_num ()); 4718117404Skan 4719117404Skan *part = reg; 4720117404Skan retv = memory_address_p (mode, ad); 4721117404Skan *part = tem; 4722117404Skan 4723117404Skan return retv; 4724117404Skan} 4725117404Skan 472618334Speter/* Record all reloads needed for handling memory address AD 472718334Speter which appears in *LOC in a memory reference to mode MODE 472818334Speter which itself is found in location *MEMREFLOC. 472918334Speter Note that we take shortcuts assuming that no multi-reg machine mode 473018334Speter occurs as part of an address. 473118334Speter 473218334Speter OPNUM and TYPE specify the purpose of this reload. 473318334Speter 473418334Speter IND_LEVELS says how many levels of indirect addressing this machine 473518334Speter supports. 473618334Speter 473750605Sobrien INSN, if nonzero, is the insn in which we do the reload. It is used 473852557Sobrien to determine if we may generate output reloads, and where to put USEs 473952557Sobrien for pseudos that we have to replace with stack slots. 474050605Sobrien 4741169699Skan Value is one if this address is reloaded or replaced as a whole; it is 4742169699Skan zero if the top level of this address was not reloaded or replaced, and 4743169699Skan it is -1 if it may or may not have been reloaded or replaced. 474418334Speter 474518334Speter Note that there is no verification that the address will be valid after 474618334Speter this routine does its work. Instead, we rely on the fact that the address 474718334Speter was valid when reload started. So we need only undo things that reload 474818334Speter could have broken. These are wrong register types, pseudos not allocated 474918334Speter to a hard register, and frame pointer elimination. */ 475018334Speter 475118334Speterstatic int 4752132727Skanfind_reloads_address (enum machine_mode mode, rtx *memrefloc, rtx ad, 4753132727Skan rtx *loc, int opnum, enum reload_type type, 4754132727Skan int ind_levels, rtx insn) 475518334Speter{ 475690285Sobrien int regno; 475752557Sobrien int removed_and = 0; 4758169699Skan int op_index; 475918334Speter rtx tem; 476018334Speter 476118334Speter /* If the address is a register, see if it is a legitimate address and 476218334Speter reload if not. We first handle the cases where we need not reload 476318334Speter or where we must reload in a non-standard way. */ 476418334Speter 4765169699Skan if (REG_P (ad)) 476618334Speter { 476718334Speter regno = REGNO (ad); 476818334Speter 476990285Sobrien /* If the register is equivalent to an invariant expression, substitute 477090285Sobrien the invariant, and eliminate any eliminable register references. */ 477190285Sobrien tem = reg_equiv_constant[regno]; 477290285Sobrien if (tem != 0 477390285Sobrien && (tem = eliminate_regs (tem, mode, insn)) 477490285Sobrien && strict_memory_address_p (mode, tem)) 477518334Speter { 477690285Sobrien *loc = ad = tem; 477752557Sobrien return 0; 477818334Speter } 477918334Speter 478052557Sobrien tem = reg_equiv_memory_loc[regno]; 478152557Sobrien if (tem != 0) 478218334Speter { 478352557Sobrien if (reg_equiv_address[regno] != 0 || num_not_at_initial_offset) 478452557Sobrien { 478552557Sobrien tem = make_memloc (ad, regno); 478652557Sobrien if (! strict_memory_address_p (GET_MODE (tem), XEXP (tem, 0))) 478752557Sobrien { 4788169699Skan rtx orig = tem; 4789169699Skan 4790117404Skan find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0), 4791117404Skan &XEXP (tem, 0), opnum, 4792117404Skan ADDR_TYPE (type), ind_levels, insn); 4793169699Skan if (tem != orig) 4794169699Skan push_reg_equiv_alt_mem (regno, tem); 479552557Sobrien } 479652557Sobrien /* We can avoid a reload if the register's equivalent memory 479752557Sobrien expression is valid as an indirect memory address. 479852557Sobrien But not all addresses are valid in a mem used as an indirect 479952557Sobrien address: only reg or reg+constant. */ 480052557Sobrien 480152557Sobrien if (ind_levels > 0 480252557Sobrien && strict_memory_address_p (mode, tem) 4803169699Skan && (REG_P (XEXP (tem, 0)) 480452557Sobrien || (GET_CODE (XEXP (tem, 0)) == PLUS 4805169699Skan && REG_P (XEXP (XEXP (tem, 0), 0)) 480652557Sobrien && CONSTANT_P (XEXP (XEXP (tem, 0), 1))))) 480752557Sobrien { 480852557Sobrien /* TEM is not the same as what we'll be replacing the 480952557Sobrien pseudo with after reload, put a USE in front of INSN 481052557Sobrien in the final reload pass. */ 481152557Sobrien if (replace_reloads 481252557Sobrien && num_not_at_initial_offset 481352557Sobrien && ! rtx_equal_p (tem, reg_equiv_mem[regno])) 481452557Sobrien { 481552557Sobrien *loc = tem; 481690285Sobrien /* We mark the USE with QImode so that we 481790285Sobrien recognize it as one that can be safely 481890285Sobrien deleted at the end of reload. */ 481990285Sobrien PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode, ad), 482090285Sobrien insn), QImode); 482190285Sobrien 482252557Sobrien /* This doesn't really count as replacing the address 482352557Sobrien as a whole, since it is still a memory access. */ 482452557Sobrien } 482552557Sobrien return 0; 482652557Sobrien } 482752557Sobrien ad = tem; 482852557Sobrien } 482918334Speter } 483018334Speter 483118334Speter /* The only remaining case where we can avoid a reload is if this is a 483218334Speter hard register that is valid as a base register and which is not the 483318334Speter subject of a CLOBBER in this insn. */ 483418334Speter 483550605Sobrien else if (regno < FIRST_PSEUDO_REGISTER 4836169699Skan && regno_ok_for_base_p (regno, mode, MEM, SCRATCH) 483790285Sobrien && ! regno_clobbered_p (regno, this_insn, mode, 0)) 483818334Speter return 0; 483918334Speter 484018334Speter /* If we do not have one of the cases above, we must do the reload. */ 4841169699Skan push_reload (ad, NULL_RTX, loc, (rtx*) 0, base_reg_class (mode, MEM, SCRATCH), 484218334Speter GET_MODE (ad), VOIDmode, 0, 0, opnum, type); 484318334Speter return 1; 484418334Speter } 484518334Speter 484618334Speter if (strict_memory_address_p (mode, ad)) 484718334Speter { 484818334Speter /* The address appears valid, so reloads are not needed. 484918334Speter But the address may contain an eliminable register. 485018334Speter This can happen because a machine with indirect addressing 485118334Speter may consider a pseudo register by itself a valid address even when 485218334Speter it has failed to get a hard reg. 485318334Speter So do a tree-walk to find and eliminate all such regs. */ 485418334Speter 485518334Speter /* But first quickly dispose of a common case. */ 485618334Speter if (GET_CODE (ad) == PLUS 485718334Speter && GET_CODE (XEXP (ad, 1)) == CONST_INT 4858169699Skan && REG_P (XEXP (ad, 0)) 485918334Speter && reg_equiv_constant[REGNO (XEXP (ad, 0))] == 0) 486018334Speter return 0; 486118334Speter 486218334Speter subst_reg_equivs_changed = 0; 486352557Sobrien *loc = subst_reg_equivs (ad, insn); 486418334Speter 486518334Speter if (! subst_reg_equivs_changed) 486618334Speter return 0; 486718334Speter 486818334Speter /* Check result for validity after substitution. */ 486918334Speter if (strict_memory_address_p (mode, ad)) 487018334Speter return 0; 487118334Speter } 487218334Speter 487350605Sobrien#ifdef LEGITIMIZE_RELOAD_ADDRESS 487450605Sobrien do 487550605Sobrien { 487650605Sobrien if (memrefloc) 487750605Sobrien { 487850605Sobrien LEGITIMIZE_RELOAD_ADDRESS (ad, GET_MODE (*memrefloc), opnum, type, 487950605Sobrien ind_levels, win); 488050605Sobrien } 488150605Sobrien break; 488250605Sobrien win: 488350605Sobrien *memrefloc = copy_rtx (*memrefloc); 488450605Sobrien XEXP (*memrefloc, 0) = ad; 488550605Sobrien move_replacements (&ad, &XEXP (*memrefloc, 0)); 4886169699Skan return -1; 488750605Sobrien } 488850605Sobrien while (0); 488950605Sobrien#endif 489050605Sobrien 489152557Sobrien /* The address is not valid. We have to figure out why. First see if 489252557Sobrien we have an outer AND and remove it if so. Then analyze what's inside. */ 489352557Sobrien 489452557Sobrien if (GET_CODE (ad) == AND) 489552557Sobrien { 489652557Sobrien removed_and = 1; 489752557Sobrien loc = &XEXP (ad, 0); 489852557Sobrien ad = *loc; 489952557Sobrien } 490052557Sobrien 490152557Sobrien /* One possibility for why the address is invalid is that it is itself 490252557Sobrien a MEM. This can happen when the frame pointer is being eliminated, a 490352557Sobrien pseudo is not allocated to a hard register, and the offset between the 490452557Sobrien frame and stack pointers is not its initial value. In that case the 490552557Sobrien pseudo will have been replaced by a MEM referring to the 490652557Sobrien stack pointer. */ 4907169699Skan if (MEM_P (ad)) 490818334Speter { 490918334Speter /* First ensure that the address in this MEM is valid. Then, unless 491018334Speter indirect addresses are valid, reload the MEM into a register. */ 491118334Speter tem = ad; 491218334Speter find_reloads_address (GET_MODE (ad), &tem, XEXP (ad, 0), &XEXP (ad, 0), 491350605Sobrien opnum, ADDR_TYPE (type), 491450605Sobrien ind_levels == 0 ? 0 : ind_levels - 1, insn); 491518334Speter 491618334Speter /* If tem was changed, then we must create a new memory reference to 491718334Speter hold it and store it back into memrefloc. */ 491818334Speter if (tem != ad && memrefloc) 491918334Speter { 492018334Speter *memrefloc = copy_rtx (*memrefloc); 492118334Speter copy_replacements (tem, XEXP (*memrefloc, 0)); 492218334Speter loc = &XEXP (*memrefloc, 0); 492352557Sobrien if (removed_and) 492452557Sobrien loc = &XEXP (*loc, 0); 492518334Speter } 492618334Speter 492718334Speter /* Check similar cases as for indirect addresses as above except 492818334Speter that we can allow pseudos and a MEM since they should have been 492918334Speter taken care of above. */ 493018334Speter 493118334Speter if (ind_levels == 0 493218334Speter || (GET_CODE (XEXP (tem, 0)) == SYMBOL_REF && ! indirect_symref_ok) 4933169699Skan || MEM_P (XEXP (tem, 0)) 4934169699Skan || ! (REG_P (XEXP (tem, 0)) 493518334Speter || (GET_CODE (XEXP (tem, 0)) == PLUS 4936169699Skan && REG_P (XEXP (XEXP (tem, 0), 0)) 493718334Speter && GET_CODE (XEXP (XEXP (tem, 0), 1)) == CONST_INT))) 493818334Speter { 493918334Speter /* Must use TEM here, not AD, since it is the one that will 494018334Speter have any subexpressions reloaded, if needed. */ 494190285Sobrien push_reload (tem, NULL_RTX, loc, (rtx*) 0, 4942169699Skan base_reg_class (mode, MEM, SCRATCH), GET_MODE (tem), 494350605Sobrien VOIDmode, 0, 494418334Speter 0, opnum, type); 494552557Sobrien return ! removed_and; 494618334Speter } 494718334Speter else 494818334Speter return 0; 494918334Speter } 495018334Speter 495118334Speter /* If we have address of a stack slot but it's not valid because the 495218334Speter displacement is too large, compute the sum in a register. 495318334Speter Handle all base registers here, not just fp/ap/sp, because on some 495418334Speter targets (namely SH) we can also get too large displacements from 495518334Speter big-endian corrections. */ 495618334Speter else if (GET_CODE (ad) == PLUS 4957169699Skan && REG_P (XEXP (ad, 0)) 495818334Speter && REGNO (XEXP (ad, 0)) < FIRST_PSEUDO_REGISTER 4959169699Skan && GET_CODE (XEXP (ad, 1)) == CONST_INT 4960169699Skan && regno_ok_for_base_p (REGNO (XEXP (ad, 0)), mode, PLUS, 4961169699Skan CONST_INT)) 4962169699Skan 496318334Speter { 496418334Speter /* Unshare the MEM rtx so we can safely alter it. */ 496518334Speter if (memrefloc) 496618334Speter { 496718334Speter *memrefloc = copy_rtx (*memrefloc); 496818334Speter loc = &XEXP (*memrefloc, 0); 496952557Sobrien if (removed_and) 497052557Sobrien loc = &XEXP (*loc, 0); 497118334Speter } 497252557Sobrien 497318334Speter if (double_reg_address_ok) 497418334Speter { 497518334Speter /* Unshare the sum as well. */ 497618334Speter *loc = ad = copy_rtx (ad); 497752557Sobrien 497818334Speter /* Reload the displacement into an index reg. 497918334Speter We assume the frame pointer or arg pointer is a base reg. */ 498018334Speter find_reloads_address_part (XEXP (ad, 1), &XEXP (ad, 1), 498152557Sobrien INDEX_REG_CLASS, GET_MODE (ad), opnum, 498252557Sobrien type, ind_levels); 498352557Sobrien return 0; 498418334Speter } 498518334Speter else 498618334Speter { 498718334Speter /* If the sum of two regs is not necessarily valid, 498818334Speter reload the sum into a base reg. 498918334Speter That will at least work. */ 4990169699Skan find_reloads_address_part (ad, loc, 4991169699Skan base_reg_class (mode, MEM, SCRATCH), 499250605Sobrien Pmode, opnum, type, ind_levels); 499318334Speter } 499452557Sobrien return ! removed_and; 499518334Speter } 499618334Speter 499718334Speter /* If we have an indexed stack slot, there are three possible reasons why 499818334Speter it might be invalid: The index might need to be reloaded, the address 499918334Speter might have been made by frame pointer elimination and hence have a 500090285Sobrien constant out of range, or both reasons might apply. 500118334Speter 500218334Speter We can easily check for an index needing reload, but even if that is the 500318334Speter case, we might also have an invalid constant. To avoid making the 500418334Speter conservative assumption and requiring two reloads, we see if this address 500518334Speter is valid when not interpreted strictly. If it is, the only problem is 500618334Speter that the index needs a reload and find_reloads_address_1 will take care 500718334Speter of it. 500818334Speter 5009117404Skan Handle all base registers here, not just fp/ap/sp, because on some 5010132727Skan targets (namely SPARC) we can also get invalid addresses from preventive 5011169699Skan subreg big-endian corrections made by find_reloads_toplev. We 5012169699Skan can also get expressions involving LO_SUM (rather than PLUS) from 5013169699Skan find_reloads_subreg_address. 5014117404Skan 5015117404Skan If we decide to do something, it must be that `double_reg_address_ok' 5016117404Skan is true. We generate a reload of the base register + constant and 501718334Speter rework the sum so that the reload register will be added to the index. 501818334Speter This is safe because we know the address isn't shared. 501918334Speter 5020117404Skan We check for the base register as both the first and second operand of 5021169699Skan the innermost PLUS and/or LO_SUM. */ 502218334Speter 5023169699Skan for (op_index = 0; op_index < 2; ++op_index) 502418334Speter { 5025169699Skan rtx operand, addend; 5026169699Skan enum rtx_code inner_code; 502718334Speter 5028169699Skan if (GET_CODE (ad) != PLUS) 5029169699Skan continue; 503090285Sobrien 5031169699Skan inner_code = GET_CODE (XEXP (ad, 0)); 5032169699Skan if (!(GET_CODE (ad) == PLUS 5033169699Skan && GET_CODE (XEXP (ad, 1)) == CONST_INT 5034169699Skan && (inner_code == PLUS || inner_code == LO_SUM))) 5035169699Skan continue; 5036169699Skan 5037169699Skan operand = XEXP (XEXP (ad, 0), op_index); 5038169699Skan if (!REG_P (operand) || REGNO (operand) >= FIRST_PSEUDO_REGISTER) 5039169699Skan continue; 5040169699Skan 5041169699Skan addend = XEXP (XEXP (ad, 0), 1 - op_index); 5042169699Skan 5043169699Skan if ((regno_ok_for_base_p (REGNO (operand), mode, inner_code, 5044169699Skan GET_CODE (addend)) 5045169699Skan || operand == frame_pointer_rtx 5046132727Skan#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM 5047169699Skan || operand == hard_frame_pointer_rtx 5048132727Skan#endif 5049132727Skan#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM 5050169699Skan || operand == arg_pointer_rtx 5051132727Skan#endif 5052169699Skan || operand == stack_pointer_rtx) 5053169699Skan && ! maybe_memory_address_p (mode, ad, 5054169699Skan &XEXP (XEXP (ad, 0), 1 - op_index))) 5055169699Skan { 5056169699Skan rtx offset_reg; 5057169699Skan enum reg_class cls; 505818334Speter 5059169699Skan offset_reg = plus_constant (operand, INTVAL (XEXP (ad, 1))); 5060169699Skan 5061169699Skan /* Form the adjusted address. */ 5062169699Skan if (GET_CODE (XEXP (ad, 0)) == PLUS) 5063169699Skan ad = gen_rtx_PLUS (GET_MODE (ad), 5064169699Skan op_index == 0 ? offset_reg : addend, 5065169699Skan op_index == 0 ? addend : offset_reg); 5066169699Skan else 5067169699Skan ad = gen_rtx_LO_SUM (GET_MODE (ad), 5068169699Skan op_index == 0 ? offset_reg : addend, 5069169699Skan op_index == 0 ? addend : offset_reg); 5070169699Skan *loc = ad; 5071169699Skan 5072169699Skan cls = base_reg_class (mode, MEM, GET_CODE (addend)); 5073169699Skan find_reloads_address_part (XEXP (ad, op_index), 5074169699Skan &XEXP (ad, op_index), cls, 5075169699Skan GET_MODE (ad), opnum, type, ind_levels); 5076169699Skan find_reloads_address_1 (mode, 5077169699Skan XEXP (ad, 1 - op_index), 1, GET_CODE (ad), 5078169699Skan GET_CODE (XEXP (ad, op_index)), 5079169699Skan &XEXP (ad, 1 - op_index), opnum, 5080169699Skan type, 0, insn); 5081169699Skan 5082169699Skan return 0; 5083169699Skan } 508418334Speter } 508590285Sobrien 508618334Speter /* See if address becomes valid when an eliminable register 508718334Speter in a sum is replaced. */ 508818334Speter 508918334Speter tem = ad; 509018334Speter if (GET_CODE (ad) == PLUS) 509118334Speter tem = subst_indexed_address (ad); 509218334Speter if (tem != ad && strict_memory_address_p (mode, tem)) 509318334Speter { 509418334Speter /* Ok, we win that way. Replace any additional eliminable 509518334Speter registers. */ 509618334Speter 509718334Speter subst_reg_equivs_changed = 0; 509852557Sobrien tem = subst_reg_equivs (tem, insn); 509918334Speter 510018334Speter /* Make sure that didn't make the address invalid again. */ 510118334Speter 510218334Speter if (! subst_reg_equivs_changed || strict_memory_address_p (mode, tem)) 510318334Speter { 510418334Speter *loc = tem; 510518334Speter return 0; 510618334Speter } 510718334Speter } 510818334Speter 510918334Speter /* If constants aren't valid addresses, reload the constant address 511018334Speter into a register. */ 511118334Speter if (CONSTANT_P (ad) && ! strict_memory_address_p (mode, ad)) 511218334Speter { 511390285Sobrien /* If AD is an address in the constant pool, the MEM rtx may be shared. 511418334Speter Unshare it so we can safely alter it. */ 511518334Speter if (memrefloc && GET_CODE (ad) == SYMBOL_REF 511618334Speter && CONSTANT_POOL_ADDRESS_P (ad)) 511718334Speter { 511818334Speter *memrefloc = copy_rtx (*memrefloc); 511918334Speter loc = &XEXP (*memrefloc, 0); 512052557Sobrien if (removed_and) 512152557Sobrien loc = &XEXP (*loc, 0); 512218334Speter } 512318334Speter 5124169699Skan find_reloads_address_part (ad, loc, base_reg_class (mode, MEM, SCRATCH), 512590285Sobrien Pmode, opnum, type, ind_levels); 512652557Sobrien return ! removed_and; 512718334Speter } 512818334Speter 5129169699Skan return find_reloads_address_1 (mode, ad, 0, MEM, SCRATCH, loc, opnum, type, 5130169699Skan ind_levels, insn); 513118334Speter} 513218334Speter 513318334Speter/* Find all pseudo regs appearing in AD 513418334Speter that are eliminable in favor of equivalent values 513552557Sobrien and do not have hard regs; replace them by their equivalents. 513652557Sobrien INSN, if nonzero, is the insn in which we do the reload. We put USEs in 513752557Sobrien front of it for pseudos that we have to replace with stack slots. */ 513818334Speter 513918334Speterstatic rtx 5140132727Skansubst_reg_equivs (rtx ad, rtx insn) 514118334Speter{ 514290285Sobrien RTX_CODE code = GET_CODE (ad); 514390285Sobrien int i; 514490285Sobrien const char *fmt; 514518334Speter 514618334Speter switch (code) 514718334Speter { 514818334Speter case HIGH: 514918334Speter case CONST_INT: 515018334Speter case CONST: 515118334Speter case CONST_DOUBLE: 515296288Sobrien case CONST_VECTOR: 515318334Speter case SYMBOL_REF: 515418334Speter case LABEL_REF: 515518334Speter case PC: 515618334Speter case CC0: 515718334Speter return ad; 515818334Speter 515918334Speter case REG: 516018334Speter { 516190285Sobrien int regno = REGNO (ad); 516218334Speter 516318334Speter if (reg_equiv_constant[regno] != 0) 516418334Speter { 516518334Speter subst_reg_equivs_changed = 1; 516618334Speter return reg_equiv_constant[regno]; 516718334Speter } 516852557Sobrien if (reg_equiv_memory_loc[regno] && num_not_at_initial_offset) 516952557Sobrien { 517052557Sobrien rtx mem = make_memloc (ad, regno); 517152557Sobrien if (! rtx_equal_p (mem, reg_equiv_mem[regno])) 517252557Sobrien { 517352557Sobrien subst_reg_equivs_changed = 1; 517490285Sobrien /* We mark the USE with QImode so that we recognize it 517590285Sobrien as one that can be safely deleted at the end of 517690285Sobrien reload. */ 517790285Sobrien PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode, ad), insn), 517890285Sobrien QImode); 517952557Sobrien return mem; 518052557Sobrien } 518152557Sobrien } 518218334Speter } 518318334Speter return ad; 518418334Speter 518518334Speter case PLUS: 518618334Speter /* Quickly dispose of a common case. */ 518718334Speter if (XEXP (ad, 0) == frame_pointer_rtx 518818334Speter && GET_CODE (XEXP (ad, 1)) == CONST_INT) 518918334Speter return ad; 519050605Sobrien break; 519190285Sobrien 519250605Sobrien default: 519350605Sobrien break; 519418334Speter } 519518334Speter 519618334Speter fmt = GET_RTX_FORMAT (code); 519718334Speter for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 519818334Speter if (fmt[i] == 'e') 519952557Sobrien XEXP (ad, i) = subst_reg_equivs (XEXP (ad, i), insn); 520018334Speter return ad; 520118334Speter} 520218334Speter 520318334Speter/* Compute the sum of X and Y, making canonicalizations assumed in an 520418334Speter address, namely: sum constant integers, surround the sum of two 520518334Speter constants with a CONST, put the constant as the second operand, and 520618334Speter group the constant on the outermost sum. 520718334Speter 520818334Speter This routine assumes both inputs are already in canonical form. */ 520918334Speter 521018334Speterrtx 5211132727Skanform_sum (rtx x, rtx y) 521218334Speter{ 521318334Speter rtx tem; 521418334Speter enum machine_mode mode = GET_MODE (x); 521518334Speter 521618334Speter if (mode == VOIDmode) 521718334Speter mode = GET_MODE (y); 521818334Speter 521918334Speter if (mode == VOIDmode) 522018334Speter mode = Pmode; 522118334Speter 522218334Speter if (GET_CODE (x) == CONST_INT) 522318334Speter return plus_constant (y, INTVAL (x)); 522418334Speter else if (GET_CODE (y) == CONST_INT) 522518334Speter return plus_constant (x, INTVAL (y)); 522618334Speter else if (CONSTANT_P (x)) 522718334Speter tem = x, x = y, y = tem; 522818334Speter 522918334Speter if (GET_CODE (x) == PLUS && CONSTANT_P (XEXP (x, 1))) 523018334Speter return form_sum (XEXP (x, 0), form_sum (XEXP (x, 1), y)); 523118334Speter 523218334Speter /* Note that if the operands of Y are specified in the opposite 523318334Speter order in the recursive calls below, infinite recursion will occur. */ 523418334Speter if (GET_CODE (y) == PLUS && CONSTANT_P (XEXP (y, 1))) 523518334Speter return form_sum (form_sum (x, XEXP (y, 0)), XEXP (y, 1)); 523618334Speter 523718334Speter /* If both constant, encapsulate sum. Otherwise, just form sum. A 523818334Speter constant will have been placed second. */ 523918334Speter if (CONSTANT_P (x) && CONSTANT_P (y)) 524018334Speter { 524118334Speter if (GET_CODE (x) == CONST) 524218334Speter x = XEXP (x, 0); 524318334Speter if (GET_CODE (y) == CONST) 524418334Speter y = XEXP (y, 0); 524518334Speter 524650605Sobrien return gen_rtx_CONST (VOIDmode, gen_rtx_PLUS (mode, x, y)); 524718334Speter } 524818334Speter 524950605Sobrien return gen_rtx_PLUS (mode, x, y); 525018334Speter} 525118334Speter 525218334Speter/* If ADDR is a sum containing a pseudo register that should be 525318334Speter replaced with a constant (from reg_equiv_constant), 525418334Speter return the result of doing so, and also apply the associative 525518334Speter law so that the result is more likely to be a valid address. 525618334Speter (But it is not guaranteed to be one.) 525718334Speter 525818334Speter Note that at most one register is replaced, even if more are 525918334Speter replaceable. Also, we try to put the result into a canonical form 526018334Speter so it is more likely to be a valid address. 526118334Speter 526218334Speter In all other cases, return ADDR. */ 526318334Speter 526418334Speterstatic rtx 5265132727Skansubst_indexed_address (rtx addr) 526618334Speter{ 526718334Speter rtx op0 = 0, op1 = 0, op2 = 0; 526818334Speter rtx tem; 526918334Speter int regno; 527018334Speter 527118334Speter if (GET_CODE (addr) == PLUS) 527218334Speter { 527318334Speter /* Try to find a register to replace. */ 527418334Speter op0 = XEXP (addr, 0), op1 = XEXP (addr, 1), op2 = 0; 5275169699Skan if (REG_P (op0) 527618334Speter && (regno = REGNO (op0)) >= FIRST_PSEUDO_REGISTER 527718334Speter && reg_renumber[regno] < 0 527818334Speter && reg_equiv_constant[regno] != 0) 527918334Speter op0 = reg_equiv_constant[regno]; 5280169699Skan else if (REG_P (op1) 528190285Sobrien && (regno = REGNO (op1)) >= FIRST_PSEUDO_REGISTER 528290285Sobrien && reg_renumber[regno] < 0 528390285Sobrien && reg_equiv_constant[regno] != 0) 528418334Speter op1 = reg_equiv_constant[regno]; 528518334Speter else if (GET_CODE (op0) == PLUS 528618334Speter && (tem = subst_indexed_address (op0)) != op0) 528718334Speter op0 = tem; 528818334Speter else if (GET_CODE (op1) == PLUS 528918334Speter && (tem = subst_indexed_address (op1)) != op1) 529018334Speter op1 = tem; 529118334Speter else 529218334Speter return addr; 529318334Speter 529418334Speter /* Pick out up to three things to add. */ 529518334Speter if (GET_CODE (op1) == PLUS) 529618334Speter op2 = XEXP (op1, 1), op1 = XEXP (op1, 0); 529718334Speter else if (GET_CODE (op0) == PLUS) 529818334Speter op2 = op1, op1 = XEXP (op0, 1), op0 = XEXP (op0, 0); 529918334Speter 530018334Speter /* Compute the sum. */ 530118334Speter if (op2 != 0) 530218334Speter op1 = form_sum (op1, op2); 530318334Speter if (op1 != 0) 530418334Speter op0 = form_sum (op0, op1); 530518334Speter 530618334Speter return op0; 530718334Speter } 530818334Speter return addr; 530918334Speter} 531018334Speter 531190285Sobrien/* Update the REG_INC notes for an insn. It updates all REG_INC 531290285Sobrien notes for the instruction which refer to REGNO the to refer 531390285Sobrien to the reload number. 531490285Sobrien 531590285Sobrien INSN is the insn for which any REG_INC notes need updating. 531690285Sobrien 531790285Sobrien REGNO is the register number which has been reloaded. 531890285Sobrien 531990285Sobrien RELOADNUM is the reload number. */ 532090285Sobrien 532190285Sobrienstatic void 5322132727Skanupdate_auto_inc_notes (rtx insn ATTRIBUTE_UNUSED, int regno ATTRIBUTE_UNUSED, 5323132727Skan int reloadnum ATTRIBUTE_UNUSED) 532490285Sobrien{ 532590285Sobrien#ifdef AUTO_INC_DEC 532690285Sobrien rtx link; 532790285Sobrien 532890285Sobrien for (link = REG_NOTES (insn); link; link = XEXP (link, 1)) 532990285Sobrien if (REG_NOTE_KIND (link) == REG_INC 5330132727Skan && (int) REGNO (XEXP (link, 0)) == regno) 533190285Sobrien push_replacement (&XEXP (link, 0), reloadnum, VOIDmode); 533290285Sobrien#endif 533390285Sobrien} 533490285Sobrien 533550605Sobrien/* Record the pseudo registers we must reload into hard registers in a 533650605Sobrien subexpression of a would-be memory address, X referring to a value 533750605Sobrien in mode MODE. (This function is not called if the address we find 533850605Sobrien is strictly valid.) 533950605Sobrien 534018334Speter CONTEXT = 1 means we are considering regs as index regs, 534118334Speter = 0 means we are considering them as base regs. 5342169699Skan OUTER_CODE is the code of the enclosing RTX, typically a MEM, a PLUS, 5343169699Skan or an autoinc code. 5344169699Skan If CONTEXT == 0 and OUTER_CODE is a PLUS or LO_SUM, then INDEX_CODE 5345169699Skan is the code of the index part of the address. Otherwise, pass SCRATCH 5346169699Skan for this argument. 534718334Speter OPNUM and TYPE specify the purpose of any reloads made. 534818334Speter 534918334Speter IND_LEVELS says how many levels of indirect addressing are 535018334Speter supported at this point in the address. 535118334Speter 535250605Sobrien INSN, if nonzero, is the insn in which we do the reload. It is used 535350605Sobrien to determine if we may generate output reloads. 535450605Sobrien 535518334Speter We return nonzero if X, as a whole, is reloaded or replaced. */ 535618334Speter 535718334Speter/* Note that we take shortcuts assuming that no multi-reg machine mode 535818334Speter occurs as part of an address. 535918334Speter Also, this is not fully machine-customizable; it works for machines 536090285Sobrien such as VAXen and 68000's and 32000's, but other possible machines 5361169699Skan could have addressing modes that this does not handle right. 5362169699Skan If you add push_reload calls here, you need to make sure gen_reload 5363169699Skan handles those cases gracefully. */ 536418334Speter 536518334Speterstatic int 5366132727Skanfind_reloads_address_1 (enum machine_mode mode, rtx x, int context, 5367169699Skan enum rtx_code outer_code, enum rtx_code index_code, 5368132727Skan rtx *loc, int opnum, enum reload_type type, 5369132727Skan int ind_levels, rtx insn) 537018334Speter{ 5371169699Skan#define REG_OK_FOR_CONTEXT(CONTEXT, REGNO, MODE, OUTER, INDEX) \ 5372169699Skan ((CONTEXT) == 0 \ 5373169699Skan ? regno_ok_for_base_p (REGNO, MODE, OUTER, INDEX) \ 5374169699Skan : REGNO_OK_FOR_INDEX_P (REGNO)) 5375169699Skan 5376169699Skan enum reg_class context_reg_class; 537790285Sobrien RTX_CODE code = GET_CODE (x); 537818334Speter 5379169699Skan if (context == 1) 5380169699Skan context_reg_class = INDEX_REG_CLASS; 5381169699Skan else 5382169699Skan context_reg_class = base_reg_class (mode, outer_code, index_code); 5383169699Skan 538418334Speter switch (code) 538518334Speter { 538618334Speter case PLUS: 538718334Speter { 538890285Sobrien rtx orig_op0 = XEXP (x, 0); 538990285Sobrien rtx orig_op1 = XEXP (x, 1); 539090285Sobrien RTX_CODE code0 = GET_CODE (orig_op0); 539190285Sobrien RTX_CODE code1 = GET_CODE (orig_op1); 539290285Sobrien rtx op0 = orig_op0; 539390285Sobrien rtx op1 = orig_op1; 539418334Speter 539518334Speter if (GET_CODE (op0) == SUBREG) 539618334Speter { 539718334Speter op0 = SUBREG_REG (op0); 539818334Speter code0 = GET_CODE (op0); 539918334Speter if (code0 == REG && REGNO (op0) < FIRST_PSEUDO_REGISTER) 540050605Sobrien op0 = gen_rtx_REG (word_mode, 540190285Sobrien (REGNO (op0) + 540290285Sobrien subreg_regno_offset (REGNO (SUBREG_REG (orig_op0)), 540390285Sobrien GET_MODE (SUBREG_REG (orig_op0)), 540490285Sobrien SUBREG_BYTE (orig_op0), 540590285Sobrien GET_MODE (orig_op0)))); 540618334Speter } 540718334Speter 540818334Speter if (GET_CODE (op1) == SUBREG) 540918334Speter { 541018334Speter op1 = SUBREG_REG (op1); 541118334Speter code1 = GET_CODE (op1); 541218334Speter if (code1 == REG && REGNO (op1) < FIRST_PSEUDO_REGISTER) 541390285Sobrien /* ??? Why is this given op1's mode and above for 541490285Sobrien ??? op0 SUBREGs we use word_mode? */ 541550605Sobrien op1 = gen_rtx_REG (GET_MODE (op1), 541690285Sobrien (REGNO (op1) + 541790285Sobrien subreg_regno_offset (REGNO (SUBREG_REG (orig_op1)), 541890285Sobrien GET_MODE (SUBREG_REG (orig_op1)), 541990285Sobrien SUBREG_BYTE (orig_op1), 542090285Sobrien GET_MODE (orig_op1)))); 542118334Speter } 5422117404Skan /* Plus in the index register may be created only as a result of 5423169699Skan register rematerialization for expression like &localvar*4. Reload it. 5424117404Skan It may be possible to combine the displacement on the outer level, 5425117404Skan but it is probably not worthwhile to do so. */ 5426169699Skan if (context == 1) 5427117404Skan { 5428117404Skan find_reloads_address (GET_MODE (x), loc, XEXP (x, 0), &XEXP (x, 0), 5429117404Skan opnum, ADDR_TYPE (type), ind_levels, insn); 5430117404Skan push_reload (*loc, NULL_RTX, loc, (rtx*) 0, 5431169699Skan context_reg_class, 5432117404Skan GET_MODE (x), VOIDmode, 0, 0, opnum, type); 5433117404Skan return 1; 5434117404Skan } 543518334Speter 543690285Sobrien if (code0 == MULT || code0 == SIGN_EXTEND || code0 == TRUNCATE 543718334Speter || code0 == ZERO_EXTEND || code1 == MEM) 543818334Speter { 5439169699Skan find_reloads_address_1 (mode, orig_op0, 1, PLUS, SCRATCH, 5440169699Skan &XEXP (x, 0), opnum, type, ind_levels, 5441169699Skan insn); 5442169699Skan find_reloads_address_1 (mode, orig_op1, 0, PLUS, code0, 5443169699Skan &XEXP (x, 1), opnum, type, ind_levels, 5444169699Skan insn); 544518334Speter } 544618334Speter 544718334Speter else if (code1 == MULT || code1 == SIGN_EXTEND || code1 == TRUNCATE 544818334Speter || code1 == ZERO_EXTEND || code0 == MEM) 544918334Speter { 5450169699Skan find_reloads_address_1 (mode, orig_op0, 0, PLUS, code1, 5451169699Skan &XEXP (x, 0), opnum, type, ind_levels, 5452169699Skan insn); 5453169699Skan find_reloads_address_1 (mode, orig_op1, 1, PLUS, SCRATCH, 5454169699Skan &XEXP (x, 1), opnum, type, ind_levels, 5455169699Skan insn); 545618334Speter } 545718334Speter 545818334Speter else if (code0 == CONST_INT || code0 == CONST 545918334Speter || code0 == SYMBOL_REF || code0 == LABEL_REF) 5460169699Skan find_reloads_address_1 (mode, orig_op1, 0, PLUS, code0, 5461169699Skan &XEXP (x, 1), opnum, type, ind_levels, 5462169699Skan insn); 546318334Speter 546418334Speter else if (code1 == CONST_INT || code1 == CONST 546518334Speter || code1 == SYMBOL_REF || code1 == LABEL_REF) 5466169699Skan find_reloads_address_1 (mode, orig_op0, 0, PLUS, code1, 5467169699Skan &XEXP (x, 0), opnum, type, ind_levels, 5468169699Skan insn); 546918334Speter 547018334Speter else if (code0 == REG && code1 == REG) 547118334Speter { 5472169699Skan if (REGNO_OK_FOR_INDEX_P (REGNO (op0)) 5473169699Skan && regno_ok_for_base_p (REGNO (op1), mode, PLUS, REG)) 547418334Speter return 0; 5475169699Skan else if (REGNO_OK_FOR_INDEX_P (REGNO (op1)) 5476169699Skan && regno_ok_for_base_p (REGNO (op0), mode, PLUS, REG)) 547718334Speter return 0; 5478169699Skan else if (regno_ok_for_base_p (REGNO (op1), mode, PLUS, REG)) 5479169699Skan find_reloads_address_1 (mode, orig_op0, 1, PLUS, SCRATCH, 5480169699Skan &XEXP (x, 0), opnum, type, ind_levels, 5481169699Skan insn); 5482169699Skan else if (regno_ok_for_base_p (REGNO (op0), mode, PLUS, REG)) 5483169699Skan find_reloads_address_1 (mode, orig_op1, 1, PLUS, SCRATCH, 5484169699Skan &XEXP (x, 1), opnum, type, ind_levels, 5485169699Skan insn); 5486169699Skan else if (REGNO_OK_FOR_INDEX_P (REGNO (op1))) 5487169699Skan find_reloads_address_1 (mode, orig_op0, 0, PLUS, REG, 5488169699Skan &XEXP (x, 0), opnum, type, ind_levels, 5489169699Skan insn); 5490169699Skan else if (REGNO_OK_FOR_INDEX_P (REGNO (op0))) 5491169699Skan find_reloads_address_1 (mode, orig_op1, 0, PLUS, REG, 5492169699Skan &XEXP (x, 1), opnum, type, ind_levels, 5493169699Skan insn); 549418334Speter else 549518334Speter { 5496169699Skan find_reloads_address_1 (mode, orig_op0, 1, PLUS, SCRATCH, 5497169699Skan &XEXP (x, 0), opnum, type, ind_levels, 5498169699Skan insn); 5499169699Skan find_reloads_address_1 (mode, orig_op1, 0, PLUS, REG, 5500169699Skan &XEXP (x, 1), opnum, type, ind_levels, 5501169699Skan insn); 550218334Speter } 550318334Speter } 550418334Speter 550518334Speter else if (code0 == REG) 550618334Speter { 5507169699Skan find_reloads_address_1 (mode, orig_op0, 1, PLUS, SCRATCH, 5508169699Skan &XEXP (x, 0), opnum, type, ind_levels, 5509169699Skan insn); 5510169699Skan find_reloads_address_1 (mode, orig_op1, 0, PLUS, REG, 5511169699Skan &XEXP (x, 1), opnum, type, ind_levels, 5512169699Skan insn); 551318334Speter } 551418334Speter 551518334Speter else if (code1 == REG) 551618334Speter { 5517169699Skan find_reloads_address_1 (mode, orig_op1, 1, PLUS, SCRATCH, 5518169699Skan &XEXP (x, 1), opnum, type, ind_levels, 5519169699Skan insn); 5520169699Skan find_reloads_address_1 (mode, orig_op0, 0, PLUS, REG, 5521169699Skan &XEXP (x, 0), opnum, type, ind_levels, 5522169699Skan insn); 552318334Speter } 552418334Speter } 552518334Speter 552618334Speter return 0; 552718334Speter 552890285Sobrien case POST_MODIFY: 552990285Sobrien case PRE_MODIFY: 553090285Sobrien { 553190285Sobrien rtx op0 = XEXP (x, 0); 553290285Sobrien rtx op1 = XEXP (x, 1); 5533169699Skan enum rtx_code index_code; 5534169699Skan int regno; 5535169699Skan int reloadnum; 553690285Sobrien 553790285Sobrien if (GET_CODE (op1) != PLUS && GET_CODE (op1) != MINUS) 553890285Sobrien return 0; 553990285Sobrien 554090285Sobrien /* Currently, we only support {PRE,POST}_MODIFY constructs 554190285Sobrien where a base register is {inc,dec}remented by the contents 554290285Sobrien of another register or by a constant value. Thus, these 554390285Sobrien operands must match. */ 5544169699Skan gcc_assert (op0 == XEXP (op1, 0)); 554590285Sobrien 554690285Sobrien /* Require index register (or constant). Let's just handle the 554790285Sobrien register case in the meantime... If the target allows 554890285Sobrien auto-modify by a constant then we could try replacing a pseudo 5549169699Skan register with its equivalent constant where applicable. 5550169699Skan 5551169699Skan If we later decide to reload the whole PRE_MODIFY or 5552169699Skan POST_MODIFY, inc_for_reload might clobber the reload register 5553169699Skan before reading the index. The index register might therefore 5554169699Skan need to live longer than a TYPE reload normally would, so be 5555169699Skan conservative and class it as RELOAD_OTHER. */ 555690285Sobrien if (REG_P (XEXP (op1, 1))) 555790285Sobrien if (!REGNO_OK_FOR_INDEX_P (REGNO (XEXP (op1, 1)))) 5558169699Skan find_reloads_address_1 (mode, XEXP (op1, 1), 1, code, SCRATCH, 5559169699Skan &XEXP (op1, 1), opnum, RELOAD_OTHER, 5560169699Skan ind_levels, insn); 556190285Sobrien 5562169699Skan gcc_assert (REG_P (XEXP (op1, 0))); 556390285Sobrien 5564169699Skan regno = REGNO (XEXP (op1, 0)); 5565169699Skan index_code = GET_CODE (XEXP (op1, 1)); 556690285Sobrien 5567169699Skan /* A register that is incremented cannot be constant! */ 5568169699Skan gcc_assert (regno < FIRST_PSEUDO_REGISTER 5569169699Skan || reg_equiv_constant[regno] == 0); 557090285Sobrien 5571169699Skan /* Handle a register that is equivalent to a memory location 5572169699Skan which cannot be addressed directly. */ 5573169699Skan if (reg_equiv_memory_loc[regno] != 0 5574169699Skan && (reg_equiv_address[regno] != 0 5575169699Skan || num_not_at_initial_offset)) 5576169699Skan { 5577169699Skan rtx tem = make_memloc (XEXP (x, 0), regno); 557890285Sobrien 5579169699Skan if (reg_equiv_address[regno] 5580169699Skan || ! rtx_equal_p (tem, reg_equiv_mem[regno])) 5581169699Skan { 5582169699Skan rtx orig = tem; 558390285Sobrien 5584169699Skan /* First reload the memory location's address. 5585169699Skan We can't use ADDR_TYPE (type) here, because we need to 5586169699Skan write back the value after reading it, hence we actually 5587169699Skan need two registers. */ 5588169699Skan find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0), 5589169699Skan &XEXP (tem, 0), opnum, 5590169699Skan RELOAD_OTHER, 5591169699Skan ind_levels, insn); 559290285Sobrien 5593169699Skan if (tem != orig) 5594169699Skan push_reg_equiv_alt_mem (regno, tem); 559590285Sobrien 5596169699Skan /* Then reload the memory location into a base 5597169699Skan register. */ 5598169699Skan reloadnum = push_reload (tem, tem, &XEXP (x, 0), 5599169699Skan &XEXP (op1, 0), 5600169699Skan base_reg_class (mode, code, 5601169699Skan index_code), 5602169699Skan GET_MODE (x), GET_MODE (x), 0, 5603169699Skan 0, opnum, RELOAD_OTHER); 560490285Sobrien 560590285Sobrien update_auto_inc_notes (this_insn, regno, reloadnum); 560690285Sobrien return 0; 560790285Sobrien } 560890285Sobrien } 5609169699Skan 5610169699Skan if (reg_renumber[regno] >= 0) 5611169699Skan regno = reg_renumber[regno]; 5612169699Skan 5613169699Skan /* We require a base register here... */ 5614169699Skan if (!regno_ok_for_base_p (regno, GET_MODE (x), code, index_code)) 5615169699Skan { 5616169699Skan reloadnum = push_reload (XEXP (op1, 0), XEXP (x, 0), 5617169699Skan &XEXP (op1, 0), &XEXP (x, 0), 5618169699Skan base_reg_class (mode, code, index_code), 5619169699Skan GET_MODE (x), GET_MODE (x), 0, 0, 5620169699Skan opnum, RELOAD_OTHER); 5621169699Skan 5622169699Skan update_auto_inc_notes (this_insn, regno, reloadnum); 5623169699Skan return 0; 5624169699Skan } 562590285Sobrien } 562690285Sobrien return 0; 562790285Sobrien 562818334Speter case POST_INC: 562918334Speter case POST_DEC: 563018334Speter case PRE_INC: 563118334Speter case PRE_DEC: 5632169699Skan if (REG_P (XEXP (x, 0))) 563318334Speter { 563490285Sobrien int regno = REGNO (XEXP (x, 0)); 563518334Speter int value = 0; 563618334Speter rtx x_orig = x; 563718334Speter 563818334Speter /* A register that is incremented cannot be constant! */ 5639169699Skan gcc_assert (regno < FIRST_PSEUDO_REGISTER 5640169699Skan || reg_equiv_constant[regno] == 0); 564118334Speter 564218334Speter /* Handle a register that is equivalent to a memory location 564318334Speter which cannot be addressed directly. */ 564452557Sobrien if (reg_equiv_memory_loc[regno] != 0 564552557Sobrien && (reg_equiv_address[regno] != 0 || num_not_at_initial_offset)) 564618334Speter { 564718334Speter rtx tem = make_memloc (XEXP (x, 0), regno); 564852557Sobrien if (reg_equiv_address[regno] 564952557Sobrien || ! rtx_equal_p (tem, reg_equiv_mem[regno])) 565052557Sobrien { 5651169699Skan rtx orig = tem; 5652169699Skan 565352557Sobrien /* First reload the memory location's address. 565452557Sobrien We can't use ADDR_TYPE (type) here, because we need to 565552557Sobrien write back the value after reading it, hence we actually 565652557Sobrien need two registers. */ 565752557Sobrien find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0), 565852557Sobrien &XEXP (tem, 0), opnum, type, 565952557Sobrien ind_levels, insn); 5660169699Skan if (tem != orig) 5661169699Skan push_reg_equiv_alt_mem (regno, tem); 566252557Sobrien /* Put this inside a new increment-expression. */ 566352557Sobrien x = gen_rtx_fmt_e (GET_CODE (x), GET_MODE (x), tem); 566452557Sobrien /* Proceed to reload that, as if it contained a register. */ 566552557Sobrien } 566618334Speter } 566718334Speter 566818334Speter /* If we have a hard register that is ok as an index, 566918334Speter don't make a reload. If an autoincrement of a nice register 567018334Speter isn't "valid", it must be that no autoincrement is "valid". 567118334Speter If that is true and something made an autoincrement anyway, 567218334Speter this must be a special context where one is allowed. 567318334Speter (For example, a "push" instruction.) 567418334Speter We can't improve this address, so leave it alone. */ 567518334Speter 567618334Speter /* Otherwise, reload the autoincrement into a suitable hard reg 567718334Speter and record how much to increment by. */ 567818334Speter 567918334Speter if (reg_renumber[regno] >= 0) 568018334Speter regno = reg_renumber[regno]; 5681169699Skan if (regno >= FIRST_PSEUDO_REGISTER 5682169699Skan || !REG_OK_FOR_CONTEXT (context, regno, mode, outer_code, 5683169699Skan index_code)) 568418334Speter { 568550605Sobrien int reloadnum; 568618334Speter 568750605Sobrien /* If we can output the register afterwards, do so, this 568850605Sobrien saves the extra update. 568950605Sobrien We can do so if we have an INSN - i.e. no JUMP_INSN nor 569050605Sobrien CALL_INSN - and it does not set CC0. 569150605Sobrien But don't do this if we cannot directly address the 569250605Sobrien memory location, since this will make it harder to 569350605Sobrien reuse address reloads, and increases register pressure. 569450605Sobrien Also don't do this if we can probably update x directly. */ 5695169699Skan rtx equiv = (MEM_P (XEXP (x, 0)) 569652557Sobrien ? XEXP (x, 0) 569752557Sobrien : reg_equiv_mem[regno]); 569850605Sobrien int icode = (int) add_optab->handlers[(int) Pmode].insn_code; 5699169699Skan if (insn && NONJUMP_INSN_P (insn) && equiv 570052557Sobrien && memory_operand (equiv, GET_MODE (equiv)) 570150605Sobrien#ifdef HAVE_cc0 570250605Sobrien && ! sets_cc0_p (PATTERN (insn)) 570350605Sobrien#endif 570450605Sobrien && ! (icode != CODE_FOR_nothing 570590285Sobrien && ((*insn_data[icode].operand[0].predicate) 570690285Sobrien (equiv, Pmode)) 570790285Sobrien && ((*insn_data[icode].operand[1].predicate) 570890285Sobrien (equiv, Pmode)))) 570950605Sobrien { 571070639Sobrien /* We use the original pseudo for loc, so that 571170639Sobrien emit_reload_insns() knows which pseudo this 571270639Sobrien reload refers to and updates the pseudo rtx, not 571370639Sobrien its equivalent memory location, as well as the 571470639Sobrien corresponding entry in reg_last_reload_reg. */ 571570639Sobrien loc = &XEXP (x_orig, 0); 571650605Sobrien x = XEXP (x, 0); 571750605Sobrien reloadnum 571850605Sobrien = push_reload (x, x, loc, loc, 5719169699Skan context_reg_class, 572090285Sobrien GET_MODE (x), GET_MODE (x), 0, 0, 572190285Sobrien opnum, RELOAD_OTHER); 572250605Sobrien } 572350605Sobrien else 572450605Sobrien { 572550605Sobrien reloadnum 572690285Sobrien = push_reload (x, NULL_RTX, loc, (rtx*) 0, 5727169699Skan context_reg_class, 572850605Sobrien GET_MODE (x), GET_MODE (x), 0, 0, 572950605Sobrien opnum, type); 573090285Sobrien rld[reloadnum].inc 573150605Sobrien = find_inc_amount (PATTERN (this_insn), XEXP (x_orig, 0)); 573290285Sobrien 573350605Sobrien value = 1; 573450605Sobrien } 573518334Speter 573690285Sobrien update_auto_inc_notes (this_insn, REGNO (XEXP (x_orig, 0)), 573790285Sobrien reloadnum); 573818334Speter } 573918334Speter return value; 574018334Speter } 574118334Speter 5742169699Skan else if (MEM_P (XEXP (x, 0))) 574318334Speter { 574418334Speter /* This is probably the result of a substitution, by eliminate_regs, 574518334Speter of an equivalent address for a pseudo that was not allocated to a 574618334Speter hard register. Verify that the specified address is valid and 574718334Speter reload it into a register. */ 574890285Sobrien /* Variable `tem' might or might not be used in FIND_REG_INC_NOTE. */ 574952557Sobrien rtx tem ATTRIBUTE_UNUSED = XEXP (x, 0); 575090285Sobrien rtx link; 575118334Speter int reloadnum; 575218334Speter 575318334Speter /* Since we know we are going to reload this item, don't decrement 575418334Speter for the indirection level. 575518334Speter 575618334Speter Note that this is actually conservative: it would be slightly 575718334Speter more efficient to use the value of SPILL_INDIRECT_LEVELS from 575818334Speter reload1.c here. */ 575950605Sobrien /* We can't use ADDR_TYPE (type) here, because we need to 576050605Sobrien write back the value after reading it, hence we actually 576150605Sobrien need two registers. */ 576218334Speter find_reloads_address (GET_MODE (x), &XEXP (x, 0), 576318334Speter XEXP (XEXP (x, 0), 0), &XEXP (XEXP (x, 0), 0), 576450605Sobrien opnum, type, ind_levels, insn); 576518334Speter 576690285Sobrien reloadnum = push_reload (x, NULL_RTX, loc, (rtx*) 0, 5767169699Skan context_reg_class, 576818334Speter GET_MODE (x), VOIDmode, 0, 0, opnum, type); 576990285Sobrien rld[reloadnum].inc 577018334Speter = find_inc_amount (PATTERN (this_insn), XEXP (x, 0)); 577118334Speter 577218334Speter link = FIND_REG_INC_NOTE (this_insn, tem); 577318334Speter if (link != 0) 577418334Speter push_replacement (&XEXP (link, 0), reloadnum, VOIDmode); 577518334Speter 577618334Speter return 1; 577718334Speter } 577818334Speter return 0; 577918334Speter 5780169699Skan case TRUNCATE: 5781169699Skan case SIGN_EXTEND: 5782169699Skan case ZERO_EXTEND: 5783169699Skan /* Look for parts to reload in the inner expression and reload them 5784169699Skan too, in addition to this operation. Reloading all inner parts in 5785169699Skan addition to this one shouldn't be necessary, but at this point, 5786169699Skan we don't know if we can possibly omit any part that *can* be 5787169699Skan reloaded. Targets that are better off reloading just either part 5788169699Skan (or perhaps even a different part of an outer expression), should 5789169699Skan define LEGITIMIZE_RELOAD_ADDRESS. */ 5790169699Skan find_reloads_address_1 (GET_MODE (XEXP (x, 0)), XEXP (x, 0), 5791169699Skan context, code, SCRATCH, &XEXP (x, 0), opnum, 5792169699Skan type, ind_levels, insn); 5793169699Skan push_reload (x, NULL_RTX, loc, (rtx*) 0, 5794169699Skan context_reg_class, 5795169699Skan GET_MODE (x), VOIDmode, 0, 0, opnum, type); 5796169699Skan return 1; 5797169699Skan 579818334Speter case MEM: 579918334Speter /* This is probably the result of a substitution, by eliminate_regs, of 580018334Speter an equivalent address for a pseudo that was not allocated to a hard 580118334Speter register. Verify that the specified address is valid and reload it 580218334Speter into a register. 580318334Speter 580418334Speter Since we know we are going to reload this item, don't decrement for 580518334Speter the indirection level. 580618334Speter 580718334Speter Note that this is actually conservative: it would be slightly more 580818334Speter efficient to use the value of SPILL_INDIRECT_LEVELS from 580918334Speter reload1.c here. */ 581018334Speter 581118334Speter find_reloads_address (GET_MODE (x), loc, XEXP (x, 0), &XEXP (x, 0), 581250605Sobrien opnum, ADDR_TYPE (type), ind_levels, insn); 581390285Sobrien push_reload (*loc, NULL_RTX, loc, (rtx*) 0, 5814169699Skan context_reg_class, 581518334Speter GET_MODE (x), VOIDmode, 0, 0, opnum, type); 581618334Speter return 1; 581718334Speter 581818334Speter case REG: 581918334Speter { 582090285Sobrien int regno = REGNO (x); 582118334Speter 582218334Speter if (reg_equiv_constant[regno] != 0) 582318334Speter { 582452557Sobrien find_reloads_address_part (reg_equiv_constant[regno], loc, 5825169699Skan context_reg_class, 582618334Speter GET_MODE (x), opnum, type, ind_levels); 582718334Speter return 1; 582818334Speter } 582918334Speter 583018334Speter#if 0 /* This might screw code in reload1.c to delete prior output-reload 583118334Speter that feeds this insn. */ 583218334Speter if (reg_equiv_mem[regno] != 0) 583318334Speter { 583490285Sobrien push_reload (reg_equiv_mem[regno], NULL_RTX, loc, (rtx*) 0, 5835169699Skan context_reg_class, 583618334Speter GET_MODE (x), VOIDmode, 0, 0, opnum, type); 583718334Speter return 1; 583818334Speter } 583918334Speter#endif 584018334Speter 584152557Sobrien if (reg_equiv_memory_loc[regno] 584252557Sobrien && (reg_equiv_address[regno] != 0 || num_not_at_initial_offset)) 584318334Speter { 584452557Sobrien rtx tem = make_memloc (x, regno); 584552557Sobrien if (reg_equiv_address[regno] != 0 584652557Sobrien || ! rtx_equal_p (tem, reg_equiv_mem[regno])) 584752557Sobrien { 584852557Sobrien x = tem; 584952557Sobrien find_reloads_address (GET_MODE (x), &x, XEXP (x, 0), 585052557Sobrien &XEXP (x, 0), opnum, ADDR_TYPE (type), 585152557Sobrien ind_levels, insn); 5852169699Skan if (x != tem) 5853169699Skan push_reg_equiv_alt_mem (regno, x); 585452557Sobrien } 585518334Speter } 585618334Speter 585718334Speter if (reg_renumber[regno] >= 0) 585818334Speter regno = reg_renumber[regno]; 585918334Speter 5860169699Skan if (regno >= FIRST_PSEUDO_REGISTER 5861169699Skan || !REG_OK_FOR_CONTEXT (context, regno, mode, outer_code, 5862169699Skan index_code)) 586318334Speter { 586490285Sobrien push_reload (x, NULL_RTX, loc, (rtx*) 0, 5865169699Skan context_reg_class, 586618334Speter GET_MODE (x), VOIDmode, 0, 0, opnum, type); 586718334Speter return 1; 586818334Speter } 586918334Speter 587018334Speter /* If a register appearing in an address is the subject of a CLOBBER 587118334Speter in this insn, reload it into some other register to be safe. 587218334Speter The CLOBBER is supposed to make the register unavailable 587318334Speter from before this insn to after it. */ 587470639Sobrien if (regno_clobbered_p (regno, this_insn, GET_MODE (x), 0)) 587518334Speter { 587690285Sobrien push_reload (x, NULL_RTX, loc, (rtx*) 0, 5877169699Skan context_reg_class, 587818334Speter GET_MODE (x), VOIDmode, 0, 0, opnum, type); 587918334Speter return 1; 588018334Speter } 588118334Speter } 588218334Speter return 0; 588318334Speter 588418334Speter case SUBREG: 5885169699Skan if (REG_P (SUBREG_REG (x))) 588618334Speter { 588718334Speter /* If this is a SUBREG of a hard register and the resulting register 588818334Speter is of the wrong class, reload the whole SUBREG. This avoids 588918334Speter needless copies if SUBREG_REG is multi-word. */ 589018334Speter if (REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER) 589118334Speter { 5892132727Skan int regno ATTRIBUTE_UNUSED = subreg_regno (x); 589318334Speter 5894169699Skan if (!REG_OK_FOR_CONTEXT (context, regno, mode, outer_code, 5895169699Skan index_code)) 589618334Speter { 589790285Sobrien push_reload (x, NULL_RTX, loc, (rtx*) 0, 5898169699Skan context_reg_class, 589918334Speter GET_MODE (x), VOIDmode, 0, 0, opnum, type); 590018334Speter return 1; 590118334Speter } 590218334Speter } 590318334Speter /* If this is a SUBREG of a pseudo-register, and the pseudo-register 590418334Speter is larger than the class size, then reload the whole SUBREG. */ 590518334Speter else 590618334Speter { 5907169699Skan enum reg_class class = context_reg_class; 5908117404Skan if ((unsigned) CLASS_MAX_NREGS (class, GET_MODE (SUBREG_REG (x))) 590918334Speter > reg_class_size[class]) 591018334Speter { 5911169699Skan x = find_reloads_subreg_address (x, 0, opnum, 5912169699Skan ADDR_TYPE (type), 591352557Sobrien ind_levels, insn); 591490285Sobrien push_reload (x, NULL_RTX, loc, (rtx*) 0, class, 591518334Speter GET_MODE (x), VOIDmode, 0, 0, opnum, type); 591618334Speter return 1; 591718334Speter } 591818334Speter } 591918334Speter } 592018334Speter break; 592190285Sobrien 592250605Sobrien default: 592350605Sobrien break; 592418334Speter } 592518334Speter 592618334Speter { 592790285Sobrien const char *fmt = GET_RTX_FORMAT (code); 592890285Sobrien int i; 592918334Speter 593018334Speter for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 593118334Speter { 593218334Speter if (fmt[i] == 'e') 5933169699Skan /* Pass SCRATCH for INDEX_CODE, since CODE can never be a PLUS once 5934169699Skan we get here. */ 5935169699Skan find_reloads_address_1 (mode, XEXP (x, i), context, code, SCRATCH, 5936169699Skan &XEXP (x, i), opnum, type, ind_levels, insn); 593718334Speter } 593818334Speter } 593918334Speter 5940169699Skan#undef REG_OK_FOR_CONTEXT 594118334Speter return 0; 594218334Speter} 594318334Speter 594418334Speter/* X, which is found at *LOC, is a part of an address that needs to be 594518334Speter reloaded into a register of class CLASS. If X is a constant, or if 594618334Speter X is a PLUS that contains a constant, check that the constant is a 594718334Speter legitimate operand and that we are supposed to be able to load 594818334Speter it into the register. 594918334Speter 595018334Speter If not, force the constant into memory and reload the MEM instead. 595118334Speter 595218334Speter MODE is the mode to use, in case X is an integer constant. 595318334Speter 595418334Speter OPNUM and TYPE describe the purpose of any reloads made. 595518334Speter 595618334Speter IND_LEVELS says how many levels of indirect addressing this machine 595718334Speter supports. */ 595818334Speter 595918334Speterstatic void 5960132727Skanfind_reloads_address_part (rtx x, rtx *loc, enum reg_class class, 5961132727Skan enum machine_mode mode, int opnum, 5962132727Skan enum reload_type type, int ind_levels) 596318334Speter{ 596418334Speter if (CONSTANT_P (x) 596518334Speter && (! LEGITIMATE_CONSTANT_P (x) 596618334Speter || PREFERRED_RELOAD_CLASS (x, class) == NO_REGS)) 596718334Speter { 596852557Sobrien rtx tem; 596952557Sobrien 597090285Sobrien tem = x = force_const_mem (mode, x); 597118334Speter find_reloads_address (mode, &tem, XEXP (tem, 0), &XEXP (tem, 0), 597250605Sobrien opnum, type, ind_levels, 0); 597318334Speter } 597418334Speter 597518334Speter else if (GET_CODE (x) == PLUS 597618334Speter && CONSTANT_P (XEXP (x, 1)) 597718334Speter && (! LEGITIMATE_CONSTANT_P (XEXP (x, 1)) 597818334Speter || PREFERRED_RELOAD_CLASS (XEXP (x, 1), class) == NO_REGS)) 597918334Speter { 598052557Sobrien rtx tem; 598118334Speter 598290285Sobrien tem = force_const_mem (GET_MODE (x), XEXP (x, 1)); 598350605Sobrien x = gen_rtx_PLUS (GET_MODE (x), XEXP (x, 0), tem); 598418334Speter find_reloads_address (mode, &tem, XEXP (tem, 0), &XEXP (tem, 0), 598550605Sobrien opnum, type, ind_levels, 0); 598618334Speter } 598718334Speter 598890285Sobrien push_reload (x, NULL_RTX, loc, (rtx*) 0, class, 598918334Speter mode, VOIDmode, 0, 0, opnum, type); 599018334Speter} 599118334Speter 599252557Sobrien/* X, a subreg of a pseudo, is a part of an address that needs to be 599352557Sobrien reloaded. 599452557Sobrien 599552557Sobrien If the pseudo is equivalent to a memory location that cannot be directly 599652557Sobrien addressed, make the necessary address reloads. 599752557Sobrien 599852557Sobrien If address reloads have been necessary, or if the address is changed 599952557Sobrien by register elimination, return the rtx of the memory location; 600052557Sobrien otherwise, return X. 600152557Sobrien 600252557Sobrien If FORCE_REPLACE is nonzero, unconditionally replace the subreg with the 600352557Sobrien memory location. 600452557Sobrien 600552557Sobrien OPNUM and TYPE identify the purpose of the reload. 600652557Sobrien 600752557Sobrien IND_LEVELS says how many levels of indirect addressing are 600852557Sobrien supported at this point in the address. 600952557Sobrien 601052557Sobrien INSN, if nonzero, is the insn in which we do the reload. It is used 601152557Sobrien to determine where to put USEs for pseudos that we have to replace with 601252557Sobrien stack slots. */ 601352557Sobrien 601452557Sobrienstatic rtx 6015132727Skanfind_reloads_subreg_address (rtx x, int force_replace, int opnum, 6016132727Skan enum reload_type type, int ind_levels, rtx insn) 601752557Sobrien{ 601852557Sobrien int regno = REGNO (SUBREG_REG (x)); 601952557Sobrien 602052557Sobrien if (reg_equiv_memory_loc[regno]) 602152557Sobrien { 602252557Sobrien /* If the address is not directly addressable, or if the address is not 602352557Sobrien offsettable, then it must be replaced. */ 602452557Sobrien if (! force_replace 602552557Sobrien && (reg_equiv_address[regno] 602652557Sobrien || ! offsettable_memref_p (reg_equiv_mem[regno]))) 602752557Sobrien force_replace = 1; 602852557Sobrien 602952557Sobrien if (force_replace || num_not_at_initial_offset) 603052557Sobrien { 603152557Sobrien rtx tem = make_memloc (SUBREG_REG (x), regno); 603252557Sobrien 603352557Sobrien /* If the address changes because of register elimination, then 603452557Sobrien it must be replaced. */ 603552557Sobrien if (force_replace 603652557Sobrien || ! rtx_equal_p (tem, reg_equiv_mem[regno])) 603752557Sobrien { 603890285Sobrien unsigned outer_size = GET_MODE_SIZE (GET_MODE (x)); 603990285Sobrien unsigned inner_size = GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))); 6040132727Skan int offset; 6041169699Skan rtx orig = tem; 6042169699Skan enum machine_mode orig_mode = GET_MODE (orig); 6043169699Skan int reloaded; 604452557Sobrien 6045132727Skan /* For big-endian paradoxical subregs, SUBREG_BYTE does not 6046132727Skan hold the correct (negative) byte offset. */ 6047132727Skan if (BYTES_BIG_ENDIAN && outer_size > inner_size) 6048132727Skan offset = inner_size - outer_size; 6049132727Skan else 6050132727Skan offset = SUBREG_BYTE (x); 6051132727Skan 605290285Sobrien XEXP (tem, 0) = plus_constant (XEXP (tem, 0), offset); 605390285Sobrien PUT_MODE (tem, GET_MODE (x)); 605490285Sobrien 605590285Sobrien /* If this was a paradoxical subreg that we replaced, the 605690285Sobrien resulting memory must be sufficiently aligned to allow 605790285Sobrien us to widen the mode of the memory. */ 6058169699Skan if (outer_size > inner_size) 605952557Sobrien { 606090285Sobrien rtx base; 606152557Sobrien 606290285Sobrien base = XEXP (tem, 0); 606390285Sobrien if (GET_CODE (base) == PLUS) 606490285Sobrien { 606590285Sobrien if (GET_CODE (XEXP (base, 1)) == CONST_INT 606690285Sobrien && INTVAL (XEXP (base, 1)) % outer_size != 0) 606790285Sobrien return x; 606890285Sobrien base = XEXP (base, 0); 606990285Sobrien } 6070169699Skan if (!REG_P (base) 607190285Sobrien || (REGNO_POINTER_ALIGN (REGNO (base)) 607290285Sobrien < outer_size * BITS_PER_UNIT)) 607390285Sobrien return x; 607452557Sobrien } 607590285Sobrien 6076169699Skan reloaded = find_reloads_address (GET_MODE (tem), &tem, 6077169699Skan XEXP (tem, 0), &XEXP (tem, 0), 6078169699Skan opnum, type, ind_levels, insn); 6079169699Skan /* ??? Do we need to handle nonzero offsets somehow? */ 6080169699Skan if (!offset && tem != orig) 6081169699Skan push_reg_equiv_alt_mem (regno, tem); 608290285Sobrien 6083169699Skan /* For some processors an address may be valid in the 6084169699Skan original mode but not in a smaller mode. For 6085169699Skan example, ARM accepts a scaled index register in 6086169699Skan SImode but not in HImode. find_reloads_address 6087169699Skan assumes that we pass it a valid address, and doesn't 6088169699Skan force a reload. This will probably be fine if 6089169699Skan find_reloads_address finds some reloads. But if it 6090169699Skan doesn't find any, then we may have just converted a 6091169699Skan valid address into an invalid one. Check for that 6092169699Skan here. */ 6093169699Skan if (reloaded != 1 6094169699Skan && strict_memory_address_p (orig_mode, XEXP (tem, 0)) 6095169699Skan && !strict_memory_address_p (GET_MODE (tem), 6096169699Skan XEXP (tem, 0))) 6097169699Skan push_reload (XEXP (tem, 0), NULL_RTX, &XEXP (tem, 0), (rtx*) 0, 6098169699Skan base_reg_class (GET_MODE (tem), MEM, SCRATCH), 6099169699Skan GET_MODE (XEXP (tem, 0)), VOIDmode, 0, 0, 6100169699Skan opnum, type); 6101169699Skan 610252557Sobrien /* If this is not a toplevel operand, find_reloads doesn't see 610352557Sobrien this substitution. We have to emit a USE of the pseudo so 610452557Sobrien that delete_output_reload can see it. */ 610590285Sobrien if (replace_reloads && recog_data.operand[opnum] != x) 610690285Sobrien /* We mark the USE with QImode so that we recognize it 610790285Sobrien as one that can be safely deleted at the end of 610890285Sobrien reload. */ 610990285Sobrien PUT_MODE (emit_insn_before (gen_rtx_USE (VOIDmode, 611090285Sobrien SUBREG_REG (x)), 611190285Sobrien insn), QImode); 611252557Sobrien x = tem; 611352557Sobrien } 611452557Sobrien } 611552557Sobrien } 611652557Sobrien return x; 611752557Sobrien} 611852557Sobrien 611918334Speter/* Substitute into the current INSN the registers into which we have reloaded 612018334Speter the things that need reloading. The array `replacements' 612190285Sobrien contains the locations of all pointers that must be changed 612218334Speter and says what to replace them with. 612318334Speter 612418334Speter Return the rtx that X translates into; usually X, but modified. */ 612518334Speter 612618334Spetervoid 6127132727Skansubst_reloads (rtx insn) 612818334Speter{ 612990285Sobrien int i; 613018334Speter 613118334Speter for (i = 0; i < n_replacements; i++) 613218334Speter { 613390285Sobrien struct replacement *r = &replacements[i]; 613490285Sobrien rtx reloadreg = rld[r->what].reg_rtx; 613518334Speter if (reloadreg) 613618334Speter { 613790285Sobrien#ifdef ENABLE_CHECKING 613890285Sobrien /* Internal consistency test. Check that we don't modify 613990285Sobrien anything in the equivalence arrays. Whenever something from 614090285Sobrien those arrays needs to be reloaded, it must be unshared before 614190285Sobrien being substituted into; the equivalence must not be modified. 614290285Sobrien Otherwise, if the equivalence is used after that, it will 614390285Sobrien have been modified, and the thing substituted (probably a 614490285Sobrien register) is likely overwritten and not a usable equivalence. */ 614590285Sobrien int check_regno; 614690285Sobrien 614790285Sobrien for (check_regno = 0; check_regno < max_regno; check_regno++) 614890285Sobrien { 614990285Sobrien#define CHECK_MODF(ARRAY) \ 6150169699Skan gcc_assert (!ARRAY[check_regno] \ 6151169699Skan || !loc_mentioned_in_p (r->where, \ 6152169699Skan ARRAY[check_regno])) 615390285Sobrien 615490285Sobrien CHECK_MODF (reg_equiv_constant); 615590285Sobrien CHECK_MODF (reg_equiv_memory_loc); 615690285Sobrien CHECK_MODF (reg_equiv_address); 615790285Sobrien CHECK_MODF (reg_equiv_mem); 615890285Sobrien#undef CHECK_MODF 615990285Sobrien } 616090285Sobrien#endif /* ENABLE_CHECKING */ 616190285Sobrien 616290285Sobrien /* If we're replacing a LABEL_REF with a register, add a 616390285Sobrien REG_LABEL note to indicate to flow which label this 616490285Sobrien register refers to. */ 616590285Sobrien if (GET_CODE (*r->where) == LABEL_REF 6166169699Skan && JUMP_P (insn)) 6167169699Skan { 6168169699Skan REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_LABEL, 6169169699Skan XEXP (*r->where, 0), 6170169699Skan REG_NOTES (insn)); 6171169699Skan JUMP_LABEL (insn) = XEXP (*r->where, 0); 6172169699Skan } 617390285Sobrien 617418334Speter /* Encapsulate RELOADREG so its machine mode matches what 617518334Speter used to be there. Note that gen_lowpart_common will 617618334Speter do the wrong thing if RELOADREG is multi-word. RELOADREG 617718334Speter will always be a REG here. */ 617818334Speter if (GET_MODE (reloadreg) != r->mode && r->mode != VOIDmode) 6179132727Skan reloadreg = reload_adjust_reg_for_mode (reloadreg, r->mode); 618018334Speter 618118334Speter /* If we are putting this into a SUBREG and RELOADREG is a 618218334Speter SUBREG, we would be making nested SUBREGs, so we have to fix 618318334Speter this up. Note that r->where == &SUBREG_REG (*r->subreg_loc). */ 618418334Speter 618518334Speter if (r->subreg_loc != 0 && GET_CODE (reloadreg) == SUBREG) 618618334Speter { 618718334Speter if (GET_MODE (*r->subreg_loc) 618818334Speter == GET_MODE (SUBREG_REG (reloadreg))) 618918334Speter *r->subreg_loc = SUBREG_REG (reloadreg); 619018334Speter else 619118334Speter { 619290285Sobrien int final_offset = 619390285Sobrien SUBREG_BYTE (*r->subreg_loc) + SUBREG_BYTE (reloadreg); 619490285Sobrien 619590285Sobrien /* When working with SUBREGs the rule is that the byte 619690285Sobrien offset must be a multiple of the SUBREG's mode. */ 619790285Sobrien final_offset = (final_offset / 619890285Sobrien GET_MODE_SIZE (GET_MODE (*r->subreg_loc))); 619990285Sobrien final_offset = (final_offset * 620090285Sobrien GET_MODE_SIZE (GET_MODE (*r->subreg_loc))); 620190285Sobrien 620218334Speter *r->where = SUBREG_REG (reloadreg); 620390285Sobrien SUBREG_BYTE (*r->subreg_loc) = final_offset; 620418334Speter } 620518334Speter } 620618334Speter else 620718334Speter *r->where = reloadreg; 620818334Speter } 620918334Speter /* If reload got no reg and isn't optional, something's wrong. */ 6210169699Skan else 6211169699Skan gcc_assert (rld[r->what].optional); 621218334Speter } 621318334Speter} 621418334Speter 621596288Sobrien/* Make a copy of any replacements being done into X and move those 621696288Sobrien copies to locations in Y, a copy of X. */ 621718334Speter 621818334Spetervoid 6219132727Skancopy_replacements (rtx x, rtx y) 622018334Speter{ 622118334Speter /* We can't support X being a SUBREG because we might then need to know its 622218334Speter location if something inside it was replaced. */ 6223169699Skan gcc_assert (GET_CODE (x) != SUBREG); 622418334Speter 622596288Sobrien copy_replacements_1 (&x, &y, n_replacements); 622696288Sobrien} 622796288Sobrien 622896288Sobrienstatic void 6229132727Skancopy_replacements_1 (rtx *px, rtx *py, int orig_replacements) 623096288Sobrien{ 623196288Sobrien int i, j; 623296288Sobrien rtx x, y; 623396288Sobrien struct replacement *r; 623496288Sobrien enum rtx_code code; 623596288Sobrien const char *fmt; 623696288Sobrien 623796288Sobrien for (j = 0; j < orig_replacements; j++) 623896288Sobrien { 623996288Sobrien if (replacements[j].subreg_loc == px) 624018334Speter { 624196288Sobrien r = &replacements[n_replacements++]; 624296288Sobrien r->where = replacements[j].where; 624396288Sobrien r->subreg_loc = py; 624496288Sobrien r->what = replacements[j].what; 624596288Sobrien r->mode = replacements[j].mode; 624618334Speter } 624796288Sobrien else if (replacements[j].where == px) 624896288Sobrien { 624996288Sobrien r = &replacements[n_replacements++]; 625096288Sobrien r->where = py; 625196288Sobrien r->subreg_loc = 0; 625296288Sobrien r->what = replacements[j].what; 625396288Sobrien r->mode = replacements[j].mode; 625496288Sobrien } 625596288Sobrien } 625696288Sobrien 625796288Sobrien x = *px; 625896288Sobrien y = *py; 625996288Sobrien code = GET_CODE (x); 626096288Sobrien fmt = GET_RTX_FORMAT (code); 626196288Sobrien 626296288Sobrien for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 626396288Sobrien { 626496288Sobrien if (fmt[i] == 'e') 626596288Sobrien copy_replacements_1 (&XEXP (x, i), &XEXP (y, i), orig_replacements); 626696288Sobrien else if (fmt[i] == 'E') 626796288Sobrien for (j = XVECLEN (x, i); --j >= 0; ) 626896288Sobrien copy_replacements_1 (&XVECEXP (x, i, j), &XVECEXP (y, i, j), 626996288Sobrien orig_replacements); 627096288Sobrien } 627118334Speter} 627250605Sobrien 6273117404Skan/* Change any replacements being done to *X to be done to *Y. */ 627450605Sobrien 627550605Sobrienvoid 6276132727Skanmove_replacements (rtx *x, rtx *y) 627750605Sobrien{ 627850605Sobrien int i; 627950605Sobrien 628050605Sobrien for (i = 0; i < n_replacements; i++) 628150605Sobrien if (replacements[i].subreg_loc == x) 628250605Sobrien replacements[i].subreg_loc = y; 628350605Sobrien else if (replacements[i].where == x) 628450605Sobrien { 628550605Sobrien replacements[i].where = y; 628650605Sobrien replacements[i].subreg_loc = 0; 628750605Sobrien } 628850605Sobrien} 628918334Speter 629018334Speter/* If LOC was scheduled to be replaced by something, return the replacement. 629118334Speter Otherwise, return *LOC. */ 629218334Speter 629318334Speterrtx 6294132727Skanfind_replacement (rtx *loc) 629518334Speter{ 629618334Speter struct replacement *r; 629718334Speter 629818334Speter for (r = &replacements[0]; r < &replacements[n_replacements]; r++) 629918334Speter { 630090285Sobrien rtx reloadreg = rld[r->what].reg_rtx; 630118334Speter 630218334Speter if (reloadreg && r->where == loc) 630318334Speter { 630418334Speter if (r->mode != VOIDmode && GET_MODE (reloadreg) != r->mode) 630550605Sobrien reloadreg = gen_rtx_REG (r->mode, REGNO (reloadreg)); 630618334Speter 630718334Speter return reloadreg; 630818334Speter } 630918334Speter else if (reloadreg && r->subreg_loc == loc) 631018334Speter { 631118334Speter /* RELOADREG must be either a REG or a SUBREG. 631218334Speter 631318334Speter ??? Is it actually still ever a SUBREG? If so, why? */ 631418334Speter 6315169699Skan if (REG_P (reloadreg)) 631650605Sobrien return gen_rtx_REG (GET_MODE (*loc), 631790285Sobrien (REGNO (reloadreg) + 631890285Sobrien subreg_regno_offset (REGNO (SUBREG_REG (*loc)), 631990285Sobrien GET_MODE (SUBREG_REG (*loc)), 632090285Sobrien SUBREG_BYTE (*loc), 632190285Sobrien GET_MODE (*loc)))); 632218334Speter else if (GET_MODE (reloadreg) == GET_MODE (*loc)) 632318334Speter return reloadreg; 632418334Speter else 632590285Sobrien { 632690285Sobrien int final_offset = SUBREG_BYTE (reloadreg) + SUBREG_BYTE (*loc); 632790285Sobrien 632890285Sobrien /* When working with SUBREGs the rule is that the byte 632990285Sobrien offset must be a multiple of the SUBREG's mode. */ 633090285Sobrien final_offset = (final_offset / GET_MODE_SIZE (GET_MODE (*loc))); 633190285Sobrien final_offset = (final_offset * GET_MODE_SIZE (GET_MODE (*loc))); 633290285Sobrien return gen_rtx_SUBREG (GET_MODE (*loc), SUBREG_REG (reloadreg), 633390285Sobrien final_offset); 633490285Sobrien } 633518334Speter } 633618334Speter } 633718334Speter 633850605Sobrien /* If *LOC is a PLUS, MINUS, or MULT, see if a replacement is scheduled for 633950605Sobrien what's inside and make a new rtl if so. */ 634050605Sobrien if (GET_CODE (*loc) == PLUS || GET_CODE (*loc) == MINUS 634150605Sobrien || GET_CODE (*loc) == MULT) 634250605Sobrien { 634350605Sobrien rtx x = find_replacement (&XEXP (*loc, 0)); 634450605Sobrien rtx y = find_replacement (&XEXP (*loc, 1)); 634550605Sobrien 634650605Sobrien if (x != XEXP (*loc, 0) || y != XEXP (*loc, 1)) 634750605Sobrien return gen_rtx_fmt_ee (GET_CODE (*loc), GET_MODE (*loc), x, y); 634850605Sobrien } 634950605Sobrien 635018334Speter return *loc; 635118334Speter} 635218334Speter 635318334Speter/* Return nonzero if register in range [REGNO, ENDREGNO) 635418334Speter appears either explicitly or implicitly in X 635518334Speter other than being stored into (except for earlyclobber operands). 635618334Speter 635718334Speter References contained within the substructure at LOC do not count. 635818334Speter LOC may be zero, meaning don't ignore anything. 635918334Speter 636018334Speter This is similar to refers_to_regno_p in rtlanal.c except that we 636118334Speter look at equivalences for pseudos that didn't get hard registers. */ 636218334Speter 6363169699Skanstatic int 6364132727Skanrefers_to_regno_for_reload_p (unsigned int regno, unsigned int endregno, 6365132727Skan rtx x, rtx *loc) 636618334Speter{ 636790285Sobrien int i; 636890285Sobrien unsigned int r; 636990285Sobrien RTX_CODE code; 637090285Sobrien const char *fmt; 637118334Speter 637218334Speter if (x == 0) 637318334Speter return 0; 637418334Speter 637518334Speter repeat: 637618334Speter code = GET_CODE (x); 637718334Speter 637818334Speter switch (code) 637918334Speter { 638018334Speter case REG: 638190285Sobrien r = REGNO (x); 638218334Speter 638318334Speter /* If this is a pseudo, a hard register must not have been allocated. 638418334Speter X must therefore either be a constant or be in memory. */ 638590285Sobrien if (r >= FIRST_PSEUDO_REGISTER) 638618334Speter { 638790285Sobrien if (reg_equiv_memory_loc[r]) 638818334Speter return refers_to_regno_for_reload_p (regno, endregno, 638990285Sobrien reg_equiv_memory_loc[r], 639090285Sobrien (rtx*) 0); 639118334Speter 6392169699Skan gcc_assert (reg_equiv_constant[r] || reg_equiv_invariant[r]); 6393169699Skan return 0; 639418334Speter } 639518334Speter 639690285Sobrien return (endregno > r 639790285Sobrien && regno < r + (r < FIRST_PSEUDO_REGISTER 6398169699Skan ? hard_regno_nregs[r][GET_MODE (x)] 639918334Speter : 1)); 640018334Speter 640118334Speter case SUBREG: 640218334Speter /* If this is a SUBREG of a hard reg, we can see exactly which 640318334Speter registers are being modified. Otherwise, handle normally. */ 6404169699Skan if (REG_P (SUBREG_REG (x)) 640518334Speter && REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER) 640618334Speter { 640790285Sobrien unsigned int inner_regno = subreg_regno (x); 640890285Sobrien unsigned int inner_endregno 640918334Speter = inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER 6410169699Skan ? hard_regno_nregs[inner_regno][GET_MODE (x)] : 1); 641118334Speter 641218334Speter return endregno > inner_regno && regno < inner_endregno; 641318334Speter } 641418334Speter break; 641518334Speter 641618334Speter case CLOBBER: 641718334Speter case SET: 641818334Speter if (&SET_DEST (x) != loc 641918334Speter /* Note setting a SUBREG counts as referring to the REG it is in for 642018334Speter a pseudo but not for hard registers since we can 642118334Speter treat each word individually. */ 642218334Speter && ((GET_CODE (SET_DEST (x)) == SUBREG 642318334Speter && loc != &SUBREG_REG (SET_DEST (x)) 6424169699Skan && REG_P (SUBREG_REG (SET_DEST (x))) 642518334Speter && REGNO (SUBREG_REG (SET_DEST (x))) >= FIRST_PSEUDO_REGISTER 642618334Speter && refers_to_regno_for_reload_p (regno, endregno, 642718334Speter SUBREG_REG (SET_DEST (x)), 642818334Speter loc)) 642918334Speter /* If the output is an earlyclobber operand, this is 643018334Speter a conflict. */ 6431169699Skan || ((!REG_P (SET_DEST (x)) 643218334Speter || earlyclobber_operand_p (SET_DEST (x))) 643318334Speter && refers_to_regno_for_reload_p (regno, endregno, 643418334Speter SET_DEST (x), loc)))) 643518334Speter return 1; 643618334Speter 643718334Speter if (code == CLOBBER || loc == &SET_SRC (x)) 643818334Speter return 0; 643918334Speter x = SET_SRC (x); 644018334Speter goto repeat; 644190285Sobrien 644250605Sobrien default: 644350605Sobrien break; 644418334Speter } 644518334Speter 644618334Speter /* X does not match, so try its subexpressions. */ 644718334Speter 644818334Speter fmt = GET_RTX_FORMAT (code); 644918334Speter for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 645018334Speter { 645118334Speter if (fmt[i] == 'e' && loc != &XEXP (x, i)) 645218334Speter { 645318334Speter if (i == 0) 645418334Speter { 645518334Speter x = XEXP (x, 0); 645618334Speter goto repeat; 645718334Speter } 645818334Speter else 645918334Speter if (refers_to_regno_for_reload_p (regno, endregno, 646018334Speter XEXP (x, i), loc)) 646118334Speter return 1; 646218334Speter } 646318334Speter else if (fmt[i] == 'E') 646418334Speter { 646590285Sobrien int j; 646690285Sobrien for (j = XVECLEN (x, i) - 1; j >= 0; j--) 646718334Speter if (loc != &XVECEXP (x, i, j) 646818334Speter && refers_to_regno_for_reload_p (regno, endregno, 646918334Speter XVECEXP (x, i, j), loc)) 647018334Speter return 1; 647118334Speter } 647218334Speter } 647318334Speter return 0; 647418334Speter} 647518334Speter 647618334Speter/* Nonzero if modifying X will affect IN. If X is a register or a SUBREG, 647718334Speter we check if any register number in X conflicts with the relevant register 647818334Speter numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN 647918334Speter contains a MEM (we don't bother checking for memory addresses that can't 648090285Sobrien conflict because we expect this to be a rare case. 648118334Speter 648290285Sobrien This function is similar to reg_overlap_mentioned_p in rtlanal.c except 648318334Speter that we look at equivalences for pseudos that didn't get hard registers. */ 648418334Speter 648518334Speterint 6486132727Skanreg_overlap_mentioned_for_reload_p (rtx x, rtx in) 648718334Speter{ 648818334Speter int regno, endregno; 648918334Speter 649050605Sobrien /* Overly conservative. */ 649190285Sobrien if (GET_CODE (x) == STRICT_LOW_PART 6492169699Skan || GET_RTX_CLASS (GET_CODE (x)) == RTX_AUTOINC) 649350605Sobrien x = XEXP (x, 0); 649450605Sobrien 649550605Sobrien /* If either argument is a constant, then modifying X can not affect IN. */ 649650605Sobrien if (CONSTANT_P (x) || CONSTANT_P (in)) 649750605Sobrien return 0; 6498169699Skan else if (GET_CODE (x) == SUBREG && GET_CODE (SUBREG_REG (x)) == MEM) 6499169699Skan return refers_to_mem_for_reload_p (in); 650050605Sobrien else if (GET_CODE (x) == SUBREG) 650118334Speter { 650218334Speter regno = REGNO (SUBREG_REG (x)); 650318334Speter if (regno < FIRST_PSEUDO_REGISTER) 650490285Sobrien regno += subreg_regno_offset (REGNO (SUBREG_REG (x)), 650590285Sobrien GET_MODE (SUBREG_REG (x)), 650690285Sobrien SUBREG_BYTE (x), 650790285Sobrien GET_MODE (x)); 650818334Speter } 6509169699Skan else if (REG_P (x)) 651018334Speter { 651118334Speter regno = REGNO (x); 651218334Speter 651318334Speter /* If this is a pseudo, it must not have been assigned a hard register. 651418334Speter Therefore, it must either be in memory or be a constant. */ 651518334Speter 651618334Speter if (regno >= FIRST_PSEUDO_REGISTER) 651718334Speter { 651818334Speter if (reg_equiv_memory_loc[regno]) 651918334Speter return refers_to_mem_for_reload_p (in); 6520169699Skan gcc_assert (reg_equiv_constant[regno]); 6521169699Skan return 0; 652218334Speter } 652318334Speter } 6524169699Skan else if (MEM_P (x)) 652518334Speter return refers_to_mem_for_reload_p (in); 652618334Speter else if (GET_CODE (x) == SCRATCH || GET_CODE (x) == PC 652718334Speter || GET_CODE (x) == CC0) 652818334Speter return reg_mentioned_p (x, in); 6529169699Skan else 6530132727Skan { 6531169699Skan gcc_assert (GET_CODE (x) == PLUS); 6532169699Skan 6533132727Skan /* We actually want to know if X is mentioned somewhere inside IN. 6534132727Skan We must not say that (plus (sp) (const_int 124)) is in 6535132727Skan (plus (sp) (const_int 64)), since that can lead to incorrect reload 6536132727Skan allocation when spuriously changing a RELOAD_FOR_OUTPUT_ADDRESS 6537132727Skan into a RELOAD_OTHER on behalf of another RELOAD_OTHER. */ 6538169699Skan while (MEM_P (in)) 6539132727Skan in = XEXP (in, 0); 6540169699Skan if (REG_P (in)) 6541132727Skan return 0; 6542132727Skan else if (GET_CODE (in) == PLUS) 6543171835Skan return (rtx_equal_p (x, in) 6544171835Skan || reg_overlap_mentioned_for_reload_p (x, XEXP (in, 0)) 6545132727Skan || reg_overlap_mentioned_for_reload_p (x, XEXP (in, 1))); 6546132727Skan else return (reg_overlap_mentioned_for_reload_p (XEXP (x, 0), in) 6547132727Skan || reg_overlap_mentioned_for_reload_p (XEXP (x, 1), in)); 6548132727Skan } 654918334Speter 655018334Speter endregno = regno + (regno < FIRST_PSEUDO_REGISTER 6551169699Skan ? hard_regno_nregs[regno][GET_MODE (x)] : 1); 655218334Speter 655390285Sobrien return refers_to_regno_for_reload_p (regno, endregno, in, (rtx*) 0); 655418334Speter} 655518334Speter 655618334Speter/* Return nonzero if anything in X contains a MEM. Look also for pseudo 655718334Speter registers. */ 655818334Speter 6559169699Skanstatic int 6560132727Skanrefers_to_mem_for_reload_p (rtx x) 656118334Speter{ 656290285Sobrien const char *fmt; 656318334Speter int i; 656418334Speter 6565169699Skan if (MEM_P (x)) 656618334Speter return 1; 656718334Speter 6568169699Skan if (REG_P (x)) 656918334Speter return (REGNO (x) >= FIRST_PSEUDO_REGISTER 657018334Speter && reg_equiv_memory_loc[REGNO (x)]); 657190285Sobrien 657218334Speter fmt = GET_RTX_FORMAT (GET_CODE (x)); 657318334Speter for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--) 657418334Speter if (fmt[i] == 'e' 6575169699Skan && (MEM_P (XEXP (x, i)) 657618334Speter || refers_to_mem_for_reload_p (XEXP (x, i)))) 657718334Speter return 1; 657890285Sobrien 657918334Speter return 0; 658018334Speter} 658118334Speter 658218334Speter/* Check the insns before INSN to see if there is a suitable register 658318334Speter containing the same value as GOAL. 658418334Speter If OTHER is -1, look for a register in class CLASS. 658518334Speter Otherwise, just see if register number OTHER shares GOAL's value. 658618334Speter 658718334Speter Return an rtx for the register found, or zero if none is found. 658818334Speter 658918334Speter If RELOAD_REG_P is (short *)1, 659018334Speter we reject any hard reg that appears in reload_reg_rtx 659118334Speter because such a hard reg is also needed coming into this insn. 659218334Speter 659318334Speter If RELOAD_REG_P is any other nonzero value, 659418334Speter it is a vector indexed by hard reg number 659518334Speter and we reject any hard reg whose element in the vector is nonnegative 659618334Speter as well as any that appears in reload_reg_rtx. 659718334Speter 659818334Speter If GOAL is zero, then GOALREG is a register number; we look 659918334Speter for an equivalent for that register. 660018334Speter 660118334Speter MODE is the machine mode of the value we want an equivalence for. 660218334Speter If GOAL is nonzero and not VOIDmode, then it must have mode MODE. 660318334Speter 660418334Speter This function is used by jump.c as well as in the reload pass. 660518334Speter 660618334Speter If GOAL is the sum of the stack pointer and a constant, we treat it 660718334Speter as if it were a constant except that sp is required to be unchanging. */ 660818334Speter 660918334Speterrtx 6610132727Skanfind_equiv_reg (rtx goal, rtx insn, enum reg_class class, int other, 6611132727Skan short *reload_reg_p, int goalreg, enum machine_mode mode) 661218334Speter{ 661390285Sobrien rtx p = insn; 661418334Speter rtx goaltry, valtry, value, where; 661590285Sobrien rtx pat; 661690285Sobrien int regno = -1; 661718334Speter int valueno; 661818334Speter int goal_mem = 0; 661918334Speter int goal_const = 0; 662018334Speter int goal_mem_addr_varies = 0; 662118334Speter int need_stable_sp = 0; 662218334Speter int nregs; 662318334Speter int valuenregs; 6624132727Skan int num = 0; 662518334Speter 662618334Speter if (goal == 0) 662718334Speter regno = goalreg; 6628169699Skan else if (REG_P (goal)) 662918334Speter regno = REGNO (goal); 6630169699Skan else if (MEM_P (goal)) 663118334Speter { 663218334Speter enum rtx_code code = GET_CODE (XEXP (goal, 0)); 663318334Speter if (MEM_VOLATILE_P (goal)) 663418334Speter return 0; 6635169699Skan if (flag_float_store && SCALAR_FLOAT_MODE_P (GET_MODE (goal))) 663618334Speter return 0; 663718334Speter /* An address with side effects must be reexecuted. */ 663818334Speter switch (code) 663918334Speter { 664018334Speter case POST_INC: 664118334Speter case PRE_INC: 664218334Speter case POST_DEC: 664318334Speter case PRE_DEC: 664490285Sobrien case POST_MODIFY: 664590285Sobrien case PRE_MODIFY: 664618334Speter return 0; 664750605Sobrien default: 664850605Sobrien break; 664918334Speter } 665018334Speter goal_mem = 1; 665118334Speter } 665218334Speter else if (CONSTANT_P (goal)) 665318334Speter goal_const = 1; 665418334Speter else if (GET_CODE (goal) == PLUS 665518334Speter && XEXP (goal, 0) == stack_pointer_rtx 665618334Speter && CONSTANT_P (XEXP (goal, 1))) 665718334Speter goal_const = need_stable_sp = 1; 665850605Sobrien else if (GET_CODE (goal) == PLUS 665950605Sobrien && XEXP (goal, 0) == frame_pointer_rtx 666050605Sobrien && CONSTANT_P (XEXP (goal, 1))) 666150605Sobrien goal_const = 1; 666218334Speter else 666318334Speter return 0; 666418334Speter 6665132727Skan num = 0; 666618334Speter /* Scan insns back from INSN, looking for one that copies 666718334Speter a value into or out of GOAL. 666818334Speter Stop and give up if we reach a label. */ 666918334Speter 667018334Speter while (1) 667118334Speter { 667218334Speter p = PREV_INSN (p); 6673132727Skan num++; 6674169699Skan if (p == 0 || LABEL_P (p) 6675132727Skan || num > PARAM_VALUE (PARAM_MAX_RELOAD_SEARCH_INSNS)) 667618334Speter return 0; 667790285Sobrien 6678169699Skan if (NONJUMP_INSN_P (p) 667950605Sobrien /* If we don't want spill regs ... */ 668018334Speter && (! (reload_reg_p != 0 668118334Speter && reload_reg_p != (short *) (HOST_WIDE_INT) 1) 668290285Sobrien /* ... then ignore insns introduced by reload; they aren't 668390285Sobrien useful and can cause results in reload_as_needed to be 668490285Sobrien different from what they were when calculating the need for 668590285Sobrien spills. If we notice an input-reload insn here, we will 668690285Sobrien reject it below, but it might hide a usable equivalent. 6687169699Skan That makes bad code. It may even fail: perhaps no reg was 668890285Sobrien spilled for this insn because it was assumed we would find 668990285Sobrien that equivalent. */ 669018334Speter || INSN_UID (p) < reload_first_uid)) 669118334Speter { 669218334Speter rtx tem; 669318334Speter pat = single_set (p); 669490285Sobrien 669518334Speter /* First check for something that sets some reg equal to GOAL. */ 669618334Speter if (pat != 0 669718334Speter && ((regno >= 0 669818334Speter && true_regnum (SET_SRC (pat)) == regno 669918334Speter && (valueno = true_regnum (valtry = SET_DEST (pat))) >= 0) 670018334Speter || 670118334Speter (regno >= 0 670218334Speter && true_regnum (SET_DEST (pat)) == regno 670318334Speter && (valueno = true_regnum (valtry = SET_SRC (pat))) >= 0) 670418334Speter || 670518334Speter (goal_const && rtx_equal_p (SET_SRC (pat), goal) 670650605Sobrien /* When looking for stack pointer + const, 670750605Sobrien make sure we don't use a stack adjust. */ 670850605Sobrien && !reg_overlap_mentioned_for_reload_p (SET_DEST (pat), goal) 670918334Speter && (valueno = true_regnum (valtry = SET_DEST (pat))) >= 0) 671018334Speter || (goal_mem 671118334Speter && (valueno = true_regnum (valtry = SET_DEST (pat))) >= 0 671218334Speter && rtx_renumbered_equal_p (goal, SET_SRC (pat))) 671318334Speter || (goal_mem 671418334Speter && (valueno = true_regnum (valtry = SET_SRC (pat))) >= 0 671518334Speter && rtx_renumbered_equal_p (goal, SET_DEST (pat))) 671618334Speter /* If we are looking for a constant, 671718334Speter and something equivalent to that constant was copied 671818334Speter into a reg, we can use that reg. */ 671990285Sobrien || (goal_const && REG_NOTES (p) != 0 672090285Sobrien && (tem = find_reg_note (p, REG_EQUIV, NULL_RTX)) 672190285Sobrien && ((rtx_equal_p (XEXP (tem, 0), goal) 672290285Sobrien && (valueno 672390285Sobrien = true_regnum (valtry = SET_DEST (pat))) >= 0) 6724169699Skan || (REG_P (SET_DEST (pat)) 672590285Sobrien && GET_CODE (XEXP (tem, 0)) == CONST_DOUBLE 6726169699Skan && SCALAR_FLOAT_MODE_P (GET_MODE (XEXP (tem, 0))) 672790285Sobrien && GET_CODE (goal) == CONST_INT 672890285Sobrien && 0 != (goaltry 672990285Sobrien = operand_subword (XEXP (tem, 0), 0, 0, 673018334Speter VOIDmode)) 673190285Sobrien && rtx_equal_p (goal, goaltry) 673290285Sobrien && (valtry 673390285Sobrien = operand_subword (SET_DEST (pat), 0, 0, 673490285Sobrien VOIDmode)) 673590285Sobrien && (valueno = true_regnum (valtry)) >= 0))) 673618334Speter || (goal_const && (tem = find_reg_note (p, REG_EQUIV, 673718334Speter NULL_RTX)) 6738169699Skan && REG_P (SET_DEST (pat)) 673918334Speter && GET_CODE (XEXP (tem, 0)) == CONST_DOUBLE 6740169699Skan && SCALAR_FLOAT_MODE_P (GET_MODE (XEXP (tem, 0))) 674118334Speter && GET_CODE (goal) == CONST_INT 674218334Speter && 0 != (goaltry = operand_subword (XEXP (tem, 0), 1, 0, 674318334Speter VOIDmode)) 674418334Speter && rtx_equal_p (goal, goaltry) 674518334Speter && (valtry 674618334Speter = operand_subword (SET_DEST (pat), 1, 0, VOIDmode)) 674718334Speter && (valueno = true_regnum (valtry)) >= 0))) 674870639Sobrien { 674970639Sobrien if (other >= 0) 675070639Sobrien { 675170639Sobrien if (valueno != other) 675270639Sobrien continue; 675370639Sobrien } 675470639Sobrien else if ((unsigned) valueno >= FIRST_PSEUDO_REGISTER) 675570639Sobrien continue; 675670639Sobrien else 675770639Sobrien { 675870639Sobrien int i; 675970639Sobrien 6760169699Skan for (i = hard_regno_nregs[valueno][mode] - 1; i >= 0; i--) 676170639Sobrien if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class], 676270639Sobrien valueno + i)) 676370639Sobrien break; 676470639Sobrien if (i >= 0) 676570639Sobrien continue; 676670639Sobrien } 676770639Sobrien value = valtry; 676870639Sobrien where = p; 676970639Sobrien break; 677070639Sobrien } 677118334Speter } 677218334Speter } 677318334Speter 677418334Speter /* We found a previous insn copying GOAL into a suitable other reg VALUE 677518334Speter (or copying VALUE into GOAL, if GOAL is also a register). 677618334Speter Now verify that VALUE is really valid. */ 677718334Speter 677818334Speter /* VALUENO is the register number of VALUE; a hard register. */ 677918334Speter 678018334Speter /* Don't try to re-use something that is killed in this insn. We want 678118334Speter to be able to trust REG_UNUSED notes. */ 678290285Sobrien if (REG_NOTES (where) != 0 && find_reg_note (where, REG_UNUSED, value)) 678318334Speter return 0; 678418334Speter 678518334Speter /* If we propose to get the value from the stack pointer or if GOAL is 678618334Speter a MEM based on the stack pointer, we need a stable SP. */ 678750605Sobrien if (valueno == STACK_POINTER_REGNUM || regno == STACK_POINTER_REGNUM 678818334Speter || (goal_mem && reg_overlap_mentioned_for_reload_p (stack_pointer_rtx, 678918334Speter goal))) 679018334Speter need_stable_sp = 1; 679118334Speter 679218334Speter /* Reject VALUE if the copy-insn moved the wrong sort of datum. */ 679318334Speter if (GET_MODE (value) != mode) 679418334Speter return 0; 679518334Speter 679618334Speter /* Reject VALUE if it was loaded from GOAL 679718334Speter and is also a register that appears in the address of GOAL. */ 679818334Speter 679950605Sobrien if (goal_mem && value == SET_DEST (single_set (where)) 680018334Speter && refers_to_regno_for_reload_p (valueno, 680118334Speter (valueno 6802169699Skan + hard_regno_nregs[valueno][mode]), 680390285Sobrien goal, (rtx*) 0)) 680418334Speter return 0; 680518334Speter 680618334Speter /* Reject registers that overlap GOAL. */ 680718334Speter 6808169699Skan if (regno >= 0 && regno < FIRST_PSEUDO_REGISTER) 6809169699Skan nregs = hard_regno_nregs[regno][mode]; 6810169699Skan else 6811169699Skan nregs = 1; 6812169699Skan valuenregs = hard_regno_nregs[valueno][mode]; 6813169699Skan 681418334Speter if (!goal_mem && !goal_const 6815169699Skan && regno + nregs > valueno && regno < valueno + valuenregs) 681618334Speter return 0; 681718334Speter 681818334Speter /* Reject VALUE if it is one of the regs reserved for reloads. 681918334Speter Reload1 knows how to reuse them anyway, and it would get 682018334Speter confused if we allocated one without its knowledge. 682118334Speter (Now that insns introduced by reload are ignored above, 682218334Speter this case shouldn't happen, but I'm not positive.) */ 682318334Speter 682470639Sobrien if (reload_reg_p != 0 && reload_reg_p != (short *) (HOST_WIDE_INT) 1) 682570639Sobrien { 682670639Sobrien int i; 682770639Sobrien for (i = 0; i < valuenregs; ++i) 682870639Sobrien if (reload_reg_p[valueno + i] >= 0) 682970639Sobrien return 0; 683070639Sobrien } 683118334Speter 683218334Speter /* Reject VALUE if it is a register being used for an input reload 683318334Speter even if it is not one of those reserved. */ 683418334Speter 683518334Speter if (reload_reg_p != 0) 683618334Speter { 683718334Speter int i; 683818334Speter for (i = 0; i < n_reloads; i++) 683990285Sobrien if (rld[i].reg_rtx != 0 && rld[i].in) 684018334Speter { 684190285Sobrien int regno1 = REGNO (rld[i].reg_rtx); 6842169699Skan int nregs1 = hard_regno_nregs[regno1] 6843169699Skan [GET_MODE (rld[i].reg_rtx)]; 684418334Speter if (regno1 < valueno + valuenregs 684518334Speter && regno1 + nregs1 > valueno) 684618334Speter return 0; 684718334Speter } 684818334Speter } 684918334Speter 685018334Speter if (goal_mem) 685118334Speter /* We must treat frame pointer as varying here, 685218334Speter since it can vary--in a nonlocal goto as generated by expand_goto. */ 685318334Speter goal_mem_addr_varies = !CONSTANT_ADDRESS_P (XEXP (goal, 0)); 685418334Speter 685518334Speter /* Now verify that the values of GOAL and VALUE remain unaltered 685618334Speter until INSN is reached. */ 685718334Speter 685818334Speter p = insn; 685918334Speter while (1) 686018334Speter { 686118334Speter p = PREV_INSN (p); 686218334Speter if (p == where) 686318334Speter return value; 686418334Speter 686518334Speter /* Don't trust the conversion past a function call 686618334Speter if either of the two is in a call-clobbered register, or memory. */ 6867169699Skan if (CALL_P (p)) 686870639Sobrien { 686970639Sobrien int i; 687018334Speter 687170639Sobrien if (goal_mem || need_stable_sp) 687270639Sobrien return 0; 687370639Sobrien 687470639Sobrien if (regno >= 0 && regno < FIRST_PSEUDO_REGISTER) 687570639Sobrien for (i = 0; i < nregs; ++i) 6876169699Skan if (call_used_regs[regno + i] 6877169699Skan || HARD_REGNO_CALL_PART_CLOBBERED (regno + i, mode)) 687870639Sobrien return 0; 687970639Sobrien 688070639Sobrien if (valueno >= 0 && valueno < FIRST_PSEUDO_REGISTER) 688170639Sobrien for (i = 0; i < valuenregs; ++i) 6882169699Skan if (call_used_regs[valueno + i] 6883169699Skan || HARD_REGNO_CALL_PART_CLOBBERED (valueno + i, mode)) 688470639Sobrien return 0; 688570639Sobrien } 688670639Sobrien 688790285Sobrien if (INSN_P (p)) 688818334Speter { 688950605Sobrien pat = PATTERN (p); 689050605Sobrien 689190285Sobrien /* Watch out for unspec_volatile, and volatile asms. */ 689290285Sobrien if (volatile_insn_p (pat)) 689350605Sobrien return 0; 689450605Sobrien 689518334Speter /* If this insn P stores in either GOAL or VALUE, return 0. 689618334Speter If GOAL is a memory ref and this insn writes memory, return 0. 689718334Speter If GOAL is a memory ref and its address is not constant, 689818334Speter and this insn P changes a register used in GOAL, return 0. */ 689918334Speter 690090285Sobrien if (GET_CODE (pat) == COND_EXEC) 690190285Sobrien pat = COND_EXEC_CODE (pat); 690218334Speter if (GET_CODE (pat) == SET || GET_CODE (pat) == CLOBBER) 690318334Speter { 690490285Sobrien rtx dest = SET_DEST (pat); 690518334Speter while (GET_CODE (dest) == SUBREG 690618334Speter || GET_CODE (dest) == ZERO_EXTRACT 690718334Speter || GET_CODE (dest) == STRICT_LOW_PART) 690818334Speter dest = XEXP (dest, 0); 6909169699Skan if (REG_P (dest)) 691018334Speter { 691190285Sobrien int xregno = REGNO (dest); 691218334Speter int xnregs; 691318334Speter if (REGNO (dest) < FIRST_PSEUDO_REGISTER) 6914169699Skan xnregs = hard_regno_nregs[xregno][GET_MODE (dest)]; 691518334Speter else 691618334Speter xnregs = 1; 691718334Speter if (xregno < regno + nregs && xregno + xnregs > regno) 691818334Speter return 0; 691918334Speter if (xregno < valueno + valuenregs 692018334Speter && xregno + xnregs > valueno) 692118334Speter return 0; 692218334Speter if (goal_mem_addr_varies 692318334Speter && reg_overlap_mentioned_for_reload_p (dest, goal)) 692418334Speter return 0; 692550605Sobrien if (xregno == STACK_POINTER_REGNUM && need_stable_sp) 692650605Sobrien return 0; 692718334Speter } 6928169699Skan else if (goal_mem && MEM_P (dest) 692918334Speter && ! push_operand (dest, GET_MODE (dest))) 693018334Speter return 0; 6931169699Skan else if (MEM_P (dest) && regno >= FIRST_PSEUDO_REGISTER 693218334Speter && reg_equiv_memory_loc[regno] != 0) 693318334Speter return 0; 693418334Speter else if (need_stable_sp && push_operand (dest, GET_MODE (dest))) 693518334Speter return 0; 693618334Speter } 693718334Speter else if (GET_CODE (pat) == PARALLEL) 693818334Speter { 693990285Sobrien int i; 694018334Speter for (i = XVECLEN (pat, 0) - 1; i >= 0; i--) 694118334Speter { 694290285Sobrien rtx v1 = XVECEXP (pat, 0, i); 694390285Sobrien if (GET_CODE (v1) == COND_EXEC) 694490285Sobrien v1 = COND_EXEC_CODE (v1); 694518334Speter if (GET_CODE (v1) == SET || GET_CODE (v1) == CLOBBER) 694618334Speter { 694790285Sobrien rtx dest = SET_DEST (v1); 694818334Speter while (GET_CODE (dest) == SUBREG 694918334Speter || GET_CODE (dest) == ZERO_EXTRACT 695018334Speter || GET_CODE (dest) == STRICT_LOW_PART) 695118334Speter dest = XEXP (dest, 0); 6952169699Skan if (REG_P (dest)) 695318334Speter { 695490285Sobrien int xregno = REGNO (dest); 695518334Speter int xnregs; 695618334Speter if (REGNO (dest) < FIRST_PSEUDO_REGISTER) 6957169699Skan xnregs = hard_regno_nregs[xregno][GET_MODE (dest)]; 695818334Speter else 695918334Speter xnregs = 1; 696018334Speter if (xregno < regno + nregs 696118334Speter && xregno + xnregs > regno) 696218334Speter return 0; 696318334Speter if (xregno < valueno + valuenregs 696418334Speter && xregno + xnregs > valueno) 696518334Speter return 0; 696618334Speter if (goal_mem_addr_varies 696718334Speter && reg_overlap_mentioned_for_reload_p (dest, 696818334Speter goal)) 696918334Speter return 0; 697050605Sobrien if (xregno == STACK_POINTER_REGNUM && need_stable_sp) 697150605Sobrien return 0; 697218334Speter } 6973169699Skan else if (goal_mem && MEM_P (dest) 697418334Speter && ! push_operand (dest, GET_MODE (dest))) 697518334Speter return 0; 6976169699Skan else if (MEM_P (dest) && regno >= FIRST_PSEUDO_REGISTER 697750605Sobrien && reg_equiv_memory_loc[regno] != 0) 697850605Sobrien return 0; 697918334Speter else if (need_stable_sp 698018334Speter && push_operand (dest, GET_MODE (dest))) 698118334Speter return 0; 698218334Speter } 698318334Speter } 698418334Speter } 698518334Speter 6986169699Skan if (CALL_P (p) && CALL_INSN_FUNCTION_USAGE (p)) 698718334Speter { 698818334Speter rtx link; 698918334Speter 699018334Speter for (link = CALL_INSN_FUNCTION_USAGE (p); XEXP (link, 1) != 0; 699118334Speter link = XEXP (link, 1)) 699218334Speter { 699318334Speter pat = XEXP (link, 0); 699418334Speter if (GET_CODE (pat) == CLOBBER) 699518334Speter { 699690285Sobrien rtx dest = SET_DEST (pat); 699790285Sobrien 6998169699Skan if (REG_P (dest)) 699918334Speter { 700090285Sobrien int xregno = REGNO (dest); 700190285Sobrien int xnregs 7002169699Skan = hard_regno_nregs[xregno][GET_MODE (dest)]; 700390285Sobrien 700418334Speter if (xregno < regno + nregs 700518334Speter && xregno + xnregs > regno) 700618334Speter return 0; 700790285Sobrien else if (xregno < valueno + valuenregs 700890285Sobrien && xregno + xnregs > valueno) 700918334Speter return 0; 701090285Sobrien else if (goal_mem_addr_varies 701190285Sobrien && reg_overlap_mentioned_for_reload_p (dest, 701218334Speter goal)) 701318334Speter return 0; 701418334Speter } 701590285Sobrien 7016169699Skan else if (goal_mem && MEM_P (dest) 701718334Speter && ! push_operand (dest, GET_MODE (dest))) 701818334Speter return 0; 701918334Speter else if (need_stable_sp 702018334Speter && push_operand (dest, GET_MODE (dest))) 702118334Speter return 0; 702218334Speter } 702318334Speter } 702418334Speter } 702518334Speter 702618334Speter#ifdef AUTO_INC_DEC 702718334Speter /* If this insn auto-increments or auto-decrements 702818334Speter either regno or valueno, return 0 now. 702918334Speter If GOAL is a memory ref and its address is not constant, 703018334Speter and this insn P increments a register used in GOAL, return 0. */ 703118334Speter { 703290285Sobrien rtx link; 703318334Speter 703418334Speter for (link = REG_NOTES (p); link; link = XEXP (link, 1)) 703518334Speter if (REG_NOTE_KIND (link) == REG_INC 7036169699Skan && REG_P (XEXP (link, 0))) 703718334Speter { 703890285Sobrien int incno = REGNO (XEXP (link, 0)); 703918334Speter if (incno < regno + nregs && incno >= regno) 704018334Speter return 0; 704118334Speter if (incno < valueno + valuenregs && incno >= valueno) 704218334Speter return 0; 704318334Speter if (goal_mem_addr_varies 704418334Speter && reg_overlap_mentioned_for_reload_p (XEXP (link, 0), 704518334Speter goal)) 704618334Speter return 0; 704718334Speter } 704818334Speter } 704918334Speter#endif 705018334Speter } 705118334Speter } 705218334Speter} 705318334Speter 705418334Speter/* Find a place where INCED appears in an increment or decrement operator 705518334Speter within X, and return the amount INCED is incremented or decremented by. 705618334Speter The value is always positive. */ 705718334Speter 705818334Speterstatic int 7059132727Skanfind_inc_amount (rtx x, rtx inced) 706018334Speter{ 706190285Sobrien enum rtx_code code = GET_CODE (x); 706290285Sobrien const char *fmt; 706390285Sobrien int i; 706418334Speter 706518334Speter if (code == MEM) 706618334Speter { 706790285Sobrien rtx addr = XEXP (x, 0); 706818334Speter if ((GET_CODE (addr) == PRE_DEC 706918334Speter || GET_CODE (addr) == POST_DEC 707018334Speter || GET_CODE (addr) == PRE_INC 707118334Speter || GET_CODE (addr) == POST_INC) 707218334Speter && XEXP (addr, 0) == inced) 707318334Speter return GET_MODE_SIZE (GET_MODE (x)); 707490285Sobrien else if ((GET_CODE (addr) == PRE_MODIFY 707590285Sobrien || GET_CODE (addr) == POST_MODIFY) 707690285Sobrien && GET_CODE (XEXP (addr, 1)) == PLUS 707790285Sobrien && XEXP (addr, 0) == XEXP (XEXP (addr, 1), 0) 707890285Sobrien && XEXP (addr, 0) == inced 707990285Sobrien && GET_CODE (XEXP (XEXP (addr, 1), 1)) == CONST_INT) 708090285Sobrien { 708190285Sobrien i = INTVAL (XEXP (XEXP (addr, 1), 1)); 708290285Sobrien return i < 0 ? -i : i; 708390285Sobrien } 708418334Speter } 708518334Speter 708618334Speter fmt = GET_RTX_FORMAT (code); 708718334Speter for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 708818334Speter { 708918334Speter if (fmt[i] == 'e') 709018334Speter { 709190285Sobrien int tem = find_inc_amount (XEXP (x, i), inced); 709218334Speter if (tem != 0) 709318334Speter return tem; 709418334Speter } 709518334Speter if (fmt[i] == 'E') 709618334Speter { 709790285Sobrien int j; 709818334Speter for (j = XVECLEN (x, i) - 1; j >= 0; j--) 709918334Speter { 710090285Sobrien int tem = find_inc_amount (XVECEXP (x, i, j), inced); 710118334Speter if (tem != 0) 710218334Speter return tem; 710318334Speter } 710418334Speter } 710518334Speter } 710618334Speter 710718334Speter return 0; 710818334Speter} 710918334Speter 7110169699Skan/* Return 1 if registers from REGNO to ENDREGNO are the subjects of a 7111169699Skan REG_INC note in insn INSN. REGNO must refer to a hard register. */ 7112169699Skan 7113169699Skan#ifdef AUTO_INC_DEC 7114169699Skanstatic int 7115169699Skanreg_inc_found_and_valid_p (unsigned int regno, unsigned int endregno, 7116169699Skan rtx insn) 7117169699Skan{ 7118169699Skan rtx link; 7119169699Skan 7120169699Skan gcc_assert (insn); 7121169699Skan 7122169699Skan if (! INSN_P (insn)) 7123169699Skan return 0; 7124169699Skan 7125169699Skan for (link = REG_NOTES (insn); link; link = XEXP (link, 1)) 7126169699Skan if (REG_NOTE_KIND (link) == REG_INC) 7127169699Skan { 7128169699Skan unsigned int test = (int) REGNO (XEXP (link, 0)); 7129169699Skan if (test >= regno && test < endregno) 7130169699Skan return 1; 7131169699Skan } 7132169699Skan return 0; 7133169699Skan} 7134169699Skan#else 7135169699Skan 7136169699Skan#define reg_inc_found_and_valid_p(regno,endregno,insn) 0 7137169699Skan 7138169699Skan#endif 7139169699Skan 714090285Sobrien/* Return 1 if register REGNO is the subject of a clobber in insn INSN. 7141169699Skan If SETS is 1, also consider SETs. If SETS is 2, enable checking 7142169699Skan REG_INC. REGNO must refer to a hard register. */ 714318334Speter 714418334Speterint 7145132727Skanregno_clobbered_p (unsigned int regno, rtx insn, enum machine_mode mode, 7146132727Skan int sets) 714718334Speter{ 7148169699Skan unsigned int nregs, endregno; 714970639Sobrien 7150169699Skan /* regno must be a hard register. */ 7151169699Skan gcc_assert (regno < FIRST_PSEUDO_REGISTER); 7152169699Skan 7153169699Skan nregs = hard_regno_nregs[regno][mode]; 7154169699Skan endregno = regno + nregs; 7155169699Skan 715670639Sobrien if ((GET_CODE (PATTERN (insn)) == CLOBBER 7157169699Skan || (sets == 1 && GET_CODE (PATTERN (insn)) == SET)) 7158169699Skan && REG_P (XEXP (PATTERN (insn), 0))) 715970639Sobrien { 716090285Sobrien unsigned int test = REGNO (XEXP (PATTERN (insn), 0)); 716118334Speter 716270639Sobrien return test >= regno && test < endregno; 716370639Sobrien } 716470639Sobrien 7165169699Skan if (sets == 2 && reg_inc_found_and_valid_p (regno, endregno, insn)) 7166169699Skan return 1; 7167169699Skan 716818334Speter if (GET_CODE (PATTERN (insn)) == PARALLEL) 716918334Speter { 717018334Speter int i = XVECLEN (PATTERN (insn), 0) - 1; 717118334Speter 717218334Speter for (; i >= 0; i--) 717318334Speter { 717418334Speter rtx elt = XVECEXP (PATTERN (insn), 0, i); 717570639Sobrien if ((GET_CODE (elt) == CLOBBER 7176169699Skan || (sets == 1 && GET_CODE (PATTERN (insn)) == SET)) 7177169699Skan && REG_P (XEXP (elt, 0))) 717870639Sobrien { 717990285Sobrien unsigned int test = REGNO (XEXP (elt, 0)); 7180117404Skan 718170639Sobrien if (test >= regno && test < endregno) 718270639Sobrien return 1; 718370639Sobrien } 7184169699Skan if (sets == 2 7185169699Skan && reg_inc_found_and_valid_p (regno, endregno, elt)) 7186169699Skan return 1; 718718334Speter } 718818334Speter } 718918334Speter 719018334Speter return 0; 719118334Speter} 719218334Speter 7193132727Skan/* Find the low part, with mode MODE, of a hard regno RELOADREG. */ 7194132727Skanrtx 7195132727Skanreload_adjust_reg_for_mode (rtx reloadreg, enum machine_mode mode) 7196132727Skan{ 7197132727Skan int regno; 7198132727Skan 7199132727Skan if (GET_MODE (reloadreg) == mode) 7200132727Skan return reloadreg; 7201132727Skan 7202132727Skan regno = REGNO (reloadreg); 7203132727Skan 7204132727Skan if (WORDS_BIG_ENDIAN) 7205169699Skan regno += (int) hard_regno_nregs[regno][GET_MODE (reloadreg)] 7206169699Skan - (int) hard_regno_nregs[regno][mode]; 7207132727Skan 7208132727Skan return gen_rtx_REG (mode, regno); 7209132727Skan} 7210132727Skan 721190285Sobrienstatic const char *const reload_when_needed_name[] = 721218334Speter{ 721390285Sobrien "RELOAD_FOR_INPUT", 721490285Sobrien "RELOAD_FOR_OUTPUT", 721518334Speter "RELOAD_FOR_INSN", 721650605Sobrien "RELOAD_FOR_INPUT_ADDRESS", 721750605Sobrien "RELOAD_FOR_INPADDR_ADDRESS", 721818334Speter "RELOAD_FOR_OUTPUT_ADDRESS", 721950605Sobrien "RELOAD_FOR_OUTADDR_ADDRESS", 722090285Sobrien "RELOAD_FOR_OPERAND_ADDRESS", 722118334Speter "RELOAD_FOR_OPADDR_ADDR", 722290285Sobrien "RELOAD_OTHER", 722318334Speter "RELOAD_FOR_OTHER_ADDRESS" 722418334Speter}; 722518334Speter 722650605Sobrien/* These functions are used to print the variables set by 'find_reloads' */ 722718334Speter 722818334Spetervoid 7229132727Skandebug_reload_to_stream (FILE *f) 723018334Speter{ 723118334Speter int r; 723290285Sobrien const char *prefix; 723318334Speter 723450605Sobrien if (! f) 723550605Sobrien f = stderr; 723618334Speter for (r = 0; r < n_reloads; r++) 723718334Speter { 723850605Sobrien fprintf (f, "Reload %d: ", r); 723918334Speter 724090285Sobrien if (rld[r].in != 0) 724118334Speter { 724250605Sobrien fprintf (f, "reload_in (%s) = ", 724390285Sobrien GET_MODE_NAME (rld[r].inmode)); 724490285Sobrien print_inline_rtx (f, rld[r].in, 24); 724550605Sobrien fprintf (f, "\n\t"); 724618334Speter } 724718334Speter 724890285Sobrien if (rld[r].out != 0) 724918334Speter { 725050605Sobrien fprintf (f, "reload_out (%s) = ", 725190285Sobrien GET_MODE_NAME (rld[r].outmode)); 725290285Sobrien print_inline_rtx (f, rld[r].out, 24); 725350605Sobrien fprintf (f, "\n\t"); 725418334Speter } 725518334Speter 725690285Sobrien fprintf (f, "%s, ", reg_class_names[(int) rld[r].class]); 725718334Speter 725850605Sobrien fprintf (f, "%s (opnum = %d)", 725990285Sobrien reload_when_needed_name[(int) rld[r].when_needed], 726090285Sobrien rld[r].opnum); 726118334Speter 726290285Sobrien if (rld[r].optional) 726350605Sobrien fprintf (f, ", optional"); 726418334Speter 726590285Sobrien if (rld[r].nongroup) 726690285Sobrien fprintf (f, ", nongroup"); 726718334Speter 726890285Sobrien if (rld[r].inc != 0) 726990285Sobrien fprintf (f, ", inc by %d", rld[r].inc); 727050605Sobrien 727190285Sobrien if (rld[r].nocombine) 727250605Sobrien fprintf (f, ", can't combine"); 727318334Speter 727490285Sobrien if (rld[r].secondary_p) 727550605Sobrien fprintf (f, ", secondary_reload_p"); 727618334Speter 727790285Sobrien if (rld[r].in_reg != 0) 727818334Speter { 727950605Sobrien fprintf (f, "\n\treload_in_reg: "); 728090285Sobrien print_inline_rtx (f, rld[r].in_reg, 24); 728118334Speter } 728218334Speter 728390285Sobrien if (rld[r].out_reg != 0) 728452557Sobrien { 728552557Sobrien fprintf (f, "\n\treload_out_reg: "); 728690285Sobrien print_inline_rtx (f, rld[r].out_reg, 24); 728752557Sobrien } 728852557Sobrien 728990285Sobrien if (rld[r].reg_rtx != 0) 729018334Speter { 729150605Sobrien fprintf (f, "\n\treload_reg_rtx: "); 729290285Sobrien print_inline_rtx (f, rld[r].reg_rtx, 24); 729318334Speter } 729418334Speter 729550605Sobrien prefix = "\n\t"; 729690285Sobrien if (rld[r].secondary_in_reload != -1) 729718334Speter { 729850605Sobrien fprintf (f, "%ssecondary_in_reload = %d", 729990285Sobrien prefix, rld[r].secondary_in_reload); 730050605Sobrien prefix = ", "; 730118334Speter } 730218334Speter 730390285Sobrien if (rld[r].secondary_out_reload != -1) 730450605Sobrien fprintf (f, "%ssecondary_out_reload = %d\n", 730590285Sobrien prefix, rld[r].secondary_out_reload); 730618334Speter 730750605Sobrien prefix = "\n\t"; 730890285Sobrien if (rld[r].secondary_in_icode != CODE_FOR_nothing) 730918334Speter { 731090285Sobrien fprintf (f, "%ssecondary_in_icode = %s", prefix, 731190285Sobrien insn_data[rld[r].secondary_in_icode].name); 731250605Sobrien prefix = ", "; 731318334Speter } 731418334Speter 731590285Sobrien if (rld[r].secondary_out_icode != CODE_FOR_nothing) 731690285Sobrien fprintf (f, "%ssecondary_out_icode = %s", prefix, 731790285Sobrien insn_data[rld[r].secondary_out_icode].name); 731818334Speter 731950605Sobrien fprintf (f, "\n"); 732018334Speter } 732150605Sobrien} 732218334Speter 732350605Sobrienvoid 7324132727Skandebug_reload (void) 732550605Sobrien{ 732650605Sobrien debug_reload_to_stream (stderr); 732718334Speter} 7328