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, 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 /* See reload.c and reload1.c for comments on these variables. */
39 /* Maximum number of reloads we can need. */
40 #define MAX_RELOADS (2 * MAX_RECOG_OPERANDS * (MAX_REGS_PER_ADDRESS + 1))
42 extern rtx reload_in
[MAX_RELOADS
];
43 extern rtx reload_out
[MAX_RELOADS
];
44 extern rtx reload_in_reg
[MAX_RELOADS
];
45 extern enum reg_class reload_reg_class
[MAX_RELOADS
];
46 extern enum machine_mode reload_inmode
[MAX_RELOADS
];
47 extern enum machine_mode reload_outmode
[MAX_RELOADS
];
48 extern char reload_optional
[MAX_RELOADS
];
49 extern int reload_inc
[MAX_RELOADS
];
50 extern int reload_opnum
[MAX_RELOADS
];
51 extern int reload_secondary_p
[MAX_RELOADS
];
52 extern int reload_secondary_in_reload
[MAX_RELOADS
];
53 extern int reload_secondary_out_reload
[MAX_RELOADS
];
55 extern enum insn_code reload_secondary_in_icode
[MAX_RELOADS
];
56 extern enum insn_code reload_secondary_out_icode
[MAX_RELOADS
];
60 extern rtx reload_reg_rtx
[MAX_RELOADS
];
62 /* Encode the usage of a reload. The following codes are supported:
64 RELOAD_FOR_INPUT reload of an input operand
65 RELOAD_FOR_OUTPUT likewise, for output
66 RELOAD_FOR_INSN a reload that must not conflict with anything
67 used in the insn, but may conflict with
68 something used before or after the insn
69 RELOAD_FOR_INPUT_ADDRESS reload for parts of the address of an object
70 that is an input reload
71 RELOAD_FOR_OUTPUT_ADDRESS likewise, for output reload
72 RELOAD_FOR_OPERAND_ADDRESS reload for the address of a non-reloaded
73 operand; these don't conflict with
75 RELOAD_FOR_OPADDR_ADDR reload needed for RELOAD_FOR_OPERAND_ADDRESS
76 reloads; usually secondary reloads
77 RELOAD_OTHER none of the above, usually multiple uses
78 RELOAD_FOR_OTHER_ADDRESS reload for part of the address of an input
79 that is marked RELOAD_OTHER.
81 This used to be "enum reload_when_needed" but some debuggers have trouble
82 with an enum tag and variable of the same name. */
86 RELOAD_FOR_INPUT
, RELOAD_FOR_OUTPUT
, RELOAD_FOR_INSN
,
87 RELOAD_FOR_INPUT_ADDRESS
, RELOAD_FOR_OUTPUT_ADDRESS
,
88 RELOAD_FOR_OPERAND_ADDRESS
, RELOAD_FOR_OPADDR_ADDR
,
89 RELOAD_OTHER
, RELOAD_FOR_OTHER_ADDRESS
92 extern enum reload_type reload_when_needed
[MAX_RELOADS
];
94 extern rtx
*reg_equiv_constant
;
95 extern rtx
*reg_equiv_memory_loc
;
96 extern rtx
*reg_equiv_address
;
97 extern rtx
*reg_equiv_mem
;
99 /* All the "earlyclobber" operands of the current insn
100 are recorded here. */
101 extern int n_earlyclobbers
;
102 extern rtx reload_earlyclobbers
[MAX_RECOG_OPERANDS
];
104 /* Save the number of operands. */
105 extern int reload_n_operands
;
107 /* First uid used by insns created by reload in this function.
108 Used in find_equiv_reg. */
109 extern int reload_first_uid
;
111 /* Nonzero if indirect addressing is supported when the innermost MEM is
112 of the form (MEM (SYMBOL_REF sym)). It is assumed that the level to
113 which these are valid is the same as spill_indirect_levels, above. */
115 extern char indirect_symref_ok
;
117 /* Nonzero if an address (plus (reg frame_pointer) (reg ...)) is valid. */
118 extern char double_reg_address_ok
;
121 /* These arrays record the insn_code of insns that may be needed to
122 perform input and output reloads of special objects. They provide a
123 place to pass a scratch register. */
124 extern enum insn_code reload_in_optab
[];
125 extern enum insn_code reload_out_optab
[];
128 /* Functions from reload.c: */
130 /* Return a memory location that will be used to copy X in mode MODE.
131 If we haven't already made a location for this mode in this insn,
132 call find_reloads_address on the location being returned. */
133 extern rtx get_secondary_mem
PROTO((rtx
, enum machine_mode
,
134 int, enum reload_type
));
136 /* Clear any secondary memory locations we've made. */
137 extern void clear_secondary_mem
PROTO((void));
139 /* Transfer all replacements that used to be in reload FROM to be in
141 extern void transfer_replacements
PROTO((int, int));
143 /* Return 1 if ADDR is a valid memory address for mode MODE,
144 and check that each pseudo reg has the proper kind of
146 extern int strict_memory_address_p
PROTO((enum machine_mode
, rtx
));
148 /* Like rtx_equal_p except that it allows a REG and a SUBREG to match
149 if they are the same hard reg, and has special hacks for
150 autoincrement and autodecrement. */
151 extern int operands_match_p
PROTO((rtx
, rtx
));
153 /* Return the number of times character C occurs in string S. */
154 extern int n_occurrences
PROTO((int, char *));
156 /* Return 1 if altering OP will not modify the value of CLOBBER. */
157 extern int safe_from_earlyclobber
PROTO((rtx
, rtx
));
159 /* Search the body of INSN for values that need reloading and record them
160 with push_reload. REPLACE nonzero means record also where the values occur
161 so that subst_reloads can be used. */
162 extern void find_reloads
PROTO((rtx
, int, int, int, short *));
164 /* Compute the sum of X and Y, making canonicalizations assumed in an
165 address, namely: sum constant integers, surround the sum of two
166 constants with a CONST, put the constant as the second operand, and
167 group the constant on the outermost sum. */
168 extern rtx form_sum
PROTO((rtx
, rtx
));
170 /* Substitute into the current INSN the registers into which we have reloaded
171 the things that need reloading. */
172 extern void subst_reloads
PROTO((void));
174 /* Make a copy of any replacements being done into X and move those copies
175 to locations in Y, a copy of X. We only look at the highest level of
177 extern void copy_replacements
PROTO((rtx
, rtx
));
179 /* If LOC was scheduled to be replaced by something, return the replacement.
180 Otherwise, return *LOC. */
181 extern rtx find_replacement
PROTO((rtx
*));
183 /* Return nonzero if register in range [REGNO, ENDREGNO)
184 appears either explicitly or implicitly in X
185 other than being stored into. */
186 extern int refers_to_regno_for_reload_p
PROTO((int, int, rtx
, rtx
*));
188 /* Nonzero if modifying X will affect IN. */
189 extern int reg_overlap_mentioned_for_reload_p
PROTO((rtx
, rtx
));
191 /* Return nonzero if anything in X contains a MEM. Look also for pseudo
193 extern int refers_to_mem_for_reload_p
PROTO((rtx
));
195 /* Check the insns before INSN to see if there is a suitable register
196 containing the same value as GOAL. */
197 extern rtx find_equiv_reg
PROTO((rtx
, rtx
, enum reg_class
, int, short *,
198 int, enum machine_mode
));
200 /* Return 1 if register REGNO is the subject of a clobber in insn INSN. */
201 extern int regno_clobbered_p
PROTO((int, rtx
));
204 /* Functions in reload1.c: */
206 /* Initialize the reload pass once per compilation. */
207 extern void init_reload
PROTO((void));
209 /* The reload pass itself. */
210 extern int reload
STDIO_PROTO((rtx
, int, FILE *));
212 /* Mark the slots in regs_ever_live for the hard regs
213 used by pseudo-reg number REGNO. */
214 extern void mark_home_live
PROTO((int));
216 /* Scan X and replace any eliminable registers (such as fp) with a
217 replacement (such as sp), plus an offset. */
218 extern rtx eliminate_regs
PROTO((rtx
, enum machine_mode
, rtx
));
220 /* Emit code to perform a reload from IN (which may be a reload register) to
221 OUT (which may also be a reload register). IN or OUT is from operand
222 OPNUM with reload type TYPE. */
223 extern rtx gen_reload
PROTO((rtx
, rtx
, int, enum reload_type
));
225 /* Functions in caller-save.c: */
227 /* Initialize for caller-save. */
228 extern void init_caller_save
PROTO((void));
230 /* Initialize save areas by showing that we haven't allocated any yet. */
231 extern void init_save_areas
PROTO((void));
233 /* Allocate save areas for any hard registers that might need saving. */
234 extern int setup_save_areas
PROTO((int *));
236 /* Find the places where hard regs are live across calls and save them. */
237 extern void save_call_clobbered_regs
PROTO((enum machine_mode
));