![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rtl.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to rtl.h CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: /* Register Transfer Language (RTL) definitions for GNU C-Compiler
2: Copyright (C) 1987, 1991, 1992, 1993 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 2, or (at your option)
9: any later version.
10:
11: GNU CC is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU CC; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20:
21: #include "machmode.h"
22:
23: #undef FFS /* Some systems predefine this symbol; don't let it interfere. */
24: #undef FLOAT /* Likewise. */
25: #undef ABS /* Likewise. */
26: #undef PC /* Likewise. */
27:
28: /* Register Transfer Language EXPRESSIONS CODES */
29:
30: #define RTX_CODE enum rtx_code
31: enum rtx_code {
32:
33: #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) ENUM ,
34: #include "rtl.def" /* rtl expressions are documented here */
35: #undef DEF_RTL_EXPR
36:
37: LAST_AND_UNUSED_RTX_CODE}; /* A convenient way to get a value for
38: NUM_RTX_CODE.
39: Assumes default enum value assignment. */
40:
41: #define NUM_RTX_CODE ((int)LAST_AND_UNUSED_RTX_CODE)
42: /* The cast here, saves many elsewhere. */
43:
44: extern int rtx_length[];
45: #define GET_RTX_LENGTH(CODE) (rtx_length[(int)(CODE)])
46:
47: extern char *rtx_name[];
48: #define GET_RTX_NAME(CODE) (rtx_name[(int)(CODE)])
49:
50: extern char *rtx_format[];
51: #define GET_RTX_FORMAT(CODE) (rtx_format[(int)(CODE)])
52:
53: extern char rtx_class[];
54: #define GET_RTX_CLASS(CODE) (rtx_class[(int)(CODE)])
55:
56: /* Common union for an element of an rtx. */
57:
58: typedef union rtunion_def
59: {
60: HOST_WIDE_INT rtwint;
61: int rtint;
62: char *rtstr;
63: struct rtx_def *rtx;
64: struct rtvec_def *rtvec;
65: enum machine_mode rttype;
66: } rtunion;
67:
68: /* RTL expression ("rtx"). */
69:
70: typedef struct rtx_def
71: {
72: #ifdef ONLY_INT_FIELDS
73: #ifdef CODE_FIELD_BUG
74: unsigned int code : 16;
75: #else
76: unsigned short code;
77: #endif
78: #else
79: /* The kind of expression this is. */
80: enum rtx_code code : 16;
81: #endif
82: /* The kind of value the expression has. */
83: #ifdef ONLY_INT_FIELDS
84: int mode : 8;
85: #else
86: enum machine_mode mode : 8;
87: #endif
88: /* 1 in an INSN if it can alter flow of control
89: within this function. Not yet used! */
90: unsigned int jump : 1;
91: /* 1 in an INSN if it can call another function. Not yet used! */
92: unsigned int call : 1;
93: /* 1 in a MEM or REG if value of this expression will never change
94: during the current function, even though it is not
95: manifestly constant.
96: 1 in a SUBREG if it is from a promoted variable that is unsigned.
97: 1 in a SYMBOL_REF if it addresses something in the per-function
98: constants pool.
99: 1 in a CALL_INSN if it is a const call.
100: 1 in a JUMP_INSN if it is a branch that should be annulled. Valid from
101: reorg until end of compilation; cleared before used. */
102: unsigned int unchanging : 1;
103: /* 1 in a MEM expression if contents of memory are volatile.
104: 1 in an INSN, CALL_INSN, JUMP_INSN, CODE_LABEL or BARRIER
105: if it is deleted.
106: 1 in a REG expression if corresponds to a variable declared by the user.
107: 0 for an internally generated temporary.
108: In a SYMBOL_REF, this flag is used for machine-specific purposes.
109: In a LABEL_REF or in a REG_LABEL note, this is LABEL_REF_NONLOCAL_P. */
110: unsigned int volatil : 1;
111: /* 1 in a MEM referring to a field of a structure (not a union!).
112: 0 if the MEM was a variable or the result of a * operator in C;
113: 1 if it was the result of a . or -> operator (on a struct) in C.
114: 1 in a REG if the register is used only in exit code a loop.
115: 1 in a SUBREG expression if was generated from a variable with a
116: promoted mode.
117: 1 in a CODE_LABEL if the label is used for nonlocal gotos
118: and must not be deleted even if its count is zero.
119: 1 in a LABEL_REF if this is a reference to a label outside the
120: current loop.
121: 1 in an INSN, JUMP_INSN, or CALL_INSN if this insn must be scheduled
122: together with the preceding insn. Valid only within sched.
123: 1 in an INSN, JUMP_INSN, or CALL_INSN if insn is in a delay slot and
124: from the target of a branch. Valid from reorg until end of compilation;
125: cleared before used. */
126: unsigned int in_struct : 1;
127: /* 1 if this rtx is used. This is used for copying shared structure.
128: See `unshare_all_rtl'.
129: In a REG, this is not needed for that purpose, and used instead
130: in `leaf_renumber_regs_insn'.
131: In a SYMBOL_REF, means that emit_library_call
132: has used it as the function. */
133: unsigned int used : 1;
134: /* Nonzero if this rtx came from procedure integration.
135: In a REG, nonzero means this reg refers to the return value
136: of the current function. */
137: unsigned integrated : 1;
138: /* The first element of the operands of this rtx.
139: The number of operands and their types are controlled
140: by the `code' field, according to rtl.def. */
141: rtunion fld[1];
142: } *rtx;
143:
144:
145: /* Add prototype support. */
146: #ifndef PROTO
147: #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
148: #define PROTO(ARGS) ARGS
149: #else
150: #define PROTO(ARGS) ()
151: #endif
152: #endif
153:
154: #define NULL_RTX (rtx) 0
155:
156: /* Define a generic NULL if one hasn't already been defined. */
157:
158: #ifndef NULL
159: #define NULL 0
160: #endif
161:
162: #ifndef GENERIC_PTR
163: #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
164: #define GENERIC_PTR void *
165: #else
166: #define GENERIC_PTR char *
167: #endif
168: #endif
169:
170: #ifndef NULL_PTR
171: #define NULL_PTR ((GENERIC_PTR)0)
172: #endif
173:
174: /* Define macros to access the `code' field of the rtx. */
175:
176: #ifdef SHORT_ENUM_BUG
177: #define GET_CODE(RTX) ((enum rtx_code) ((RTX)->code))
178: #define PUT_CODE(RTX, CODE) ((RTX)->code = ((short) (CODE)))
179: #else
180: #define GET_CODE(RTX) ((RTX)->code)
181: #define PUT_CODE(RTX, CODE) ((RTX)->code = (CODE))
182: #endif
183:
184: #define GET_MODE(RTX) ((RTX)->mode)
185: #define PUT_MODE(RTX, MODE) ((RTX)->mode = (MODE))
186:
187: #define RTX_INTEGRATED_P(RTX) ((RTX)->integrated)
188: #define RTX_UNCHANGING_P(RTX) ((RTX)->unchanging)
189:
190: /* RTL vector. These appear inside RTX's when there is a need
191: for a variable number of things. The principle use is inside
192: PARALLEL expressions. */
193:
194: typedef struct rtvec_def{
195: unsigned num_elem; /* number of elements */
196: rtunion elem[1];
197: } *rtvec;
198:
199: #define NULL_RTVEC (rtvec) 0
200:
201: #define GET_NUM_ELEM(RTVEC) ((RTVEC)->num_elem)
202: #define PUT_NUM_ELEM(RTVEC, NUM) ((RTVEC)->num_elem = (unsigned) NUM)
203:
204: #define RTVEC_ELT(RTVEC, I) ((RTVEC)->elem[(I)].rtx)
205:
206: /* 1 if X is a REG. */
207:
208: #define REG_P(X) (GET_CODE (X) == REG)
209:
210: /* 1 if X is a constant value that is an integer. */
211:
212: #define CONSTANT_P(X) \
213: (GET_CODE (X) == LABEL_REF || GET_CODE (X) == SYMBOL_REF \
214: || GET_CODE (X) == CONST_INT || GET_CODE (X) == CONST_DOUBLE \
215: || GET_CODE (X) == CONST || GET_CODE (X) == HIGH)
216:
217: /* General accessor macros for accessing the fields of an rtx. */
218:
219: #define XEXP(RTX, N) ((RTX)->fld[N].rtx)
220: #define XINT(RTX, N) ((RTX)->fld[N].rtint)
221: #define XWINT(RTX, N) ((RTX)->fld[N].rtwint)
222: #define XSTR(RTX, N) ((RTX)->fld[N].rtstr)
223: #define XVEC(RTX, N) ((RTX)->fld[N].rtvec)
224: #define XVECLEN(RTX, N) ((RTX)->fld[N].rtvec->num_elem)
225: #define XVECEXP(RTX,N,M)((RTX)->fld[N].rtvec->elem[M].rtx)
226:
227: /* ACCESS MACROS for particular fields of insns. */
228:
229: /* Holds a unique number for each insn.
230: These are not necessarily sequentially increasing. */
231: #define INSN_UID(INSN) ((INSN)->fld[0].rtint)
232:
233: /* Chain insns together in sequence. */
234: #define PREV_INSN(INSN) ((INSN)->fld[1].rtx)
235: #define NEXT_INSN(INSN) ((INSN)->fld[2].rtx)
236:
237: /* The body of an insn. */
238: #define PATTERN(INSN) ((INSN)->fld[3].rtx)
239:
240: /* Code number of instruction, from when it was recognized.
241: -1 means this instruction has not been recognized yet. */
242: #define INSN_CODE(INSN) ((INSN)->fld[4].rtint)
243:
244: /* Set up in flow.c; empty before then.
245: Holds a chain of INSN_LIST rtx's whose first operands point at
246: previous insns with direct data-flow connections to this one.
247: That means that those insns set variables whose next use is in this insn.
248: They are always in the same basic block as this insn. */
249: #define LOG_LINKS(INSN) ((INSN)->fld[5].rtx)
250:
251: /* 1 if insn has been deleted. */
252: #define INSN_DELETED_P(INSN) ((INSN)->volatil)
253:
254: /* 1 if insn is a call to a const function. */
255: #define CONST_CALL_P(INSN) ((INSN)->unchanging)
256:
257: /* 1 if insn is a branch that should not unconditionally execute its
258: delay slots, i.e., it is an annulled branch. */
259: #define INSN_ANNULLED_BRANCH_P(INSN) ((INSN)->unchanging)
260:
261: /* 1 if insn is in a delay slot and is from the target of the branch. If
262: the branch insn has INSN_ANNULLED_BRANCH_P set, this insn should only be
263: executed if the branch is taken. For annulled branches with this bit
264: clear, the insn should be executed only if the branch is not taken. */
265: #define INSN_FROM_TARGET_P(INSN) ((INSN)->in_struct)
266:
267: /* Holds a list of notes on what this insn does to various REGs.
268: It is a chain of EXPR_LIST rtx's, where the second operand
269: is the chain pointer and the first operand is the REG being described.
270: The mode field of the EXPR_LIST contains not a real machine mode
271: but a value that says what this note says about the REG:
272: REG_DEAD means that the value in REG dies in this insn (i.e., it is
273: not needed past this insn). If REG is set in this insn, the REG_DEAD
274: note may, but need not, be omitted.
275: REG_INC means that the REG is autoincremented or autodecremented.
276: REG_EQUIV describes the insn as a whole; it says that the
277: insn sets a register to a constant value or to be equivalent to
278: a memory address. If the
279: register is spilled to the stack then the constant value
280: should be substituted for it. The contents of the REG_EQUIV
281: is the constant value or memory address, which may be different
282: from the source of the SET although it has the same value.
283: REG_EQUAL is like REG_EQUIV except that the destination
284: is only momentarily equal to the specified rtx. Therefore, it
285: cannot be used for substitution; but it can be used for cse.
286: REG_RETVAL means that this insn copies the return-value of
287: a library call out of the hard reg for return values. This note
288: is actually an INSN_LIST and it points to the first insn involved
289: in setting up arguments for the call. flow.c uses this to delete
290: the entire library call when its result is dead.
291: REG_LIBCALL is the inverse of REG_RETVAL: it goes on the first insn
292: of the library call and points at the one that has the REG_RETVAL.
293: REG_WAS_0 says that the register set in this insn held 0 before the insn.
294: The contents of the note is the insn that stored the 0.
295: If that insn is deleted or patched to a NOTE, the REG_WAS_0 is inoperative.
296: The REG_WAS_0 note is actually an INSN_LIST, not an EXPR_LIST.
297: REG_NONNEG means that the register is always nonnegative during
298: the containing loop. This is used in branches so that decrement and
299: branch instructions terminating on zero can be matched. There must be
300: an insn pattern in the md file named `decrement_and_branch_until_zero'
301: or else this will never be added to any instructions.
302: REG_NO_CONFLICT means there is no conflict *after this insn*
303: between the register in the note and the destination of this insn.
304: REG_UNUSED identifies a register set in this insn and never used.
305: REG_CC_SETTER and REG_CC_USER link a pair of insns that set and use
306: CC0, respectively. Normally, these are required to be consecutive insns,
307: but we permit putting a cc0-setting insn in the delay slot of a branch
308: as long as only one copy of the insn exists. In that case, these notes
309: point from one to the other to allow code generation to determine what
310: any require information and to properly update CC_STATUS.
311: REG_LABEL points to a CODE_LABEL. Used by non-JUMP_INSNs to
312: say that the CODE_LABEL contained in the REG_LABEL note is used
313: by the insn.
314: REG_DEP_ANTI is used in LOG_LINKS which represent anti (write after read)
315: dependencies. REG_DEP_OUTPUT is used in LOG_LINKS which represent output
316: (write after write) dependencies. Data dependencies, which are the only
317: type of LOG_LINK created by flow, are represented by a 0 reg note kind. */
318:
319: #define REG_NOTES(INSN) ((INSN)->fld[6].rtx)
320:
321: /* Don't forget to change reg_note_name in rtl.c. */
322: enum reg_note { REG_DEAD = 1, REG_INC = 2, REG_EQUIV = 3, REG_WAS_0 = 4,
323: REG_EQUAL = 5, REG_RETVAL = 6, REG_LIBCALL = 7,
324: REG_NONNEG = 8, REG_NO_CONFLICT = 9, REG_UNUSED = 10,
325: REG_CC_SETTER = 11, REG_CC_USER = 12, REG_LABEL = 13,
326: REG_DEP_ANTI = 14, REG_DEP_OUTPUT = 15 };
327:
328: /* Define macros to extract and insert the reg-note kind in an EXPR_LIST. */
329: #define REG_NOTE_KIND(LINK) ((enum reg_note) GET_MODE (LINK))
330: #define PUT_REG_NOTE_KIND(LINK,KIND) PUT_MODE(LINK, (enum machine_mode) (KIND))
331:
332: /* Names for REG_NOTE's in EXPR_LIST insn's. */
333:
334: extern char *reg_note_name[];
335: #define GET_REG_NOTE_NAME(MODE) (reg_note_name[(int)(MODE)])
336:
337: /* The label-number of a code-label. The assembler label
338: is made from `L' and the label-number printed in decimal.
339: Label numbers are unique in a compilation. */
340: #define CODE_LABEL_NUMBER(INSN) ((INSN)->fld[3].rtint)
341:
342: #define LINE_NUMBER NOTE
343:
344: /* In a NOTE that is a line number, this is a string for the file name
345: that the line is in. We use the same field to record block numbers
346: temporarily in NOTE_INSN_BLOCK_BEG and NOTE_INSN_BLOCK_END notes.
347: (We avoid lots of casts between ints and pointers if we use a
348: different macro for the bock number.) */
349:
350: #define NOTE_SOURCE_FILE(INSN) ((INSN)->fld[3].rtstr)
351: #define NOTE_BLOCK_NUMBER(INSN) ((INSN)->fld[3].rtint)
352:
353: /* In a NOTE that is a line number, this is the line number.
354: Other kinds of NOTEs are identified by negative numbers here. */
355: #define NOTE_LINE_NUMBER(INSN) ((INSN)->fld[4].rtint)
356:
357: /* Codes that appear in the NOTE_LINE_NUMBER field
358: for kinds of notes that are not line numbers.
359:
360: Notice that we do not try to use zero here for any of
361: the special note codes because sometimes the source line
362: actually can be zero! This happens (for example) when we
363: are generating code for the per-translation-unit constructor
364: and destructor routines for some C++ translation unit.
365:
366: If you should change any of the following values, or if you
367: should add a new value here, don't forget to change the
368: note_insn_name array in rtl.c. */
369:
370: /* This note is used to get rid of an insn
371: when it isn't safe to patch the insn out of the chain. */
372: #define NOTE_INSN_DELETED -1
373: #define NOTE_INSN_BLOCK_BEG -2
374: #define NOTE_INSN_BLOCK_END -3
375: #define NOTE_INSN_LOOP_BEG -4
376: #define NOTE_INSN_LOOP_END -5
377: /* This kind of note is generated at the end of the function body,
378: just before the return insn or return label.
379: In an optimizing compilation it is deleted by the first jump optimization,
380: after enabling that optimizer to determine whether control can fall
381: off the end of the function body without a return statement. */
382: #define NOTE_INSN_FUNCTION_END -6
383: /* This kind of note is generated just after each call to `setjmp', et al. */
384: #define NOTE_INSN_SETJMP -7
385: /* Generated at the place in a loop that `continue' jumps to. */
386: #define NOTE_INSN_LOOP_CONT -8
387: /* Generated at the start of a duplicated exit test. */
388: #define NOTE_INSN_LOOP_VTOP -9
389: /* This marks the point immediately after the last prologue insn. */
390: #define NOTE_INSN_PROLOGUE_END -10
391: /* This marks the point immediately prior to the first epilogue insn. */
392: #define NOTE_INSN_EPILOGUE_BEG -11
393: /* Generated in place of user-declared labels when they are deleted. */
394: #define NOTE_INSN_DELETED_LABEL -12
395: /* This note indicates the start of the real body of the function,
396: i.e. the point just after all of the parms have been moved into
397: their homes, etc. */
398: #define NOTE_INSN_FUNCTION_BEG -13
399:
400:
401: #if 0 /* These are not used, and I don't know what they were for. --rms. */
402: #define NOTE_DECL_NAME(INSN) ((INSN)->fld[3].rtstr)
403: #define NOTE_DECL_CODE(INSN) ((INSN)->fld[4].rtint)
404: #define NOTE_DECL_RTL(INSN) ((INSN)->fld[5].rtx)
405: #define NOTE_DECL_IDENTIFIER(INSN) ((INSN)->fld[6].rtint)
406: #define NOTE_DECL_TYPE(INSN) ((INSN)->fld[7].rtint)
407: #endif /* 0 */
408:
409: /* Names for NOTE insn's other than line numbers. */
410:
411: extern char *note_insn_name[];
412: #define GET_NOTE_INSN_NAME(NOTE_CODE) (note_insn_name[-(NOTE_CODE)])
413:
414: /* The name of a label, in case it corresponds to an explicit label
415: in the input source code. */
416: #define LABEL_NAME(LABEL) ((LABEL)->fld[4].rtstr)
417:
418: /* In jump.c, each label contains a count of the number
419: of LABEL_REFs that point at it, so unused labels can be deleted. */
420: #define LABEL_NUSES(LABEL) ((LABEL)->fld[5].rtint)
421:
422: /* The rest is used instead of the above, in a CODE_LABEL,
423: if bytecode is being output.
424: We make the slightly klugy assumption that a LABEL has enough slots
425: to hold these things. That happens to be true. */
426:
427: /* For static or external objects. */
428: #define BYTECODE_LABEL(X) (XEXP ((X), 0))
429:
430: /* For goto labels inside bytecode functions. */
431: #define BYTECODE_BC_LABEL(X) (*(struct bc_label **) &XEXP ((X), 1))
432:
433: /* In jump.c, each JUMP_INSN can point to a label that it can jump to,
434: so that if the JUMP_INSN is deleted, the label's LABEL_NUSES can
435: be decremented and possibly the label can be deleted. */
436: #define JUMP_LABEL(INSN) ((INSN)->fld[7].rtx)
437:
438: /* Once basic blocks are found in flow.c,
439: each CODE_LABEL starts a chain that goes through
440: all the LABEL_REFs that jump to that label.
441: The chain eventually winds up at the CODE_LABEL; it is circular. */
442: #define LABEL_REFS(LABEL) ((LABEL)->fld[5].rtx)
443:
444: /* This is the field in the LABEL_REF through which the circular chain
445: of references to a particular label is linked.
446: This chain is set up in flow.c. */
447:
448: #define LABEL_NEXTREF(REF) ((REF)->fld[1].rtx)
449:
450: /* Once basic blocks are found in flow.c,
451: Each LABEL_REF points to its containing instruction with this field. */
452:
453: #define CONTAINING_INSN(RTX) ((RTX)->fld[2].rtx)
454:
455: /* For a REG rtx, REGNO extracts the register number. */
456:
457: #define REGNO(RTX) ((RTX)->fld[0].rtint)
458:
459: /* For a REG rtx, REG_FUNCTION_VALUE_P is nonzero if the reg
460: is the current function's return value. */
461:
462: #define REG_FUNCTION_VALUE_P(RTX) ((RTX)->integrated)
463:
464: /* 1 in a REG rtx if it corresponds to a variable declared by the user. */
465: #define REG_USERVAR_P(RTX) ((RTX)->volatil)
466:
467: /* For a CONST_INT rtx, INTVAL extracts the integer. */
468:
469: #define INTVAL(RTX) ((RTX)->fld[0].rtwint)
470:
471: /* For a SUBREG rtx, SUBREG_REG extracts the value we want a subreg of.
472: SUBREG_WORD extracts the word-number. */
473:
474: #define SUBREG_REG(RTX) ((RTX)->fld[0].rtx)
475: #define SUBREG_WORD(RTX) ((RTX)->fld[1].rtint)
476:
477: /* 1 if the REG contained in SUBREG_REG is already known to be
478: sign- or zero-extended from the mode of the SUBREG to the mode of
479: the reg. SUBREG_PROMOTED_UNSIGNED_P gives the signedness of the
480: extension.
481:
482: When used as a LHS, is means that this extension must be done
483: when assigning to SUBREG_REG. */
484:
485: #define SUBREG_PROMOTED_VAR_P(RTX) ((RTX)->in_struct)
486: #define SUBREG_PROMOTED_UNSIGNED_P(RTX) ((RTX)->unchanging)
487:
488: /* Access various components of an ASM_OPERANDS rtx. */
489:
490: #define ASM_OPERANDS_TEMPLATE(RTX) XSTR ((RTX), 0)
491: #define ASM_OPERANDS_OUTPUT_CONSTRAINT(RTX) XSTR ((RTX), 1)
492: #define ASM_OPERANDS_OUTPUT_IDX(RTX) XINT ((RTX), 2)
493: #define ASM_OPERANDS_INPUT_VEC(RTX) XVEC ((RTX), 3)
494: #define ASM_OPERANDS_INPUT_CONSTRAINT_VEC(RTX) XVEC ((RTX), 4)
495: #define ASM_OPERANDS_INPUT(RTX, N) XVECEXP ((RTX), 3, (N))
496: #define ASM_OPERANDS_INPUT_LENGTH(RTX) XVECLEN ((RTX), 3)
497: #define ASM_OPERANDS_INPUT_CONSTRAINT(RTX, N) XSTR (XVECEXP ((RTX), 4, (N)), 0)
498: #define ASM_OPERANDS_INPUT_MODE(RTX, N) GET_MODE (XVECEXP ((RTX), 4, (N)))
499: #define ASM_OPERANDS_SOURCE_FILE(RTX) XSTR ((RTX), 5)
500: #define ASM_OPERANDS_SOURCE_LINE(RTX) XINT ((RTX), 6)
501:
502: /* For a MEM rtx, 1 if it's a volatile reference.
503: Also in an ASM_OPERANDS rtx. */
504: #define MEM_VOLATILE_P(RTX) ((RTX)->volatil)
505:
506: /* For a MEM rtx, 1 if it refers to a structure or union component. */
507: #define MEM_IN_STRUCT_P(RTX) ((RTX)->in_struct)
508:
509: /* For a LABEL_REF, 1 means that this reference is to a label outside the
510: loop containing the reference. */
511: #define LABEL_OUTSIDE_LOOP_P(RTX) ((RTX)->in_struct)
512:
513: /* For a LABEL_REF, 1 means it is for a nonlocal label. */
514: /* Likewise in an EXPR_LIST for a REG_LABEL note. */
515: #define LABEL_REF_NONLOCAL_P(RTX) ((RTX)->volatil)
516:
517: /* For a CODE_LABEL, 1 means always consider this label to be needed. */
518: #define LABEL_PRESERVE_P(RTX) ((RTX)->in_struct)
519:
520: /* For a REG, 1 means the register is used only in an exit test of a loop. */
521: #define REG_LOOP_TEST_P(RTX) ((RTX)->in_struct)
522:
523: /* During sched, for an insn, 1 means that the insn must be scheduled together
524: with the preceding insn. */
525: #define SCHED_GROUP_P(INSN) ((INSN)->in_struct)
526:
527: /* During sched, for the LOG_LINKS of an insn, these cache the adjusted
528: cost of the dependence link. The cost of executing an instruction
529: may vary based on how the results are used. LINK_COST_ZERO is 1 when
530: the cost through the link varies and is unchanged (i.e., the link has
531: zero additional cost). LINK_COST_FREE is 1 when the cost through the
532: link is zero (i.e., the link makes the cost free). In other cases,
533: the adjustment to the cost is recomputed each time it is needed. */
534: #define LINK_COST_ZERO(X) ((X)->jump)
535: #define LINK_COST_FREE(X) ((X)->call)
536:
537: /* For a SET rtx, SET_DEST is the place that is set
538: and SET_SRC is the value it is set to. */
539: #define SET_DEST(RTX) ((RTX)->fld[0].rtx)
540: #define SET_SRC(RTX) ((RTX)->fld[1].rtx)
541:
542: /* For a TRAP_IF rtx, TRAP_CONDITION is an expression. */
543: #define TRAP_CONDITION(RTX) ((RTX)->fld[0].rtx)
544:
545: /* 1 in a SYMBOL_REF if it addresses this function's constants pool. */
546: #define CONSTANT_POOL_ADDRESS_P(RTX) ((RTX)->unchanging)
547:
548: /* Flag in a SYMBOL_REF for machine-specific purposes. */
549: #define SYMBOL_REF_FLAG(RTX) ((RTX)->volatil)
550:
551: /* 1 means a SYMBOL_REF has been the library function in emit_library_call. */
552: #define SYMBOL_REF_USED(RTX) ((RTX)->used)
553:
554: /* For an INLINE_HEADER rtx, FIRST_FUNCTION_INSN is the first insn
555: of the function that is not involved in copying parameters to
556: pseudo-registers. FIRST_PARM_INSN is the very first insn of
557: the function, including the parameter copying.
558: We keep this around in case we must splice
559: this function into the assembly code at the end of the file.
560: FIRST_LABELNO is the first label number used by the function (inclusive).
561: LAST_LABELNO is the last label used by the function (exclusive).
562: MAX_REGNUM is the largest pseudo-register used by that function.
563: FUNCTION_ARGS_SIZE is the size of the argument block in the stack.
564: POPS_ARGS is the number of bytes of input arguments popped by the function
565: STACK_SLOT_LIST is the list of stack slots.
566: FUNCTION_FLAGS are where single-bit flags are saved.
567: OUTGOING_ARGS_SIZE is the size of the largest outgoing stack parameter list.
568: ORIGINAL_ARG_VECTOR is a vector of the original DECL_RTX values
569: for the function arguments.
570: ORIGINAL_DECL_INITIAL is a pointer to the original DECL_INITIAL for the
571: function.
572:
573: We want this to lay down like an INSN. The PREV_INSN field
574: is always NULL. The NEXT_INSN field always points to the
575: first function insn of the function being squirreled away. */
576:
577: #define FIRST_FUNCTION_INSN(RTX) ((RTX)->fld[2].rtx)
578: #define FIRST_PARM_INSN(RTX) ((RTX)->fld[3].rtx)
579: #define FIRST_LABELNO(RTX) ((RTX)->fld[4].rtint)
580: #define LAST_LABELNO(RTX) ((RTX)->fld[5].rtint)
581: #define MAX_PARMREG(RTX) ((RTX)->fld[6].rtint)
582: #define MAX_REGNUM(RTX) ((RTX)->fld[7].rtint)
583: #define FUNCTION_ARGS_SIZE(RTX) ((RTX)->fld[8].rtint)
584: #define POPS_ARGS(RTX) ((RTX)->fld[9].rtint)
585: #define STACK_SLOT_LIST(RTX) ((RTX)->fld[10].rtx)
586: #define FUNCTION_FLAGS(RTX) ((RTX)->fld[11].rtint)
587: #define OUTGOING_ARGS_SIZE(RTX) ((RTX)->fld[12].rtint)
588: #define ORIGINAL_ARG_VECTOR(RTX) ((RTX)->fld[13].rtvec)
589: #define ORIGINAL_DECL_INITIAL(RTX) ((RTX)->fld[14].rtx)
590:
591: /* In FUNCTION_FLAGS we save some variables computed when emitting the code
592: for the function and which must be `or'ed into the current flag values when
593: insns from that function are being inlined. */
594:
595: /* These ought to be an enum, but non-ANSI compilers don't like that. */
596: #define FUNCTION_FLAGS_CALLS_ALLOCA 01
597: #define FUNCTION_FLAGS_CALLS_SETJMP 02
598: #define FUNCTION_FLAGS_RETURNS_STRUCT 04
599: #define FUNCTION_FLAGS_RETURNS_PCC_STRUCT 010
600: #define FUNCTION_FLAGS_NEEDS_CONTEXT 020
601: #define FUNCTION_FLAGS_HAS_NONLOCAL_LABEL 040
602: #define FUNCTION_FLAGS_RETURNS_POINTER 0100
603: #define FUNCTION_FLAGS_USES_CONST_POOL 0200
604: #define FUNCTION_FLAGS_CALLS_LONGJMP 0400
605: #define FUNCTION_FLAGS_USES_PIC_OFFSET_TABLE 01000
606:
607: /* Define a macro to look for REG_INC notes,
608: but save time on machines where they never exist. */
609:
610: /* Don't continue this line--convex cc version 4.1 would lose. */
611: #if (defined (HAVE_PRE_INCREMENT) || defined (HAVE_PRE_DECREMENT) || defined (HAVE_POST_INCREMENT) || defined (HAVE_POST_DECREMENT))
612: #define FIND_REG_INC_NOTE(insn, reg) (find_reg_note ((insn), REG_INC, (reg)))
613: #else
614: #define FIND_REG_INC_NOTE(insn, reg) 0
615: #endif
616:
617: /* Indicate whether the machine has any sort of auto increment addressing.
618: If not, we can avoid checking for REG_INC notes. */
619:
620: /* Don't continue this line--convex cc version 4.1 would lose. */
621: #if (defined (HAVE_PRE_INCREMENT) || defined (HAVE_PRE_DECREMENT) || defined (HAVE_POST_INCREMENT) || defined (HAVE_POST_DECREMENT))
622: #define AUTO_INC_DEC
623: #endif
624:
625: /* Generally useful functions. */
626:
627: /* The following functions accept a wide integer argument. Rather than
628: having to cast on every function call, we use a macro instead, that is
629: defined here and in tree.h. */
630:
631: #ifndef exact_log2
632: #define exact_log2(N) exact_log2_wide ((HOST_WIDE_INT) (N))
633: #define floor_log2(N) floor_log2_wide ((HOST_WIDE_INT) (N))
634: #endif
635:
636: #define plus_constant(X,C) plus_constant_wide (X, (HOST_WIDE_INT) (C))
637:
638: #define plus_constant_for_output(X,C) \
639: plus_constant_for_output_wide (X, (HOST_WIDE_INT) (C))
640:
641: extern rtx plus_constant_wide PROTO((rtx, HOST_WIDE_INT));
642: extern rtx plus_constant_for_output_wide PROTO((rtx, HOST_WIDE_INT));
643:
644: #define GEN_INT(N) gen_rtx (CONST_INT, VOIDmode, (HOST_WIDE_INT) (N))
645:
646: #if 0
647: /* We cannot define prototypes for the variable argument functions,
648: since they have not been ANSI-fied, and an ANSI compiler would
649: complain when compiling the definition of these functions. */
650:
651: extern rtx gen_rtx PROTO((enum rtx_code, enum machine_mode, ...));
652: extern rtvec gen_rtvec PROTO((int, ...));
653:
654: #else
655: extern rtx bc_gen_rtx ();
656: extern rtx gen_rtx ();
657: extern rtvec gen_rtvec ();
658: #endif
659:
660: #ifdef BUFSIZ /* stdio.h has been included */
661: extern rtx read_rtx PROTO((FILE *));
662: #else
663: extern rtx read_rtx ();
664: #endif
665:
666: #if 0
667: /* At present, don't prototype xrealloc, since all of the callers don't
668: cast their pointers to char *, and all of the xrealloc's don't use
669: void * yet. */
670: extern char *xmalloc PROTO((size_t));
671: extern char *xrealloc PROTO((void *, size_t));
672: #else
673: extern char *xmalloc ();
674: extern char *xrealloc ();
675: #endif
676:
677: extern char *oballoc PROTO((int));
678: extern char *permalloc PROTO((int));
679: extern void free PROTO((void *));
680: extern rtx rtx_alloc PROTO((RTX_CODE));
681: extern rtvec rtvec_alloc PROTO((int));
682: extern rtx find_reg_note PROTO((rtx, enum reg_note, rtx));
683: extern rtx find_regno_note PROTO((rtx, enum reg_note, int));
684: extern HOST_WIDE_INT get_integer_term PROTO((rtx));
685: extern rtx get_related_value PROTO((rtx));
686: extern rtx single_set PROTO((rtx));
687: extern rtx find_last_value PROTO((rtx, rtx *, rtx));
688: extern rtx copy_rtx PROTO((rtx));
689: extern rtx copy_rtx_if_shared PROTO((rtx));
690: extern rtx copy_most_rtx PROTO((rtx, rtx));
691: extern rtx replace_rtx PROTO((rtx, rtx, rtx));
692: extern rtvec gen_rtvec_v PROTO((int, rtx *));
693: extern rtx gen_reg_rtx PROTO((enum machine_mode));
694: extern rtx gen_label_rtx PROTO((void));
695: extern rtx gen_inline_header_rtx PROTO((rtx, rtx, int, int, int, int, int, int, rtx, int, int, rtvec, rtx));
696: extern rtx gen_lowpart_common PROTO((enum machine_mode, rtx));
697: extern rtx gen_lowpart PROTO((enum machine_mode, rtx));
698: extern rtx gen_lowpart_if_possible PROTO((enum machine_mode, rtx));
699: extern rtx gen_highpart PROTO((enum machine_mode, rtx));
700: extern rtx gen_realpart PROTO((enum machine_mode, rtx));
701: extern rtx gen_imagpart PROTO((enum machine_mode, rtx));
702: extern rtx operand_subword PROTO((rtx, int, int, enum machine_mode));
703: extern rtx operand_subword_force PROTO((rtx, int, enum machine_mode));
704: extern int subreg_lowpart_p PROTO((rtx));
705: extern rtx make_safe_from PROTO((rtx, rtx));
706: extern rtx memory_address PROTO((enum machine_mode, rtx));
707: extern rtx get_insns PROTO((void));
708: extern rtx get_last_insn PROTO((void));
709: extern rtx get_last_insn_anywhere PROTO((void));
710: extern void start_sequence PROTO((void));
711: extern void push_to_sequence PROTO((rtx));
712: extern void end_sequence PROTO((void));
713: extern rtx gen_sequence PROTO((void));
714: extern rtx immed_double_const PROTO((HOST_WIDE_INT, HOST_WIDE_INT, enum machine_mode));
715: extern rtx force_const_mem PROTO((enum machine_mode, rtx));
716: extern rtx force_reg PROTO((enum machine_mode, rtx));
717: extern rtx get_pool_constant PROTO((rtx));
718: extern enum machine_mode get_pool_mode PROTO((rtx));
719: extern int get_pool_offset PROTO((rtx));
720: extern rtx simplify_subtraction PROTO((rtx));
721: extern rtx assign_stack_local PROTO((enum machine_mode, int, int));
722: extern rtx assign_stack_temp PROTO((enum machine_mode, int, int));
723: extern rtx protect_from_queue PROTO((rtx, int));
724: extern void emit_queue PROTO((void));
725: extern rtx emit_move_insn PROTO((rtx, rtx));
726: extern rtx emit_insn_before PROTO((rtx, rtx));
727: extern rtx emit_jump_insn_before PROTO((rtx, rtx));
728: extern rtx emit_call_insn_before PROTO((rtx, rtx));
729: extern rtx emit_barrier_before PROTO((rtx));
730: extern rtx emit_note_before PROTO((int, rtx));
731: extern rtx emit_insn_after PROTO((rtx, rtx));
732: extern rtx emit_jump_insn_after PROTO((rtx, rtx));
733: extern rtx emit_barrier_after PROTO((rtx));
734: extern rtx emit_label_after PROTO((rtx, rtx));
735: extern rtx emit_note_after PROTO((int, rtx));
736: extern rtx emit_line_note_after PROTO((char *, int, rtx));
737: extern rtx emit_insn PROTO((rtx));
738: extern rtx emit_insns PROTO((rtx));
739: extern rtx emit_insns_before PROTO((rtx, rtx));
740: extern rtx emit_jump_insn PROTO((rtx));
741: extern rtx emit_call_insn PROTO((rtx));
742: extern rtx emit_label PROTO((rtx));
743: extern rtx emit_barrier PROTO((void));
744: extern rtx emit_line_note PROTO((char *, int));
745: extern rtx emit_note PROTO((char *, int));
746: extern rtx emit_line_note_force PROTO((char *, int));
747: extern rtx make_insn_raw PROTO((rtx));
748: extern rtx previous_insn PROTO((rtx));
749: extern rtx next_insn PROTO((rtx));
750: extern rtx prev_nonnote_insn PROTO((rtx));
751: extern rtx next_nonnote_insn PROTO((rtx));
752: extern rtx prev_real_insn PROTO((rtx));
753: extern rtx next_real_insn PROTO((rtx));
754: extern rtx prev_active_insn PROTO((rtx));
755: extern rtx next_active_insn PROTO((rtx));
756: extern rtx prev_label PROTO((rtx));
757: extern rtx next_label PROTO((rtx));
758: extern rtx next_cc0_user PROTO((rtx));
759: extern rtx prev_cc0_setter PROTO((rtx));
760: extern rtx reg_set_last PROTO((rtx, rtx));
761: extern rtx next_nondeleted_insn PROTO((rtx));
762: extern enum rtx_code reverse_condition PROTO((enum rtx_code));
763: extern enum rtx_code swap_condition PROTO((enum rtx_code));
764: extern enum rtx_code unsigned_condition PROTO((enum rtx_code));
765: extern enum rtx_code signed_condition PROTO((enum rtx_code));
766: extern rtx find_equiv_reg PROTO((rtx, rtx, enum reg_class, int, short *, int, enum machine_mode));
767: extern rtx squeeze_notes PROTO((rtx, rtx));
768: extern rtx delete_insn PROTO((rtx));
769: extern void delete_jump PROTO((rtx));
770: extern rtx get_label_before PROTO((rtx));
771: extern rtx get_label_after PROTO((rtx));
772: extern rtx follow_jumps PROTO((rtx));
773: extern rtx adj_offsettable_operand PROTO((rtx, int));
774: extern rtx try_split PROTO((rtx, rtx, int));
775: extern rtx split_insns PROTO((rtx, rtx));
776: extern rtx simplify_unary_operation PROTO((enum rtx_code, enum machine_mode, rtx, enum machine_mode));
777: extern rtx simplify_binary_operation PROTO((enum rtx_code, enum machine_mode, rtx, rtx));
778: extern rtx simplify_ternary_operation PROTO((enum rtx_code, enum machine_mode, enum machine_mode, rtx, rtx, rtx));
779: extern rtx simplify_relational_operation PROTO((enum rtx_code, enum machine_mode, rtx, rtx));
780: extern rtx nonlocal_label_rtx_list PROTO((void));
781: extern rtx gen_move_insn PROTO((rtx, rtx));
782: extern rtx gen_jump PROTO((rtx));
783: extern rtx gen_beq PROTO((rtx));
784: extern rtx gen_bge PROTO((rtx));
785: extern rtx gen_ble PROTO((rtx));
786: extern rtx eliminate_constant_term PROTO((rtx, rtx *));
787: extern rtx expand_complex_abs PROTO((enum machine_mode, rtx, rtx, int));
788:
789: /* Maximum number of parallel sets and clobbers in any insn in this fn.
790: Always at least 3, since the combiner could put that many togetherm
791: and we want this to remain correct for all the remaining passes. */
792:
793: extern int max_parallel;
794:
795: extern int asm_noperands PROTO((rtx));
796: extern char *decode_asm_operands PROTO((rtx, rtx *, rtx **, char **, enum machine_mode *));
797:
798: extern enum reg_class reg_preferred_class PROTO((int));
799: extern enum reg_class reg_alternate_class PROTO((int));
800:
801: extern rtx get_first_nonparm_insn PROTO((void));
802:
803: /* Standard pieces of rtx, to be substituted directly into things. */
804: extern rtx pc_rtx;
805: extern rtx cc0_rtx;
806: extern rtx const0_rtx;
807: extern rtx const1_rtx;
808: extern rtx const2_rtx;
809: extern rtx constm1_rtx;
810: extern rtx const_true_rtx;
811:
812: extern rtx const_tiny_rtx[3][(int) MAX_MACHINE_MODE];
813:
814: /* Returns a constant 0 rtx in mode MODE. Integer modes are treated the
815: same as VOIDmode. */
816:
817: #define CONST0_RTX(MODE) (const_tiny_rtx[0][(int) (MODE)])
818:
819: /* Likewise, for the constants 1 and 2. */
820:
821: #define CONST1_RTX(MODE) (const_tiny_rtx[1][(int) (MODE)])
822: #define CONST2_RTX(MODE) (const_tiny_rtx[2][(int) (MODE)])
823:
824: /* All references to certain hard regs, except those created
825: by allocating pseudo regs into them (when that's possible),
826: go through these unique rtx objects. */
827: extern rtx stack_pointer_rtx;
828: extern rtx frame_pointer_rtx;
829: extern rtx hard_frame_pointer_rtx;
830: extern rtx arg_pointer_rtx;
831: extern rtx pic_offset_table_rtx;
832: extern rtx struct_value_rtx;
833: extern rtx struct_value_incoming_rtx;
834: extern rtx static_chain_rtx;
835: extern rtx static_chain_incoming_rtx;
836:
837: /* If HARD_FRAME_POINTER_REGNUM is defined, then a special dummy reg
838: is used to represent the frame pointer. This is because the
839: hard frame pointer and the automatic variables are separated by an amount
840: that cannot be determined until after register allocation. We can assume
841: that in this case ELIMINABLE_REGS will be defined, one action of which
842: will be to eliminate FRAME_POINTER_REGNUM into HARD_FRAME_POINTER_REGNUM. */
843: #ifndef HARD_FRAME_POINTER_REGNUM
844: #define HARD_FRAME_POINTER_REGNUM FRAME_POINTER_REGNUM
845: #endif
846:
847: /* Virtual registers are used during RTL generation to refer to locations into
848: the stack frame when the actual location isn't known until RTL generation
849: is complete. The routine instantiate_virtual_regs replaces these with
850: the proper value, which is normally {frame,arg,stack}_pointer_rtx plus
851: a constant. */
852:
853: #define FIRST_VIRTUAL_REGISTER (FIRST_PSEUDO_REGISTER)
854:
855: /* This points to the first word of the incoming arguments passed on the stack,
856: either by the caller or by the callee when pretending it was passed by the
857: caller. */
858:
859: extern rtx virtual_incoming_args_rtx;
860:
861: #define VIRTUAL_INCOMING_ARGS_REGNUM (FIRST_VIRTUAL_REGISTER)
862:
863: /* If FRAME_GROWS_DOWNWARD, this points to immediately above the first
864: variable on the stack. Otherwise, it points to the first variable on
865: the stack. */
866:
867: extern rtx virtual_stack_vars_rtx;
868:
869: #define VIRTUAL_STACK_VARS_REGNUM ((FIRST_VIRTUAL_REGISTER) + 1)
870:
871: /* This points to the location of dynamically-allocated memory on the stack
872: immediately after the stack pointer has been adjusted by the amount
873: desired. */
874:
875: extern rtx virtual_stack_dynamic_rtx;
876:
877: #define VIRTUAL_STACK_DYNAMIC_REGNUM ((FIRST_VIRTUAL_REGISTER) + 2)
878:
879: /* This points to the location in the stack at which outgoing arguments should
880: be written when the stack is pre-pushed (arguments pushed using push
881: insns always use sp). */
882:
883: extern rtx virtual_outgoing_args_rtx;
884:
885: #define VIRTUAL_OUTGOING_ARGS_REGNUM ((FIRST_VIRTUAL_REGISTER) + 3)
886:
887: #define LAST_VIRTUAL_REGISTER ((FIRST_VIRTUAL_REGISTER) + 3)
888:
889: extern rtx find_next_ref PROTO((rtx, rtx));
890: extern rtx *find_single_use PROTO((rtx, rtx, rtx *));
891:
892: /* It is hard to write the prototype for expand_expr, since it needs
893: expr.h to be included for the enumeration. */
894:
895: extern rtx expand_expr ();
896: extern rtx immed_real_const_1();
897:
898: #ifdef TREE_CODE
899: /* rtl.h and tree.h were included. */
900: extern rtx output_constant_def PROTO((tree));
901: extern rtx immed_real_const PROTO((tree));
902: extern rtx immed_real_const_1 PROTO((REAL_VALUE_TYPE, enum machine_mode));
903: extern tree make_tree PROTO((tree, rtx));
904:
905: #else
906: extern rtx output_constant_def ();
907: extern rtx immed_real_const ();
908: extern rtx immed_real_const_1 ();
909: #endif
910:
911: /* Define a default value for STORE_FLAG_VALUE. */
912:
913: #ifndef STORE_FLAG_VALUE
914: #define STORE_FLAG_VALUE 1
915: #endif
916:
917: /* Nonzero after end of reload pass.
918: Set to 1 or 0 by toplev.c. */
919:
920: extern int reload_completed;
921:
922: /* Set to 1 while reload_as_needed is operating.
923: Required by some machines to handle any generated moves differently. */
924:
925: extern int reload_in_progress;
926:
927: /* If this is nonzero, we do not bother generating VOLATILE
928: around volatile memory references, and we are willing to
929: output indirect addresses. If cse is to follow, we reject
930: indirect addresses so a useful potential cse is generated;
931: if it is used only once, instruction combination will produce
932: the same indirect address eventually. */
933: extern int cse_not_expected;
934:
935: /* Indexed by pseudo register number, gives the rtx for that pseudo.
936: Allocated in parallel with regno_pointer_flag. */
937: extern rtx *regno_reg_rtx;
938:
939: /* Translates rtx code to tree code, for those codes needed by
940: REAL_ARITHMETIC. */
941: extern int rtx_to_tree_code ();
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.