![[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.