1 /* Communication between reload.c and reload1.c.
2 Copyright (C) 1987, 1991, 1992, 1993, 1994 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* Add prototype support. */
23 #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
24 #define PROTO(ARGS) ARGS
26 #define PROTO(ARGS) ()
32 #define STDIO_PROTO(ARGS) PROTO(ARGS)
34 #define STDIO_PROTO(ARGS) ()
38 /* If secondary reloads are the same for inputs and outputs, define those
41 #ifdef SECONDARY_RELOAD_CLASS
42 #define SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, X) \
43 SECONDARY_RELOAD_CLASS (CLASS, MODE, X)
44 #define SECONDARY_OUTPUT_RELOAD_CLASS(CLASS, MODE, X) \
45 SECONDARY_RELOAD_CLASS (CLASS, MODE, X)
48 /* If either macro is defined, show that we need secondary reloads. */
49 #if defined(SECONDARY_INPUT_RELOAD_CLASS) || defined(SECONDARY_OUTPUT_RELOAD_CLASS)
50 #define HAVE_SECONDARY_RELOADS
53 /* See reload.c and reload1.c for comments on these variables. */
55 /* Maximum number of reloads we can need. */
56 #define MAX_RELOADS (2 * MAX_RECOG_OPERANDS * (MAX_REGS_PER_ADDRESS + 1))
58 extern rtx reload_in
[MAX_RELOADS
];
59 extern rtx reload_out
[MAX_RELOADS
];
60 extern rtx reload_in_reg
[MAX_RELOADS
];
61 extern enum reg_class reload_reg_class
[MAX_RELOADS
];
62 extern enum machine_mode reload_inmode
[MAX_RELOADS
];
63 extern enum machine_mode reload_outmode
[MAX_RELOADS
];
64 extern char reload_optional
[MAX_RELOADS
];
65 extern int reload_inc
[MAX_RELOADS
];
66 extern int reload_opnum
[MAX_RELOADS
];
67 extern int reload_secondary_p
[MAX_RELOADS
];
68 extern int reload_secondary_in_reload
[MAX_RELOADS
];
69 extern int reload_secondary_out_reload
[MAX_RELOADS
];
71 extern enum insn_code reload_secondary_in_icode
[MAX_RELOADS
];
72 extern enum insn_code reload_secondary_out_icode
[MAX_RELOADS
];
76 extern rtx reload_reg_rtx
[MAX_RELOADS
];
78 /* Encode the usage of a reload. The following codes are supported:
80 RELOAD_FOR_INPUT reload of an input operand
81 RELOAD_FOR_OUTPUT likewise, for output
82 RELOAD_FOR_INSN a reload that must not conflict with anything
83 used in the insn, but may conflict with
84 something used before or after the insn
85 RELOAD_FOR_INPUT_ADDRESS reload for parts of the address of an object
86 that is an input reload
87 RELOAD_FOR_OUTPUT_ADDRESS likewise, for output reload
88 RELOAD_FOR_OPERAND_ADDRESS reload for the address of a non-reloaded
89 operand; these don't conflict with
91 RELOAD_OTHER none of the above, usually multiple uses
92 RELOAD_FOR_OTHER_ADDRESS reload for part of the address of an input
93 that is marked RELOAD_OTHER.
95 This used to be "enum reload_when_needed" but some debuggers have trouble
96 with an enum tag and variable of the same name. */
100 RELOAD_FOR_INPUT
, RELOAD_FOR_OUTPUT
, RELOAD_FOR_INSN
,
101 RELOAD_FOR_INPUT_ADDRESS
, RELOAD_FOR_OUTPUT_ADDRESS
,
102 RELOAD_FOR_OPERAND_ADDRESS
, RELOAD_OTHER
, RELOAD_FOR_OTHER_ADDRESS
105 extern enum reload_type reload_when_needed
[MAX_RELOADS
];
107 extern rtx
*reg_equiv_constant
;
108 extern rtx
*reg_equiv_memory_loc
;
109 extern rtx
*reg_equiv_address
;
110 extern rtx
*reg_equiv_mem
;
112 /* All the "earlyclobber" operands of the current insn
113 are recorded here. */
114 extern int n_earlyclobbers
;
115 extern rtx reload_earlyclobbers
[MAX_RECOG_OPERANDS
];
117 /* Save the number of operands. */
118 extern int reload_n_operands
;
120 /* First uid used by insns created by reload in this function.
121 Used in find_equiv_reg. */
122 extern int reload_first_uid
;
124 /* Nonzero if indirect addressing is supported when the innermost MEM is
125 of the form (MEM (SYMBOL_REF sym)). It is assumed that the level to
126 which these are valid is the same as spill_indirect_levels, above. */
128 extern char indirect_symref_ok
;
130 /* Nonzero if an address (plus (reg frame_pointer) (reg ...)) is valid. */
131 extern char double_reg_address_ok
;
134 /* These arrays record the insn_code of insns that may be needed to
135 perform input and output reloads of special objects. They provide a
136 place to pass a scratch register. */
137 extern enum insn_code reload_in_optab
[];
138 extern enum insn_code reload_out_optab
[];
141 /* Functions from reload.c: */
143 /* Return a memory location that will be used to copy X in mode MODE.
144 If we haven't already made a location for this mode in this insn,
145 call find_reloads_address on the location being returned. */
146 extern rtx get_secondary_mem
PROTO((rtx
, enum machine_mode
,
147 int, enum reload_type
));
149 /* Clear any secondary memory locations we've made. */
150 extern void clear_secondary_mem
PROTO((void));
152 /* Transfer all replacements that used to be in reload FROM to be in
154 extern void transfer_replacements
PROTO((int, int));
156 /* Return 1 if ADDR is a valid memory address for mode MODE,
157 and check that each pseudo reg has the proper kind of
159 extern int strict_memory_address_p
PROTO((enum machine_mode
, rtx
));
161 /* Like rtx_equal_p except that it allows a REG and a SUBREG to match
162 if they are the same hard reg, and has special hacks for
163 autoincrement and autodecrement. */
164 extern int operands_match_p
PROTO((rtx
, rtx
));
166 /* Return the number of times character C occurs in string S. */
167 extern int n_occurrences
PROTO((int, char *));
169 /* Return 1 if altering OP will not modify the value of CLOBBER. */
170 extern int safe_from_earlyclobber
PROTO((rtx
, rtx
));
172 /* Search the body of INSN for values that need reloading and record them
173 with push_reload. REPLACE nonzero means record also where the values occur
174 so that subst_reloads can be used. */
175 extern void find_reloads
PROTO((rtx
, int, int, int, short *));
177 /* Compute the sum of X and Y, making canonicalizations assumed in an
178 address, namely: sum constant integers, surround the sum of two
179 constants with a CONST, put the constant as the second operand, and
180 group the constant on the outermost sum. */
181 extern rtx form_sum
PROTO((rtx
, rtx
));
183 /* Substitute into the current INSN the registers into which we have reloaded
184 the things that need reloading. */
185 extern void subst_reloads
PROTO((void));
187 /* Make a copy of any replacements being done into X and move those copies
188 to locations in Y, a copy of X. We only look at the highest level of
190 extern void copy_replacements
PROTO((rtx
, rtx
));
192 /* If LOC was scheduled to be replaced by something, return the replacement.
193 Otherwise, return *LOC. */
194 extern rtx find_replacement
PROTO((rtx
*));
196 /* Return nonzero if register in range [REGNO, ENDREGNO)
197 appears either explicitly or implicitly in X
198 other than being stored into. */
199 extern int refers_to_regno_for_reload_p
PROTO((int, int, rtx
, rtx
*));
201 /* Nonzero if modifying X will affect IN. */
202 extern int reg_overlap_mentioned_for_reload_p
PROTO((rtx
, rtx
));
204 /* Return nonzero if anything in X contains a MEM. Look also for pseudo
206 extern int refers_to_mem_for_reload_p
PROTO((rtx
));
208 /* Check the insns before INSN to see if there is a suitable register
209 containing the same value as GOAL. */
210 extern rtx find_equiv_reg
PROTO((rtx
, rtx
, enum reg_class
, int, short *,
211 int, enum machine_mode
));
213 /* Return 1 if register REGNO is the subject of a clobber in insn INSN. */
214 extern int regno_clobbered_p
PROTO((int, rtx
));
217 /* Functions in reload1.c: */
219 /* Initialize the reload pass once per compilation. */
220 extern void init_reload
PROTO((void));
222 /* The reload pass itself. */
223 extern int reload
STDIO_PROTO((rtx
, int, FILE *));
225 /* Mark the slots in regs_ever_live for the hard regs
226 used by pseudo-reg number REGNO. */
227 extern void mark_home_live
PROTO((int));
229 /* Scan X and replace any eliminable registers (such as fp) with a
230 replacement (such as sp), plus an offset. */
231 extern rtx eliminate_regs
PROTO((rtx
, enum machine_mode
, rtx
));
233 /* Emit code to perform an input reload of IN to RELOADREG. IN is from
234 operand OPNUM with reload type TYPE. */
235 extern rtx gen_input_reload
PROTO((rtx
, rtx
, int, enum reload_type
));
237 /* Functions in caller-save.c: */
239 /* Initialize for caller-save. */
240 extern void init_caller_save
PROTO((void));
242 /* Initialize save areas by showing that we haven't allocated any yet. */
243 extern void init_save_areas
PROTO((void));
245 /* Allocate save areas for any hard registers that might need saving. */
246 extern int setup_save_areas
PROTO((int *));
248 /* Find the places where hard regs are live across calls and save them. */
249 extern void save_call_clobbered_regs
PROTO((enum machine_mode
));