![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to expr.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 expr.h CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 ! root 1: /* Definitions for code generation pass of GNU 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: #ifndef __STDC__ ! 22: #ifndef const ! 23: #define const ! 24: #endif ! 25: #endif ! 26: ! 27: /* The default branch cost is 1. */ ! 28: #ifndef BRANCH_COST ! 29: #define BRANCH_COST 1 ! 30: #endif ! 31: ! 32: /* The default is that we do not promote the mode of an object. */ ! 33: #ifndef PROMOTE_MODE ! 34: #define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE) ! 35: #endif ! 36: ! 37: /* Macros to access the slots of a QUEUED rtx. ! 38: Here rather than in rtl.h because only the expansion pass ! 39: should ever encounter a QUEUED. */ ! 40: ! 41: /* The variable for which an increment is queued. */ ! 42: #define QUEUED_VAR(P) XEXP (P, 0) ! 43: /* If the increment has been emitted, this is the insn ! 44: that does the increment. It is zero before the increment is emitted. */ ! 45: #define QUEUED_INSN(P) XEXP (P, 1) ! 46: /* If a pre-increment copy has been generated, this is the copy ! 47: (it is a temporary reg). Zero if no copy made yet. */ ! 48: #define QUEUED_COPY(P) XEXP (P, 2) ! 49: /* This is the body to use for the insn to do the increment. ! 50: It is used to emit the increment. */ ! 51: #define QUEUED_BODY(P) XEXP (P, 3) ! 52: /* Next QUEUED in the queue. */ ! 53: #define QUEUED_NEXT(P) XEXP (P, 4) ! 54: ! 55: /* This is the 4th arg to `expand_expr'. ! 56: EXPAND_SUM means it is ok to return a PLUS rtx or MULT rtx. ! 57: EXPAND_INITIALIZER is similar but also record any labels on forced_labels. ! 58: EXPAND_CONST_ADDRESS means it is ok to return a MEM whose address ! 59: is a constant that is not a legitimate address. */ ! 60: enum expand_modifier {EXPAND_NORMAL, EXPAND_SUM, ! 61: EXPAND_CONST_ADDRESS, EXPAND_INITIALIZER}; ! 62: ! 63: /* List of labels that must never be deleted. */ ! 64: extern rtx forced_labels; ! 65: ! 66: /* List (chain of EXPR_LISTs) of pseudo-regs of SAVE_EXPRs. ! 67: So we can mark them all live at the end of the function, if stupid. */ ! 68: extern rtx save_expr_regs; ! 69: ! 70: extern int current_function_calls_alloca; ! 71: extern int current_function_outgoing_args_size; ! 72: ! 73: /* This is the offset from the arg pointer to the place where the first ! 74: anonymous arg can be found, if there is one. */ ! 75: extern rtx current_function_arg_offset_rtx; ! 76: ! 77: /* This is nonzero if the current function uses the constant pool. */ ! 78: extern int current_function_uses_const_pool; ! 79: ! 80: /* This is nonzero if the current function uses pic_offset_table_rtx. */ ! 81: extern int current_function_uses_pic_offset_table; ! 82: ! 83: /* The arg pointer hard register, or the pseudo into which it was copied. */ ! 84: extern rtx current_function_internal_arg_pointer; ! 85: ! 86: /* Nonzero means stack pops must not be deferred, and deferred stack ! 87: pops must not be output. It is nonzero inside a function call, ! 88: inside a conditional expression, inside a statement expression, ! 89: and in other cases as well. */ ! 90: extern int inhibit_defer_pop; ! 91: ! 92: /* Number of function calls seen so far in current function. */ ! 93: ! 94: extern int function_call_count; ! 95: ! 96: /* RTX for stack slot that holds the current handler for nonlocal gotos. ! 97: Zero when function does not have nonlocal labels. */ ! 98: ! 99: extern rtx nonlocal_goto_handler_slot; ! 100: ! 101: /* RTX for stack slot that holds the stack pointer value to restore ! 102: for a nonlocal goto. ! 103: Zero when function does not have nonlocal labels. */ ! 104: ! 105: extern rtx nonlocal_goto_stack_level; ! 106: ! 107: /* List (chain of TREE_LIST) of LABEL_DECLs for all nonlocal labels ! 108: (labels to which there can be nonlocal gotos from nested functions) ! 109: in this function. */ ! 110: ! 111: #ifdef TREE_CODE /* Don't lose if tree.h not included. */ ! 112: extern tree nonlocal_labels; ! 113: #endif ! 114: ! 115: #define NO_DEFER_POP (inhibit_defer_pop += 1) ! 116: #define OK_DEFER_POP (inhibit_defer_pop -= 1) ! 117: ! 118: /* Number of units that we should eventually pop off the stack. ! 119: These are the arguments to function calls that have already returned. */ ! 120: extern int pending_stack_adjust; ! 121: ! 122: /* A list of all cleanups which belong to the arguments of ! 123: function calls being expanded by expand_call. */ ! 124: #ifdef TREE_CODE /* Don't lose if tree.h not included. */ ! 125: extern tree cleanups_this_call; ! 126: #endif ! 127: ! 128: #ifdef TREE_CODE /* Don't lose if tree.h not included. */ ! 129: /* Structure to record the size of a sequence of arguments ! 130: as the sum of a tree-expression and a constant. */ ! 131: ! 132: struct args_size ! 133: { ! 134: int constant; ! 135: tree var; ! 136: }; ! 137: #endif ! 138: ! 139: /* Add the value of the tree INC to the `struct args_size' TO. */ ! 140: ! 141: #define ADD_PARM_SIZE(TO, INC) \ ! 142: { tree inc = (INC); \ ! 143: if (TREE_CODE (inc) == INTEGER_CST) \ ! 144: (TO).constant += TREE_INT_CST_LOW (inc); \ ! 145: else if ((TO).var == 0) \ ! 146: (TO).var = inc; \ ! 147: else \ ! 148: (TO).var = size_binop (PLUS_EXPR, (TO).var, inc); } ! 149: ! 150: #define SUB_PARM_SIZE(TO, DEC) \ ! 151: { tree dec = (DEC); \ ! 152: if (TREE_CODE (dec) == INTEGER_CST) \ ! 153: (TO).constant -= TREE_INT_CST_LOW (dec); \ ! 154: else if ((TO).var == 0) \ ! 155: (TO).var = size_binop (MINUS_EXPR, integer_zero_node, dec); \ ! 156: else \ ! 157: (TO).var = size_binop (MINUS_EXPR, (TO).var, dec); } ! 158: ! 159: /* Convert the implicit sum in a `struct args_size' into an rtx. */ ! 160: #define ARGS_SIZE_RTX(SIZE) \ ! 161: ((SIZE).var == 0 ? GEN_INT ((SIZE).constant) \ ! 162: : expand_expr (size_binop (PLUS_EXPR, (SIZE).var, \ ! 163: size_int ((SIZE).constant)), \ ! 164: NULL_RTX, VOIDmode, 0)) ! 165: ! 166: /* Convert the implicit sum in a `struct args_size' into a tree. */ ! 167: #define ARGS_SIZE_TREE(SIZE) \ ! 168: ((SIZE).var == 0 ? size_int ((SIZE).constant) \ ! 169: : size_binop (PLUS_EXPR, (SIZE).var, size_int ((SIZE).constant))) ! 170: ! 171: /* Supply a default definition for FUNCTION_ARG_PADDING: ! 172: usually pad upward, but pad short args downward on ! 173: big-endian machines. */ ! 174: ! 175: enum direction {none, upward, downward}; /* Value has this type. */ ! 176: ! 177: #ifndef FUNCTION_ARG_PADDING ! 178: #if BYTES_BIG_ENDIAN ! 179: #define FUNCTION_ARG_PADDING(MODE, TYPE) \ ! 180: (((MODE) == BLKmode \ ! 181: ? ((TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \ ! 182: && int_size_in_bytes (TYPE) < (PARM_BOUNDARY / BITS_PER_UNIT)) \ ! 183: : GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY) \ ! 184: ? downward : upward) ! 185: #else ! 186: #define FUNCTION_ARG_PADDING(MODE, TYPE) upward ! 187: #endif ! 188: #endif ! 189: ! 190: /* Supply a default definition for FUNCTION_ARG_BOUNDARY. Normally, we let ! 191: FUNCTION_ARG_PADDING, which also pads the length, handle any needed ! 192: alignment. */ ! 193: ! 194: #ifndef FUNCTION_ARG_BOUNDARY ! 195: #define FUNCTION_ARG_BOUNDARY(MODE, TYPE) PARM_BOUNDARY ! 196: #endif ! 197: ! 198: /* Nonzero if we do not know how to pass TYPE solely in registers. ! 199: We cannot do so in the following cases: ! 200: ! 201: - if the type has variable size ! 202: - if the type is marked as addressable (it is required to be constructed ! 203: into the stack) ! 204: - if the padding and mode of the type is such that a copy into a register ! 205: would put it into the wrong part of the register. ! 206: ! 207: Which padding can't be supported depends on the byte endianness. ! 208: ! 209: A value in a register is implicitly padded at the most significant end. ! 210: On a big-endian machine, that is the lower end in memory. ! 211: So a value padded in memory at the upper end can't go in a register. ! 212: For a little-endian machine, the reverse is true. */ ! 213: ! 214: #if BYTES_BIG_ENDIAN ! 215: #define MUST_PASS_IN_STACK_BAD_PADDING upward ! 216: #else ! 217: #define MUST_PASS_IN_STACK_BAD_PADDING downward ! 218: #endif ! 219: ! 220: #define MUST_PASS_IN_STACK(MODE,TYPE) \ ! 221: ((TYPE) != 0 \ ! 222: && (TREE_CODE (TYPE_SIZE (TYPE)) != INTEGER_CST \ ! 223: || TREE_ADDRESSABLE (TYPE) \ ! 224: || ((MODE) == BLKmode \ ! 225: && ! ((TYPE) != 0 && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \ ! 226: && 0 == (int_size_in_bytes (TYPE) \ ! 227: % (PARM_BOUNDARY / BITS_PER_UNIT))) \ ! 228: && (FUNCTION_ARG_PADDING (MODE, TYPE) \ ! 229: == MUST_PASS_IN_STACK_BAD_PADDING)))) ! 230: ! 231: /* Nonzero if type TYPE should be returned in memory. ! 232: Most machines can use the following default definition. */ ! 233: ! 234: #ifndef RETURN_IN_MEMORY ! 235: #define RETURN_IN_MEMORY(TYPE) (TYPE_MODE (TYPE) == BLKmode) ! 236: #endif ! 237: ! 238: /* Optabs are tables saying how to generate insn bodies ! 239: for various machine modes and numbers of operands. ! 240: Each optab applies to one operation. ! 241: For example, add_optab applies to addition. ! 242: ! 243: The insn_code slot is the enum insn_code that says how to ! 244: generate an insn for this operation on a particular machine mode. ! 245: It is CODE_FOR_nothing if there is no such insn on the target machine. ! 246: ! 247: The `lib_call' slot is the name of the library function that ! 248: can be used to perform the operation. ! 249: ! 250: A few optabs, such as move_optab and cmp_optab, are used ! 251: by special code. */ ! 252: ! 253: /* Everything that uses expr.h needs to define enum insn_code ! 254: but we don't list it in the Makefile dependencies just for that. */ ! 255: #include "insn-codes.h" ! 256: ! 257: typedef struct optab ! 258: { ! 259: enum rtx_code code; ! 260: struct { ! 261: enum insn_code insn_code; ! 262: rtx libfunc; ! 263: } handlers [NUM_MACHINE_MODES]; ! 264: } * optab; ! 265: ! 266: /* Given an enum insn_code, access the function to construct ! 267: the body of that kind of insn. */ ! 268: #ifdef FUNCTION_CONVERSION_BUG ! 269: /* Some compilers fail to convert a function properly to a ! 270: pointer-to-function when used as an argument. ! 271: So produce the pointer-to-function directly. ! 272: Luckily, these compilers seem to work properly when you ! 273: call the pointer-to-function. */ ! 274: #define GEN_FCN(CODE) (insn_gen_function[(int) (CODE)]) ! 275: #else ! 276: #define GEN_FCN(CODE) (*insn_gen_function[(int) (CODE)]) ! 277: #endif ! 278: ! 279: extern rtx (*const insn_gen_function[]) (); ! 280: ! 281: extern optab add_optab; ! 282: extern optab sub_optab; ! 283: extern optab smul_optab; /* Signed and floating-point multiply */ ! 284: extern optab smul_widen_optab; /* Signed multiply with result ! 285: one machine mode wider than args */ ! 286: extern optab umul_widen_optab; ! 287: extern optab sdiv_optab; /* Signed divide */ ! 288: extern optab sdivmod_optab; /* Signed divide-and-remainder in one */ ! 289: extern optab udiv_optab; ! 290: extern optab udivmod_optab; ! 291: extern optab smod_optab; /* Signed remainder */ ! 292: extern optab umod_optab; ! 293: extern optab flodiv_optab; /* Optab for floating divide. */ ! 294: extern optab ftrunc_optab; /* Convert float to integer in float fmt */ ! 295: extern optab and_optab; /* Logical and */ ! 296: extern optab ior_optab; /* Logical or */ ! 297: extern optab xor_optab; /* Logical xor */ ! 298: extern optab ashl_optab; /* Arithmetic shift left */ ! 299: extern optab ashr_optab; /* Arithmetic shift right */ ! 300: extern optab lshl_optab; /* Logical shift left */ ! 301: extern optab lshr_optab; /* Logical shift right */ ! 302: extern optab rotl_optab; /* Rotate left */ ! 303: extern optab rotr_optab; /* Rotate right */ ! 304: extern optab smin_optab; /* Signed and floating-point minimum value */ ! 305: extern optab smax_optab; /* Signed and floating-point maximum value */ ! 306: extern optab umin_optab; /* Unsigned minimum value */ ! 307: extern optab umax_optab; /* Unsigned maximum value */ ! 308: ! 309: extern optab mov_optab; /* Move instruction. */ ! 310: extern optab movstrict_optab; /* Move, preserving high part of register. */ ! 311: ! 312: extern optab cmp_optab; /* Compare insn; two operands. */ ! 313: extern optab tst_optab; /* tst insn; compare one operand against 0 */ ! 314: ! 315: /* Unary operations */ ! 316: extern optab neg_optab; /* Negation */ ! 317: extern optab abs_optab; /* Abs value */ ! 318: extern optab one_cmpl_optab; /* Bitwise not */ ! 319: extern optab ffs_optab; /* Find first bit set */ ! 320: extern optab sqrt_optab; /* Square root */ ! 321: extern optab sin_optab; /* Sine */ ! 322: extern optab cos_optab; /* Cosine */ ! 323: extern optab strlen_optab; /* String length */ ! 324: ! 325: /* Tables of patterns for extending one integer mode to another. */ ! 326: extern enum insn_code extendtab[MAX_MACHINE_MODE][MAX_MACHINE_MODE][2]; ! 327: ! 328: /* Tables of patterns for converting between fixed and floating point. */ ! 329: extern enum insn_code fixtab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2]; ! 330: extern enum insn_code fixtrunctab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2]; ! 331: extern enum insn_code floattab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2]; ! 332: ! 333: /* Contains the optab used for each rtx code. */ ! 334: extern optab code_to_optab[NUM_RTX_CODE + 1]; ! 335: ! 336: /* Passed to expand_binop and expand_unop to say which options to try to use ! 337: if the requested operation can't be open-coded on the requisite mode. ! 338: Either OPTAB_LIB or OPTAB_LIB_WIDEN says try using a library call. ! 339: Either OPTAB_WIDEN or OPTAB_LIB_WIDEN says try using a wider mode. ! 340: OPTAB_MUST_WIDEN says try widening and don't try anything else. */ ! 341: ! 342: enum optab_methods ! 343: { ! 344: OPTAB_DIRECT, ! 345: OPTAB_LIB, ! 346: OPTAB_WIDEN, ! 347: OPTAB_LIB_WIDEN, ! 348: OPTAB_MUST_WIDEN ! 349: }; ! 350: ! 351: /* SYMBOL_REF rtx's for the library functions that are called ! 352: implicitly and not via optabs. */ ! 353: ! 354: extern rtx extendsfdf2_libfunc; ! 355: extern rtx extendsfxf2_libfunc; ! 356: extern rtx extendsftf2_libfunc; ! 357: extern rtx extenddfxf2_libfunc; ! 358: extern rtx extenddftf2_libfunc; ! 359: ! 360: extern rtx truncdfsf2_libfunc; ! 361: extern rtx truncxfsf2_libfunc; ! 362: extern rtx trunctfsf2_libfunc; ! 363: extern rtx truncxfdf2_libfunc; ! 364: extern rtx trunctfdf2_libfunc; ! 365: ! 366: extern rtx memcpy_libfunc; ! 367: extern rtx bcopy_libfunc; ! 368: extern rtx memcmp_libfunc; ! 369: extern rtx bcmp_libfunc; ! 370: extern rtx memset_libfunc; ! 371: extern rtx bzero_libfunc; ! 372: ! 373: extern rtx eqsf2_libfunc; ! 374: extern rtx nesf2_libfunc; ! 375: extern rtx gtsf2_libfunc; ! 376: extern rtx gesf2_libfunc; ! 377: extern rtx ltsf2_libfunc; ! 378: extern rtx lesf2_libfunc; ! 379: ! 380: extern rtx eqdf2_libfunc; ! 381: extern rtx nedf2_libfunc; ! 382: extern rtx gtdf2_libfunc; ! 383: extern rtx gedf2_libfunc; ! 384: extern rtx ltdf2_libfunc; ! 385: extern rtx ledf2_libfunc; ! 386: ! 387: extern rtx eqxf2_libfunc; ! 388: extern rtx nexf2_libfunc; ! 389: extern rtx gtxf2_libfunc; ! 390: extern rtx gexf2_libfunc; ! 391: extern rtx ltxf2_libfunc; ! 392: extern rtx lexf2_libfunc; ! 393: ! 394: extern rtx eqtf2_libfunc; ! 395: extern rtx netf2_libfunc; ! 396: extern rtx gttf2_libfunc; ! 397: extern rtx getf2_libfunc; ! 398: extern rtx lttf2_libfunc; ! 399: extern rtx letf2_libfunc; ! 400: ! 401: extern rtx floatsisf_libfunc; ! 402: extern rtx floatdisf_libfunc; ! 403: extern rtx floattisf_libfunc; ! 404: ! 405: extern rtx floatsidf_libfunc; ! 406: extern rtx floatdidf_libfunc; ! 407: extern rtx floattidf_libfunc; ! 408: ! 409: extern rtx floatsixf_libfunc; ! 410: extern rtx floatdixf_libfunc; ! 411: extern rtx floattixf_libfunc; ! 412: ! 413: extern rtx floatsitf_libfunc; ! 414: extern rtx floatditf_libfunc; ! 415: extern rtx floattitf_libfunc; ! 416: ! 417: extern rtx fixsfsi_libfunc; ! 418: extern rtx fixsfdi_libfunc; ! 419: extern rtx fixsfti_libfunc; ! 420: ! 421: extern rtx fixdfsi_libfunc; ! 422: extern rtx fixdfdi_libfunc; ! 423: extern rtx fixdfti_libfunc; ! 424: ! 425: extern rtx fixxfsi_libfunc; ! 426: extern rtx fixxfdi_libfunc; ! 427: extern rtx fixxfti_libfunc; ! 428: ! 429: extern rtx fixtfsi_libfunc; ! 430: extern rtx fixtfdi_libfunc; ! 431: extern rtx fixtfti_libfunc; ! 432: ! 433: extern rtx fixunssfsi_libfunc; ! 434: extern rtx fixunssfdi_libfunc; ! 435: extern rtx fixunssfti_libfunc; ! 436: ! 437: extern rtx fixunsdfsi_libfunc; ! 438: extern rtx fixunsdfdi_libfunc; ! 439: extern rtx fixunsdfti_libfunc; ! 440: ! 441: extern rtx fixunsxfsi_libfunc; ! 442: extern rtx fixunsxfdi_libfunc; ! 443: extern rtx fixunsxfti_libfunc; ! 444: ! 445: extern rtx fixunstfsi_libfunc; ! 446: extern rtx fixunstfdi_libfunc; ! 447: extern rtx fixunstfti_libfunc; ! 448: ! 449: typedef rtx (*rtxfun) (); ! 450: ! 451: /* Indexed by the rtx-code for a conditional (eg. EQ, LT,...) ! 452: gives the gen_function to make a branch to test that condition. */ ! 453: ! 454: extern rtxfun bcc_gen_fctn[NUM_RTX_CODE]; ! 455: ! 456: /* Indexed by the rtx-code for a conditional (eg. EQ, LT,...) ! 457: gives the insn code to make a store-condition insn ! 458: to test that condition. */ ! 459: ! 460: extern enum insn_code setcc_gen_code[NUM_RTX_CODE]; ! 461: ! 462: /* This array records the insn_code of insns to perform block moves. */ ! 463: extern enum insn_code movstr_optab[NUM_MACHINE_MODES]; ! 464: ! 465: /* Define functions given in optabs.c. */ ! 466: ! 467: /* Expand a binary operation given optab and rtx operands. */ ! 468: extern rtx expand_binop PROTO((enum machine_mode, optab, rtx, rtx, rtx, ! 469: int, enum optab_methods)); ! 470: ! 471: /* Expand a binary operation with both signed and unsigned forms. */ ! 472: extern rtx sign_expand_binop PROTO((enum machine_mode, optab, optab, rtx, ! 473: rtx, rtx, int, enum optab_methods)); ! 474: ! 475: /* Generate code to perform an operation on two operands with two results. */ ! 476: extern int expand_twoval_binop PROTO((optab, rtx, rtx, rtx, rtx, int)); ! 477: ! 478: /* Expand a unary arithmetic operation given optab rtx operand. */ ! 479: extern rtx expand_unop PROTO((enum machine_mode, optab, rtx, rtx, int)); ! 480: ! 481: /* Expand the complex absolute value operation. */ ! 482: extern rtx expand_complex_abs PROTO((enum machine_mode, rtx, rtx, int)); ! 483: ! 484: /* Generate an instruction with a given INSN_CODE with an output and ! 485: an input. */ ! 486: extern void emit_unop_insn PROTO((int, rtx, rtx, enum rtx_code)); ! 487: ! 488: /* Emit code to perform a series of operations on a multi-word quantity, one ! 489: word at a time. */ ! 490: extern rtx emit_no_conflict_block PROTO((rtx, rtx, rtx, rtx, rtx)); ! 491: ! 492: /* Emit code to make a call to a constant function or a library call. */ ! 493: extern void emit_libcall_block PROTO((rtx, rtx, rtx, rtx)); ! 494: ! 495: /* Emit one rtl instruction to store zero in specified rtx. */ ! 496: extern void emit_clr_insn PROTO((rtx)); ! 497: ! 498: /* Emit one rtl insn to store 1 in specified rtx assuming it contains 0. */ ! 499: extern void emit_0_to_1_insn PROTO((rtx)); ! 500: ! 501: /* Emit one rtl insn to compare two rtx's. */ ! 502: extern void emit_cmp_insn PROTO((rtx, rtx, enum rtx_code, rtx, ! 503: enum machine_mode, int, int)); ! 504: ! 505: /* Nonzero if a compare of mode MODE can be done straightforwardly ! 506: (without splitting it into pieces). */ ! 507: extern int can_compare_p PROTO((enum machine_mode)); ! 508: ! 509: /* Generate code to indirectly jump to a location given in the rtx LOC. */ ! 510: extern void emit_indirect_jump PROTO((rtx)); ! 511: ! 512: /* Create but don't emit one rtl instruction to add one rtx into another. ! 513: Modes must match; operands must meet the operation's predicates. ! 514: Likewise for subtraction and for just copying. ! 515: These do not call protect_from_queue; caller must do so. */ ! 516: extern rtx gen_add2_insn PROTO((rtx, rtx)); ! 517: extern rtx gen_sub2_insn PROTO((rtx, rtx)); ! 518: extern rtx gen_move_insn PROTO((rtx, rtx)); ! 519: extern int have_add2_insn PROTO((enum machine_mode)); ! 520: extern int have_sub2_insn PROTO((enum machine_mode)); ! 521: ! 522: /* Return the INSN_CODE to use for an extend operation. */ ! 523: extern enum insn_code can_extend_p PROTO((enum machine_mode, ! 524: enum machine_mode, int)); ! 525: ! 526: /* Generate the body of an insn to extend Y (with mode MFROM) ! 527: into X (with mode MTO). Do zero-extension if UNSIGNEDP is nonzero. */ ! 528: extern rtx gen_extend_insn PROTO((rtx, rtx, enum machine_mode, ! 529: enum machine_mode, int)); ! 530: ! 531: /* Initialize the tables that control conversion between fixed and ! 532: floating values. */ ! 533: extern void init_fixtab PROTO((void)); ! 534: extern void init_floattab PROTO((void)); ! 535: ! 536: /* Generate code for a FLOAT_EXPR. */ ! 537: extern void expand_float PROTO((rtx, rtx, int)); ! 538: ! 539: /* Generate code for a FIX_EXPR. */ ! 540: extern void expand_fix PROTO((rtx, rtx, int)); ! 541: ! 542: /* Call this once to initialize the contents of the optabs ! 543: appropriately for the current target machine. */ ! 544: extern void init_optabs PROTO((void)); ! 545: ! 546: /* Functions from expmed.c: */ ! 547: ! 548: /* Arguments MODE, RTX: return an rtx for the negation of that value. ! 549: May emit insns. */ ! 550: extern rtx negate_rtx PROTO((enum machine_mode, rtx)); ! 551: ! 552: /* Expand a logical AND operation. */ ! 553: extern rtx expand_and PROTO((rtx, rtx, rtx)); ! 554: ! 555: /* Emit a store-flag operation. */ ! 556: extern rtx emit_store_flag PROTO((rtx, enum rtx_code, rtx, rtx, ! 557: enum machine_mode, int, int)); ! 558: ! 559: /* Functions from loop.c: */ ! 560: ! 561: /* Given a JUMP_INSN, return a description of the test being made. */ ! 562: extern rtx get_condition PROTO((rtx, rtx *)); ! 563: ! 564: /* Functions from expr.c: */ ! 565: ! 566: /* This is run once per compilation to set up which modes can be used ! 567: directly in memory and to initialize the block move optab. */ ! 568: extern void init_expr_once PROTO((void)); ! 569: ! 570: /* This is run at the start of compiling a function. */ ! 571: extern void init_expr PROTO((void)); ! 572: ! 573: /* Use protect_from_queue to convert a QUEUED expression ! 574: into something that you can put immediately into an instruction. */ ! 575: extern rtx protect_from_queue PROTO((rtx, int)); ! 576: ! 577: /* Perform all the pending incrementations. */ ! 578: extern void emit_queue PROTO((void)); ! 579: ! 580: /* Emit some rtl insns to move data between rtx's, converting machine modes. ! 581: Both modes must be floating or both fixed. */ ! 582: extern void convert_move PROTO((rtx, rtx, int)); ! 583: ! 584: /* Convert an rtx to specified machine mode and return the result. */ ! 585: extern rtx convert_to_mode PROTO((enum machine_mode, rtx, int)); ! 586: ! 587: /* Convert an rtx to MODE from OLDMODE and return the result. */ ! 588: extern rtx convert_modes PROTO((enum machine_mode, enum machine_mode, rtx, int)); ! 589: ! 590: /* Emit code to move a block Y to a block X. */ ! 591: extern void emit_block_move PROTO((rtx, rtx, rtx, int)); ! 592: ! 593: /* Copy all or part of a value X into registers starting at REGNO. ! 594: The number of registers to be filled is NREGS. */ ! 595: extern void move_block_to_reg PROTO((int, rtx, int, enum machine_mode)); ! 596: ! 597: /* Copy all or part of a BLKmode value X out of registers starting at REGNO. ! 598: The number of registers to be filled is NREGS. */ ! 599: extern void move_block_from_reg PROTO((int, rtx, int, int)); ! 600: ! 601: /* Mark NREGS consecutive regs, starting at REGNO, as being live now. */ ! 602: extern void use_regs PROTO((int, int)); ! 603: ! 604: /* Write zeros through the storage of OBJECT. ! 605: If OBJECT has BLKmode, SIZE is its length in bytes. */ ! 606: extern void clear_storage PROTO((rtx, int)); ! 607: ! 608: /* Emit insns to set X from Y. */ ! 609: extern rtx emit_move_insn PROTO((rtx, rtx)); ! 610: ! 611: /* Emit insns to set X from Y, with no frills. */ ! 612: extern rtx emit_move_insn_1 PROTO ((rtx, rtx)); ! 613: ! 614: /* Push a block of length SIZE (perhaps variable) ! 615: and return an rtx to address the beginning of the block. */ ! 616: extern rtx push_block PROTO((rtx, int, int)); ! 617: ! 618: /* Make an operand to push someting on the stack. */ ! 619: extern rtx gen_push_operand PROTO((void)); ! 620: ! 621: #ifdef TREE_CODE ! 622: /* Generate code to push something onto the stack, given its mode and type. */ ! 623: extern void emit_push_insn PROTO((rtx, enum machine_mode, tree, rtx, int, ! 624: int, rtx, int, rtx, rtx)); ! 625: ! 626: /* Emit library call. These cannot have accurate prototypes since they have ! 627: a variable number of args. */ ! 628: extern void emit_library_call (); ! 629: extern rtx emit_library_call_value (); ! 630: ! 631: /* Expand an assignment that stores the value of FROM into TO. */ ! 632: extern rtx expand_assignment PROTO((tree, tree, int, int)); ! 633: ! 634: /* Generate code for computing expression EXP, ! 635: and storing the value into TARGET. ! 636: If SUGGEST_REG is nonzero, copy the value through a register ! 637: and return that register, if that is possible. */ ! 638: extern rtx store_expr PROTO((tree, rtx, int)); ! 639: #endif ! 640: ! 641: /* Given an rtx that may include add and multiply operations, ! 642: generate them as insns and return a pseudo-reg containing the value. ! 643: Useful after calling expand_expr with 1 as sum_ok. */ ! 644: extern rtx force_operand PROTO((rtx, rtx)); ! 645: ! 646: #ifdef TREE_CODE ! 647: /* Generate code for computing expression EXP. ! 648: An rtx for the computed value is returned. The value is never null. ! 649: In the case of a void EXP, const0_rtx is returned. */ ! 650: extern rtx expand_expr PROTO((tree, rtx, enum machine_mode, ! 651: enum expand_modifier)); ! 652: #endif ! 653: ! 654: /* At the start of a function, record that we have no previously-pushed ! 655: arguments waiting to be popped. */ ! 656: extern void init_pending_stack_adjust PROTO((void)); ! 657: ! 658: /* When exiting from function, if safe, clear out any pending stack adjust ! 659: so the adjustment won't get done. */ ! 660: extern void clear_pending_stack_adjust PROTO((void)); ! 661: ! 662: /* Pop any previously-pushed arguments that have not been popped yet. */ ! 663: extern void do_pending_stack_adjust PROTO((void)); ! 664: ! 665: #ifdef TREE_CODE ! 666: /* Expand all cleanups up to OLD_CLEANUPS. */ ! 667: extern void expand_cleanups_to PROTO((tree)); ! 668: ! 669: /* Generate code to evaluate EXP and jump to LABEL if the value is zero. */ ! 670: extern void jumpifnot PROTO((tree, rtx)); ! 671: ! 672: /* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */ ! 673: extern void jumpif PROTO((tree, rtx)); ! 674: ! 675: /* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if ! 676: the result is zero, or IF_TRUE_LABEL if the result is one. */ ! 677: extern void do_jump PROTO((tree, rtx, rtx)); ! 678: #endif ! 679: ! 680: /* Generate rtl to compare two rtx's, will call emit_cmp_insn. */ ! 681: extern rtx compare_from_rtx PROTO((rtx, rtx, enum rtx_code, int, ! 682: enum machine_mode, rtx, int)); ! 683: ! 684: /* Generate a tablejump instruction (used for switch statements). */ ! 685: extern void do_tablejump PROTO((rtx, enum machine_mode, rtx, rtx, rtx)); ! 686: ! 687: #ifdef TREE_CODE ! 688: /* rtl.h and tree.h were included. */ ! 689: /* Return an rtx for the size in bytes of the value of an expr. */ ! 690: extern rtx expr_size PROTO((tree)); ! 691: ! 692: extern rtx lookup_static_chain PROTO((tree)); ! 693: ! 694: /* Convert a stack slot address ADDR valid in function FNDECL ! 695: into an address valid in this function (using a static chain). */ ! 696: extern rtx fix_lexical_addr PROTO((rtx, tree)); ! 697: ! 698: /* Return the address of the trampoline for entering nested fn FUNCTION. */ ! 699: extern rtx trampoline_address PROTO((tree)); ! 700: ! 701: /* Return an rtx that refers to the value returned by a function ! 702: in its original home. This becomes invalid if any more code is emitted. */ ! 703: extern rtx hard_function_value PROTO((tree, tree)); ! 704: ! 705: extern rtx prepare_call_address PROTO((rtx, tree, rtx *)); ! 706: ! 707: extern rtx expand_call PROTO((tree, rtx, int)); ! 708: ! 709: extern rtx expand_shift PROTO((enum tree_code, enum machine_mode, rtx, tree, rtx, int)); ! 710: extern rtx expand_divmod PROTO((int, enum tree_code, enum machine_mode, rtx, rtx, rtx, int)); ! 711: extern void locate_and_pad_parm PROTO((enum machine_mode, tree, int, tree, struct args_size *, struct args_size *, struct args_size *)); ! 712: extern rtx expand_inline_function PROTO((tree, tree, rtx, int, tree, rtx)); ! 713: /* Return the CODE_LABEL rtx for a LABEL_DECL, creating it if necessary. */ ! 714: extern rtx label_rtx PROTO((tree)); ! 715: #endif ! 716: ! 717: /* Indicate how an input argument register was promoted. */ ! 718: extern rtx promoted_input_arg PROTO((int, enum machine_mode *, int *)); ! 719: ! 720: /* Return an rtx like arg but sans any constant terms. ! 721: Returns the original rtx if it has no constant terms. ! 722: The constant terms are added and stored via a second arg. */ ! 723: extern rtx eliminate_constant_term PROTO((rtx, rtx *)); ! 724: ! 725: /* Convert arg to a valid memory address for specified machine mode, ! 726: by emitting insns to perform arithmetic if nec. */ ! 727: extern rtx memory_address PROTO((enum machine_mode, rtx)); ! 728: ! 729: /* Like `memory_address' but pretent `flag_force_addr' is 0. */ ! 730: extern rtx memory_address_noforce PROTO((enum machine_mode, rtx)); ! 731: ! 732: /* Return a memory reference like MEMREF, but with its mode changed ! 733: to MODE and its address changed to ADDR. ! 734: (VOIDmode means don't change the mode. ! 735: NULL for ADDR means don't change the address.) */ ! 736: extern rtx change_address PROTO((rtx, enum machine_mode, rtx)); ! 737: ! 738: /* Return a memory reference like MEMREF, but which is known to have a ! 739: valid address. */ ! 740: ! 741: extern rtx validize_mem PROTO((rtx)); ! 742: ! 743: /* Assemble the static constant template for function entry trampolines. */ ! 744: extern rtx assemble_trampoline_template PROTO((void)); ! 745: ! 746: /* Return 1 if two rtx's are equivalent in structure and elements. */ ! 747: extern int rtx_equal_p PROTO((rtx, rtx)); ! 748: ! 749: /* Given rtx, return new rtx whose address won't be affected by ! 750: any side effects. It has been copied to a new temporary reg. */ ! 751: extern rtx stabilize PROTO((rtx)); ! 752: ! 753: /* Given an rtx, copy all regs it refers to into new temps ! 754: and return a modified copy that refers to the new temps. */ ! 755: extern rtx copy_all_regs PROTO((rtx)); ! 756: ! 757: /* Copy given rtx to a new temp reg and return that. */ ! 758: extern rtx copy_to_reg PROTO((rtx)); ! 759: ! 760: /* Like copy_to_reg but always make the reg Pmode. */ ! 761: extern rtx copy_addr_to_reg PROTO((rtx)); ! 762: ! 763: /* Like copy_to_reg but always make the reg the specified mode MODE. */ ! 764: extern rtx copy_to_mode_reg PROTO((enum machine_mode, rtx)); ! 765: ! 766: /* Copy given rtx to given temp reg and return that. */ ! 767: extern rtx copy_to_suggested_reg PROTO((rtx, rtx, enum machine_mode)); ! 768: ! 769: /* Copy a value to a register if it isn't already a register. ! 770: Args are mode (in case value is a constant) and the value. */ ! 771: extern rtx force_reg PROTO((enum machine_mode, rtx)); ! 772: ! 773: /* Return given rtx, copied into a new temp reg if it was in memory. */ ! 774: extern rtx force_not_mem PROTO((rtx)); ! 775: ! 776: /* Remove some bytes from the stack. An rtx says how many. */ ! 777: extern void adjust_stack PROTO((rtx)); ! 778: ! 779: /* Add some bytes to the stack. An rtx says how many. */ ! 780: extern void anti_adjust_stack PROTO((rtx)); ! 781: ! 782: /* This enum is used for the following two functions. */ ! 783: enum save_level {SAVE_BLOCK, SAVE_FUNCTION, SAVE_NONLOCAL}; ! 784: ! 785: /* Save the stack pointer at the specified level. */ ! 786: extern void emit_stack_save PROTO((enum save_level, rtx *, rtx)); ! 787: ! 788: /* Restore the stack pointer from a save area of the specified level. */ ! 789: extern void emit_stack_restore PROTO((enum save_level, rtx, rtx)); ! 790: ! 791: /* Allocate some space on the stack dynamically and return its address. An rtx ! 792: says how many bytes. */ ! 793: extern rtx allocate_dynamic_stack_space PROTO((rtx, rtx, int)); ! 794: ! 795: /* Emit code to copy function value to a new temp reg and return that reg. */ ! 796: extern rtx function_value (); ! 797: ! 798: /* Return an rtx that refers to the value returned by a library call ! 799: in its original home. This becomes invalid if any more code is emitted. */ ! 800: extern rtx hard_libcall_value PROTO((enum machine_mode)); ! 801: ! 802: /* Given an rtx, return an rtx for a value rounded up to a multiple ! 803: of STACK_BOUNDARY / BITS_PER_UNIT. */ ! 804: extern rtx round_push PROTO((rtx)); ! 805: ! 806: extern void emit_block_move PROTO((rtx, rtx, rtx, int)); ! 807: ! 808: extern rtx store_bit_field PROTO((rtx, int, int, enum machine_mode, rtx, int, int)); ! 809: extern rtx extract_bit_field PROTO((rtx, int, int, int, rtx, enum machine_mode, enum machine_mode, int, int)); ! 810: extern rtx expand_mult PROTO((enum machine_mode, rtx, rtx, rtx, int)); ! 811: extern rtx expand_mult_add PROTO((rtx, rtx, rtx, rtx,enum machine_mode, int)); ! 812: ! 813: extern rtx assemble_static_space PROTO((int)); ! 814: ! 815: /* Hook called by expand_expr for language-specific tree codes. ! 816: It is up to the language front end to install a hook ! 817: if it has any such codes that expand_expr needs to know about. */ ! 818: extern rtx (*lang_expand_expr) ();
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.