|
0
|
1 /* Communication between reload.c, reload1.c and the rest of compiler.
|
|
|
2 Copyright (C) 1987, 1991, 1992, 1993, 1994, 1995, 1997, 1998, 1999,
|
|
|
3 2000, 2001, 2003, 2004, 2007, 2008 Free Software Foundation, Inc.
|
|
|
4
|
|
|
5 This file is part of GCC.
|
|
|
6
|
|
|
7 GCC is free software; you can redistribute it and/or modify it under
|
|
|
8 the terms of the GNU General Public License as published by the Free
|
|
|
9 Software Foundation; either version 3, or (at your option) any later
|
|
|
10 version.
|
|
|
11
|
|
|
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
15 for more details.
|
|
|
16
|
|
|
17 You should have received a copy of the GNU General Public License
|
|
|
18 along with GCC; see the file COPYING3. If not see
|
|
|
19 <http://www.gnu.org/licenses/>. */
|
|
|
20
|
|
|
21
|
|
|
22 /* If secondary reloads are the same for inputs and outputs, define those
|
|
|
23 macros here. */
|
|
|
24
|
|
|
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)
|
|
|
30 #endif
|
|
|
31
|
|
|
32 /* If MEMORY_MOVE_COST isn't defined, give it a default here. */
|
|
|
33 #ifndef MEMORY_MOVE_COST
|
|
|
34 #define MEMORY_MOVE_COST(MODE,CLASS,IN) \
|
|
|
35 (4 + memory_move_secondary_cost ((MODE), (CLASS), (IN)))
|
|
|
36 #endif
|
|
|
37 extern int memory_move_secondary_cost (enum machine_mode, enum reg_class, int);
|
|
|
38
|
|
|
39 /* Maximum number of reloads we can need. */
|
|
|
40 #define MAX_RELOADS (2 * MAX_RECOG_OPERANDS * (MAX_REGS_PER_ADDRESS + 1))
|
|
|
41
|
|
|
42 /* Encode the usage of a reload. The following codes are supported:
|
|
|
43
|
|
|
44 RELOAD_FOR_INPUT reload of an input operand
|
|
|
45 RELOAD_FOR_OUTPUT likewise, for output
|
|
|
46 RELOAD_FOR_INSN a reload that must not conflict with anything
|
|
|
47 used in the insn, but may conflict with
|
|
|
48 something used before or after the insn
|
|
|
49 RELOAD_FOR_INPUT_ADDRESS reload for parts of the address of an object
|
|
|
50 that is an input reload
|
|
|
51 RELOAD_FOR_INPADDR_ADDRESS reload needed for RELOAD_FOR_INPUT_ADDRESS
|
|
|
52 RELOAD_FOR_OUTPUT_ADDRESS like RELOAD_FOR INPUT_ADDRESS, for output
|
|
|
53 RELOAD_FOR_OUTADDR_ADDRESS reload needed for RELOAD_FOR_OUTPUT_ADDRESS
|
|
|
54 RELOAD_FOR_OPERAND_ADDRESS reload for the address of a non-reloaded
|
|
|
55 operand; these don't conflict with
|
|
|
56 any other addresses.
|
|
|
57 RELOAD_FOR_OPADDR_ADDR reload needed for RELOAD_FOR_OPERAND_ADDRESS
|
|
|
58 reloads; usually secondary reloads
|
|
|
59 RELOAD_OTHER none of the above, usually multiple uses
|
|
|
60 RELOAD_FOR_OTHER_ADDRESS reload for part of the address of an input
|
|
|
61 that is marked RELOAD_OTHER.
|
|
|
62
|
|
|
63 This used to be "enum reload_when_needed" but some debuggers have trouble
|
|
|
64 with an enum tag and variable of the same name. */
|
|
|
65
|
|
|
66 enum reload_type
|
|
|
67 {
|
|
|
68 RELOAD_FOR_INPUT, RELOAD_FOR_OUTPUT, RELOAD_FOR_INSN,
|
|
|
69 RELOAD_FOR_INPUT_ADDRESS, RELOAD_FOR_INPADDR_ADDRESS,
|
|
|
70 RELOAD_FOR_OUTPUT_ADDRESS, RELOAD_FOR_OUTADDR_ADDRESS,
|
|
|
71 RELOAD_FOR_OPERAND_ADDRESS, RELOAD_FOR_OPADDR_ADDR,
|
|
|
72 RELOAD_OTHER, RELOAD_FOR_OTHER_ADDRESS
|
|
|
73 };
|
|
|
74
|
|
|
75 #ifdef GCC_INSN_CODES_H
|
|
|
76 /* Each reload is recorded with a structure like this. */
|
|
|
77 struct reload
|
|
|
78 {
|
|
|
79 /* The value to reload from */
|
|
|
80 rtx in;
|
|
|
81 /* Where to store reload-reg afterward if nec (often the same as
|
|
|
82 reload_in) */
|
|
|
83 rtx out;
|
|
|
84
|
|
|
85 /* The class of registers to reload into. */
|
|
|
86 enum reg_class rclass;
|
|
|
87
|
|
|
88 /* The mode this operand should have when reloaded, on input. */
|
|
|
89 enum machine_mode inmode;
|
|
|
90 /* The mode this operand should have when reloaded, on output. */
|
|
|
91 enum machine_mode outmode;
|
|
|
92
|
|
|
93 /* The mode of the reload register. */
|
|
|
94 enum machine_mode mode;
|
|
|
95
|
|
|
96 /* the largest number of registers this reload will require. */
|
|
|
97 unsigned int nregs;
|
|
|
98
|
|
|
99 /* Positive amount to increment or decrement by if
|
|
|
100 reload_in is a PRE_DEC, PRE_INC, POST_DEC, POST_INC.
|
|
|
101 Ignored otherwise (don't assume it is zero). */
|
|
|
102 int inc;
|
|
|
103 /* A reg for which reload_in is the equivalent.
|
|
|
104 If reload_in is a symbol_ref which came from
|
|
|
105 reg_equiv_constant, then this is the pseudo
|
|
|
106 which has that symbol_ref as equivalent. */
|
|
|
107 rtx in_reg;
|
|
|
108 rtx out_reg;
|
|
|
109
|
|
|
110 /* Used in find_reload_regs to record the allocated register. */
|
|
|
111 int regno;
|
|
|
112 /* This is the register to reload into. If it is zero when `find_reloads'
|
|
|
113 returns, you must find a suitable register in the class specified by
|
|
|
114 reload_reg_class, and store here an rtx for that register with mode from
|
|
|
115 reload_inmode or reload_outmode. */
|
|
|
116 rtx reg_rtx;
|
|
|
117 /* The operand number being reloaded. This is used to group related reloads
|
|
|
118 and need not always be equal to the actual operand number in the insn,
|
|
|
119 though it current will be; for in-out operands, it is one of the two
|
|
|
120 operand numbers. */
|
|
|
121 int opnum;
|
|
|
122
|
|
|
123 /* Gives the reload number of a secondary input reload, when needed;
|
|
|
124 otherwise -1. */
|
|
|
125 int secondary_in_reload;
|
|
|
126 /* Gives the reload number of a secondary output reload, when needed;
|
|
|
127 otherwise -1. */
|
|
|
128 int secondary_out_reload;
|
|
|
129 /* If a secondary input reload is required, gives the INSN_CODE that uses the
|
|
|
130 secondary reload as a scratch register, or CODE_FOR_nothing if the
|
|
|
131 secondary reload register is to be an intermediate register. */
|
|
|
132 enum insn_code secondary_in_icode;
|
|
|
133 /* Likewise, for a secondary output reload. */
|
|
|
134 enum insn_code secondary_out_icode;
|
|
|
135
|
|
|
136 /* Classifies reload as needed either for addressing an input reload,
|
|
|
137 addressing an output, for addressing a non-reloaded mem ref, or for
|
|
|
138 unspecified purposes (i.e., more than one of the above). */
|
|
|
139 enum reload_type when_needed;
|
|
|
140
|
|
|
141 /* Nonzero for an optional reload. Optional reloads are ignored unless the
|
|
|
142 value is already sitting in a register. */
|
|
|
143 unsigned int optional:1;
|
|
|
144 /* nonzero if this reload shouldn't be combined with another reload. */
|
|
|
145 unsigned int nocombine:1;
|
|
|
146 /* Nonzero if this is a secondary register for one or more reloads. */
|
|
|
147 unsigned int secondary_p:1;
|
|
|
148 /* Nonzero if this reload must use a register not already allocated to a
|
|
|
149 group. */
|
|
|
150 unsigned int nongroup:1;
|
|
|
151 };
|
|
|
152
|
|
|
153 extern struct reload rld[MAX_RELOADS];
|
|
|
154 extern int n_reloads;
|
|
|
155 #endif
|
|
|
156
|
|
|
157 extern GTY (()) VEC(rtx,gc) *reg_equiv_memory_loc_vec;
|
|
|
158 extern rtx *reg_equiv_constant;
|
|
|
159 extern rtx *reg_equiv_invariant;
|
|
|
160 extern rtx *reg_equiv_memory_loc;
|
|
|
161 extern rtx *reg_equiv_address;
|
|
|
162 extern rtx *reg_equiv_mem;
|
|
|
163 extern rtx *reg_equiv_alt_mem_list;
|
|
|
164
|
|
|
165 /* Element N is the list of insns that initialized reg N from its equivalent
|
|
|
166 constant or memory slot. */
|
|
|
167 extern GTY((length("reg_equiv_init_size"))) rtx *reg_equiv_init;
|
|
|
168
|
|
|
169 /* The size of the previous array, for GC purposes. */
|
|
|
170 extern GTY(()) int reg_equiv_init_size;
|
|
|
171
|
|
|
172 /* All the "earlyclobber" operands of the current insn
|
|
|
173 are recorded here. */
|
|
|
174 extern int n_earlyclobbers;
|
|
|
175 extern rtx reload_earlyclobbers[MAX_RECOG_OPERANDS];
|
|
|
176
|
|
|
177 /* Save the number of operands. */
|
|
|
178 extern int reload_n_operands;
|
|
|
179
|
|
|
180 /* First uid used by insns created by reload in this function.
|
|
|
181 Used in find_equiv_reg. */
|
|
|
182 extern int reload_first_uid;
|
|
|
183
|
|
|
184 /* Nonzero if indirect addressing is supported when the innermost MEM is
|
|
|
185 of the form (MEM (SYMBOL_REF sym)). It is assumed that the level to
|
|
|
186 which these are valid is the same as spill_indirect_levels, above. */
|
|
|
187
|
|
|
188 extern char indirect_symref_ok;
|
|
|
189
|
|
|
190 /* Nonzero if an address (plus (reg frame_pointer) (reg ...)) is valid. */
|
|
|
191 extern char double_reg_address_ok;
|
|
|
192
|
|
|
193 extern int num_not_at_initial_offset;
|
|
|
194
|
|
|
195 #if defined SET_HARD_REG_BIT && defined CLEAR_REG_SET
|
|
|
196 /* This structure describes instructions which are relevant for reload.
|
|
|
197 Apart from all regular insns, this also includes CODE_LABELs, since they
|
|
|
198 must be examined for register elimination. */
|
|
|
199 struct insn_chain
|
|
|
200 {
|
|
|
201 /* Links to the neighbor instructions. */
|
|
|
202 struct insn_chain *next, *prev;
|
|
|
203
|
|
|
204 /* Link through a chains set up by calculate_needs_all_insns, containing
|
|
|
205 all insns that need reloading. */
|
|
|
206 struct insn_chain *next_need_reload;
|
|
|
207
|
|
|
208 /* The rtx of the insn. */
|
|
|
209 rtx insn;
|
|
|
210
|
|
|
211 /* The basic block this insn is in. */
|
|
|
212 int block;
|
|
|
213
|
|
|
214 /* Nonzero if find_reloads said the insn requires reloading. */
|
|
|
215 unsigned int need_reload:1;
|
|
|
216 /* Nonzero if find_reloads needs to be run during reload_as_needed to
|
|
|
217 perform modifications on any operands. */
|
|
|
218 unsigned int need_operand_change:1;
|
|
|
219 /* Nonzero if eliminate_regs_in_insn said it requires eliminations. */
|
|
|
220 unsigned int need_elim:1;
|
|
|
221 /* Nonzero if this insn was inserted by perform_caller_saves. */
|
|
|
222 unsigned int is_caller_save_insn:1;
|
|
|
223
|
|
|
224 /* Register life information: record all live hard registers, and
|
|
|
225 all live pseudos that have a hard register. This set also
|
|
|
226 contains pseudos spilled by IRA. */
|
|
|
227 regset_head live_throughout;
|
|
|
228 regset_head dead_or_set;
|
|
|
229
|
|
|
230 /* Copies of the global variables computed by find_reloads. */
|
|
|
231 struct reload *rld;
|
|
|
232 int n_reloads;
|
|
|
233
|
|
|
234 /* Indicates which registers have already been used for spills. */
|
|
|
235 HARD_REG_SET used_spill_regs;
|
|
|
236 };
|
|
|
237
|
|
|
238 /* A chain of insn_chain structures to describe all non-note insns in
|
|
|
239 a function. */
|
|
|
240 extern struct insn_chain *reload_insn_chain;
|
|
|
241
|
|
|
242 /* Allocate a new insn_chain structure. */
|
|
|
243 extern struct insn_chain *new_insn_chain (void);
|
|
|
244
|
|
|
245 extern void compute_use_by_pseudos (HARD_REG_SET *, regset);
|
|
|
246 #endif
|
|
|
247
|
|
|
248 /* Functions from reload.c: */
|
|
|
249
|
|
|
250 extern enum reg_class secondary_reload_class (bool, enum reg_class,
|
|
|
251 enum machine_mode, rtx);
|
|
|
252
|
|
|
253 #ifdef GCC_INSN_CODES_H
|
|
|
254 extern enum reg_class scratch_reload_class (enum insn_code);
|
|
|
255 #endif
|
|
|
256
|
|
|
257 /* Return a memory location that will be used to copy X in mode MODE.
|
|
|
258 If we haven't already made a location for this mode in this insn,
|
|
|
259 call find_reloads_address on the location being returned. */
|
|
|
260 extern rtx get_secondary_mem (rtx, enum machine_mode, int, enum reload_type);
|
|
|
261
|
|
|
262 /* Clear any secondary memory locations we've made. */
|
|
|
263 extern void clear_secondary_mem (void);
|
|
|
264
|
|
|
265 /* Transfer all replacements that used to be in reload FROM to be in
|
|
|
266 reload TO. */
|
|
|
267 extern void transfer_replacements (int, int);
|
|
|
268
|
|
|
269 /* IN_RTX is the value loaded by a reload that we now decided to inherit,
|
|
|
270 or a subpart of it. If we have any replacements registered for IN_RTX,
|
|
|
271 cancel the reloads that were supposed to load them.
|
|
|
272 Return nonzero if we canceled any reloads. */
|
|
|
273 extern int remove_address_replacements (rtx in_rtx);
|
|
|
274
|
|
|
275 /* Like rtx_equal_p except that it allows a REG and a SUBREG to match
|
|
|
276 if they are the same hard reg, and has special hacks for
|
|
|
277 autoincrement and autodecrement. */
|
|
|
278 extern int operands_match_p (rtx, rtx);
|
|
|
279
|
|
|
280 /* Return 1 if altering OP will not modify the value of CLOBBER. */
|
|
|
281 extern int safe_from_earlyclobber (rtx, rtx);
|
|
|
282
|
|
|
283 /* Search the body of INSN for values that need reloading and record them
|
|
|
284 with push_reload. REPLACE nonzero means record also where the values occur
|
|
|
285 so that subst_reloads can be used. */
|
|
|
286 extern int find_reloads (rtx, int, int, int, short *);
|
|
|
287
|
|
|
288 /* Compute the sum of X and Y, making canonicalizations assumed in an
|
|
|
289 address, namely: sum constant integers, surround the sum of two
|
|
|
290 constants with a CONST, put the constant as the second operand, and
|
|
|
291 group the constant on the outermost sum. */
|
|
|
292 extern rtx form_sum (rtx, rtx);
|
|
|
293
|
|
|
294 /* Substitute into the current INSN the registers into which we have reloaded
|
|
|
295 the things that need reloading. */
|
|
|
296 extern void subst_reloads (rtx);
|
|
|
297
|
|
|
298 /* Make a copy of any replacements being done into X and move those copies
|
|
|
299 to locations in Y, a copy of X. We only look at the highest level of
|
|
|
300 the RTL. */
|
|
|
301 extern void copy_replacements (rtx, rtx);
|
|
|
302
|
|
|
303 /* Change any replacements being done to *X to be done to *Y */
|
|
|
304 extern void move_replacements (rtx *x, rtx *y);
|
|
|
305
|
|
|
306 /* If LOC was scheduled to be replaced by something, return the replacement.
|
|
|
307 Otherwise, return *LOC. */
|
|
|
308 extern rtx find_replacement (rtx *);
|
|
|
309
|
|
|
310 /* Nonzero if modifying X will affect IN. */
|
|
|
311 extern int reg_overlap_mentioned_for_reload_p (rtx, rtx);
|
|
|
312
|
|
|
313 /* Check the insns before INSN to see if there is a suitable register
|
|
|
314 containing the same value as GOAL. */
|
|
|
315 extern rtx find_equiv_reg (rtx, rtx, enum reg_class, int, short *,
|
|
|
316 int, enum machine_mode);
|
|
|
317
|
|
|
318 /* Return 1 if register REGNO is the subject of a clobber in insn INSN. */
|
|
|
319 extern int regno_clobbered_p (unsigned int, rtx, enum machine_mode, int);
|
|
|
320
|
|
|
321 /* Return 1 if X is an operand of an insn that is being earlyclobbered. */
|
|
|
322 extern int earlyclobber_operand_p (rtx);
|
|
|
323
|
|
|
324 /* Record one reload that needs to be performed. */
|
|
|
325 extern int push_reload (rtx, rtx, rtx *, rtx *, enum reg_class,
|
|
|
326 enum machine_mode, enum machine_mode,
|
|
|
327 int, int, int, enum reload_type);
|
|
|
328
|
|
|
329 /* Functions in postreload.c: */
|
|
|
330 extern void reload_cse_regs (rtx);
|
|
|
331
|
|
|
332 /* Functions in reload1.c: */
|
|
|
333
|
|
|
334 /* Initialize the reload pass once per compilation. */
|
|
|
335 extern void init_reload (void);
|
|
|
336
|
|
|
337 /* The reload pass itself. */
|
|
|
338 extern int reload (rtx, int);
|
|
|
339
|
|
|
340 /* Mark the slots in regs_ever_live for the hard regs
|
|
|
341 used by pseudo-reg number REGNO. */
|
|
|
342 extern void mark_home_live (int);
|
|
|
343
|
|
|
344 /* Scan X and replace any eliminable registers (such as fp) with a
|
|
|
345 replacement (such as sp), plus an offset. */
|
|
|
346 extern rtx eliminate_regs (rtx, enum machine_mode, rtx);
|
|
|
347 extern bool elimination_target_reg_p (rtx);
|
|
|
348
|
|
|
349 /* Deallocate the reload register used by reload number R. */
|
|
|
350 extern void deallocate_reload_reg (int r);
|
|
|
351
|
|
|
352 /* Functions in caller-save.c: */
|
|
|
353
|
|
|
354 /* Initialize for caller-save. */
|
|
|
355 extern void init_caller_save (void);
|
|
|
356
|
|
|
357 /* Initialize save areas by showing that we haven't allocated any yet. */
|
|
|
358 extern void init_save_areas (void);
|
|
|
359
|
|
|
360 /* Allocate save areas for any hard registers that might need saving. */
|
|
|
361 extern void setup_save_areas (void);
|
|
|
362
|
|
|
363 /* Find the places where hard regs are live across calls and save them. */
|
|
|
364 extern void save_call_clobbered_regs (void);
|
|
|
365
|
|
|
366 /* Replace (subreg (reg)) with the appropriate (reg) for any operands. */
|
|
|
367 extern void cleanup_subreg_operands (rtx);
|
|
|
368
|
|
|
369 /* Debugging support. */
|
|
|
370 extern void debug_reload_to_stream (FILE *);
|
|
|
371 extern void debug_reload (void);
|
|
|
372
|
|
|
373 /* Compute the actual register we should reload to, in case we're
|
|
|
374 reloading to/from a register that is wider than a word. */
|
|
|
375 extern rtx reload_adjust_reg_for_mode (rtx, enum machine_mode);
|
