OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [reload.h] - Blame information for rev 841

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* Communication between reload.c and reload1.c.
2
   Copyright (C) 1987, 1991, 1992, 1993, 1994, 1995, 1997, 1998,
3
   1999, 2000, 2001, 2003, 2004, 2007 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 class;
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 basic block this insn is in.  */
209
  int block;
210
  /* The rtx of the insn.  */
211
  rtx insn;
212
  /* Register life information: record all live hard registers, and all
213
     live pseudos that have a hard register.  */
214
  regset_head live_throughout;
215
  regset_head dead_or_set;
216
 
217
  /* Copies of the global variables computed by find_reloads.  */
218
  struct reload *rld;
219
  int n_reloads;
220
 
221
  /* Indicates which registers have already been used for spills.  */
222
  HARD_REG_SET used_spill_regs;
223
 
224
  /* Nonzero if find_reloads said the insn requires reloading.  */
225
  unsigned int need_reload:1;
226
  /* Nonzero if find_reloads needs to be run during reload_as_needed to
227
     perform modifications on any operands.  */
228
  unsigned int need_operand_change:1;
229
  /* Nonzero if eliminate_regs_in_insn said it requires eliminations.  */
230
  unsigned int need_elim:1;
231
  /* Nonzero if this insn was inserted by perform_caller_saves.  */
232
  unsigned int is_caller_save_insn:1;
233
};
234
 
235
/* A chain of insn_chain structures to describe all non-note insns in
236
   a function.  */
237
extern struct insn_chain *reload_insn_chain;
238
 
239
/* Allocate a new insn_chain structure.  */
240
extern struct insn_chain *new_insn_chain (void);
241
 
242
extern void compute_use_by_pseudos (HARD_REG_SET *, regset);
243
#endif
244
 
245
/* Functions from reload.c:  */
246
 
247
extern enum reg_class secondary_reload_class (bool, enum reg_class,
248
                                              enum machine_mode, rtx);
249
 
250
#ifdef GCC_INSN_CODES_H
251
extern enum reg_class scratch_reload_class (enum insn_code);
252
#endif
253
 
254
/* Return a memory location that will be used to copy X in mode MODE.
255
   If we haven't already made a location for this mode in this insn,
256
   call find_reloads_address on the location being returned.  */
257
extern rtx get_secondary_mem (rtx, enum machine_mode, int, enum reload_type);
258
 
259
/* Clear any secondary memory locations we've made.  */
260
extern void clear_secondary_mem (void);
261
 
262
/* Transfer all replacements that used to be in reload FROM to be in
263
   reload TO.  */
264
extern void transfer_replacements (int, int);
265
 
266
/* IN_RTX is the value loaded by a reload that we now decided to inherit,
267
   or a subpart of it.  If we have any replacements registered for IN_RTX,
268
   cancel the reloads that were supposed to load them.
269
   Return nonzero if we canceled any reloads.  */
270
extern int remove_address_replacements (rtx in_rtx);
271
 
272
/* Like rtx_equal_p except that it allows a REG and a SUBREG to match
273
   if they are the same hard reg, and has special hacks for
274
   autoincrement and autodecrement.  */
275
extern int operands_match_p (rtx, rtx);
276
 
277
/* Return 1 if altering OP will not modify the value of CLOBBER.  */
278
extern int safe_from_earlyclobber (rtx, rtx);
279
 
280
/* Search the body of INSN for values that need reloading and record them
281
   with push_reload.  REPLACE nonzero means record also where the values occur
282
   so that subst_reloads can be used.  */
283
extern int find_reloads (rtx, int, int, int, short *);
284
 
285
/* Compute the sum of X and Y, making canonicalizations assumed in an
286
   address, namely: sum constant integers, surround the sum of two
287
   constants with a CONST, put the constant as the second operand, and
288
   group the constant on the outermost sum.  */
289
extern rtx form_sum (rtx, rtx);
290
 
291
/* Substitute into the current INSN the registers into which we have reloaded
292
   the things that need reloading.  */
293
extern void subst_reloads (rtx);
294
 
295
/* Make a copy of any replacements being done into X and move those copies
296
   to locations in Y, a copy of X.  We only look at the highest level of
297
   the RTL.  */
298
extern void copy_replacements (rtx, rtx);
299
 
300
/* Change any replacements being done to *X to be done to *Y */
301
extern void move_replacements (rtx *x, rtx *y);
302
 
303
/* If LOC was scheduled to be replaced by something, return the replacement.
304
   Otherwise, return *LOC.  */
305
extern rtx find_replacement (rtx *);
306
 
307
/* Nonzero if modifying X will affect IN.  */
308
extern int reg_overlap_mentioned_for_reload_p (rtx, rtx);
309
 
310
/* Check the insns before INSN to see if there is a suitable register
311
   containing the same value as GOAL.  */
312
extern rtx find_equiv_reg (rtx, rtx, enum reg_class, int, short *,
313
                           int, enum machine_mode);
314
 
315
/* Return 1 if register REGNO is the subject of a clobber in insn INSN.  */
316
extern int regno_clobbered_p (unsigned int, rtx, enum machine_mode, int);
317
 
318
/* Return 1 if X is an operand of an insn that is being earlyclobbered.  */
319
extern int earlyclobber_operand_p (rtx);
320
 
321
/* Record one reload that needs to be performed.  */
322
extern int push_reload (rtx, rtx, rtx *, rtx *, enum reg_class,
323
                        enum machine_mode, enum machine_mode,
324
                        int, int, int, enum reload_type);
325
 
326
/* Functions in postreload.c:  */
327
extern void reload_cse_regs (rtx);
328
 
329
/* Functions in reload1.c:  */
330
 
331
/* Initialize the reload pass once per compilation.  */
332
extern void init_reload (void);
333
 
334
/* The reload pass itself.  */
335
extern int reload (rtx, int);
336
 
337
/* Mark the slots in regs_ever_live for the hard regs
338
   used by pseudo-reg number REGNO.  */
339
extern void mark_home_live (int);
340
 
341
/* Scan X and replace any eliminable registers (such as fp) with a
342
   replacement (such as sp), plus an offset.  */
343
extern rtx eliminate_regs (rtx, enum machine_mode, rtx);
344
 
345
/* Deallocate the reload register used by reload number R.  */
346
extern void deallocate_reload_reg (int r);
347
 
348
/* Functions in caller-save.c:  */
349
 
350
/* Initialize for caller-save.  */
351
extern void init_caller_save (void);
352
 
353
/* Initialize save areas by showing that we haven't allocated any yet.  */
354
extern void init_save_areas (void);
355
 
356
/* Allocate save areas for any hard registers that might need saving.  */
357
extern void setup_save_areas (void);
358
 
359
/* Find the places where hard regs are live across calls and save them.  */
360
extern void save_call_clobbered_regs (void);
361
 
362
/* Replace (subreg (reg)) with the appropriate (reg) for any operands.  */
363
extern void cleanup_subreg_operands (rtx);
364
 
365
/* Debugging support.  */
366
extern void debug_reload_to_stream (FILE *);
367
extern void debug_reload (void);
368
 
369
/* Compute the actual register we should reload to, in case we're
370
   reloading to/from a register that is wider than a word.  */
371
extern rtx reload_adjust_reg_for_mode (rtx, enum machine_mode);

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.