1 /* Communication between reload.c and reload1.c.
2 Copyright (C) 1987, 91-95, 1997, 1998 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
22 /* If secondary reloads are the same for inputs and outputs, define those
25 #ifdef SECONDARY_RELOAD_CLASS
26 #define SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, X) \
27 SECONDARY_RELOAD_CLASS (CLASS, MODE, X)
28 #define SECONDARY_OUTPUT_RELOAD_CLASS(CLASS, MODE, X) \
29 SECONDARY_RELOAD_CLASS (CLASS, MODE, X)
32 /* If either macro is defined, show that we need secondary reloads. */
33 #if defined(SECONDARY_INPUT_RELOAD_CLASS) || defined(SECONDARY_OUTPUT_RELOAD_CLASS)
34 #define HAVE_SECONDARY_RELOADS
37 /* If MEMORY_MOVE_COST isn't defined, give it a default here. */
38 #ifndef MEMORY_MOVE_COST
39 #ifdef HAVE_SECONDARY_RELOADS
40 #define MEMORY_MOVE_COST(MODE,CLASS,IN) \
41 (4 + memory_move_secondary_cost ((MODE), (CLASS), (IN)))
43 #define MEMORY_MOVE_COST(MODE,CLASS,IN) 4
46 extern int memory_move_secondary_cost
PROTO ((enum machine_mode
, enum reg_class
, int));
48 /* See reload.c and reload1.c for comments on these variables. */
50 /* Maximum number of reloads we can need. */
51 #define MAX_RELOADS (2 * MAX_RECOG_OPERANDS * (MAX_REGS_PER_ADDRESS + 1))
53 extern enum reg_class reload_address_base_reg_class
;
54 extern enum reg_class reload_address_index_reg_class
;
55 extern rtx reload_in
[MAX_RELOADS
];
56 extern rtx reload_out
[MAX_RELOADS
];
57 extern rtx reload_in_reg
[MAX_RELOADS
];
58 extern enum reg_class reload_reg_class
[MAX_RELOADS
];
59 extern enum machine_mode reload_inmode
[MAX_RELOADS
];
60 extern enum machine_mode reload_outmode
[MAX_RELOADS
];
61 extern char reload_optional
[MAX_RELOADS
];
62 extern int reload_inc
[MAX_RELOADS
];
63 extern int reload_opnum
[MAX_RELOADS
];
64 extern int reload_secondary_p
[MAX_RELOADS
];
65 extern int reload_secondary_in_reload
[MAX_RELOADS
];
66 extern int reload_secondary_out_reload
[MAX_RELOADS
];
68 extern enum insn_code reload_secondary_in_icode
[MAX_RELOADS
];
69 extern enum insn_code reload_secondary_out_icode
[MAX_RELOADS
];
73 extern rtx reload_reg_rtx
[MAX_RELOADS
];
75 /* Encode the usage of a reload. The following codes are supported:
77 RELOAD_FOR_INPUT reload of an input operand
78 RELOAD_FOR_OUTPUT likewise, for output
79 RELOAD_FOR_INSN a reload that must not conflict with anything
80 used in the insn, but may conflict with
81 something used before or after the insn
82 RELOAD_FOR_INPUT_ADDRESS reload for parts of the address of an object
83 that is an input reload
84 RELOAD_FOR_INPADDR_ADDRESS reload needed for RELOAD_FOR_INPUT_ADDRESS
85 RELOAD_FOR_OUTPUT_ADDRESS like RELOAD_FOR INPUT_ADDRESS, for output
86 RELOAD_FOR_OUTADDR_ADDRESS reload needed for RELOAD_FOR_OUTPUT_ADDRESS
87 RELOAD_FOR_OPERAND_ADDRESS reload for the address of a non-reloaded
88 operand; these don't conflict with
90 RELOAD_FOR_OPADDR_ADDR reload needed for RELOAD_FOR_OPERAND_ADDRESS
91 reloads; usually secondary reloads
92 RELOAD_OTHER none of the above, usually multiple uses
93 RELOAD_FOR_OTHER_ADDRESS reload for part of the address of an input
94 that is marked RELOAD_OTHER.
96 This used to be "enum reload_when_needed" but some debuggers have trouble
97 with an enum tag and variable of the same name. */
101 RELOAD_FOR_INPUT
, RELOAD_FOR_OUTPUT
, RELOAD_FOR_INSN
,
102 RELOAD_FOR_INPUT_ADDRESS
, RELOAD_FOR_INPADDR_ADDRESS
,
103 RELOAD_FOR_OUTPUT_ADDRESS
, RELOAD_FOR_OUTADDR_ADDRESS
,
104 RELOAD_FOR_OPERAND_ADDRESS
, RELOAD_FOR_OPADDR_ADDR
,
105 RELOAD_OTHER
, RELOAD_FOR_OTHER_ADDRESS
108 extern enum reload_type reload_when_needed
[MAX_RELOADS
];
110 extern rtx
*reg_equiv_constant
;
111 extern rtx
*reg_equiv_memory_loc
;
112 extern rtx
*reg_equiv_address
;
113 extern rtx
*reg_equiv_mem
;
115 /* All the "earlyclobber" operands of the current insn
116 are recorded here. */
117 extern int n_earlyclobbers
;
118 extern rtx reload_earlyclobbers
[MAX_RECOG_OPERANDS
];
120 /* Save the number of operands. */
121 extern int reload_n_operands
;
123 /* First uid used by insns created by reload in this function.
124 Used in find_equiv_reg. */
125 extern int reload_first_uid
;
127 /* Nonzero if indirect addressing is supported when the innermost MEM is
128 of the form (MEM (SYMBOL_REF sym)). It is assumed that the level to
129 which these are valid is the same as spill_indirect_levels, above. */
131 extern char indirect_symref_ok
;
133 /* Nonzero if an address (plus (reg frame_pointer) (reg ...)) is valid. */
134 extern char double_reg_address_ok
;
137 /* These arrays record the insn_code of insns that may be needed to
138 perform input and output reloads of special objects. They provide a
139 place to pass a scratch register. */
140 extern enum insn_code reload_in_optab
[];
141 extern enum insn_code reload_out_optab
[];
144 /* Functions from reload.c: */
146 /* Return a memory location that will be used to copy X in mode MODE.
147 If we haven't already made a location for this mode in this insn,
148 call find_reloads_address on the location being returned. */
149 extern rtx get_secondary_mem
PROTO((rtx
, enum machine_mode
,
150 int, enum reload_type
));
152 /* Clear any secondary memory locations we've made. */
153 extern void clear_secondary_mem
PROTO((void));
155 /* Transfer all replacements that used to be in reload FROM to be in
157 extern void transfer_replacements
PROTO((int, int));
159 /* Like rtx_equal_p except that it allows a REG and a SUBREG to match
160 if they are the same hard reg, and has special hacks for
161 autoincrement and autodecrement. */
162 extern int operands_match_p
PROTO((rtx
, rtx
));
164 /* Return the number of times character C occurs in string S. */
165 extern int n_occurrences
PROTO((int, char *));
167 /* Return 1 if altering OP will not modify the value of CLOBBER. */
168 extern int safe_from_earlyclobber
PROTO((rtx
, rtx
));
170 /* Search the body of INSN for values that need reloading and record them
171 with push_reload. REPLACE nonzero means record also where the values occur
172 so that subst_reloads can be used. */
173 extern void find_reloads
PROTO((rtx
, int, int, int, short *));
175 /* Compute the sum of X and Y, making canonicalizations assumed in an
176 address, namely: sum constant integers, surround the sum of two
177 constants with a CONST, put the constant as the second operand, and
178 group the constant on the outermost sum. */
179 extern rtx form_sum
PROTO((rtx
, rtx
));
181 /* Substitute into the current INSN the registers into which we have reloaded
182 the things that need reloading. */
183 extern void subst_reloads
PROTO((void));
185 /* Make a copy of any replacements being done into X and move those copies
186 to locations in Y, a copy of X. We only look at the highest level of
188 extern void copy_replacements
PROTO((rtx
, rtx
));
190 /* Change any replacements being done to *X to be done to *Y */
191 extern void move_replacements
PROTO((rtx
*x
, rtx
*y
));
193 /* If LOC was scheduled to be replaced by something, return the replacement.
194 Otherwise, return *LOC. */
195 extern rtx find_replacement
PROTO((rtx
*));
197 /* Return nonzero if register in range [REGNO, ENDREGNO)
198 appears either explicitly or implicitly in X
199 other than being stored into. */
200 extern int refers_to_regno_for_reload_p
PROTO((int, int, rtx
, rtx
*));
202 /* Nonzero if modifying X will affect IN. */
203 extern int reg_overlap_mentioned_for_reload_p
PROTO((rtx
, rtx
));
205 /* Return nonzero if anything in X contains a MEM. Look also for pseudo
207 extern int refers_to_mem_for_reload_p
PROTO((rtx
));
209 /* Check the insns before INSN to see if there is a suitable register
210 containing the same value as GOAL. */
211 extern rtx find_equiv_reg
PROTO((rtx
, rtx
, enum reg_class
, int, short *,
212 int, enum machine_mode
));
214 /* Return 1 if register REGNO is the subject of a clobber in insn INSN. */
215 extern int regno_clobbered_p
PROTO((int, rtx
));
217 /* Functions in reload1.c: */
219 int count_occurrences
PROTO((rtx
, rtx
));
221 /* Initialize the reload pass once per compilation. */
222 extern void init_reload
PROTO((void));
224 /* The reload pass itself. */
225 extern int reload
PROTO((rtx
, int, FILE *));
227 /* Mark the slots in regs_ever_live for the hard regs
228 used by pseudo-reg number REGNO. */
229 extern void mark_home_live
PROTO((int));
231 /* Scan X and replace any eliminable registers (such as fp) with a
232 replacement (such as sp), plus an offset. */
233 extern rtx eliminate_regs
PROTO((rtx
, enum machine_mode
, rtx
));
235 /* Emit code to perform a reload from IN (which may be a reload register) to
236 OUT (which may also be a reload register). IN or OUT is from operand
237 OPNUM with reload type TYPE. */
238 extern rtx gen_reload
PROTO((rtx
, rtx
, int, enum reload_type
));
240 /* Functions in caller-save.c: */
242 /* Initialize for caller-save. */
243 extern void init_caller_save
PROTO((void));
245 /* Initialize save areas by showing that we haven't allocated any yet. */
246 extern void init_save_areas
PROTO((void));
248 /* Allocate save areas for any hard registers that might need saving. */
249 extern int setup_save_areas
PROTO((int *));
251 /* Find the places where hard regs are live across calls and save them. */
252 extern void save_call_clobbered_regs
PROTO((enum machine_mode
));