1 /* Communication between reload.c and reload1.c.
2 Copyright (C) 1987, 1991, 1992, 1993 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_reload
[MAX_RELOADS
];
68 extern int reload_secondary_p
[MAX_RELOADS
];
70 extern enum insn_code reload_secondary_icode
[MAX_RELOADS
];
74 extern rtx reload_reg_rtx
[MAX_RELOADS
];
76 /* Encode the usage of a reload. The following codes are supported:
78 RELOAD_FOR_INPUT reload of an input operand
79 RELOAD_FOR_OUTPUT likewise, for output
80 RELOAD_FOR_INSN a reload that must not conflict with anything
81 used in the insn, but may conflict with
82 something used before or after the insn
83 RELOAD_FOR_INPUT_ADDRESS reload for parts of the address of an object
84 that is an input reload
85 RELOAD_FOR_OUTPUT_ADDRESS likewise, for output reload
86 RELOAD_FOR_OPERAND_ADDRESS reload for the address of a non-reloaded
87 operand; these don't conflict with
89 RELOAD_OTHER none of the above, usually multiple uses
90 RELOAD_FOR_OTHER_ADDRESS reload for part of the address of an input
91 that is marked RELOAD_OTHER.
93 This used to be "enum reload_when_needed" but some debuggers have trouble
94 with an enum tag and variable of the same name. */
98 RELOAD_FOR_INPUT
, RELOAD_FOR_OUTPUT
, RELOAD_FOR_INSN
,
99 RELOAD_FOR_INPUT_ADDRESS
, RELOAD_FOR_OUTPUT_ADDRESS
,
100 RELOAD_FOR_OPERAND_ADDRESS
, RELOAD_OTHER
, RELOAD_FOR_OTHER_ADDRESS
103 extern enum reload_type reload_when_needed
[MAX_RELOADS
];
105 extern rtx
*reg_equiv_constant
;
106 extern rtx
*reg_equiv_memory_loc
;
107 extern rtx
*reg_equiv_address
;
108 extern rtx
*reg_equiv_mem
;
110 /* All the "earlyclobber" operands of the current insn
111 are recorded here. */
112 extern int n_earlyclobbers
;
113 extern rtx reload_earlyclobbers
[MAX_RECOG_OPERANDS
];
115 /* Save the number of operands. */
116 extern int reload_n_operands
;
118 /* First uid used by insns created by reload in this function.
119 Used in find_equiv_reg. */
120 extern int reload_first_uid
;
122 /* Nonzero if indirect addressing is supported when the innermost MEM is
123 of the form (MEM (SYMBOL_REF sym)). It is assumed that the level to
124 which these are valid is the same as spill_indirect_levels, above. */
126 extern char indirect_symref_ok
;
128 /* Nonzero if an address (plus (reg frame_pointer) (reg ...)) is valid. */
129 extern char double_reg_address_ok
;
132 /* These arrays record the insn_code of insns that may be needed to
133 perform input and output reloads of special objects. They provide a
134 place to pass a scratch register. */
135 extern enum insn_code reload_in_optab
[];
136 extern enum insn_code reload_out_optab
[];
139 /* Functions from reload.c: */
141 /* Return a memory location that will be used to copy X in mode MODE.
142 If we haven't already made a location for this mode in this insn,
143 call find_reloads_address on the location being returned. */
144 extern rtx get_secondary_mem
PROTO((rtx
, enum machine_mode
,
145 int, enum reload_type
));
147 /* Clear any secondary memory locations we've made. */
148 extern void clear_secondary_mem
PROTO((void));
150 /* Transfer all replacements that used to be in reload FROM to be in
152 extern void transfer_replacements
PROTO((int, int));
154 /* Return 1 if ADDR is a valid memory address for mode MODE,
155 and check that each pseudo reg has the proper kind of
157 extern int strict_memory_address_p
PROTO((enum machine_mode
, rtx
));
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 /* If LOC was scheduled to be replaced by something, return the replacement.
191 Otherwise, return *LOC. */
192 extern rtx find_replacement
PROTO((rtx
*));
194 /* Return nonzero if register in range [REGNO, ENDREGNO)
195 appears either explicitly or implicitly in X
196 other than being stored into. */
197 extern int refers_to_regno_for_reload_p
PROTO((int, int, rtx
, rtx
*));
199 /* Nonzero if modifying X will affect IN. */
200 extern int reg_overlap_mentioned_for_reload_p
PROTO((rtx
, rtx
));
202 /* Return nonzero if anything in X contains a MEM. Look also for pseudo
204 extern int refers_to_mem_for_reload_p
PROTO((rtx
));
206 /* Check the insns before INSN to see if there is a suitable register
207 containing the same value as GOAL. */
208 extern rtx find_equiv_reg
PROTO((rtx
, rtx
, enum reg_class
, int, short *,
209 int, enum machine_mode
));
211 /* Return 1 if register REGNO is the subject of a clobber in insn INSN. */
212 extern int regno_clobbered_p
PROTO((int, rtx
));
215 /* Functions in reload1.c: */
217 /* Initialize the reload pass once per compilation. */
218 extern void init_reload
PROTO((void));
220 /* The reload pass itself. */
221 extern int reload
STDIO_PROTO((rtx
, int, FILE *));
223 /* Mark the slots in regs_ever_live for the hard regs
224 used by pseudo-reg number REGNO. */
225 extern void mark_home_live
PROTO((int));
227 /* Scan X and replace any eliminable registers (such as fp) with a
228 replacement (such as sp), plus an offset. */
229 extern rtx eliminate_regs
PROTO((rtx
, enum machine_mode
, rtx
));
231 /* Emit code to perform an input reload of IN to RELOADREG. IN is from
232 operand OPNUM with reload type TYPE. */
233 extern rtx gen_input_reload
PROTO((rtx
, rtx
, int, enum reload_type
));
235 /* Functions in caller-save.c: */
237 /* Initialize for caller-save. */
238 extern void init_caller_save
PROTO((void));
240 /* Initialize save areas by showing that we haven't allocated any yet. */
241 extern void init_save_areas
PROTO((void));
243 /* Allocate save areas for any hard registers that might need saving. */
244 extern int setup_save_areas
PROTO((int *));
246 /* Find the places where hard regs are live across calls and save them. */
247 extern void save_call_clobbered_regs
PROTO((enum machine_mode
));