?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2003-06-19 Aldy Hernandez <aldyh@redhat.com>
[official-gcc.git] / gcc / rtl.h
blobd71a6ae8a82bd666697b2b2a5a0b7e2794b7965e
1 /* Register Transfer Language (RTL) definitions for GCC
2 Copyright (C) 1987, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003 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 2, 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 COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA. */
21
22 #ifndef GCC_RTL_H
23 #define GCC_RTL_H
24
25 struct function;
26
27 #include "machmode.h"
28 #include "input.h"
29
30 #undef FFS /* Some systems predefine this symbol; don't let it interfere. */
31 #undef FLOAT /* Likewise. */
32 #undef ABS /* Likewise. */
33 #undef PC /* Likewise. */
34
35 /* Value used by some passes to "recognize" noop moves as valid
36 instructions. */
37 #define NOOP_MOVE_INSN_CODE INT_MAX
38
39 /* Register Transfer Language EXPRESSIONS CODES */
40
41 #define RTX_CODE enum rtx_code
42 enum rtx_code {
43
44 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) ENUM ,
45 #include "rtl.def" /* rtl expressions are documented here */
46 #undef DEF_RTL_EXPR
47
48 LAST_AND_UNUSED_RTX_CODE}; /* A convenient way to get a value for
49 NUM_RTX_CODE.
50 Assumes default enum value assignment. */
51
52 #define NUM_RTX_CODE ((int) LAST_AND_UNUSED_RTX_CODE)
53 /* The cast here, saves many elsewhere. */
54
55 extern const unsigned char rtx_length[NUM_RTX_CODE];
56 #define GET_RTX_LENGTH(CODE) (rtx_length[(int) (CODE)])
57
58 extern const char * const rtx_name[NUM_RTX_CODE];
59 #define GET_RTX_NAME(CODE) (rtx_name[(int) (CODE)])
60
61 extern const char * const rtx_format[NUM_RTX_CODE];
62 #define GET_RTX_FORMAT(CODE) (rtx_format[(int) (CODE)])
63
64 extern const char rtx_class[NUM_RTX_CODE];
65 #define GET_RTX_CLASS(CODE) (rtx_class[(int) (CODE)])
66
67 extern const unsigned char rtx_next[NUM_RTX_CODE];
68 \f
69 /* The flags and bitfields of an ADDR_DIFF_VEC. BASE is the base label
70 relative to which the offsets are calculated, as explained in rtl.def. */
71 typedef struct
72 {
73 /* Set at the start of shorten_branches - ONLY WHEN OPTIMIZING - : */
74 unsigned min_align: 8;
75 /* Flags: */
76 unsigned base_after_vec: 1; /* BASE is after the ADDR_DIFF_VEC. */
77 unsigned min_after_vec: 1; /* minimum address target label is
78 after the ADDR_DIFF_VEC. */
79 unsigned max_after_vec: 1; /* maximum address target label is
80 after the ADDR_DIFF_VEC. */
81 unsigned min_after_base: 1; /* minimum address target label is
82 after BASE. */
83 unsigned max_after_base: 1; /* maximum address target label is
84 after BASE. */
85 /* Set by the actual branch shortening process - ONLY WHEN OPTIMIZING - : */
86 unsigned offset_unsigned: 1; /* offsets have to be treated as unsigned. */
87 unsigned : 2;
88 unsigned scale : 8;
89 } addr_diff_vec_flags;
90
91 /* Structure used to describe the attributes of a MEM. These are hashed
92 so MEMs that the same attributes share a data structure. This means
93 they cannot be modified in place. If any element is nonzero, it means
94 the value of the corresponding attribute is unknown. */
95 /* ALIGN and SIZE are the alignment and size of the MEM itself,
96 while EXPR can describe a larger underlying object, which might have a
97 stricter alignment; OFFSET is the offset of the MEM within that object. */
98 typedef struct mem_attrs GTY(())
99 {
100 HOST_WIDE_INT alias; /* Memory alias set. */
101 tree expr; /* expr corresponding to MEM. */
102 rtx offset; /* Offset from start of DECL, as CONST_INT. */
103 rtx size; /* Size in bytes, as a CONST_INT. */
104 unsigned int align; /* Alignment of MEM in bits. */
105 } mem_attrs;
106
107 /* Structure used to describe the attributes of a REG in similar way as
108 mem_attrs does for MEM above. */
109
110 typedef struct reg_attrs GTY(())
111 {
112 tree decl; /* decl corresponding to REG. */
113 HOST_WIDE_INT offset; /* Offset from start of DECL. */
114 } reg_attrs;
115
116 /* Common union for an element of an rtx. */
117
118 union rtunion_def
119 {
120 HOST_WIDE_INT rtwint;
121 int rtint;
122 unsigned int rtuint;
123 const char *rtstr;
124 rtx rtx;
125 rtvec rtvec;
126 enum machine_mode rttype;
127 addr_diff_vec_flags rt_addr_diff_vec_flags;
128 struct cselib_val_struct *rt_cselib;
129 struct bitmap_head_def *rtbit;
130 tree rttree;
131 struct basic_block_def *bb;
132 mem_attrs *rtmem;
133 reg_attrs *rtreg;
134 };
135 typedef union rtunion_def rtunion;
136
137 /* RTL expression ("rtx"). */
138
139 struct rtx_def GTY((chain_next ("RTX_NEXT (&%h)"),
140 chain_prev ("RTX_PREV (&%h)")))
141 {
142 /* The kind of expression this is. */
143 ENUM_BITFIELD(rtx_code) code: 16;
144
145 /* The kind of value the expression has. */
146 ENUM_BITFIELD(machine_mode) mode : 8;
147
148 /* 1 in a MEM if we should keep the alias set for this mem unchanged
149 when we access a component.
150 1 in a CALL_INSN if it is a sibling call.
151 1 in a SET that is for a return.
152 In a CODE_LABEL, part of the two-bit alternate entry field. */
153 unsigned int jump : 1;
154 /* In a CODE_LABEL, part of the two-bit alternate entry field.
155 1 in a MEM if it cannot trap. */
156 unsigned int call : 1;
157 /* 1 in a REG, MEM, or CONCAT if the value is set at most once, anywhere.
158 1 in a SUBREG if it references an unsigned object whose mode has been
159 from a promoted to a wider mode.
160 1 in a SYMBOL_REF if it addresses something in the per-function
161 constants pool.
162 1 in a CALL_INSN, NOTE, or EXPR_LIST for a const or pure call.
163 1 in a JUMP_INSN, CALL_INSN, or INSN of an annulling branch. */
164 unsigned int unchanging : 1;
165 /* 1 in a MEM or ASM_OPERANDS expression if the memory reference is volatile.
166 1 in an INSN, CALL_INSN, JUMP_INSN, CODE_LABEL, BARRIER, or NOTE
167 if it has been deleted.
168 1 in a REG expression if corresponds to a variable declared by the user,
169 0 for an internally generated temporary.
170 1 in a SUBREG with a negative value.
171 1 in a LABEL_REF or in a REG_LABEL note for a non-local label.
172 In a SYMBOL_REF, this flag is used for machine-specific purposes. */
173 unsigned int volatil : 1;
174 /* 1 in a MEM referring to a field of an aggregate.
175 0 if the MEM was a variable or the result of a * operator in C;
176 1 if it was the result of a . or -> operator (on a struct) in C.
177 1 in a REG if the register is used only in exit code a loop.
178 1 in a SUBREG expression if was generated from a variable with a
179 promoted mode.
180 1 in a CODE_LABEL if the label is used for nonlocal gotos
181 and must not be deleted even if its count is zero.
182 1 in a LABEL_REF if this is a reference to a label outside the
183 current loop.
184 1 in an INSN, JUMP_INSN or CALL_INSN if this insn must be scheduled
185 together with the preceding insn. Valid only within sched.
186 1 in an INSN, JUMP_INSN, or CALL_INSN if insn is in a delay slot and
187 from the target of a branch. Valid from reorg until end of compilation;
188 cleared before used.
189 1 in an INSN, JUMP_INSN or CALL_INSN or related rtx if this insn is
190 dead code. Valid only during dead-code elimination phase; cleared
191 before use. */
192 unsigned int in_struct : 1;
193 /* At the end of RTL generation, 1 if this rtx is used. This is used for
194 copying shared structure. See `unshare_all_rtl'.
195 In a REG, this is not needed for that purpose, and used instead
196 in `leaf_renumber_regs_insn'.
197 1 in a SYMBOL_REF, means that emit_library_call
198 has used it as the function. */
199 unsigned int used : 1;
200 /* Nonzero if this rtx came from procedure integration.
201 1 in a REG or PARALLEL means this rtx refers to the return value
202 of the current function.
203 1 in a SYMBOL_REF if the symbol is weak. */
204 unsigned integrated : 1;
205 /* 1 in an INSN or a SET if this rtx is related to the call frame,
206 either changing how we compute the frame address or saving and
207 restoring registers in the prologue and epilogue.
208 1 in a MEM if the MEM refers to a scalar, rather than a member of
209 an aggregate.
210 1 in a REG if the register is a pointer.
211 1 in a SYMBOL_REF if it addresses something in the per-function
212 constant string pool. */
213 unsigned frame_related : 1;
214
215 /* The first element of the operands of this rtx.
216 The number of operands and their types are controlled
217 by the `code' field, according to rtl.def. */
218 rtunion GTY ((special ("rtx_def"),
219 desc ("GET_CODE (&%0)"))) fld[1];
220 };
221
222 #define NULL_RTX (rtx) 0
223
224 /* The "next" and "previous" RTX, relative to this one. */
225
226 #define RTX_NEXT(X) (rtx_next[GET_CODE (X)] == 0 ? NULL \
227 : *(rtx *)(((char *)X) + rtx_next[GET_CODE (X)]))
228
229 /* FIXME: the "NEXT_INSN (PREV_INSN (X)) == X" condition shouldn't be needed.
230 */
231 #define RTX_PREV(X) ((GET_CODE (X) == INSN \
232 || GET_CODE (X) == CALL_INSN \
233 || GET_CODE (X) == JUMP_INSN \
234 || GET_CODE (X) == NOTE \
235 || GET_CODE (X) == BARRIER \
236 || GET_CODE (X) == CODE_LABEL) \
237 && PREV_INSN (X) != NULL \
238 && NEXT_INSN (PREV_INSN (X)) == X \
239 ? PREV_INSN (X) : NULL)
240
241 /* Define macros to access the `code' field of the rtx. */
242
243 #define GET_CODE(RTX) ((enum rtx_code) (RTX)->code)
244 #define PUT_CODE(RTX, CODE) ((RTX)->code = (ENUM_BITFIELD(rtx_code)) (CODE))
245
246 #define GET_MODE(RTX) ((enum machine_mode) (RTX)->mode)
247 #define PUT_MODE(RTX, MODE) ((RTX)->mode = (ENUM_BITFIELD(machine_mode)) (MODE))
248
249 /* RTL vector. These appear inside RTX's when there is a need
250 for a variable number of things. The principle use is inside
251 PARALLEL expressions. */
252
253 struct rtvec_def GTY(()) {
254 int num_elem; /* number of elements */
255 rtx GTY ((length ("%h.num_elem"))) elem[1];
256 };
257
258 #define NULL_RTVEC (rtvec) 0
259
260 #define GET_NUM_ELEM(RTVEC) ((RTVEC)->num_elem)
261 #define PUT_NUM_ELEM(RTVEC, NUM) ((RTVEC)->num_elem = (NUM))
262
263 /* Predicate yielding nonzero iff X is an rtl for a register. */
264 #define REG_P(X) (GET_CODE (X) == REG)
265
266 /* Predicate yielding nonzero iff X is a label insn. */
267 #define LABEL_P(X) (GET_CODE (X) == CODE_LABEL)
268
269 /* Predicate yielding nonzero iff X is a jump insn. */
270 #define JUMP_P(X) (GET_CODE (X) == JUMP_INSN)
271
272 /* Predicate yielding nonzero iff X is a note insn. */
273 #define NOTE_P(X) (GET_CODE (X) == NOTE)
274
275 /* Predicate yielding nonzero iff X is a barrier insn. */
276 #define BARRIER_P(X) (GET_CODE (X) == BARRIER)
277
278 /* Predicate yielding nonzero iff X is a data for a jump table. */
279 #define JUMP_TABLE_DATA_P(INSN) \
280 (JUMP_P (INSN) && (GET_CODE (PATTERN (INSN)) == ADDR_VEC || \
281 GET_CODE (PATTERN (INSN)) == ADDR_DIFF_VEC))
282
283 /* 1 if X is a constant value that is an integer. */
284
285 #define CONSTANT_P(X) \
286 (GET_CODE (X) == LABEL_REF || GET_CODE (X) == SYMBOL_REF \
287 || GET_CODE (X) == CONST_INT || GET_CODE (X) == CONST_DOUBLE \
288 || GET_CODE (X) == CONST || GET_CODE (X) == HIGH \
289 || GET_CODE (X) == CONST_VECTOR \
290 || GET_CODE (X) == CONSTANT_P_RTX)
291
292 /* General accessor macros for accessing the fields of an rtx. */
293
294 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
295 /* The bit with a star outside the statement expr and an & inside is
296 so that N can be evaluated only once. */
297 #define RTL_CHECK1(RTX, N, C1) __extension__ \
298 (*({ rtx const _rtx = (RTX); const int _n = (N); \
299 const enum rtx_code _code = GET_CODE (_rtx); \
300 if (_n < 0 || _n >= GET_RTX_LENGTH (_code)) \
301 rtl_check_failed_bounds (_rtx, _n, __FILE__, __LINE__, \
302 __FUNCTION__); \
303 if (GET_RTX_FORMAT(_code)[_n] != C1) \
304 rtl_check_failed_type1 (_rtx, _n, C1, __FILE__, __LINE__, \
305 __FUNCTION__); \
306 &_rtx->fld[_n]; }))
307
308 #define RTL_CHECK2(RTX, N, C1, C2) __extension__ \
309 (*({ rtx const _rtx = (RTX); const int _n = (N); \
310 const enum rtx_code _code = GET_CODE (_rtx); \
311 if (_n < 0 || _n >= GET_RTX_LENGTH (_code)) \
312 rtl_check_failed_bounds (_rtx, _n, __FILE__, __LINE__, \
313 __FUNCTION__); \
314 if (GET_RTX_FORMAT(_code)[_n] != C1 \
315 && GET_RTX_FORMAT(_code)[_n] != C2) \
316 rtl_check_failed_type2 (_rtx, _n, C1, C2, __FILE__, __LINE__, \
317 __FUNCTION__); \
318 &_rtx->fld[_n]; }))
319
320 #define RTL_CHECKC1(RTX, N, C) __extension__ \
321 (*({ rtx const _rtx = (RTX); const int _n = (N); \
322 if (GET_CODE (_rtx) != (C)) \
323 rtl_check_failed_code1 (_rtx, (C), __FILE__, __LINE__, \
324 __FUNCTION__); \
325 &_rtx->fld[_n]; }))
326
327 #define RTL_CHECKC2(RTX, N, C1, C2) __extension__ \
328 (*({ rtx const _rtx = (RTX); const int _n = (N); \
329 const enum rtx_code _code = GET_CODE (_rtx); \
330 if (_code != (C1) && _code != (C2)) \
331 rtl_check_failed_code2 (_rtx, (C1), (C2), __FILE__, __LINE__, \
332 __FUNCTION__); \
333 &_rtx->fld[_n]; }))
334
335 #define RTVEC_ELT(RTVEC, I) __extension__ \
336 (*({ rtvec const _rtvec = (RTVEC); const int _i = (I); \
337 if (_i < 0 || _i >= GET_NUM_ELEM (_rtvec)) \
338 rtvec_check_failed_bounds (_rtvec, _i, __FILE__, __LINE__, \
339 __FUNCTION__); \
340 &_rtvec->elem[_i]; }))
341
342 extern void rtl_check_failed_bounds PARAMS ((rtx, int,
343 const char *, int, const char *))
344 ATTRIBUTE_NORETURN;
345 extern void rtl_check_failed_type1 PARAMS ((rtx, int, int,
346 const char *, int, const char *))
347 ATTRIBUTE_NORETURN;
348 extern void rtl_check_failed_type2 PARAMS ((rtx, int, int, int,
349 const char *, int, const char *))
350 ATTRIBUTE_NORETURN;
351 extern void rtl_check_failed_code1 PARAMS ((rtx, enum rtx_code,
352 const char *, int, const char *))
353 ATTRIBUTE_NORETURN;
354 extern void rtl_check_failed_code2 PARAMS ((rtx, enum rtx_code, enum rtx_code,
355 const char *, int, const char *))
356 ATTRIBUTE_NORETURN;
357 extern void rtvec_check_failed_bounds PARAMS ((rtvec, int,
358 const char *, int, const char *))
359 ATTRIBUTE_NORETURN;
360
361 #else /* not ENABLE_RTL_CHECKING */
362
363 #define RTL_CHECK1(RTX, N, C1) ((RTX)->fld[N])
364 #define RTL_CHECK2(RTX, N, C1, C2) ((RTX)->fld[N])
365 #define RTL_CHECKC1(RTX, N, C) ((RTX)->fld[N])
366 #define RTL_CHECKC2(RTX, N, C1, C2) ((RTX)->fld[N])
367 #define RTVEC_ELT(RTVEC, I) ((RTVEC)->elem[I])
368
369 #endif
370
371 /* General accessor macros for accessing the flags of an rtx. */
372
373 /* Access an individual rtx flag, with no checking of any kind. */
374 #define RTX_FLAG(RTX, FLAG) ((RTX)->FLAG)
375
376 #if defined ENABLE_RTL_FLAG_CHECKING && (GCC_VERSION >= 2007)
377 #define RTL_FLAG_CHECK1(NAME, RTX, C1) __extension__ \
378 ({ rtx const _rtx = (RTX); \
379 if (GET_CODE(_rtx) != C1) \
380 rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \
381 __FUNCTION__); \
382 _rtx; })
383
384 #define RTL_FLAG_CHECK2(NAME, RTX, C1, C2) __extension__ \
385 ({ rtx const _rtx = (RTX); \
386 if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2) \
387 rtl_check_failed_flag (NAME,_rtx, __FILE__, __LINE__, \
388 __FUNCTION__); \
389 _rtx; })
390
391 #define RTL_FLAG_CHECK3(NAME, RTX, C1, C2, C3) __extension__ \
392 ({ rtx const _rtx = (RTX); \
393 if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \
394 && GET_CODE(_rtx) != C3) \
395 rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \
396 __FUNCTION__); \
397 _rtx; })
398
399 #define RTL_FLAG_CHECK4(NAME, RTX, C1, C2, C3, C4) __extension__ \
400 ({ rtx const _rtx = (RTX); \
401 if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \
402 && GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4) \
403 rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \
404 __FUNCTION__); \
405 _rtx; })
406
407 #define RTL_FLAG_CHECK5(NAME, RTX, C1, C2, C3, C4, C5) __extension__ \
408 ({ rtx const _rtx = (RTX); \
409 if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \
410 && GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4 \
411 && GET_CODE(_rtx) != C5) \
412 rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \
413 __FUNCTION__); \
414 _rtx; })
415
416 #define RTL_FLAG_CHECK6(NAME, RTX, C1, C2, C3, C4, C5, C6) \
417 __extension__ \
418 ({ rtx const _rtx = (RTX); \
419 if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \
420 && GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4 \
421 && GET_CODE(_rtx) != C5 && GET_CODE(_rtx) != C6) \
422 rtl_check_failed_flag (NAME,_rtx, __FILE__, __LINE__, \
423 __FUNCTION__); \
424 _rtx; })
425
426 #define RTL_FLAG_CHECK7(NAME, RTX, C1, C2, C3, C4, C5, C6, C7) \
427 __extension__ \
428 ({ rtx const _rtx = (RTX); \
429 if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \
430 && GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4 \
431 && GET_CODE(_rtx) != C5 && GET_CODE(_rtx) != C6 \
432 && GET_CODE(_rtx) != C7) \
433 rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \
434 __FUNCTION__); \
435 _rtx; })
436
437 #define RTL_FLAG_CHECK8(NAME, RTX, C1, C2, C3, C4, C5, C6, C7, C8) \
438 __extension__ \
439 ({ rtx const _rtx = (RTX); \
440 if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \
441 && GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4 \
442 && GET_CODE(_rtx) != C5 && GET_CODE(_rtx) != C6 \
443 && GET_CODE(_rtx) != C7 && GET_CODE(_rtx) != C8) \
444 rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \
445 __FUNCTION__); \
446 _rtx; })
447
448 extern void rtl_check_failed_flag PARAMS ((const char *, rtx, const char *,
449 int, const char *))
450 ATTRIBUTE_NORETURN
451 ;
452
453 #else /* not ENABLE_RTL_FLAG_CHECKING */
454
455 #define RTL_FLAG_CHECK1(NAME, RTX, C1) (RTX)
456 #define RTL_FLAG_CHECK2(NAME, RTX, C1, C2) (RTX)
457 #define RTL_FLAG_CHECK3(NAME, RTX, C1, C2, C3) (RTX)
458 #define RTL_FLAG_CHECK4(NAME, RTX, C1, C2, C3, C4) (RTX)
459 #define RTL_FLAG_CHECK5(NAME, RTX, C1, C2, C3, C4, C5) (RTX)
460 #define RTL_FLAG_CHECK6(NAME, RTX, C1, C2, C3, C4, C5, C6) (RTX)
461 #define RTL_FLAG_CHECK7(NAME, RTX, C1, C2, C3, C4, C5, C6, C7) (RTX)
462 #define RTL_FLAG_CHECK8(NAME, RTX, C1, C2, C3, C4, C5, C6, C7, C8) (RTX)
463 #endif
464
465 #define CLEAR_RTX_FLAGS(RTX) \
466 do { \
467 rtx const _rtx = (RTX); \
468 _rtx->call = 0; \
469 _rtx->frame_related = 0; \
470 _rtx->in_struct = 0; \
471 _rtx->integrated = 0; \
472 _rtx->jump = 0; \
473 _rtx->unchanging = 0; \
474 _rtx->used = 0; \
475 _rtx->volatil = 0; \
476 } while (0)
477
478 #define XWINT(RTX, N) (RTL_CHECK1 (RTX, N, 'w').rtwint)
479 #define XINT(RTX, N) (RTL_CHECK2 (RTX, N, 'i', 'n').rtint)
480 #define XSTR(RTX, N) (RTL_CHECK2 (RTX, N, 's', 'S').rtstr)
481 #define XEXP(RTX, N) (RTL_CHECK2 (RTX, N, 'e', 'u').rtx)
482 #define XVEC(RTX, N) (RTL_CHECK2 (RTX, N, 'E', 'V').rtvec)
483 #define XMODE(RTX, N) (RTL_CHECK1 (RTX, N, 'M').rttype)
484 #define XBITMAP(RTX, N) (RTL_CHECK1 (RTX, N, 'b').rtbit)
485 #define XTREE(RTX, N) (RTL_CHECK1 (RTX, N, 't').rttree)
486 #define XBBDEF(RTX, N) (RTL_CHECK1 (RTX, N, 'B').bb)
487 #define XTMPL(RTX, N) (RTL_CHECK1 (RTX, N, 'T').rtstr)
488
489 #define XVECEXP(RTX, N, M) RTVEC_ELT (XVEC (RTX, N), M)
490 #define XVECLEN(RTX, N) GET_NUM_ELEM (XVEC (RTX, N))
491
492 /* These are like XWINT, etc. except that they expect a '0' field instead
493 of the normal type code. */
494
495 #define X0WINT(RTX, N) (RTL_CHECK1 (RTX, N, '0').rtwint)
496 #define X0INT(RTX, N) (RTL_CHECK1 (RTX, N, '0').rtint)
497 #define X0UINT(RTX, N) (RTL_CHECK1 (RTX, N, '0').rtuint)
498 #define X0STR(RTX, N) (RTL_CHECK1 (RTX, N, '0').rtstr)
499 #define X0EXP(RTX, N) (RTL_CHECK1 (RTX, N, '0').rtx)
500 #define X0VEC(RTX, N) (RTL_CHECK1 (RTX, N, '0').rtvec)
501 #define X0MODE(RTX, N) (RTL_CHECK1 (RTX, N, '0').rttype)
502 #define X0BITMAP(RTX, N) (RTL_CHECK1 (RTX, N, '0').rtbit)
503 #define X0TREE(RTX, N) (RTL_CHECK1 (RTX, N, '0').rttree)
504 #define X0BBDEF(RTX, N) (RTL_CHECK1 (RTX, N, '0').bb)
505 #define X0ADVFLAGS(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_addr_diff_vec_flags)
506 #define X0CSELIB(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_cselib)
507 #define X0MEMATTR(RTX, N) (RTL_CHECKC1 (RTX, N, MEM).rtmem)
508 #define X0REGATTR(RTX, N) (RTL_CHECKC1 (RTX, N, REG).rtreg)
509
510 #define XCWINT(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rtwint)
511 #define XCINT(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rtint)
512 #define XCUINT(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rtuint)
513 #define XCSTR(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rtstr)
514 #define XCEXP(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rtx)
515 #define XCVEC(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rtvec)
516 #define XCMODE(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rttype)
517 #define XCBITMAP(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rtbit)
518 #define XCTREE(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rttree)
519 #define XCBBDEF(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).bb)
520 #define XCADVFLAGS(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_addr_diff_vec_flags)
521 #define XCCSELIB(RTX, N, C) (RTL_CHECKC1 (RTX, N, C).rt_cselib)
522
523 #define XCVECEXP(RTX, N, M, C) RTVEC_ELT (XCVEC (RTX, N, C), M)
524 #define XCVECLEN(RTX, N, C) GET_NUM_ELEM (XCVEC (RTX, N, C))
525
526 #define XC2EXP(RTX, N, C1, C2) (RTL_CHECKC2 (RTX, N, C1, C2).rtx)
527 \f
528 /* ACCESS MACROS for particular fields of insns. */
529
530 /* Determines whether X is an insn. */
531 #define INSN_P(X) (GET_RTX_CLASS (GET_CODE(X)) == 'i')
532
533 /* Holds a unique number for each insn.
534 These are not necessarily sequentially increasing. */
535 #define INSN_UID(INSN) XINT (INSN, 0)
536
537 /* Chain insns together in sequence. */
538 #define PREV_INSN(INSN) XEXP (INSN, 1)
539 #define NEXT_INSN(INSN) XEXP (INSN, 2)
540
541 #define BLOCK_FOR_INSN(INSN) XBBDEF (INSN, 3)
542 #define INSN_LOCATOR(INSN) XINT (INSN, 4)
543 /* The body of an insn. */
544 #define PATTERN(INSN) XEXP (INSN, 5)
545
546 /* Code number of instruction, from when it was recognized.
547 -1 means this instruction has not been recognized yet. */
548 #define INSN_CODE(INSN) XINT (INSN, 6)
549
550 /* Set up in flow.c; empty before then.
551 Holds a chain of INSN_LIST rtx's whose first operands point at
552 previous insns with direct data-flow connections to this one.
553 That means that those insns set variables whose next use is in this insn.
554 They are always in the same basic block as this insn. */
555 #define LOG_LINKS(INSN) XEXP(INSN, 7)
556
557 #define RTX_INTEGRATED_P(RTX) \
558 (RTL_FLAG_CHECK8("RTX_INTEGRATED_P", (RTX), INSN, CALL_INSN, \
559 JUMP_INSN, INSN_LIST, BARRIER, CODE_LABEL, CONST, \
560 NOTE)->integrated)
561 #define RTX_UNCHANGING_P(RTX) \
562 (RTL_FLAG_CHECK3("RTX_UNCHANGING_P", (RTX), REG, MEM, CONCAT)->unchanging)
563 #define RTX_FRAME_RELATED_P(RTX) \
564 (RTL_FLAG_CHECK5("RTX_FRAME_RELATED_P", (RTX), INSN, CALL_INSN, \
565 JUMP_INSN, BARRIER, SET)->frame_related)
566
567 /* 1 if RTX is an insn that has been deleted. */
568 #define INSN_DELETED_P(RTX) \
569 (RTL_FLAG_CHECK6("INSN_DELETED_P", (RTX), INSN, CALL_INSN, JUMP_INSN, \
570 CODE_LABEL, BARRIER, NOTE)->volatil)
571
572 /* 1 if RTX is a call to a const or pure function. */
573 #define CONST_OR_PURE_CALL_P(RTX) \
574 (RTL_FLAG_CHECK3("CONST_OR_PURE_CALL_P", (RTX), CALL_INSN, NOTE, \
575 EXPR_LIST)->unchanging)
576
577 /* 1 if RTX is a call_insn for a sibling call. */
578 #define SIBLING_CALL_P(RTX) \
579 (RTL_FLAG_CHECK1("SIBLING_CALL_P", (RTX), CALL_INSN)->jump)
580
581 /* 1 if RTX is a jump_insn, call_insn, or insn that is an annulling branch. */
582 #define INSN_ANNULLED_BRANCH_P(RTX) \
583 (RTL_FLAG_CHECK3("INSN_ANNULLED_BRANCH_P", (RTX), JUMP_INSN, CALL_INSN, INSN)->unchanging)
584
585 /* 1 if RTX is an insn that is dead code. Valid only for dead-code
586 elimination phase. */
587 #define INSN_DEAD_CODE_P(RTX) \
588 (RTL_FLAG_CHECK3("INSN_DEAD_CODE_P", (RTX), INSN, CALL_INSN, JUMP_INSN)->in_struct)
589
590 /* 1 if RTX is an insn in a delay slot and is from the target of the branch.
591 If the branch insn has INSN_ANNULLED_BRANCH_P set, this insn should only be
592 executed if the branch is taken. For annulled branches with this bit
593 clear, the insn should be executed only if the branch is not taken. */
594 #define INSN_FROM_TARGET_P(RTX) \
595 (RTL_FLAG_CHECK3("INSN_FROM_TARGET_P", (RTX), INSN, JUMP_INSN, CALL_INSN)->in_struct)
596
597 #define ADDR_DIFF_VEC_FLAGS(RTX) X0ADVFLAGS(RTX, 4)
598
599 #define CSELIB_VAL_PTR(RTX) X0CSELIB(RTX, 0)
600
601 /* Holds a list of notes on what this insn does to various REGs.
602 It is a chain of EXPR_LIST rtx's, where the second operand is the
603 chain pointer and the first operand is the REG being described.
604 The mode field of the EXPR_LIST contains not a real machine mode
605 but a value from enum reg_note. */
606
607 #define REG_NOTES(INSN) XEXP(INSN, 8)
608
609 /* Don't forget to change reg_note_name in rtl.c. */
610 enum reg_note
611 {
612 /* The value in REG dies in this insn (i.e., it is not needed past
613 this insn). If REG is set in this insn, the REG_DEAD note may,
614 but need not, be omitted. */
615 REG_DEAD = 1,
616
617 /* The REG is autoincremented or autodecremented. */
618 REG_INC,
619
620 /* Describes the insn as a whole; it says that the insn sets a register
621 to a constant value or to be equivalent to a memory address. If the
622 register is spilled to the stack then the constant value should be
623 substituted for it. The contents of the REG_EQUIV is the constant
624 value or memory address, which may be different from the source of
625 the SET although it has the same value. A REG_EQUIV note may also
626 appear on an insn which copies a register parameter to a pseudo-register,
627 if there is a memory address which could be used to hold that
628 pseudo-register throughout the function. */
629 REG_EQUIV,
630
631 /* Like REG_EQUIV except that the destination is only momentarily equal
632 to the specified rtx. Therefore, it cannot be used for substitution;
633 but it can be used for cse. */
634 REG_EQUAL,
635
636 /* The register set in this insn held 0 before the insn. The contents of
637 the note is the insn that stored the 0. If that insn is deleted or
638 patched to a NOTE, the REG_WAS_0 is inoperative. The REG_WAS_0 note
639 is actually an INSN_LIST, not an EXPR_LIST. */
640 REG_WAS_0,
641
642 /* This insn copies the return-value of a library call out of the hard reg
643 for return values. This note is actually an INSN_LIST and it points to
644 the first insn involved in setting up arguments for the call. flow.c
645 uses this to delete the entire library call when its result is dead. */
646 REG_RETVAL,
647
648 /* The inverse of REG_RETVAL: it goes on the first insn of the library call
649 and points at the one that has the REG_RETVAL. This note is also an
650 INSN_LIST. */
651 REG_LIBCALL,
652
653 /* The register is always nonnegative during the containing loop. This is
654 used in branches so that decrement and branch instructions terminating
655 on zero can be matched. There must be an insn pattern in the md file
656 named `decrement_and_branch_until_zero' or else this will never be added
657 to any instructions. */
658 REG_NONNEG,
659
660 /* There is no conflict *after this insn* between the register in the note
661 and the destination of this insn. */
662 REG_NO_CONFLICT,
663
664 /* Identifies a register set in this insn and never used. */
665 REG_UNUSED,
666
667 /* REG_CC_SETTER and REG_CC_USER link a pair of insns that set and use CC0,
668 respectively. Normally, these are required to be consecutive insns, but
669 we permit putting a cc0-setting insn in the delay slot of a branch as
670 long as only one copy of the insn exists. In that case, these notes
671 point from one to the other to allow code generation to determine what
672 any require information and to properly update CC_STATUS. These notes
673 are INSN_LISTs. */
674 REG_CC_SETTER, REG_CC_USER,
675
676 /* Points to a CODE_LABEL. Used by non-JUMP_INSNs to say that the
677 CODE_LABEL contained in the REG_LABEL note is used by the insn.
678 This note is an INSN_LIST. */
679 REG_LABEL,
680
681 /* REG_DEP_ANTI and REG_DEP_OUTPUT are used in LOG_LINKS to represent
682 write-after-read and write-after-write dependencies respectively.
683 Data dependencies, which are the only type of LOG_LINK created by
684 flow, are represented by a 0 reg note kind. */
685 REG_DEP_ANTI, REG_DEP_OUTPUT,
686
687 /* REG_BR_PROB is attached to JUMP_INSNs and CALL_INSNs.
688 It has an integer value. For jumps, it is the probability that this is a
689 taken branch. For calls, it is the probability that this call won't
690 return. */
691 REG_BR_PROB,
692
693 /* Attached to a call insn; indicates that the call is malloc-like and
694 that the pointer returned cannot alias anything else. */
695 REG_NOALIAS,
696
697 /* Used to optimize rtl generated by dynamic stack allocations for targets
698 where SETJMP_VIA_SAVE_AREA is true. */
699 REG_SAVE_AREA,
700
701 /* REG_BR_PRED is attached to JUMP_INSNs and CALL_INSNSs. It contains
702 CONCAT of two integer value. First specifies the branch predictor
703 that added the note, second specifies the predicted hitrate of branch
704 in the same format as REG_BR_PROB note uses. */
705 REG_BR_PRED,
706
707 /* Attached to insns that are RTX_FRAME_RELATED_P, but are too complex
708 for DWARF to interpret what they imply. The attached rtx is used
709 instead of intuition. */
710 REG_FRAME_RELATED_EXPR,
711
712 /* Indicates that REG holds the exception context for the function.
713 This context is shared by inline functions, so the code to acquire
714 the real exception context is delayed until after inlining. */
715 REG_EH_CONTEXT,
716
717 /* Indicates what exception region an INSN belongs in. This is used to
718 indicate what region to which a call may throw. REGION 0 indicates
719 that a call cannot throw at all. REGION -1 indicates that it cannot
720 throw, nor will it execute a non-local goto. */
721 REG_EH_REGION,
722
723 /* Used by haifa-sched to save NOTE_INSN notes across scheduling. */
724 REG_SAVE_NOTE,
725
726 /* Indicates that this insn (which is part of the prologue) computes
727 a value which might not be used later, and if so it's OK to delete
728 the insn. Normally, deleting any insn in the prologue is an error.
729 At present the parameter is unused and set to (const_int 0). */
730 REG_MAYBE_DEAD,
731
732 /* Indicates that a call does not return. */
733 REG_NORETURN,
734
735 /* Indicates that an indirect jump is a non-local goto instead of a
736 computed goto. */
737 REG_NON_LOCAL_GOTO,
738
739 /* This kind of note is generated at each to `setjmp',
740 and similar functions that can return twice. */
741 REG_SETJMP,
742
743 /* Indicate calls that always returns. */
744 REG_ALWAYS_RETURN,
745
746 /* Indicate that the memory load references a vtable. The expression
747 is of the form (plus (symbol_ref vtable_sym) (const_int offset)). */
748 REG_VTABLE_REF
749 };
750
751 /* The base value for branch probability notes. */
752 #define REG_BR_PROB_BASE 10000
753
754 /* Define macros to extract and insert the reg-note kind in an EXPR_LIST. */
755 #define REG_NOTE_KIND(LINK) ((enum reg_note) GET_MODE (LINK))
756 #define PUT_REG_NOTE_KIND(LINK, KIND) \
757 PUT_MODE (LINK, (enum machine_mode) (KIND))
758
759 /* Names for REG_NOTE's in EXPR_LIST insn's. */
760
761 extern const char * const reg_note_name[];
762 #define GET_REG_NOTE_NAME(MODE) (reg_note_name[(int) (MODE)])
763
764 /* This field is only present on CALL_INSNs. It holds a chain of EXPR_LIST of
765 USE and CLOBBER expressions.
766 USE expressions list the registers filled with arguments that
767 are passed to the function.
768 CLOBBER expressions document the registers explicitly clobbered
769 by this CALL_INSN.
770 Pseudo registers can not be mentioned in this list. */
771 #define CALL_INSN_FUNCTION_USAGE(INSN) XEXP(INSN, 9)
772
773 /* The label-number of a code-label. The assembler label
774 is made from `L' and the label-number printed in decimal.
775 Label numbers are unique in a compilation. */
776 #define CODE_LABEL_NUMBER(INSN) XINT (INSN, 6)
777
778 #define LINE_NUMBER NOTE
779
780 /* In a NOTE that is a line number, this is a string for the file name that the
781 line is in. We use the same field to record block numbers temporarily in
782 NOTE_INSN_BLOCK_BEG and NOTE_INSN_BLOCK_END notes. (We avoid lots of casts
783 between ints and pointers if we use a different macro for the block number.)
784 */
785
786 /* Opaque data. */
787 #define NOTE_DATA(INSN) XCINT (INSN, 4, NOTE)
788 #define NOTE_SOURCE_FILE(INSN) XCSTR (INSN, 4, NOTE)
789 #define NOTE_BLOCK(INSN) XCTREE (INSN, 4, NOTE)
790 #define NOTE_EH_HANDLER(INSN) XCINT (INSN, 4, NOTE)
791 #define NOTE_BASIC_BLOCK(INSN) XCBBDEF (INSN, 4, NOTE)
792 #define NOTE_EXPECTED_VALUE(INSN) XCEXP (INSN, 4, NOTE)
793 #define NOTE_PREDICTION(INSN) XCINT (INSN, 4, NOTE)
794 #define NOTE_PRECONDITIONED(INSN) XCINT (INSN, 4, NOTE)
795
796 /* In a NOTE that is a line number, this is the line number.
797 Other kinds of NOTEs are identified by negative numbers here. */
798 #define NOTE_LINE_NUMBER(INSN) XCINT (INSN, 5, NOTE)
799
800 /* Nonzero if INSN is a note marking the beginning of a basic block. */
801 #define NOTE_INSN_BASIC_BLOCK_P(INSN) \
802 (GET_CODE (INSN) == NOTE \
803 && NOTE_LINE_NUMBER (INSN) == NOTE_INSN_BASIC_BLOCK)
804
805 /* Algorithm and flags for prediction. */
806 #define NOTE_PREDICTION_ALG(INSN) (XCINT(INSN, 4, NOTE)>>8)
807 #define NOTE_PREDICTION_FLAGS(INSN) (XCINT(INSN, 4, NOTE)&0xff)
808 #define NOTE_PREDICT(ALG,FLAGS) ((ALG<<8)+(FLAGS))
809
810 /* Codes that appear in the NOTE_LINE_NUMBER field
811 for kinds of notes that are not line numbers.
812
813 Notice that we do not try to use zero here for any of
814 the special note codes because sometimes the source line
815 actually can be zero! This happens (for example) when we
816 are generating code for the per-translation-unit constructor
817 and destructor routines for some C++ translation unit.
818
819 If you should change any of the following values, or if you
820 should add a new value here, don't forget to change the
821 note_insn_name array in rtl.c. */
822
823 enum insn_note
824 {
825 /* Keep all of these numbers negative. Adjust as needed. */
826 NOTE_INSN_BIAS = -100,
827
828 /* This note is used to get rid of an insn
829 when it isn't safe to patch the insn out of the chain. */
830 NOTE_INSN_DELETED,
831
832 /* These are used to mark the beginning and end of a lexical block.
833 See NOTE_BLOCK, identify_blocks and reorder_blocks. */
834 NOTE_INSN_BLOCK_BEG,
835 NOTE_INSN_BLOCK_END,
836
837 /* These mark the extremes of a loop. */
838 NOTE_INSN_LOOP_BEG,
839 NOTE_INSN_LOOP_END,
840
841 /* Generated at the place in a loop that `continue' jumps to. */
842 NOTE_INSN_LOOP_CONT,
843 /* Generated at the start of a duplicated exit test. */
844 NOTE_INSN_LOOP_VTOP,
845
846 /* Generated at the end of a conditional at the top of the loop.
847 This is used to perform a lame form of loop rotation in lieu
848 of actually understanding the loop structure. The note is
849 discarded after rotation is complete. */
850 NOTE_INSN_LOOP_END_TOP_COND,
851
852 /* This kind of note is generated at the end of the function body,
853 just before the return insn or return label. In an optimizing
854 compilation it is deleted by the first jump optimization, after
855 enabling that optimizer to determine whether control can fall
856 off the end of the function body without a return statement. */
857 NOTE_INSN_FUNCTION_END,
858
859 /* This marks the point immediately after the last prologue insn. */
860 NOTE_INSN_PROLOGUE_END,
861
862 /* This marks the point immediately prior to the first epilogue insn. */
863 NOTE_INSN_EPILOGUE_BEG,
864
865 /* Generated in place of user-declared labels when they are deleted. */
866 NOTE_INSN_DELETED_LABEL,
867
868 /* This note indicates the start of the real body of the function,
869 i.e. the point just after all of the parms have been moved into
870 their homes, etc. */
871 NOTE_INSN_FUNCTION_BEG,
872
873 /* These note where exception handling regions begin and end.
874 Uses NOTE_EH_HANDLER to identify the region in question. */
875 NOTE_INSN_EH_REGION_BEG,
876 NOTE_INSN_EH_REGION_END,
877
878 /* Generated whenever a duplicate line number note is output. For example,
879 one is output after the end of an inline function, in order to prevent
880 the line containing the inline call from being counted twice in gcov. */
881 NOTE_INSN_REPEATED_LINE_NUMBER,
882
883 /* Record the struct for the following basic block. Uses NOTE_BASIC_BLOCK. */
884 NOTE_INSN_BASIC_BLOCK,
885
886 /* Record the expected value of a register at a location. Uses
887 NOTE_EXPECTED_VALUE; stored as (eq (reg) (const_int)). */
888 NOTE_INSN_EXPECTED_VALUE,
889
890 /* Record a prediction. Uses NOTE_PREDICTION. */
891 NOTE_INSN_PREDICTION,
892
893 NOTE_INSN_MAX
894 };
895
896 /* Names for NOTE insn's other than line numbers. */
897
898 extern const char * const note_insn_name[NOTE_INSN_MAX - NOTE_INSN_BIAS];
899 #define GET_NOTE_INSN_NAME(NOTE_CODE) \
900 (note_insn_name[(NOTE_CODE) - (int) NOTE_INSN_BIAS])
901
902 /* The name of a label, in case it corresponds to an explicit label
903 in the input source code. */
904 #define LABEL_NAME(RTX) XCSTR (RTX, 7, CODE_LABEL)
905
906 /* In jump.c, each label contains a count of the number
907 of LABEL_REFs that point at it, so unused labels can be deleted. */
908 #define LABEL_NUSES(RTX) XCINT (RTX, 4, CODE_LABEL)
909
910 /* Labels carry a two-bit field composed of the ->jump and ->call
911 bits. This field indicates whether the label is an alternate
912 entry point, and if so, what kind. */
913 enum label_kind
914 {
915 LABEL_NORMAL = 0, /* ordinary label */
916 LABEL_STATIC_ENTRY, /* alternate entry point, not exported */
917 LABEL_GLOBAL_ENTRY, /* alternate entry point, exported */
918 LABEL_WEAK_ENTRY /* alternate entry point, exported as weak symbol */
919 };
920
921 #if defined ENABLE_RTL_FLAG_CHECKING && (GCC_VERSION > 2007)
922
923 /* Retrieve the kind of LABEL. */
924 #define LABEL_KIND(LABEL) __extension__ \
925 ({ rtx const _label = (LABEL); \
926 if (GET_CODE (_label) != CODE_LABEL) \
927 rtl_check_failed_flag ("LABEL_KIND", _label, __FILE__, __LINE__, \
928 __FUNCTION__); \
929 (enum label_kind) ((_label->jump << 1) | _label->call); })
930
931 /* Set the kind of LABEL. */
932 #define SET_LABEL_KIND(LABEL, KIND) do { \
933 rtx _label = (LABEL); \
934 unsigned int _kind = (KIND); \
935 if (GET_CODE (_label) != CODE_LABEL) \
936 rtl_check_failed_flag ("SET_LABEL_KIND", _label, __FILE__, __LINE__, \
937 __FUNCTION__); \
938 _label->jump = ((_kind >> 1) & 1); \
939 _label->call = (_kind & 1); \
940 } while (0)
941
942 #else
943
944 /* Retrieve the kind of LABEL. */
945 #define LABEL_KIND(LABEL) \
946 ((enum label_kind) (((LABEL)->jump << 1) | (LABEL)->call))
947
948 /* Set the kind of LABEL. */
949 #define SET_LABEL_KIND(LABEL, KIND) do { \
950 rtx _label = (LABEL); \
951 unsigned int _kind = (KIND); \
952 _label->jump = ((_kind >> 1) & 1); \
953 _label->call = (_kind & 1); \
954 } while (0)
955
956 #endif /* rtl flag checking */
957
958 #define LABEL_ALT_ENTRY_P(LABEL) (LABEL_KIND (LABEL) != LABEL_NORMAL)
959
960 /* The original regno this ADDRESSOF was built for. */
961 #define ADDRESSOF_REGNO(RTX) XCUINT (RTX, 1, ADDRESSOF)
962
963 /* The variable in the register we took the address of. */
964 #define ADDRESSOF_DECL(RTX) XCTREE (RTX, 2, ADDRESSOF)
965
966 /* In jump.c, each JUMP_INSN can point to a label that it can jump to,
967 so that if the JUMP_INSN is deleted, the label's LABEL_NUSES can
968 be decremented and possibly the label can be deleted. */
969 #define JUMP_LABEL(INSN) XCEXP (INSN, 9, JUMP_INSN)
970
971 /* Once basic blocks are found in flow.c,
972 each CODE_LABEL starts a chain that goes through
973 all the LABEL_REFs that jump to that label.
974 The chain eventually winds up at the CODE_LABEL: it is circular. */
975 #define LABEL_REFS(LABEL) XCEXP (LABEL, 5, CODE_LABEL)
976 \f
977 /* This is the field in the LABEL_REF through which the circular chain
978 of references to a particular label is linked.
979 This chain is set up in flow.c. */
980
981 #define LABEL_NEXTREF(REF) XCEXP (REF, 1, LABEL_REF)
982
983 /* Once basic blocks are found in flow.c,
984 Each LABEL_REF points to its containing instruction with this field. */
985
986 #define CONTAINING_INSN(RTX) XCEXP (RTX, 2, LABEL_REF)
987
988 /* For a REG rtx, REGNO extracts the register number. ORIGINAL_REGNO holds
989 the number the register originally had; for a pseudo register turned into
990 a hard reg this will hold the old pseudo register number. */
991
992 #define REGNO(RTX) XCUINT (RTX, 0, REG)
993 #define ORIGINAL_REGNO(RTX) X0UINT (RTX, 1)
994
995 /* 1 if RTX is a reg or parallel that is the current function's return
996 value. */
997 #define REG_FUNCTION_VALUE_P(RTX) \
998 (RTL_FLAG_CHECK2("REG_FUNCTION_VALUE_P", (RTX), REG, PARALLEL)->integrated)
999
1000 /* 1 if RTX is a reg that corresponds to a variable declared by the user. */
1001 #define REG_USERVAR_P(RTX) \
1002 (RTL_FLAG_CHECK1("REG_USERVAR_P", (RTX), REG)->volatil)
1003
1004 /* 1 if RTX is a reg that holds a pointer value. */
1005 #define REG_POINTER(RTX) \
1006 (RTL_FLAG_CHECK1("REG_POINTER", (RTX), REG)->frame_related)
1007
1008 /* 1 if the given register REG corresponds to a hard register. */
1009 #define HARD_REGISTER_P(REG) (HARD_REGISTER_NUM_P (REGNO (REG)))
1010
1011 /* 1 if the given register number REG_NO corresponds to a hard register. */
1012 #define HARD_REGISTER_NUM_P(REG_NO) ((REG_NO) < FIRST_PSEUDO_REGISTER)
1013
1014 /* For a CONST_INT rtx, INTVAL extracts the integer. */
1015
1016 #define INTVAL(RTX) XCWINT(RTX, 0, CONST_INT)
1017
1018 /* For a CONST_DOUBLE:
1019 For a DImode, there are two integers CONST_DOUBLE_LOW is the
1020 low-order word and ..._HIGH the high-order.
1021 For a float, there is a REAL_VALUE_TYPE structure, and
1022 CONST_DOUBLE_REAL_VALUE(r) is a pointer to it. */
1023 #define CONST_DOUBLE_LOW(r) XCWINT (r, 0, CONST_DOUBLE)
1024 #define CONST_DOUBLE_HIGH(r) XCWINT (r, 1, CONST_DOUBLE)
1025 #define CONST_DOUBLE_REAL_VALUE(r) ((struct real_value *)&CONST_DOUBLE_LOW(r))
1026
1027 /* For a CONST_VECTOR, return element #n. */
1028 #define CONST_VECTOR_ELT(RTX, N) XCVECEXP (RTX, 0, N, CONST_VECTOR)
1029
1030 /* For a CONST_VECTOR, return the number of elements in a vector. */
1031 #define CONST_VECTOR_NUNITS(RTX) XCVECLEN (RTX, 0, CONST_VECTOR)
1032
1033 /* For a SUBREG rtx, SUBREG_REG extracts the value we want a subreg of.
1034 SUBREG_BYTE extracts the byte-number. */
1035
1036 #define SUBREG_REG(RTX) XCEXP (RTX, 0, SUBREG)
1037 #define SUBREG_BYTE(RTX) XCUINT (RTX, 1, SUBREG)
1038
1039 /* in rtlanal.c */
1040 extern unsigned int subreg_lsb PARAMS ((rtx));
1041 extern unsigned int subreg_regno_offset PARAMS ((unsigned int,
1042 enum machine_mode,
1043 unsigned int,
1044 enum machine_mode));
1045 extern bool subreg_offset_representable_p PARAMS ((unsigned int,
1046 enum machine_mode,
1047 unsigned int,
1048 enum machine_mode));
1049 extern unsigned int subreg_regno PARAMS ((rtx));
1050
1051 /* 1 if RTX is a subreg containing a reg that is already known to be
1052 sign- or zero-extended from the mode of the subreg to the mode of
1053 the reg. SUBREG_PROMOTED_UNSIGNED_P gives the signedness of the
1054 extension.
1055
1056 When used as a LHS, is means that this extension must be done
1057 when assigning to SUBREG_REG. */
1058
1059 #define SUBREG_PROMOTED_VAR_P(RTX) \
1060 (RTL_FLAG_CHECK1("SUBREG_PROMOTED", (RTX), SUBREG)->in_struct)
1061
1062 #define SUBREG_PROMOTED_UNSIGNED_SET(RTX, VAL) \
1063 do { \
1064 rtx const _rtx = RTL_FLAG_CHECK1("SUBREG_PROMOTED_UNSIGNED_SET", (RTX), SUBREG); \
1065 if ((VAL) < 0) \
1066 _rtx->volatil = 1; \
1067 else { \
1068 _rtx->volatil = 0; \
1069 _rtx->unchanging = (VAL); \
1070 } \
1071 } while (0)
1072 #define SUBREG_PROMOTED_UNSIGNED_P(RTX) \
1073 ((RTL_FLAG_CHECK1("SUBREG_PROMOTED_UNSIGNED_P", (RTX), SUBREG)->volatil) \
1074 ? -1 : (RTX)->unchanging)
1075
1076 /* Access various components of an ASM_OPERANDS rtx. */
1077
1078 #define ASM_OPERANDS_TEMPLATE(RTX) XCSTR (RTX, 0, ASM_OPERANDS)
1079 #define ASM_OPERANDS_OUTPUT_CONSTRAINT(RTX) XCSTR (RTX, 1, ASM_OPERANDS)
1080 #define ASM_OPERANDS_OUTPUT_IDX(RTX) XCINT (RTX, 2, ASM_OPERANDS)
1081 #define ASM_OPERANDS_INPUT_VEC(RTX) XCVEC (RTX, 3, ASM_OPERANDS)
1082 #define ASM_OPERANDS_INPUT_CONSTRAINT_VEC(RTX) XCVEC (RTX, 4, ASM_OPERANDS)
1083 #define ASM_OPERANDS_INPUT(RTX, N) XCVECEXP (RTX, 3, N, ASM_OPERANDS)
1084 #define ASM_OPERANDS_INPUT_LENGTH(RTX) XCVECLEN (RTX, 3, ASM_OPERANDS)
1085 #define ASM_OPERANDS_INPUT_CONSTRAINT_EXP(RTX, N) \
1086 XCVECEXP (RTX, 4, N, ASM_OPERANDS)
1087 #define ASM_OPERANDS_INPUT_CONSTRAINT(RTX, N) \
1088 XSTR (XCVECEXP (RTX, 4, N, ASM_OPERANDS), 0)
1089 #define ASM_OPERANDS_INPUT_MODE(RTX, N) \
1090 GET_MODE (XCVECEXP (RTX, 4, N, ASM_OPERANDS))
1091 #define ASM_OPERANDS_SOURCE_FILE(RTX) XCSTR (RTX, 5, ASM_OPERANDS)
1092 #define ASM_OPERANDS_SOURCE_LINE(RTX) XCINT (RTX, 6, ASM_OPERANDS)
1093
1094 /* 1 if RTX is a mem and we should keep the alias set for this mem
1095 unchanged when we access a component. Set to 1, or example, when we
1096 are already in a non-addressable component of an aggregate. */
1097 #define MEM_KEEP_ALIAS_SET_P(RTX) \
1098 (RTL_FLAG_CHECK1("MEM_KEEP_ALIAS_SET_P", (RTX), MEM)->jump)
1099
1100 /* 1 if RTX is a mem or asm_operand for a volatile reference. */
1101 #define MEM_VOLATILE_P(RTX) \
1102 (RTL_FLAG_CHECK3("MEM_VOLATILE_P", (RTX), MEM, ASM_OPERANDS, \
1103 ASM_INPUT)->volatil)
1104
1105 /* 1 if RTX is a mem that refers to an aggregate, either to the
1106 aggregate itself of to a field of the aggregate. If zero, RTX may
1107 or may not be such a reference. */
1108 #define MEM_IN_STRUCT_P(RTX) \
1109 (RTL_FLAG_CHECK1("MEM_IN_STRUCT_P", (RTX), MEM)->in_struct)
1110
1111 /* 1 if RTX is a mem that refers to a scalar. If zero, RTX may or may
1112 not refer to a scalar. */
1113 #define MEM_SCALAR_P(RTX) \
1114 (RTL_FLAG_CHECK1("MEM_SCALAR_P", (RTX), MEM)->frame_related)
1115
1116 /* 1 if RTX is a mem that cannot trap. */
1117 #define MEM_NOTRAP_P(RTX) \
1118 (RTL_FLAG_CHECK1("MEM_NOTRAP_P", (RTX), MEM)->call)
1119
1120 /* If VAL is nonzero, set MEM_IN_STRUCT_P and clear MEM_SCALAR_P in
1121 RTX. Otherwise, vice versa. Use this macro only when you are
1122 *sure* that you know that the MEM is in a structure, or is a
1123 scalar. VAL is evaluated only once. */
1124 #define MEM_SET_IN_STRUCT_P(RTX, VAL) \
1125 do { \
1126 if (VAL) \
1127 { \
1128 MEM_IN_STRUCT_P (RTX) = 1; \
1129 MEM_SCALAR_P (RTX) = 0; \
1130 } \
1131 else \
1132 { \
1133 MEM_IN_STRUCT_P (RTX) = 0; \
1134 MEM_SCALAR_P (RTX) = 1; \
1135 } \
1136 } while (0)
1137
1138 /* The memory attribute block. We provide access macros for each value
1139 in the block and provide defaults if none specified. */
1140 #define MEM_ATTRS(RTX) X0MEMATTR (RTX, 1)
1141
1142 /* The register attribute block. We provide access macros for each value
1143 in the block and provide defaults if none specified. */
1144 #define REG_ATTRS(RTX) X0REGATTR (RTX, 2)
1145
1146 /* For a MEM rtx, the alias set. If 0, this MEM is not in any alias
1147 set, and may alias anything. Otherwise, the MEM can only alias
1148 MEMs in a conflicting alias set. This value is set in a
1149 language-dependent manner in the front-end, and should not be
1150 altered in the back-end. These set numbers are tested with
1151 alias_sets_conflict_p. */
1152 #define MEM_ALIAS_SET(RTX) (MEM_ATTRS (RTX) == 0 ? 0 : MEM_ATTRS (RTX)->alias)
1153
1154 /* For a MEM rtx, the decl it is known to refer to, if it is known to
1155 refer to part of a DECL. It may also be a COMPONENT_REF. */
1156 #define MEM_EXPR(RTX) (MEM_ATTRS (RTX) == 0 ? 0 : MEM_ATTRS (RTX)->expr)
1157
1158 /* For a MEM rtx, the offset from the start of MEM_EXPR, if known, as a
1159 RTX that is always a CONST_INT. */
1160 #define MEM_OFFSET(RTX) (MEM_ATTRS (RTX) == 0 ? 0 : MEM_ATTRS (RTX)->offset)
1161
1162 /* For a MEM rtx, the size in bytes of the MEM, if known, as an RTX that
1163 is always a CONST_INT. */
1164 #define MEM_SIZE(RTX) \
1165 (MEM_ATTRS (RTX) != 0 ? MEM_ATTRS (RTX)->size \
1166 : GET_MODE (RTX) != BLKmode ? GEN_INT (GET_MODE_SIZE (GET_MODE (RTX))) \
1167 : 0)
1168
1169 /* For a MEM rtx, the alignment in bits. We can use the alignment of the
1170 mode as a default when STRICT_ALIGNMENT, but not if not. */
1171 #define MEM_ALIGN(RTX) \
1172 (MEM_ATTRS (RTX) != 0 ? MEM_ATTRS (RTX)->align \
1173 : (STRICT_ALIGNMENT && GET_MODE (RTX) != BLKmode \
1174 ? GET_MODE_ALIGNMENT (GET_MODE (RTX)) : BITS_PER_UNIT))
1175
1176 /* For a REG rtx, the decl it is known to refer to, if it is known to
1177 refer to part of a DECL. */
1178 #define REG_EXPR(RTX) (REG_ATTRS (RTX) == 0 ? 0 : REG_ATTRS (RTX)->decl)
1179
1180 /* For a MEM rtx, the offset from the start of MEM_DECL, if known, as a
1181 RTX that is always a CONST_INT. */
1182 #define REG_OFFSET(RTX) (REG_ATTRS (RTX) == 0 ? 0 : REG_ATTRS (RTX)->offset)
1183
1184 /* Copy the attributes that apply to memory locations from RHS to LHS. */
1185 #define MEM_COPY_ATTRIBUTES(LHS, RHS) \
1186 (MEM_VOLATILE_P (LHS) = MEM_VOLATILE_P (RHS), \
1187 MEM_IN_STRUCT_P (LHS) = MEM_IN_STRUCT_P (RHS), \
1188 MEM_SCALAR_P (LHS) = MEM_SCALAR_P (RHS), \
1189 MEM_NOTRAP_P (LHS) = MEM_NOTRAP_P (RHS), \
1190 RTX_UNCHANGING_P (LHS) = RTX_UNCHANGING_P (RHS), \
1191 MEM_KEEP_ALIAS_SET_P (LHS) = MEM_KEEP_ALIAS_SET_P (RHS), \
1192 MEM_ATTRS (LHS) = MEM_ATTRS (RHS))
1193
1194 /* 1 if RTX is a label_ref to a label outside the loop containing the
1195 reference. */
1196 #define LABEL_OUTSIDE_LOOP_P(RTX) \
1197 (RTL_FLAG_CHECK1("LABEL_OUTSIDE_LOOP_P", (RTX), LABEL_REF)->in_struct)
1198
1199 /* 1 if RTX is a label_ref for a nonlocal label. */
1200 /* Likewise in an expr_list for a reg_label note. */
1201 #define LABEL_REF_NONLOCAL_P(RTX) \
1202 (RTL_FLAG_CHECK2("LABEL_REF_NONLOCAL_P", (RTX), LABEL_REF, \
1203 REG_LABEL)->volatil)
1204
1205 /* 1 if RTX is a code_label that should always be considered to be needed. */
1206 #define LABEL_PRESERVE_P(RTX) \
1207 (RTL_FLAG_CHECK2("LABEL_PRESERVE_P", (RTX), CODE_LABEL, NOTE)->in_struct)
1208
1209 /* 1 if RTX is a reg that is used only in an exit test of a loop. */
1210 #define REG_LOOP_TEST_P(RTX) \
1211 (RTL_FLAG_CHECK1("REG_LOOP_TEST_P", (RTX), REG)->in_struct)
1212
1213 /* During sched, 1 if RTX is an insn that must be scheduled together
1214 with the preceding insn. */
1215 #define SCHED_GROUP_P(RTX) \
1216 (RTL_FLAG_CHECK3("SCHED_GROUP_P", (RTX), INSN, JUMP_INSN, CALL_INSN \
1217 )->in_struct)
1218
1219 /* For a SET rtx, SET_DEST is the place that is set
1220 and SET_SRC is the value it is set to. */
1221 #define SET_DEST(RTX) XC2EXP(RTX, 0, SET, CLOBBER)
1222 #define SET_SRC(RTX) XCEXP(RTX, 1, SET)
1223 #define SET_IS_RETURN_P(RTX) \
1224 (RTL_FLAG_CHECK1("SET_IS_RETURN_P", (RTX), SET)->jump)
1225
1226 /* For a TRAP_IF rtx, TRAP_CONDITION is an expression. */
1227 #define TRAP_CONDITION(RTX) XCEXP (RTX, 0, TRAP_IF)
1228 #define TRAP_CODE(RTX) XCEXP (RTX, 1, TRAP_IF)
1229
1230 /* For a COND_EXEC rtx, COND_EXEC_TEST is the condition to base
1231 conditionally executing the code on, COND_EXEC_CODE is the code
1232 to execute if the condition is true. */
1233 #define COND_EXEC_TEST(RTX) XCEXP (RTX, 0, COND_EXEC)
1234 #define COND_EXEC_CODE(RTX) XCEXP (RTX, 1, COND_EXEC)
1235
1236 /* 1 if RTX is a symbol_ref that addresses this function's rtl
1237 constants pool. */
1238 #define CONSTANT_POOL_ADDRESS_P(RTX) \
1239 (RTL_FLAG_CHECK1("CONSTANT_POOL_ADDRESS_P", (RTX), SYMBOL_REF)->unchanging)
1240
1241 /* 1 if RTX is a symbol_ref that addresses a value in the file's
1242 tree constant pool. This information is private to varasm.c. */
1243 #define TREE_CONSTANT_POOL_ADDRESS_P(RTX) \
1244 (RTL_FLAG_CHECK1("TREE_CONSTANT_POOL_ADDRESS_P", \
1245 (RTX), SYMBOL_REF)->frame_related)
1246
1247 /* Used if RTX is a symbol_ref, for machine-specific purposes. */
1248 #define SYMBOL_REF_FLAG(RTX) \
1249 (RTL_FLAG_CHECK1("SYMBOL_REF_FLAG", (RTX), SYMBOL_REF)->volatil)
1250
1251 /* 1 if RTX is a symbol_ref that has been the library function in
1252 emit_library_call. */
1253 #define SYMBOL_REF_USED(RTX) \
1254 (RTL_FLAG_CHECK1("SYMBOL_REF_USED", (RTX), SYMBOL_REF)->used)
1255
1256 /* 1 if RTX is a symbol_ref for a weak symbol. */
1257 #define SYMBOL_REF_WEAK(RTX) \
1258 (RTL_FLAG_CHECK1("SYMBOL_REF_WEAK", (RTX), SYMBOL_REF)->integrated)
1259
1260 /* The tree (decl or constant) associated with the symbol, or null. */
1261 #define SYMBOL_REF_DECL(RTX) X0TREE ((RTX), 2)
1262
1263 /* A set of flags on a symbol_ref that are, in some respects, redundant with
1264 information derivable from the tree decl associated with this symbol.
1265 Except that we build a *lot* of SYMBOL_REFs that aren't associated with a
1266 decl. In some cases this is a bug. But beyond that, it's nice to cache
1267 this information to avoid recomputing it. Finally, this allows space for
1268 the target to store more than one bit of information, as with
1269 SYMBOL_REF_FLAG. */
1270 #define SYMBOL_REF_FLAGS(RTX) X0INT ((RTX), 1)
1271
1272 /* These flags are common enough to be defined for all targets. They
1273 are computed by the default version of targetm.encode_section_info. */
1274
1275 /* Set if this symbol is a function. */
1276 #define SYMBOL_FLAG_FUNCTION (1 << 0)
1277 #define SYMBOL_REF_FUNCTION_P(RTX) \
1278 ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_FUNCTION) != 0)
1279 /* Set if targetm.binds_local_p is true. */
1280 #define SYMBOL_FLAG_LOCAL (1 << 1)
1281 #define SYMBOL_REF_LOCAL_P(RTX) \
1282 ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_LOCAL) != 0)
1283 /* Set if targetm.in_small_data_p is true. */
1284 #define SYMBOL_FLAG_SMALL (1 << 2)
1285 #define SYMBOL_REF_SMALL_P(RTX) \
1286 ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_SMALL) != 0)
1287 /* The three-bit field at [5:3] is true for TLS variables; use
1288 SYMBOL_REF_TLS_MODEL to extract the field as an enum tls_model. */
1289 #define SYMBOL_FLAG_TLS_SHIFT 3
1290 #define SYMBOL_REF_TLS_MODEL(RTX) \
1291 ((enum tls_model) ((SYMBOL_REF_FLAGS (RTX) >> SYMBOL_FLAG_TLS_SHIFT) & 7))
1292 /* Set if this symbol is not defined in this translation unit. */
1293 #define SYMBOL_FLAG_EXTERNAL (1 << 6)
1294 #define SYMBOL_REF_EXTERNAL_P(RTX) \
1295 ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_EXTERNAL) != 0)
1296
1297 /* Subsequent bits are available for the target to use. */
1298 #define SYMBOL_FLAG_MACH_DEP_SHIFT 7
1299 #define SYMBOL_FLAG_MACH_DEP (1 << SYMBOL_FLAG_MACH_DEP_SHIFT)
1300
1301 /* Define a macro to look for REG_INC notes,
1302 but save time on machines where they never exist. */
1303
1304 #if (defined (HAVE_PRE_INCREMENT) || defined (HAVE_PRE_DECREMENT) || defined (HAVE_POST_INCREMENT) || defined (HAVE_POST_DECREMENT))
1305 #define FIND_REG_INC_NOTE(INSN, REG) \
1306 ((REG) != NULL_RTX && REG_P ((REG)) \
1307 ? find_regno_note ((INSN), REG_INC, REGNO (REG)) \
1308 : find_reg_note ((INSN), REG_INC, (REG)))
1309 #else
1310 #define FIND_REG_INC_NOTE(INSN, REG) 0
1311 #endif
1312
1313 /* Indicate whether the machine has any sort of auto increment addressing.
1314 If not, we can avoid checking for REG_INC notes. */
1315
1316 #if (defined (HAVE_PRE_INCREMENT) || defined (HAVE_PRE_DECREMENT) || defined (HAVE_POST_INCREMENT) || defined (HAVE_POST_DECREMENT))
1317 #define AUTO_INC_DEC
1318 #endif
1319
1320 #ifndef HAVE_PRE_INCREMENT
1321 #define HAVE_PRE_INCREMENT 0
1322 #endif
1323
1324 #ifndef HAVE_PRE_DECREMENT
1325 #define HAVE_PRE_DECREMENT 0
1326 #endif
1327
1328 #ifndef HAVE_POST_INCREMENT
1329 #define HAVE_POST_INCREMENT 0
1330 #endif
1331
1332 #ifndef HAVE_POST_DECREMENT
1333 #define HAVE_POST_DECREMENT 0
1334 #endif
1335
1336 #ifndef HAVE_POST_MODIFY_DISP
1337 #define HAVE_POST_MODIFY_DISP 0
1338 #endif
1339
1340 #ifndef HAVE_POST_MODIFY_REG
1341 #define HAVE_POST_MODIFY_REG 0
1342 #endif
1343
1344 #ifndef HAVE_PRE_MODIFY_DISP
1345 #define HAVE_PRE_MODIFY_DISP 0
1346 #endif
1347
1348 #ifndef HAVE_PRE_MODIFY_REG
1349 #define HAVE_PRE_MODIFY_REG 0
1350 #endif
1351
1352
1353 /* Some architectures do not have complete pre/post increment/decrement
1354 instruction sets, or only move some modes efficiently. These macros
1355 allow us to tune autoincrement generation. */
1356
1357 #ifndef USE_LOAD_POST_INCREMENT
1358 #define USE_LOAD_POST_INCREMENT(MODE) HAVE_POST_INCREMENT
1359 #endif
1360
1361 #ifndef USE_LOAD_POST_DECREMENT
1362 #define USE_LOAD_POST_DECREMENT(MODE) HAVE_POST_DECREMENT
1363 #endif
1364
1365 #ifndef USE_LOAD_PRE_INCREMENT
1366 #define USE_LOAD_PRE_INCREMENT(MODE) HAVE_PRE_INCREMENT
1367 #endif
1368
1369 #ifndef USE_LOAD_PRE_DECREMENT
1370 #define USE_LOAD_PRE_DECREMENT(MODE) HAVE_PRE_DECREMENT
1371 #endif
1372
1373 #ifndef USE_STORE_POST_INCREMENT
1374 #define USE_STORE_POST_INCREMENT(MODE) HAVE_POST_INCREMENT
1375 #endif
1376
1377 #ifndef USE_STORE_POST_DECREMENT
1378 #define USE_STORE_POST_DECREMENT(MODE) HAVE_POST_DECREMENT
1379 #endif
1380
1381 #ifndef USE_STORE_PRE_INCREMENT
1382 #define USE_STORE_PRE_INCREMENT(MODE) HAVE_PRE_INCREMENT
1383 #endif
1384
1385 #ifndef USE_STORE_PRE_DECREMENT
1386 #define USE_STORE_PRE_DECREMENT(MODE) HAVE_PRE_DECREMENT
1387 #endif
1388
1389 /* Determine if the insn is a PHI node. */
1390 #define PHI_NODE_P(X) \
1391 ((X) && GET_CODE (X) == INSN \
1392 && GET_CODE (PATTERN (X)) == SET \
1393 && GET_CODE (SET_SRC (PATTERN (X))) == PHI)
1394 \f
1395 /* Nonzero if we need to distinguish between the return value of this function
1396 and the return value of a function called by this function. This helps
1397 integrate.c.
1398 This is 1 until after the rtl generation pass. */
1399 extern int rtx_equal_function_value_matters;
1400
1401 /* Nonzero when we are generating CONCATs. */
1402 extern int generating_concat_p;
1403
1404 /* Generally useful functions. */
1405
1406 /* In expmed.c */
1407 extern int ceil_log2 PARAMS ((unsigned HOST_WIDE_INT));
1408
1409 #define plus_constant(X, C) plus_constant_wide ((X), (HOST_WIDE_INT) (C))
1410
1411 /* In builtins.c */
1412 extern rtx expand_builtin_expect_jump (tree, rtx, rtx);
1413 extern void purge_builtin_constant_p (void);
1414
1415 /* In explow.c */
1416 extern void set_stack_check_libfunc PARAMS ((rtx));
1417 extern HOST_WIDE_INT trunc_int_for_mode PARAMS ((HOST_WIDE_INT,
1418 enum machine_mode));
1419 extern rtx plus_constant_wide PARAMS ((rtx, HOST_WIDE_INT));
1420 extern rtx plus_constant_for_output_wide PARAMS ((rtx, HOST_WIDE_INT));
1421 extern void optimize_save_area_alloca PARAMS ((rtx));
1422
1423 /* In emit-rtl.c */
1424 extern rtx gen_rtx PARAMS ((enum rtx_code,
1425 enum machine_mode, ...));
1426 extern rtvec gen_rtvec PARAMS ((int, ...));
1427 extern rtx copy_insn_1 PARAMS ((rtx));
1428 extern rtx copy_insn PARAMS ((rtx));
1429 extern rtx gen_int_mode PARAMS ((HOST_WIDE_INT,
1430 enum machine_mode));
1431 extern rtx emit_copy_of_insn_after PARAMS ((rtx, rtx));
1432 extern void set_reg_attrs_from_mem PARAMS ((rtx, rtx));
1433 extern void set_mem_attrs_from_reg PARAMS ((rtx, rtx));
1434 extern void set_reg_attrs_for_parm PARAMS ((rtx, rtx));
1435
1436 /* In rtl.c */
1437 extern rtx rtx_alloc PARAMS ((RTX_CODE));
1438 extern rtvec rtvec_alloc PARAMS ((int));
1439 extern rtx copy_rtx PARAMS ((rtx));
1440
1441 /* In emit-rtl.c */
1442 extern rtx copy_rtx_if_shared PARAMS ((rtx));
1443
1444 /* In rtl.c */
1445 extern rtx copy_most_rtx PARAMS ((rtx, rtx));
1446 extern rtx shallow_copy_rtx PARAMS ((rtx));
1447 extern int rtx_equal_p PARAMS ((rtx, rtx));
1448
1449 /* In emit-rtl.c */
1450 extern rtvec gen_rtvec_v PARAMS ((int, rtx *));
1451 extern rtx gen_reg_rtx PARAMS ((enum machine_mode));
1452 extern rtx gen_rtx_REG_offset PARAMS ((rtx, enum machine_mode,
1453 unsigned int, int));
1454 extern rtx gen_label_rtx PARAMS ((void));
1455 extern int subreg_hard_regno PARAMS ((rtx, int));
1456 extern rtx gen_lowpart_common PARAMS ((enum machine_mode, rtx));
1457 extern rtx gen_lowpart PARAMS ((enum machine_mode, rtx));
1458
1459 /* In cse.c */
1460 extern rtx gen_lowpart_if_possible PARAMS ((enum machine_mode, rtx));
1461
1462 /* In emit-rtl.c */
1463 extern rtx gen_highpart PARAMS ((enum machine_mode, rtx));
1464 extern rtx gen_highpart_mode PARAMS ((enum machine_mode,
1465 enum machine_mode, rtx));
1466 extern rtx gen_realpart PARAMS ((enum machine_mode, rtx));
1467 extern rtx gen_imagpart PARAMS ((enum machine_mode, rtx));
1468 extern rtx operand_subword PARAMS ((rtx, unsigned int, int,
1469 enum machine_mode));
1470 extern rtx constant_subword PARAMS ((rtx, int,
1471 enum machine_mode));
1472
1473 /* In emit-rtl.c */
1474 extern rtx operand_subword_force PARAMS ((rtx, unsigned int,
1475 enum machine_mode));
1476 extern int subreg_lowpart_p PARAMS ((rtx));
1477 extern unsigned int subreg_lowpart_offset PARAMS ((enum machine_mode,
1478 enum machine_mode));
1479 extern unsigned int subreg_highpart_offset PARAMS ((enum machine_mode,
1480 enum machine_mode));
1481 extern rtx make_safe_from PARAMS ((rtx, rtx));
1482 extern rtx convert_memory_address PARAMS ((enum machine_mode, rtx));
1483 extern rtx get_insns PARAMS ((void));
1484 extern const char *get_insn_name PARAMS ((int));
1485 extern rtx get_last_insn PARAMS ((void));
1486 extern rtx get_last_insn_anywhere PARAMS ((void));
1487 extern rtx get_first_nonnote_insn PARAMS ((void));
1488 extern rtx get_last_nonnote_insn PARAMS ((void));
1489 extern void start_sequence PARAMS ((void));
1490 extern void push_to_sequence PARAMS ((rtx));
1491 extern void end_sequence PARAMS ((void));
1492 extern void push_to_full_sequence PARAMS ((rtx, rtx));
1493 extern void end_full_sequence PARAMS ((rtx*, rtx*));
1494
1495 /* In varasm.c */
1496 extern rtx immed_double_const PARAMS ((HOST_WIDE_INT, HOST_WIDE_INT, enum machine_mode));
1497 extern rtx mem_for_const_double PARAMS ((rtx));
1498 extern rtx force_const_mem PARAMS ((enum machine_mode, rtx));
1499
1500 /* In varasm.c */
1501 extern rtx get_pool_constant PARAMS ((rtx));
1502 extern rtx get_pool_constant_mark PARAMS ((rtx, bool *));
1503 extern enum machine_mode get_pool_mode PARAMS ((rtx));
1504 extern rtx get_pool_constant_for_function PARAMS ((struct function *, rtx));
1505 extern enum machine_mode get_pool_mode_for_function PARAMS ((struct function *, rtx));
1506 extern int get_pool_offset PARAMS ((rtx));
1507 extern rtx simplify_subtraction PARAMS ((rtx));
1508
1509 /* In function.c */
1510 extern rtx assign_stack_local PARAMS ((enum machine_mode,
1511 HOST_WIDE_INT, int));
1512 extern rtx assign_stack_temp PARAMS ((enum machine_mode,
1513 HOST_WIDE_INT, int));
1514 extern rtx assign_stack_temp_for_type PARAMS ((enum machine_mode,
1515 HOST_WIDE_INT, int, tree));
1516 extern rtx assign_temp PARAMS ((tree, int, int, int));
1517
1518 /* In emit-rtl.c */
1519 extern rtx emit_insn_before PARAMS ((rtx, rtx));
1520 extern rtx emit_insn_before_setloc PARAMS ((rtx, rtx, int));
1521 extern rtx emit_jump_insn_before PARAMS ((rtx, rtx));
1522 extern rtx emit_jump_insn_before_setloc PARAMS ((rtx, rtx, int));
1523 extern rtx emit_call_insn_before PARAMS ((rtx, rtx));
1524 extern rtx emit_call_insn_before_setloc PARAMS ((rtx, rtx, int));
1525 extern rtx emit_barrier_before PARAMS ((rtx));
1526 extern rtx emit_label_before PARAMS ((rtx, rtx));
1527 extern rtx emit_note_before PARAMS ((int, rtx));
1528 extern rtx emit_insn_after PARAMS ((rtx, rtx));
1529 extern rtx emit_insn_after_setloc PARAMS ((rtx, rtx, int));
1530 extern rtx emit_jump_insn_after PARAMS ((rtx, rtx));
1531 extern rtx emit_jump_insn_after_setloc PARAMS ((rtx, rtx, int));
1532 extern rtx emit_call_insn_after PARAMS ((rtx, rtx));
1533 extern rtx emit_call_insn_after_setloc PARAMS ((rtx, rtx, int));
1534 extern rtx emit_barrier_after PARAMS ((rtx));
1535 extern rtx emit_label_after PARAMS ((rtx, rtx));
1536 extern rtx emit_note_after PARAMS ((int, rtx));
1537 extern rtx emit_line_note_after PARAMS ((const char *, int, rtx));
1538 extern rtx emit_insn PARAMS ((rtx));
1539 extern rtx emit_jump_insn PARAMS ((rtx));
1540 extern rtx emit_call_insn PARAMS ((rtx));
1541 extern rtx emit_label PARAMS ((rtx));
1542 extern rtx emit_barrier PARAMS ((void));
1543 extern rtx emit_line_note PARAMS ((const char *, int));
1544 extern rtx emit_note PARAMS ((const char *, int));
1545 extern rtx emit_line_note_force PARAMS ((const char *, int));
1546 extern rtx make_insn_raw PARAMS ((rtx));
1547 extern void add_function_usage_to PARAMS ((rtx, rtx));
1548 extern rtx last_call_insn PARAMS ((void));
1549 extern rtx previous_insn PARAMS ((rtx));
1550 extern rtx next_insn PARAMS ((rtx));
1551 extern rtx prev_nonnote_insn PARAMS ((rtx));
1552 extern rtx next_nonnote_insn PARAMS ((rtx));
1553 extern rtx prev_real_insn PARAMS ((rtx));
1554 extern rtx next_real_insn PARAMS ((rtx));
1555 extern rtx prev_active_insn PARAMS ((rtx));
1556 extern rtx next_active_insn PARAMS ((rtx));
1557 extern int active_insn_p PARAMS ((rtx));
1558 extern rtx prev_label PARAMS ((rtx));
1559 extern rtx next_label PARAMS ((rtx));
1560 extern rtx next_cc0_user PARAMS ((rtx));
1561 extern rtx prev_cc0_setter PARAMS ((rtx));
1562
1563 /* In cfglayout.c */
1564 extern tree choose_inner_scope PARAMS ((tree, tree));
1565 extern int insn_line PARAMS ((rtx));
1566 extern const char * insn_file PARAMS ((rtx));
1567 extern int prologue_locator, epilogue_locator;
1568
1569 /* In jump.c */
1570 extern rtx next_nondeleted_insn PARAMS ((rtx));
1571 extern enum rtx_code reverse_condition PARAMS ((enum rtx_code));
1572 extern enum rtx_code reverse_condition_maybe_unordered PARAMS ((enum rtx_code));
1573 extern enum rtx_code swap_condition PARAMS ((enum rtx_code));
1574 extern enum rtx_code unsigned_condition PARAMS ((enum rtx_code));
1575 extern enum rtx_code signed_condition PARAMS ((enum rtx_code));
1576 extern void mark_jump_label PARAMS ((rtx, rtx, int));
1577 extern void cleanup_barriers PARAMS ((void));
1578
1579 /* In jump.c */
1580 extern bool squeeze_notes PARAMS ((rtx *, rtx *));
1581 extern rtx delete_related_insns PARAMS ((rtx));
1582 extern void delete_jump PARAMS ((rtx));
1583 extern void delete_barrier PARAMS ((rtx));
1584 extern rtx get_label_before PARAMS ((rtx));
1585 extern rtx get_label_after PARAMS ((rtx));
1586 extern rtx follow_jumps PARAMS ((rtx));
1587
1588 /* In recog.c */
1589 extern rtx *find_constant_term_loc PARAMS ((rtx *));
1590
1591 /* In emit-rtl.c */
1592 extern rtx try_split PARAMS ((rtx, rtx, int));
1593 extern int split_branch_probability;
1594
1595 /* In unknown file */
1596 extern rtx split_insns PARAMS ((rtx, rtx));
1597
1598 /* In simplify-rtx.c */
1599 extern rtx simplify_unary_operation PARAMS ((enum rtx_code,
1600 enum machine_mode, rtx,
1601 enum machine_mode));
1602 extern rtx simplify_binary_operation PARAMS ((enum rtx_code,
1603 enum machine_mode, rtx,
1604 rtx));
1605 extern rtx simplify_ternary_operation PARAMS ((enum rtx_code,
1606 enum machine_mode,
1607 enum machine_mode, rtx, rtx,
1608 rtx));
1609 extern rtx simplify_relational_operation PARAMS ((enum rtx_code,
1610 enum machine_mode, rtx,
1611 rtx));
1612 extern rtx simplify_gen_binary PARAMS ((enum rtx_code,
1613 enum machine_mode,
1614 rtx, rtx));
1615 extern rtx simplify_gen_unary PARAMS ((enum rtx_code,
1616 enum machine_mode, rtx,
1617 enum machine_mode));
1618 extern rtx simplify_gen_ternary PARAMS ((enum rtx_code,
1619 enum machine_mode,
1620 enum machine_mode,
1621 rtx, rtx, rtx));
1622 extern rtx simplify_gen_relational PARAMS ((enum rtx_code,
1623 enum machine_mode,
1624 enum machine_mode,
1625 rtx, rtx));
1626 extern rtx simplify_subreg PARAMS ((enum machine_mode,
1627 rtx,
1628 enum machine_mode,
1629 unsigned int));
1630 extern rtx simplify_gen_subreg PARAMS ((enum machine_mode,
1631 rtx,
1632 enum machine_mode,
1633 unsigned int));
1634 extern rtx simplify_replace_rtx PARAMS ((rtx, rtx, rtx));
1635 extern rtx simplify_rtx PARAMS ((rtx));
1636 extern rtx avoid_constant_pool_reference PARAMS ((rtx));
1637
1638 /* In function.c */
1639 extern rtx gen_mem_addressof PARAMS ((rtx, tree, int));
1640
1641 /* In regclass.c */
1642 extern enum machine_mode choose_hard_reg_mode PARAMS ((unsigned int,
1643 unsigned int));
1644
1645 /* In emit-rtl.c */
1646 extern rtx set_unique_reg_note PARAMS ((rtx, enum reg_note, rtx));
1647
1648 /* Functions in rtlanal.c */
1649
1650 /* Single set is implemented as macro for performance reasons. */
1651 #define single_set(I) (INSN_P (I) \
1652 ? (GET_CODE (PATTERN (I)) == SET \
1653 ? PATTERN (I) : single_set_1 (I)) \
1654 : NULL_RTX)
1655 #define single_set_1(I) single_set_2 (I, PATTERN (I))
1656
1657 /* Structure used for passing data to REPLACE_LABEL. */
1658 typedef struct replace_label_data
1659 {
1660 rtx r1;
1661 rtx r2;
1662 bool update_label_nuses;
1663 } replace_label_data;
1664
1665 extern int rtx_addr_can_trap_p PARAMS ((rtx));
1666 extern bool nonzero_address_p PARAMS ((rtx));
1667 extern int rtx_unstable_p PARAMS ((rtx));
1668 extern int rtx_varies_p PARAMS ((rtx, int));
1669 extern int rtx_addr_varies_p PARAMS ((rtx, int));
1670 extern HOST_WIDE_INT get_integer_term PARAMS ((rtx));
1671 extern rtx get_related_value PARAMS ((rtx));
1672 extern rtx get_jump_table_offset PARAMS ((rtx, rtx *));
1673 extern int global_reg_mentioned_p PARAMS ((rtx));
1674 extern int reg_mentioned_p PARAMS ((rtx, rtx));
1675 extern int count_occurrences PARAMS ((rtx, rtx, int));
1676 extern int reg_referenced_p PARAMS ((rtx, rtx));
1677 extern int reg_used_between_p PARAMS ((rtx, rtx, rtx));
1678 extern int reg_referenced_between_p PARAMS ((rtx, rtx, rtx));
1679 extern int reg_set_between_p PARAMS ((rtx, rtx, rtx));
1680 extern int regs_set_between_p PARAMS ((rtx, rtx, rtx));
1681 extern int commutative_operand_precedence PARAMS ((rtx));
1682 extern int swap_commutative_operands_p PARAMS ((rtx, rtx));
1683 extern int modified_between_p PARAMS ((rtx, rtx, rtx));
1684 extern int no_labels_between_p PARAMS ((rtx, rtx));
1685 extern int no_jumps_between_p PARAMS ((rtx, rtx));
1686 extern int modified_in_p PARAMS ((rtx, rtx));
1687 extern int insn_dependent_p PARAMS ((rtx, rtx));
1688 extern int reg_set_p PARAMS ((rtx, rtx));
1689 extern rtx single_set_2 PARAMS ((rtx, rtx));
1690 extern int multiple_sets PARAMS ((rtx));
1691 extern int set_noop_p PARAMS ((rtx));
1692 extern int noop_move_p PARAMS ((rtx));
1693 extern rtx find_last_value PARAMS ((rtx, rtx *, rtx, int));
1694 extern int refers_to_regno_p PARAMS ((unsigned int, unsigned int,
1695 rtx, rtx *));
1696 extern int reg_overlap_mentioned_p PARAMS ((rtx, rtx));
1697 extern rtx set_of PARAMS ((rtx, rtx));
1698 extern void note_stores PARAMS ((rtx,
1699 void (*) (rtx, rtx, void *),
1700 void *));
1701 extern void note_uses PARAMS ((rtx *,
1702 void (*) (rtx *, void *),
1703 void *));
1704 extern rtx reg_set_last PARAMS ((rtx, rtx));
1705 extern int dead_or_set_p PARAMS ((rtx, rtx));
1706 extern int dead_or_set_regno_p PARAMS ((rtx, unsigned int));
1707 extern rtx find_reg_note PARAMS ((rtx, enum reg_note, rtx));
1708 extern rtx find_regno_note PARAMS ((rtx, enum reg_note,
1709 unsigned int));
1710 extern rtx find_reg_equal_equiv_note PARAMS ((rtx));
1711 extern int find_reg_fusage PARAMS ((rtx, enum rtx_code, rtx));
1712 extern int find_regno_fusage PARAMS ((rtx, enum rtx_code,
1713 unsigned int));
1714 extern int pure_call_p PARAMS ((rtx));
1715 extern void remove_note PARAMS ((rtx, rtx));
1716 extern int side_effects_p PARAMS ((rtx));
1717 extern int volatile_refs_p PARAMS ((rtx));
1718 extern int volatile_insn_p PARAMS ((rtx));
1719 extern int may_trap_p PARAMS ((rtx));
1720 extern int inequality_comparisons_p PARAMS ((rtx));
1721 extern rtx replace_rtx PARAMS ((rtx, rtx, rtx));
1722 extern rtx replace_regs PARAMS ((rtx, rtx *, unsigned int,
1723 int));
1724 extern int replace_label PARAMS ((rtx *, void *));
1725 extern int rtx_referenced_p PARAMS ((rtx, rtx));
1726 extern bool tablejump_p PARAMS ((rtx, rtx *, rtx *));
1727 extern int computed_jump_p PARAMS ((rtx));
1728 typedef int (*rtx_function) PARAMS ((rtx *, void *));
1729 extern int for_each_rtx PARAMS ((rtx *, rtx_function, void *));
1730 extern rtx regno_use_in PARAMS ((unsigned int, rtx));
1731 extern int auto_inc_p PARAMS ((rtx));
1732 extern int in_expr_list_p PARAMS ((rtx, rtx));
1733 extern void remove_node_from_expr_list PARAMS ((rtx, rtx *));
1734 extern int insns_safe_to_move_p PARAMS ((rtx, rtx, rtx *));
1735 extern int loc_mentioned_in_p PARAMS ((rtx *, rtx));
1736 extern rtx find_first_parameter_load PARAMS ((rtx, rtx));
1737 extern bool keep_with_call_p PARAMS ((rtx));
1738
1739 /* flow.c */
1740
1741 extern rtx find_use_as_address PARAMS ((rtx, rtx, HOST_WIDE_INT));
1742
1743 /* lists.c */
1744
1745 void free_EXPR_LIST_list (rtx *);
1746 void free_INSN_LIST_list (rtx *);
1747 void free_EXPR_LIST_node (rtx);
1748 void free_INSN_LIST_node (rtx);
1749 rtx alloc_INSN_LIST (rtx, rtx);
1750 rtx alloc_EXPR_LIST (int, rtx, rtx);
1751
1752 /* regclass.c */
1753
1754 /* Maximum number of parallel sets and clobbers in any insn in this fn.
1755 Always at least 3, since the combiner could put that many togetherm
1756 and we want this to remain correct for all the remaining passes. */
1757
1758 extern int max_parallel;
1759
1760 /* Free up register info memory. */
1761 extern void free_reg_info PARAMS ((void));
1762
1763 /* recog.c */
1764 extern int asm_noperands PARAMS ((rtx));
1765 extern const char *decode_asm_operands PARAMS ((rtx, rtx *, rtx **,
1766 const char **,
1767 enum machine_mode *));
1768
1769 extern enum reg_class reg_preferred_class PARAMS ((int));
1770 extern enum reg_class reg_alternate_class PARAMS ((int));
1771
1772 extern rtx get_first_nonparm_insn PARAMS ((void));
1773
1774 extern void split_all_insns PARAMS ((int));
1775 extern void split_all_insns_noflow PARAMS ((void));
1776
1777 #define MAX_SAVED_CONST_INT 64
1778 extern GTY(()) rtx const_int_rtx[MAX_SAVED_CONST_INT * 2 + 1];
1779
1780 #define const0_rtx (const_int_rtx[MAX_SAVED_CONST_INT])
1781 #define const1_rtx (const_int_rtx[MAX_SAVED_CONST_INT+1])
1782 #define const2_rtx (const_int_rtx[MAX_SAVED_CONST_INT+2])
1783 #define constm1_rtx (const_int_rtx[MAX_SAVED_CONST_INT-1])
1784 extern GTY(()) rtx const_true_rtx;
1785
1786 extern GTY(()) rtx const_tiny_rtx[3][(int) MAX_MACHINE_MODE];
1787
1788 /* Returns a constant 0 rtx in mode MODE. Integer modes are treated the
1789 same as VOIDmode. */
1790
1791 #define CONST0_RTX(MODE) (const_tiny_rtx[0][(int) (MODE)])
1792
1793 /* Likewise, for the constants 1 and 2. */
1794
1795 #define CONST1_RTX(MODE) (const_tiny_rtx[1][(int) (MODE)])
1796 #define CONST2_RTX(MODE) (const_tiny_rtx[2][(int) (MODE)])
1797
1798 /* If HARD_FRAME_POINTER_REGNUM is defined, then a special dummy reg
1799 is used to represent the frame pointer. This is because the
1800 hard frame pointer and the automatic variables are separated by an amount
1801 that cannot be determined until after register allocation. We can assume
1802 that in this case ELIMINABLE_REGS will be defined, one action of which
1803 will be to eliminate FRAME_POINTER_REGNUM into HARD_FRAME_POINTER_REGNUM. */
1804 #ifndef HARD_FRAME_POINTER_REGNUM
1805 #define HARD_FRAME_POINTER_REGNUM FRAME_POINTER_REGNUM
1806 #endif
1807
1808 /* Index labels for global_rtl. */
1809 enum global_rtl_index
1810 {
1811 GR_PC,
1812 GR_CC0,
1813 GR_STACK_POINTER,
1814 GR_FRAME_POINTER,
1815 /* For register elimination to work properly these hard_frame_pointer_rtx,
1816 frame_pointer_rtx, and arg_pointer_rtx must be the same if they refer to
1817 the same register. */
1818 #if FRAME_POINTER_REGNUM == ARG_POINTER_REGNUM
1819 GR_ARG_POINTER = GR_FRAME_POINTER,
1820 #endif
1821 #if HARD_FRAME_POINTER_REGNUM == FRAME_POINTER_REGNUM
1822 GR_HARD_FRAME_POINTER = GR_FRAME_POINTER,
1823 #else
1824 GR_HARD_FRAME_POINTER,
1825 #endif
1826 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1827 #if HARD_FRAME_POINTER_REGNUM == ARG_POINTER_REGNUM
1828 GR_ARG_POINTER = GR_HARD_FRAME_POINTER,
1829 #else
1830 GR_ARG_POINTER,
1831 #endif
1832 #endif
1833 GR_VIRTUAL_INCOMING_ARGS,
1834 GR_VIRTUAL_STACK_ARGS,
1835 GR_VIRTUAL_STACK_DYNAMIC,
1836 GR_VIRTUAL_OUTGOING_ARGS,
1837 GR_VIRTUAL_CFA,
1838
1839 GR_MAX
1840 };
1841
1842 /* Pointers to standard pieces of rtx are stored here. */
1843 extern GTY(()) rtx global_rtl[GR_MAX];
1844
1845 /* Standard pieces of rtx, to be substituted directly into things. */
1846 #define pc_rtx (global_rtl[GR_PC])
1847 #define cc0_rtx (global_rtl[GR_CC0])
1848
1849 /* All references to certain hard regs, except those created
1850 by allocating pseudo regs into them (when that's possible),
1851 go through these unique rtx objects. */
1852 #define stack_pointer_rtx (global_rtl[GR_STACK_POINTER])
1853 #define frame_pointer_rtx (global_rtl[GR_FRAME_POINTER])
1854 #define hard_frame_pointer_rtx (global_rtl[GR_HARD_FRAME_POINTER])
1855 #define arg_pointer_rtx (global_rtl[GR_ARG_POINTER])
1856
1857 extern GTY(()) rtx pic_offset_table_rtx;
1858 extern GTY(()) rtx struct_value_rtx;
1859 extern GTY(()) rtx struct_value_incoming_rtx;
1860 extern GTY(()) rtx static_chain_rtx;
1861 extern GTY(()) rtx static_chain_incoming_rtx;
1862 extern GTY(()) rtx return_address_pointer_rtx;
1863
1864 /* Include the RTL generation functions. */
1865
1866 #ifndef NO_GENRTL_H
1867 #include "genrtl.h"
1868 #endif
1869
1870 /* There are some RTL codes that require special attention; the
1871 generation functions included above do the raw handling. If you
1872 add to this list, modify special_rtx in gengenrtl.c as well. You
1873 should also modify gen_rtx to use the special function. */
1874
1875 extern rtx gen_rtx_CONST_INT PARAMS ((enum machine_mode, HOST_WIDE_INT));
1876 extern rtx gen_rtx_CONST_VECTOR PARAMS ((enum machine_mode, rtvec));
1877 extern rtx gen_raw_REG PARAMS ((enum machine_mode, int));
1878 extern rtx gen_rtx_REG PARAMS ((enum machine_mode, unsigned));
1879 extern rtx gen_rtx_SUBREG PARAMS ((enum machine_mode, rtx, int));
1880 extern rtx gen_rtx_MEM PARAMS ((enum machine_mode, rtx));
1881
1882 extern rtx gen_lowpart_SUBREG PARAMS ((enum machine_mode, rtx));
1883
1884 /* We need the cast here to ensure that we get the same result both with
1885 and without prototypes. */
1886 #define GEN_INT(N) gen_rtx_CONST_INT (VOIDmode, (HOST_WIDE_INT) (N))
1887
1888 /* Virtual registers are used during RTL generation to refer to locations into
1889 the stack frame when the actual location isn't known until RTL generation
1890 is complete. The routine instantiate_virtual_regs replaces these with
1891 the proper value, which is normally {frame,arg,stack}_pointer_rtx plus
1892 a constant. */
1893
1894 #define FIRST_VIRTUAL_REGISTER (FIRST_PSEUDO_REGISTER)
1895
1896 /* This points to the first word of the incoming arguments passed on the stack,
1897 either by the caller or by the callee when pretending it was passed by the
1898 caller. */
1899
1900 #define virtual_incoming_args_rtx (global_rtl[GR_VIRTUAL_INCOMING_ARGS])
1901
1902 #define VIRTUAL_INCOMING_ARGS_REGNUM (FIRST_VIRTUAL_REGISTER)
1903
1904 /* If FRAME_GROWS_DOWNWARD, this points to immediately above the first
1905 variable on the stack. Otherwise, it points to the first variable on
1906 the stack. */
1907
1908 #define virtual_stack_vars_rtx (global_rtl[GR_VIRTUAL_STACK_ARGS])
1909
1910 #define VIRTUAL_STACK_VARS_REGNUM ((FIRST_VIRTUAL_REGISTER) + 1)
1911
1912 /* This points to the location of dynamically-allocated memory on the stack
1913 immediately after the stack pointer has been adjusted by the amount
1914 desired. */
1915
1916 #define virtual_stack_dynamic_rtx (global_rtl[GR_VIRTUAL_STACK_DYNAMIC])
1917
1918 #define VIRTUAL_STACK_DYNAMIC_REGNUM ((FIRST_VIRTUAL_REGISTER) + 2)
1919
1920 /* This points to the location in the stack at which outgoing arguments should
1921 be written when the stack is pre-pushed (arguments pushed using push
1922 insns always use sp). */
1923
1924 #define virtual_outgoing_args_rtx (global_rtl[GR_VIRTUAL_OUTGOING_ARGS])
1925
1926 #define VIRTUAL_OUTGOING_ARGS_REGNUM ((FIRST_VIRTUAL_REGISTER) + 3)
1927
1928 /* This points to the Canonical Frame Address of the function. This
1929 should correspond to the CFA produced by INCOMING_FRAME_SP_OFFSET,
1930 but is calculated relative to the arg pointer for simplicity; the
1931 frame pointer nor stack pointer are necessarily fixed relative to
1932 the CFA until after reload. */
1933
1934 #define virtual_cfa_rtx (global_rtl[GR_VIRTUAL_CFA])
1935
1936 #define VIRTUAL_CFA_REGNUM ((FIRST_VIRTUAL_REGISTER) + 4)
1937
1938 #define LAST_VIRTUAL_REGISTER ((FIRST_VIRTUAL_REGISTER) + 4)
1939
1940 /* Nonzero if REGNUM is a pointer into the stack frame. */
1941 #define REGNO_PTR_FRAME_P(REGNUM) \
1942 ((REGNUM) == STACK_POINTER_REGNUM \
1943 || (REGNUM) == FRAME_POINTER_REGNUM \
1944 || (REGNUM) == HARD_FRAME_POINTER_REGNUM \
1945 || (REGNUM) == ARG_POINTER_REGNUM \
1946 || ((REGNUM) >= FIRST_VIRTUAL_REGISTER \
1947 && (REGNUM) <= LAST_VIRTUAL_REGISTER))
1948
1949 /* REGNUM never really appearing in the INSN stream. */
1950 #define INVALID_REGNUM (~(unsigned int) 0)
1951
1952 extern rtx find_next_ref PARAMS ((rtx, rtx));
1953
1954 extern rtx output_constant_def PARAMS ((tree, int));
1955
1956 /* Called from integrate.c when a deferred constant is inlined. */
1957 extern void notice_rtl_inlining_of_deferred_constant PARAMS ((void));
1958
1959 /* Nonzero after the second flow pass has completed.
1960 Set to 1 or 0 by toplev.c */
1961 extern int flow2_completed;
1962
1963 /* Nonzero after end of reload pass.
1964 Set to 1 or 0 by reload1.c. */
1965
1966 extern int reload_completed;
1967
1968 /* Nonzero after thread_prologue_and_epilogue_insns has run. */
1969 extern int epilogue_completed;
1970
1971 /* Set to 1 while reload_as_needed is operating.
1972 Required by some machines to handle any generated moves differently. */
1973
1974 extern int reload_in_progress;
1975
1976 /* If this is nonzero, we do not bother generating VOLATILE
1977 around volatile memory references, and we are willing to
1978 output indirect addresses. If cse is to follow, we reject
1979 indirect addresses so a useful potential cse is generated;
1980 if it is used only once, instruction combination will produce
1981 the same indirect address eventually. */
1982 extern int cse_not_expected;
1983
1984 /* Set to nonzero before life analysis to indicate that it is unsafe to
1985 generate any new pseudo registers. */
1986 extern int no_new_pseudos;
1987
1988 /* Translates rtx code to tree code, for those codes needed by
1989 REAL_ARITHMETIC. The function returns an int because the caller may not
1990 know what `enum tree_code' means. */
1991
1992 extern int rtx_to_tree_code PARAMS ((enum rtx_code));
1993
1994 /* In cse.c */
1995 struct cse_basic_block_data;
1996
1997 /* Return the right cost to give to an operation
1998 to make the cost of the corresponding register-to-register instruction
1999 N times that of a fast register-to-register instruction. */
2000 #define COSTS_N_INSNS(N) ((N) * 4)
2001
2002 /* Maximum cost of a rtl expression. This value has the special meaning
2003 not to use an rtx with this cost under any circumstances. */
2004 #define MAX_COST INT_MAX
2005
2006 extern int rtx_cost PARAMS ((rtx, enum rtx_code));
2007 extern int address_cost PARAMS ((rtx, enum machine_mode));
2008 extern int delete_trivially_dead_insns PARAMS ((rtx, int));
2009 #ifdef BUFSIZ
2010 extern int cse_main PARAMS ((rtx, int, int, FILE *));
2011 #endif
2012 extern void cse_end_of_basic_block PARAMS ((rtx,
2013 struct cse_basic_block_data *,
2014 int, int, int));
2015
2016 /* In jump.c */
2017 extern int comparison_dominates_p PARAMS ((enum rtx_code, enum rtx_code));
2018 extern int condjump_p PARAMS ((rtx));
2019 extern int any_condjump_p PARAMS ((rtx));
2020 extern int any_uncondjump_p PARAMS ((rtx));
2021 extern int safe_to_remove_jump_p PARAMS ((rtx));
2022 extern rtx pc_set PARAMS ((rtx));
2023 extern rtx condjump_label PARAMS ((rtx));
2024 extern int simplejump_p PARAMS ((rtx));
2025 extern int returnjump_p PARAMS ((rtx));
2026 extern int onlyjump_p PARAMS ((rtx));
2027 extern int only_sets_cc0_p PARAMS ((rtx));
2028 extern int sets_cc0_p PARAMS ((rtx));
2029 extern int invert_jump_1 PARAMS ((rtx, rtx));
2030 extern int invert_jump PARAMS ((rtx, rtx, int));
2031 extern int rtx_renumbered_equal_p PARAMS ((rtx, rtx));
2032 extern int true_regnum PARAMS ((rtx));
2033 extern unsigned int reg_or_subregno PARAMS ((rtx));
2034 extern int redirect_jump_1 PARAMS ((rtx, rtx));
2035 extern int redirect_jump PARAMS ((rtx, rtx, int));
2036 extern void rebuild_jump_labels PARAMS ((rtx));
2037 extern enum rtx_code reversed_comparison_code PARAMS ((rtx, rtx));
2038 extern enum rtx_code reversed_comparison_code_parts PARAMS ((enum rtx_code,
2039 rtx, rtx, rtx));
2040 extern void delete_for_peephole PARAMS ((rtx, rtx));
2041 extern int condjump_in_parallel_p PARAMS ((rtx));
2042 extern void never_reached_warning PARAMS ((rtx, rtx));
2043 extern void purge_line_number_notes PARAMS ((rtx));
2044 extern void copy_loop_headers PARAMS ((rtx));
2045
2046 /* In emit-rtl.c. */
2047 extern int max_reg_num PARAMS ((void));
2048 extern int max_label_num PARAMS ((void));
2049 extern int get_first_label_num PARAMS ((void));
2050 extern void delete_insns_since PARAMS ((rtx));
2051 extern void mark_reg_pointer PARAMS ((rtx, int));
2052 extern void mark_user_reg PARAMS ((rtx));
2053 extern void reset_used_flags PARAMS ((rtx));
2054 extern void reorder_insns PARAMS ((rtx, rtx, rtx));
2055 extern void reorder_insns_nobb PARAMS ((rtx, rtx, rtx));
2056 extern int get_max_uid PARAMS ((void));
2057 extern int in_sequence_p PARAMS ((void));
2058 extern void force_next_line_note PARAMS ((void));
2059 extern void init_emit PARAMS ((void));
2060 extern void init_emit_once PARAMS ((int));
2061 extern void push_topmost_sequence PARAMS ((void));
2062 extern void pop_topmost_sequence PARAMS ((void));
2063 extern int subreg_realpart_p PARAMS ((rtx));
2064 extern void reverse_comparison PARAMS ((rtx));
2065 extern void set_new_first_and_last_insn PARAMS ((rtx, rtx));
2066 extern void set_new_first_and_last_label_num PARAMS ((int, int));
2067 extern void set_new_last_label_num PARAMS ((int));
2068 extern void unshare_all_rtl_again PARAMS ((rtx));
2069 extern void set_first_insn PARAMS ((rtx));
2070 extern void set_last_insn PARAMS ((rtx));
2071 extern void link_cc0_insns PARAMS ((rtx));
2072 extern void add_insn PARAMS ((rtx));
2073 extern void add_insn_before PARAMS ((rtx, rtx));
2074 extern void add_insn_after PARAMS ((rtx, rtx));
2075 extern void remove_insn PARAMS ((rtx));
2076 extern void reorder_insns_with_line_notes PARAMS ((rtx, rtx, rtx));
2077 extern void emit_insn_after_with_line_notes PARAMS ((rtx, rtx, rtx));
2078 extern enum rtx_code classify_insn PARAMS ((rtx));
2079 extern rtx emit PARAMS ((rtx));
2080 /* Query and clear/ restore no_line_numbers. This is used by the
2081 switch / case handling in stmt.c to give proper line numbers in
2082 warnings about unreachable code. */
2083 int force_line_numbers PARAMS ((void));
2084 void restore_line_number_status PARAMS ((int old_value));
2085 extern void renumber_insns PARAMS ((FILE *));
2086 extern void remove_unnecessary_notes PARAMS ((void));
2087 extern rtx delete_insn PARAMS ((rtx));
2088 extern void delete_insn_chain PARAMS ((rtx, rtx));
2089 extern rtx unlink_insn_chain PARAMS ((rtx, rtx));
2090 extern rtx delete_insn_and_edges PARAMS ((rtx));
2091 extern void delete_insn_chain_and_edges PARAMS ((rtx, rtx));
2092
2093 /* In combine.c */
2094 extern int combine_instructions (rtx, unsigned int);
2095 extern unsigned int extended_count (rtx, enum machine_mode, int);
2096 extern rtx remove_death (unsigned int, rtx);
2097 #ifdef BUFSIZ
2098 extern void dump_combine_stats (FILE *);
2099 extern void dump_combine_total_stats (FILE *);
2100 #endif
2101
2102 /* In sched.c. */
2103 #ifdef BUFSIZ
2104 extern void schedule_insns PARAMS ((FILE *));
2105 extern void schedule_ebbs PARAMS ((FILE *));
2106 #endif
2107 extern void fix_sched_param PARAMS ((const char *, const char *));
2108
2109 /* In print-rtl.c */
2110 extern const char *print_rtx_head;
2111 extern void debug_rtx PARAMS ((rtx));
2112 extern void debug_rtx_list PARAMS ((rtx, int));
2113 extern void debug_rtx_range PARAMS ((rtx, rtx));
2114 extern rtx debug_rtx_find PARAMS ((rtx, int));
2115 #ifdef BUFSIZ
2116 extern void print_mem_expr PARAMS ((FILE *, tree));
2117 extern void print_rtl PARAMS ((FILE *, rtx));
2118 extern void print_simple_rtl PARAMS ((FILE *, rtx));
2119 extern int print_rtl_single PARAMS ((FILE *, rtx));
2120 extern void print_inline_rtx PARAMS ((FILE *, rtx, int));
2121 #endif
2122
2123 /* In loop.c */
2124 extern void init_loop PARAMS ((void));
2125 extern rtx libcall_other_reg PARAMS ((rtx, rtx));
2126 #ifdef BUFSIZ
2127 extern void loop_optimize PARAMS ((rtx, FILE *, int));
2128 #endif
2129 extern void branch_target_load_optimize (rtx, bool);
2130 extern void record_excess_regs PARAMS ((rtx, rtx, rtx *));
2131
2132 /* In function.c */
2133 extern void reposition_prologue_and_epilogue_notes PARAMS ((rtx));
2134 extern void thread_prologue_and_epilogue_insns PARAMS ((rtx));
2135 extern int prologue_epilogue_contains PARAMS ((rtx));
2136 extern int sibcall_epilogue_contains PARAMS ((rtx));
2137 extern void preserve_rtl_expr_result PARAMS ((rtx));
2138 extern void mark_temp_addr_taken PARAMS ((rtx));
2139 extern void update_temp_slot_address PARAMS ((rtx, rtx));
2140 extern void purge_addressof PARAMS ((rtx));
2141 extern void purge_hard_subreg_sets PARAMS ((rtx));
2142
2143 /* In stmt.c */
2144 extern void set_file_and_line_for_stmt PARAMS ((const char *, int));
2145 extern void expand_null_return PARAMS ((void));
2146 extern void emit_jump PARAMS ((rtx));
2147 extern int preserve_subexpressions_p PARAMS ((void));
2148
2149 /* In expr.c */
2150 extern rtx move_by_pieces PARAMS ((rtx, rtx,
2151 unsigned HOST_WIDE_INT,
2152 unsigned int, int));
2153
2154 /* In flow.c */
2155 extern void recompute_reg_usage PARAMS ((rtx, int));
2156 extern int initialize_uninitialized_subregs PARAMS ((void));
2157 extern void delete_dead_jumptables PARAMS ((void));
2158 #ifdef BUFSIZ
2159 extern void print_rtl_with_bb PARAMS ((FILE *, rtx));
2160 extern void dump_flow_info PARAMS ((FILE *));
2161 #endif
2162
2163 /* In expmed.c */
2164 extern void init_expmed PARAMS ((void));
2165 extern void expand_inc PARAMS ((rtx, rtx));
2166 extern void expand_dec PARAMS ((rtx, rtx));
2167 extern rtx expand_mult_highpart PARAMS ((enum machine_mode, rtx,
2168 unsigned HOST_WIDE_INT, rtx,
2169 int, int));
2170
2171 /* In gcse.c */
2172 extern bool can_copy_p PARAMS ((enum machine_mode));
2173 extern rtx fis_get_condition PARAMS ((rtx));
2174 #ifdef BUFSIZ
2175 extern int gcse_main PARAMS ((rtx, FILE *));
2176 extern int bypass_jumps PARAMS ((FILE *));
2177 #endif
2178
2179 /* In global.c */
2180 extern void mark_elimination PARAMS ((int, int));
2181 #ifdef BUFSIZ
2182 extern int global_alloc PARAMS ((FILE *));
2183 extern void dump_global_regs PARAMS ((FILE *));
2184 #endif
2185 #ifdef HARD_CONST
2186 /* Yes, this ifdef is silly, but HARD_REG_SET is not always defined. */
2187 extern void retry_global_alloc PARAMS ((int, HARD_REG_SET));
2188 #endif
2189 extern void build_insn_chain PARAMS ((rtx));
2190
2191 /* In regclass.c */
2192 extern int reg_classes_intersect_p PARAMS ((enum reg_class, enum reg_class));
2193 extern int reg_class_subset_p PARAMS ((enum reg_class, enum reg_class));
2194 extern void globalize_reg PARAMS ((int));
2195 extern void init_regs PARAMS ((void));
2196 extern void init_fake_stack_mems PARAMS ((void));
2197 extern void init_reg_sets PARAMS ((void));
2198 extern void regset_release_memory PARAMS ((void));
2199 extern void regclass_init PARAMS ((void));
2200 extern void regclass PARAMS ((rtx, int, FILE *));
2201 extern void reg_scan PARAMS ((rtx, unsigned int, int));
2202 extern void reg_scan_update PARAMS ((rtx, rtx, unsigned int));
2203 extern void fix_register PARAMS ((const char *, int, int));
2204 #ifdef HARD_CONST
2205 extern void cannot_change_mode_set_regs PARAMS ((HARD_REG_SET *,
2206 enum machine_mode,
2207 unsigned int));
2208 #endif
2209 extern bool invalid_mode_change_p PARAMS ((unsigned int,
2210 enum reg_class,
2211 enum machine_mode));
2212
2213 extern int delete_null_pointer_checks PARAMS ((rtx));
2214
2215 /* In regmove.c */
2216 #ifdef BUFSIZ
2217 extern void regmove_optimize PARAMS ((rtx, int, FILE *));
2218 #endif
2219 extern void combine_stack_adjustments PARAMS ((void));
2220
2221 /* In reorg.c */
2222 #ifdef BUFSIZ
2223 extern void dbr_schedule PARAMS ((rtx, FILE *));
2224 #endif
2225
2226 /* In local-alloc.c */
2227 #ifdef BUFSIZ
2228 extern void dump_local_alloc PARAMS ((FILE *));
2229 #endif
2230 extern int local_alloc PARAMS ((void));
2231 extern int function_invariant_p PARAMS ((rtx));
2232
2233 /* In profile.c */
2234 extern void init_branch_prob PARAMS ((void));
2235 extern void branch_prob PARAMS ((void));
2236 extern void end_branch_prob PARAMS ((void));
2237
2238 /* In reg-stack.c */
2239 #ifdef BUFSIZ
2240 extern bool reg_to_stack PARAMS ((rtx, FILE *));
2241 #endif
2242
2243 /* In calls.c */
2244 enum libcall_type
2245 {
2246 LCT_NORMAL = 0,
2247 LCT_CONST = 1,
2248 LCT_PURE = 2,
2249 LCT_CONST_MAKE_BLOCK = 3,
2250 LCT_PURE_MAKE_BLOCK = 4,
2251 LCT_NORETURN = 5,
2252 LCT_THROW = 6,
2253 LCT_ALWAYS_RETURN = 7,
2254 LCT_RETURNS_TWICE = 8
2255 };
2256
2257 extern void emit_library_call PARAMS ((rtx, enum libcall_type,
2258 enum machine_mode, int,
2259 ...));
2260 extern rtx emit_library_call_value PARAMS ((rtx, rtx, enum libcall_type,
2261 enum machine_mode, int,
2262 ...));
2263
2264 /* In unroll.c */
2265 extern int set_dominates_use PARAMS ((int, int, int, rtx, rtx));
2266
2267 /* In varasm.c */
2268 extern int in_data_section PARAMS ((void));
2269 extern void init_varasm_once PARAMS ((void));
2270
2271 /* In rtl.c */
2272 extern void init_rtl PARAMS ((void));
2273 extern void traverse_md_constants PARAMS ((int (*) (void **, void *),
2274 void *));
2275 struct md_constant { char *name, *value; };
2276
2277 #ifdef BUFSIZ
2278 extern int read_skip_spaces PARAMS ((FILE *));
2279 extern rtx read_rtx PARAMS ((FILE *));
2280 #endif
2281
2282 extern const char *read_rtx_filename;
2283 extern int read_rtx_lineno;
2284
2285 /* Redefine abort to report an internal error w/o coredump, and
2286 reporting the location of the error in the source file. This logic
2287 is duplicated in rtl.h and tree.h because every file that needs the
2288 special abort includes one or both. toplev.h gets too few files,
2289 system.h gets too many. */
2290
2291 extern void fancy_abort PARAMS ((const char *, int, const char *))
2292 ATTRIBUTE_NORETURN;
2293 #define abort() fancy_abort (__FILE__, __LINE__, __FUNCTION__)
2294
2295 /* In alias.c */
2296 extern void clear_reg_alias_info (rtx);
2297 extern rtx canon_rtx (rtx);
2298 extern int true_dependence (rtx, enum machine_mode, rtx, int (*)(rtx, int));
2299 extern rtx get_addr (rtx);
2300 extern int canon_true_dependence (rtx, enum machine_mode, rtx, rtx,
2301 int (*)(rtx, int));
2302 extern int read_dependence (rtx, rtx);
2303 extern int anti_dependence (rtx, rtx);
2304 extern int output_dependence (rtx, rtx);
2305 extern void mark_constant_function (void);
2306 extern void init_alias_once (void);
2307 extern void init_alias_analysis (void);
2308 extern void end_alias_analysis (void);
2309 extern rtx addr_side_effect_eval (rtx, int, int);
2310 extern bool memory_modified_in_insn_p (rtx, rtx);
2311 extern rtx find_base_term (rtx);
2312
2313 /* In sibcall.c */
2314 typedef enum {
2315 sibcall_use_normal = 1,
2316 sibcall_use_tail_recursion,
2317 sibcall_use_sibcall
2318 } sibcall_use_t;
2319
2320 extern void optimize_sibling_and_tail_recursive_calls PARAMS ((void));
2321 extern void replace_call_placeholder PARAMS ((rtx, sibcall_use_t));
2322
2323 #ifdef STACK_REGS
2324 extern int stack_regs_mentioned PARAMS ((rtx insn));
2325 #endif
2326
2327 /* In toplev.c */
2328 extern GTY(()) rtx stack_limit_rtx;
2329
2330 /* In regrename.c */
2331 extern void regrename_optimize PARAMS ((void));
2332 extern void copyprop_hardreg_forward PARAMS ((void));
2333
2334 /* In ifcvt.c */
2335 extern void if_convert PARAMS ((int));
2336
2337 /* In predict.c */
2338 extern void invert_br_probabilities PARAMS ((rtx));
2339 extern bool expensive_function_p PARAMS ((int));
2340 /* In tracer.c */
2341 extern void tracer PARAMS ((void));
2342
2343 /* In calls.c */
2344
2345 /* Nonzero if this is a call to a `const' function. */
2346 #define ECF_CONST 1
2347 /* Nonzero if this is a call to a `volatile' function. */
2348 #define ECF_NORETURN 2
2349 /* Nonzero if this is a call to malloc or a related function. */
2350 #define ECF_MALLOC 4
2351 /* Nonzero if it is plausible that this is a call to alloca. */
2352 #define ECF_MAY_BE_ALLOCA 8
2353 /* Nonzero if this is a call to a function that won't throw an exception. */
2354 #define ECF_NOTHROW 16
2355 /* Nonzero if this is a call to setjmp or a related function. */
2356 #define ECF_RETURNS_TWICE 32
2357 /* Nonzero if this is a call to `longjmp'. */
2358 #define ECF_LONGJMP 64
2359 /* Nonzero if this is a syscall that makes a new process in the image of
2360 the current one. */
2361 #define ECF_FORK_OR_EXEC 128
2362 #define ECF_SIBCALL 256
2363 /* Nonzero if this is a call to "pure" function (like const function,
2364 but may read memory. */
2365 #define ECF_PURE 512
2366 /* Nonzero if this is a call to a function that returns with the stack
2367 pointer depressed. */
2368 #define ECF_SP_DEPRESSED 1024
2369 /* Nonzero if this call is known to always return. */
2370 #define ECF_ALWAYS_RETURN 2048
2371 /* Create libcall block around the call. */
2372 #define ECF_LIBCALL_BLOCK 4096
2373
2374 extern int flags_from_decl_or_type PARAMS ((tree));
2375
2376 #endif /* ! GCC_RTL_H */
Mirror of the offical gcc git repository hosted at gcc.gnu.org