![[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 [GCC 2.x] / gcc|
Return to expr.h CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Definitions for code generation pass of GNU compiler. 1.1.1.5 ! root 2: Copyright (C) 1987, 1991, 1992, 1993 Free Software Foundation, Inc. 1.1 root 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: 1.1.1.4 root 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: 1.1 root 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) \ 1.1.1.4 root 161: ((SIZE).var == 0 ? GEN_INT ((SIZE).constant) \ 1.1 root 162: : expand_expr (size_binop (PLUS_EXPR, (SIZE).var, \ 163: size_int ((SIZE).constant)), \ 1.1.1.4 root 164: NULL_RTX, VOIDmode, 0)) 1.1 root 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: 1.1.1.4 root 172: usually pad upward, but pad short args downward on 1.1 root 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 \ 1.1.1.5 ! root 182: && int_size_in_bytes (TYPE) < (PARM_BOUNDARY / BITS_PER_UNIT)) \ 1.1 root 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 1.1.1.5 ! root 205: would put it into the wrong part of the register. ! 206: ! 207: Which padding can't be supported depends on the byte endianness. 1.1 root 208: 1.1.1.5 ! root 209: A value in a register is implicitly padded at the most significant end. 1.1 root 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 \ 1.1.1.5 ! root 225: && ! ((TYPE) != 0 && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \ ! 226: && 0 == (int_size_in_bytes (TYPE) \ ! 227: % (PARM_BOUNDARY / BITS_PER_UNIT))) \ 1.1 root 228: && (FUNCTION_ARG_PADDING (MODE, TYPE) \ 1.1.1.5 ! root 229: == MUST_PASS_IN_STACK_BAD_PADDING)))) 1.1 root 230: 1.1.1.5 ! root 231: /* Nonzero if type TYPE should be returned in memory. 1.1 root 232: Most machines can use the following default definition. */ 233: 234: #ifndef RETURN_IN_MEMORY 1.1.1.5 ! root 235: #define RETURN_IN_MEMORY(TYPE) (TYPE_MODE (TYPE) == BLKmode) 1.1 root 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; 1.1.1.3 root 283: extern optab smul_optab; /* Signed and floating-point multiply */ 1.1 root 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 */ 1.1.1.3 root 304: extern optab smin_optab; /* Signed and floating-point minimum value */ 305: extern optab smax_optab; /* Signed and floating-point maximum value */ 1.1 root 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 */ 1.1.1.2 root 320: extern optab sqrt_optab; /* Square root */ 1.1.1.4 root 321: extern optab sin_optab; /* Sine */ 322: extern optab cos_optab; /* Cosine */ 1.1.1.3 root 323: extern optab strlen_optab; /* String length */ 1.1 root 324: 1.1.1.5 ! root 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: 1.1 root 333: /* Passed to expand_binop and expand_unop to say which options to try to use 334: if the requested operation can't be open-coded on the requisite mode. 335: Either OPTAB_LIB or OPTAB_LIB_WIDEN says try using a library call. 336: Either OPTAB_WIDEN or OPTAB_LIB_WIDEN says try using a wider mode. 337: OPTAB_MUST_WIDEN says try widening and don't try anything else. */ 338: 339: enum optab_methods 340: { 341: OPTAB_DIRECT, 342: OPTAB_LIB, 343: OPTAB_WIDEN, 344: OPTAB_LIB_WIDEN, 345: OPTAB_MUST_WIDEN 346: }; 347: 348: /* SYMBOL_REF rtx's for the library functions that are called 349: implicitly and not via optabs. */ 350: 351: extern rtx extendsfdf2_libfunc; 1.1.1.4 root 352: extern rtx extendsfxf2_libfunc; 353: extern rtx extendsftf2_libfunc; 354: extern rtx extenddfxf2_libfunc; 355: extern rtx extenddftf2_libfunc; 356: 1.1 root 357: extern rtx truncdfsf2_libfunc; 1.1.1.4 root 358: extern rtx truncxfsf2_libfunc; 359: extern rtx trunctfsf2_libfunc; 360: extern rtx truncxfdf2_libfunc; 361: extern rtx trunctfdf2_libfunc; 362: 1.1 root 363: extern rtx memcpy_libfunc; 364: extern rtx bcopy_libfunc; 365: extern rtx memcmp_libfunc; 366: extern rtx bcmp_libfunc; 367: extern rtx memset_libfunc; 368: extern rtx bzero_libfunc; 1.1.1.4 root 369: 1.1 root 370: extern rtx eqsf2_libfunc; 371: extern rtx nesf2_libfunc; 372: extern rtx gtsf2_libfunc; 373: extern rtx gesf2_libfunc; 374: extern rtx ltsf2_libfunc; 375: extern rtx lesf2_libfunc; 1.1.1.4 root 376: 1.1 root 377: extern rtx eqdf2_libfunc; 378: extern rtx nedf2_libfunc; 379: extern rtx gtdf2_libfunc; 380: extern rtx gedf2_libfunc; 381: extern rtx ltdf2_libfunc; 382: extern rtx ledf2_libfunc; 1.1.1.4 root 383: 384: extern rtx eqxf2_libfunc; 385: extern rtx nexf2_libfunc; 386: extern rtx gtxf2_libfunc; 387: extern rtx gexf2_libfunc; 388: extern rtx ltxf2_libfunc; 389: extern rtx lexf2_libfunc; 390: 391: extern rtx eqtf2_libfunc; 392: extern rtx netf2_libfunc; 393: extern rtx gttf2_libfunc; 394: extern rtx getf2_libfunc; 395: extern rtx lttf2_libfunc; 396: extern rtx letf2_libfunc; 397: 1.1 root 398: extern rtx floatsisf_libfunc; 1.1.1.4 root 399: extern rtx floatdisf_libfunc; 400: extern rtx floattisf_libfunc; 401: 1.1 root 402: extern rtx floatsidf_libfunc; 1.1.1.4 root 403: extern rtx floatdidf_libfunc; 404: extern rtx floattidf_libfunc; 405: 406: extern rtx floatsixf_libfunc; 407: extern rtx floatdixf_libfunc; 408: extern rtx floattixf_libfunc; 409: 410: extern rtx floatsitf_libfunc; 411: extern rtx floatditf_libfunc; 412: extern rtx floattitf_libfunc; 413: 1.1 root 414: extern rtx fixsfsi_libfunc; 415: extern rtx fixsfdi_libfunc; 1.1.1.4 root 416: extern rtx fixsfti_libfunc; 417: 1.1 root 418: extern rtx fixdfsi_libfunc; 419: extern rtx fixdfdi_libfunc; 1.1.1.4 root 420: extern rtx fixdfti_libfunc; 421: 422: extern rtx fixxfsi_libfunc; 423: extern rtx fixxfdi_libfunc; 424: extern rtx fixxfti_libfunc; 425: 426: extern rtx fixtfsi_libfunc; 427: extern rtx fixtfdi_libfunc; 428: extern rtx fixtfti_libfunc; 429: 1.1 root 430: extern rtx fixunssfsi_libfunc; 431: extern rtx fixunssfdi_libfunc; 1.1.1.4 root 432: extern rtx fixunssfti_libfunc; 433: 1.1 root 434: extern rtx fixunsdfsi_libfunc; 435: extern rtx fixunsdfdi_libfunc; 1.1.1.4 root 436: extern rtx fixunsdfti_libfunc; 437: 438: extern rtx fixunsxfsi_libfunc; 439: extern rtx fixunsxfdi_libfunc; 440: extern rtx fixunsxfti_libfunc; 441: 442: extern rtx fixunstfsi_libfunc; 443: extern rtx fixunstfdi_libfunc; 444: extern rtx fixunstfti_libfunc; 1.1 root 445: 446: typedef rtx (*rtxfun) (); 447: 448: /* Indexed by the rtx-code for a conditional (eg. EQ, LT,...) 449: gives the gen_function to make a branch to test that condition. */ 450: 451: extern rtxfun bcc_gen_fctn[NUM_RTX_CODE]; 452: 453: /* Indexed by the rtx-code for a conditional (eg. EQ, LT,...) 454: gives the insn code to make a store-condition insn 455: to test that condition. */ 456: 457: extern enum insn_code setcc_gen_code[NUM_RTX_CODE]; 458: 1.1.1.5 ! root 459: /* This array records the insn_code of insns to perform block moves. */ ! 460: extern enum insn_code movstr_optab[NUM_MACHINE_MODES]; ! 461: ! 462: /* Define functions given in optabs.c. */ ! 463: 1.1 root 464: /* Expand a binary operation given optab and rtx operands. */ 1.1.1.5 ! root 465: extern rtx expand_binop PROTO((enum machine_mode, optab, rtx, rtx, rtx, ! 466: int, enum optab_methods)); 1.1 root 467: 468: /* Expand a binary operation with both signed and unsigned forms. */ 1.1.1.5 ! root 469: extern rtx sign_expand_binop PROTO((enum machine_mode, optab, optab, rtx, ! 470: rtx, rtx, int, enum optab_methods)); ! 471: ! 472: /* Generate code to perform an operation on two operands with two results. */ ! 473: extern int expand_twoval_binop PROTO((optab, rtx, rtx, rtx, rtx, int)); 1.1 root 474: 475: /* Expand a unary arithmetic operation given optab rtx operand. */ 1.1.1.5 ! root 476: extern rtx expand_unop PROTO((enum machine_mode, optab, rtx, rtx, int)); 1.1 root 477: 1.1.1.4 root 478: /* Expand the complex absolute value operation. */ 1.1.1.5 ! root 479: extern rtx expand_complex_abs PROTO((enum machine_mode, rtx, rtx, int)); 1.1.1.4 root 480: 1.1.1.5 ! root 481: /* Generate an instruction with a given INSN_CODE with an output and ! 482: an input. */ ! 483: extern void emit_unop_insn PROTO((int, rtx, rtx, enum rtx_code)); ! 484: ! 485: /* Emit code to perform a series of operations on a multi-word quantity, one ! 486: word at a time. */ ! 487: extern rtx emit_no_conflict_block PROTO((rtx, rtx, rtx, rtx, rtx)); 1.1 root 488: 1.1.1.5 ! root 489: /* Emit code to make a call to a constant function or a library call. */ ! 490: extern void emit_libcall_block PROTO((rtx, rtx, rtx, rtx)); 1.1 root 491: 1.1.1.5 ! root 492: /* Emit one rtl instruction to store zero in specified rtx. */ ! 493: extern void emit_clr_insn PROTO((rtx)); 1.1 root 494: 1.1.1.5 ! root 495: /* Emit one rtl insn to store 1 in specified rtx assuming it contains 0. */ ! 496: extern void emit_0_to_1_insn PROTO((rtx)); 1.1 root 497: 1.1.1.5 ! root 498: /* Emit one rtl insn to compare two rtx's. */ ! 499: extern void emit_cmp_insn PROTO((rtx, rtx, enum rtx_code, rtx, ! 500: enum machine_mode, int, int)); ! 501: ! 502: /* Nonzero if a compare of mode MODE can be done straightforwardly ! 503: (without splitting it into pieces). */ ! 504: extern int can_compare_p PROTO((enum machine_mode)); ! 505: ! 506: /* Generate code to indirectly jump to a location given in the rtx LOC. */ ! 507: extern void emit_indirect_jump PROTO((rtx)); ! 508: ! 509: /* Create but don't emit one rtl instruction to add one rtx into another. ! 510: Modes must match; operands must meet the operation's predicates. ! 511: Likewise for subtraction and for just copying. ! 512: These do not call protect_from_queue; caller must do so. */ ! 513: extern rtx gen_add2_insn PROTO((rtx, rtx)); ! 514: extern rtx gen_sub2_insn PROTO((rtx, rtx)); ! 515: extern rtx gen_move_insn PROTO((rtx, rtx)); ! 516: extern int have_add2_insn PROTO((enum machine_mode)); ! 517: extern int have_sub2_insn PROTO((enum machine_mode)); 1.1 root 518: 519: /* Return the INSN_CODE to use for an extend operation. */ 1.1.1.5 ! root 520: extern enum insn_code can_extend_p PROTO((enum machine_mode, ! 521: enum machine_mode, int)); ! 522: ! 523: /* Generate the body of an insn to extend Y (with mode MFROM) ! 524: into X (with mode MTO). Do zero-extension if UNSIGNEDP is nonzero. */ ! 525: extern rtx gen_extend_insn PROTO((rtx, rtx, enum machine_mode, ! 526: enum machine_mode, int)); 1.1 root 527: 528: /* Initialize the tables that control conversion between fixed and 529: floating values. */ 1.1.1.5 ! root 530: extern void init_fixtab PROTO((void)); ! 531: extern void init_floattab PROTO((void)); ! 532: ! 533: /* Generate code for a FLOAT_EXPR. */ ! 534: extern void expand_float PROTO((rtx, rtx, int)); 1.1 root 535: 536: /* Generate code for a FIX_EXPR. */ 1.1.1.5 ! root 537: extern void expand_fix PROTO((rtx, rtx, int)); 1.1 root 538: 1.1.1.5 ! root 539: /* Call this once to initialize the contents of the optabs ! 540: appropriately for the current target machine. */ ! 541: extern void init_optabs PROTO((void)); ! 542: ! 543: /* Functions from expmed.c: */ 1.1 root 544: 1.1.1.5 ! root 545: /* Arguments MODE, RTX: return an rtx for the negation of that value. ! 546: May emit insns. */ ! 547: extern rtx negate_rtx PROTO((enum machine_mode, rtx)); 1.1 root 548: 1.1.1.5 ! root 549: /* Expand a logical AND operation. */ ! 550: extern rtx expand_and PROTO((rtx, rtx, rtx)); 1.1 root 551: 1.1.1.5 ! root 552: /* Emit a store-flag operation. */ ! 553: extern rtx emit_store_flag PROTO((rtx, enum rtx_code, rtx, rtx, ! 554: enum machine_mode, int, int)); 1.1 root 555: 1.1.1.5 ! root 556: /* Functions from loop.c: */ 1.1 root 557: 1.1.1.5 ! root 558: /* Given a JUMP_INSN, return a description of the test being made. */ ! 559: extern rtx get_condition PROTO((rtx, rtx *)); ! 560: ! 561: /* Functions from expr.c: */ ! 562: ! 563: /* This is run once per compilation to set up which modes can be used ! 564: directly in memory and to initialize the block move optab. */ ! 565: extern void init_expr_once PROTO((void)); ! 566: ! 567: /* This is run at the start of compiling a function. */ ! 568: extern void init_expr PROTO((void)); ! 569: ! 570: /* Use protect_from_queue to convert a QUEUED expression ! 571: into something that you can put immediately into an instruction. */ ! 572: extern rtx protect_from_queue PROTO((rtx, int)); ! 573: ! 574: /* Perform all the pending incrementations. */ ! 575: extern void emit_queue PROTO((void)); 1.1 root 576: 577: /* Emit some rtl insns to move data between rtx's, converting machine modes. 578: Both modes must be floating or both fixed. */ 1.1.1.5 ! root 579: extern void convert_move PROTO((rtx, rtx, int)); 1.1 root 580: 581: /* Convert an rtx to specified machine mode and return the result. */ 1.1.1.5 ! root 582: extern rtx convert_to_mode PROTO((enum machine_mode, rtx, int)); ! 583: ! 584: /* Emit code to move a block Y to a block X. */ ! 585: extern void emit_block_move PROTO((rtx, rtx, rtx, int)); ! 586: ! 587: /* Copy all or part of a value X into registers starting at REGNO. ! 588: The number of registers to be filled is NREGS. */ ! 589: extern void move_block_to_reg PROTO((int, rtx, int, enum machine_mode)); ! 590: ! 591: /* Copy all or part of a BLKmode value X out of registers starting at REGNO. ! 592: The number of registers to be filled is NREGS. */ ! 593: extern void move_block_from_reg PROTO((int, rtx, int)); ! 594: ! 595: /* Mark NREGS consecutive regs, starting at REGNO, as being live now. */ ! 596: extern void use_regs PROTO((int, int)); ! 597: ! 598: /* Write zeros through the storage of OBJECT. ! 599: If OBJECT has BLKmode, SIZE is its length in bytes. */ ! 600: extern void clear_storage PROTO((rtx, int)); ! 601: ! 602: /* Emit insns to set X from Y. */ ! 603: extern rtx emit_move_insn PROTO((rtx, rtx)); ! 604: ! 605: /* Emit insns to set X from Y, with no frills. */ ! 606: extern rtx emit_move_insn_1 PROTO ((rtx, rtx)); ! 607: ! 608: /* Push a block of length SIZE (perhaps variable) ! 609: and return an rtx to address the beginning of the block. */ ! 610: extern rtx push_block PROTO((rtx, int, int)); ! 611: ! 612: /* Make an operand to push someting on the stack. */ ! 613: extern rtx gen_push_operand PROTO((void)); 1.1 root 614: 1.1.1.5 ! root 615: #ifdef TREE_CODE ! 616: /* Generate code to push something onto the stack, given its mode and type. */ ! 617: extern void emit_push_insn PROTO((rtx, enum machine_mode, tree, rtx, int, ! 618: int, rtx, int, rtx, rtx)); ! 619: ! 620: /* Emit library call. These cannot have accurate prototypes since they have ! 621: a variable number of args. */ 1.1 root 622: extern void emit_library_call (); 1.1.1.5 ! root 623: extern void emit_library_call_value (); ! 624: ! 625: /* Expand an assignment that stores the value of FROM into TO. */ ! 626: extern rtx expand_assignment PROTO((tree, tree, int, int)); ! 627: ! 628: /* Generate code for computing expression EXP, ! 629: and storing the value into TARGET. ! 630: If SUGGEST_REG is nonzero, copy the value through a register ! 631: and return that register, if that is possible. */ ! 632: extern rtx store_expr PROTO((tree, rtx, int)); ! 633: #endif 1.1 root 634: 635: /* Given an rtx that may include add and multiply operations, 636: generate them as insns and return a pseudo-reg containing the value. 637: Useful after calling expand_expr with 1 as sum_ok. */ 1.1.1.5 ! root 638: extern rtx force_operand PROTO((rtx, rtx)); ! 639: ! 640: #ifdef TREE_CODE ! 641: /* Generate code for computing expression EXP. ! 642: An rtx for the computed value is returned. The value is never null. ! 643: In the case of a void EXP, const0_rtx is returned. */ ! 644: extern rtx expand_expr PROTO((tree, rtx, enum machine_mode, ! 645: enum expand_modifier)); ! 646: #endif ! 647: ! 648: /* At the start of a function, record that we have no previously-pushed ! 649: arguments waiting to be popped. */ ! 650: extern void init_pending_stack_adjust PROTO((void)); ! 651: ! 652: /* When exiting from function, if safe, clear out any pending stack adjust ! 653: so the adjustment won't get done. */ ! 654: extern void clear_pending_stack_adjust PROTO((void)); 1.1 root 655: 1.1.1.5 ! root 656: /* Pop any previously-pushed arguments that have not been popped yet. */ ! 657: extern void do_pending_stack_adjust PROTO((void)); ! 658: ! 659: #ifdef TREE_CODE ! 660: /* Expand all cleanups up to OLD_CLEANUPS. */ ! 661: extern void expand_cleanups_to PROTO((tree)); ! 662: ! 663: /* Generate code to evaluate EXP and jump to LABEL if the value is zero. */ ! 664: extern void jumpifnot PROTO((tree, rtx)); ! 665: ! 666: /* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */ ! 667: extern void jumpif PROTO((tree, rtx)); ! 668: ! 669: /* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if ! 670: the result is zero, or IF_TRUE_LABEL if the result is one. */ ! 671: extern void do_jump PROTO((tree, rtx, rtx)); ! 672: #endif ! 673: ! 674: /* Generate rtl to compare two rtx's, will call emit_cmp_insn. */ ! 675: extern rtx compare_from_rtx PROTO((rtx, rtx, enum rtx_code, int, ! 676: enum machine_mode, rtx, int)); ! 677: ! 678: /* Generate a tablejump instruction (used for switch statements). */ ! 679: extern void do_tablejump PROTO((rtx, enum machine_mode, rtx, rtx, rtx)); ! 680: ! 681: #ifdef TREE_CODE ! 682: /* rtl.h and tree.h were included. */ 1.1 root 683: /* Return an rtx for the size in bytes of the value of an expr. */ 1.1.1.5 ! root 684: extern rtx expr_size PROTO((tree)); 1.1 root 685: 1.1.1.5 ! root 686: extern rtx lookup_static_chain PROTO((tree)); ! 687: ! 688: /* Convert a stack slot address ADDR valid in function FNDECL ! 689: into an address valid in this function (using a static chain). */ ! 690: extern rtx fix_lexical_addr PROTO((rtx, tree)); ! 691: ! 692: /* Return the address of the trampoline for entering nested fn FUNCTION. */ ! 693: extern rtx trampoline_address PROTO((tree)); ! 694: ! 695: /* Return an rtx that refers to the value returned by a function ! 696: in its original home. This becomes invalid if any more code is emitted. */ ! 697: extern rtx hard_function_value PROTO((tree, tree)); ! 698: ! 699: extern rtx prepare_call_address PROTO((rtx, tree, rtx *)); ! 700: ! 701: extern rtx expand_call PROTO((tree, rtx, int)); ! 702: ! 703: extern rtx expand_shift PROTO((enum tree_code, enum machine_mode, rtx, tree, rtx, int)); ! 704: extern rtx expand_divmod PROTO((int, enum tree_code, enum machine_mode, rtx, rtx, rtx, int)); ! 705: extern void locate_and_pad_parm PROTO((enum machine_mode, tree, int, tree, struct args_size *, struct args_size *, struct args_size *)); ! 706: extern rtx expand_inline_function PROTO((tree, tree, rtx, int, tree, rtx)); ! 707: /* Return the CODE_LABEL rtx for a LABEL_DECL, creating it if necessary. */ ! 708: extern rtx label_rtx PROTO((tree)); ! 709: #endif ! 710: ! 711: /* Indicate how an input argument register was promoted. */ ! 712: extern rtx promoted_input_arg PROTO((int, enum machine_mode *, int *)); 1.1 root 713: 714: /* Return an rtx like arg but sans any constant terms. 715: Returns the original rtx if it has no constant terms. 716: The constant terms are added and stored via a second arg. */ 1.1.1.5 ! root 717: extern rtx eliminate_constant_term PROTO((rtx, rtx *)); 1.1 root 718: 719: /* Convert arg to a valid memory address for specified machine mode, 720: by emitting insns to perform arithmetic if nec. */ 1.1.1.5 ! root 721: extern rtx memory_address PROTO((enum machine_mode, rtx)); 1.1 root 722: 723: /* Like `memory_address' but pretent `flag_force_addr' is 0. */ 1.1.1.5 ! root 724: extern rtx memory_address_noforce PROTO((enum machine_mode, rtx)); 1.1 root 725: 726: /* Return a memory reference like MEMREF, but with its mode changed 727: to MODE and its address changed to ADDR. 728: (VOIDmode means don't change the mode. 729: NULL for ADDR means don't change the address.) */ 1.1.1.5 ! root 730: extern rtx change_address PROTO((rtx, enum machine_mode, rtx)); 1.1 root 731: 732: /* Return a memory reference like MEMREF, but which is known to have a 733: valid address. */ 734: 1.1.1.5 ! root 735: extern rtx validize_mem PROTO((rtx)); 1.1 root 736: 737: /* Assemble the static constant template for function entry trampolines. */ 1.1.1.5 ! root 738: extern rtx assemble_trampoline_template PROTO((void)); 1.1 root 739: 740: /* Return 1 if two rtx's are equivalent in structure and elements. */ 1.1.1.5 ! root 741: extern int rtx_equal_p PROTO((rtx, rtx)); 1.1 root 742: 743: /* Given rtx, return new rtx whose address won't be affected by 744: any side effects. It has been copied to a new temporary reg. */ 1.1.1.5 ! root 745: extern rtx stabilize PROTO((rtx)); 1.1 root 746: 747: /* Given an rtx, copy all regs it refers to into new temps 748: and return a modified copy that refers to the new temps. */ 1.1.1.5 ! root 749: extern rtx copy_all_regs PROTO((rtx)); 1.1 root 750: 751: /* Copy given rtx to a new temp reg and return that. */ 1.1.1.5 ! root 752: extern rtx copy_to_reg PROTO((rtx)); 1.1 root 753: 754: /* Like copy_to_reg but always make the reg Pmode. */ 1.1.1.5 ! root 755: extern rtx copy_addr_to_reg PROTO((rtx)); 1.1 root 756: 757: /* Like copy_to_reg but always make the reg the specified mode MODE. */ 1.1.1.5 ! root 758: extern rtx copy_to_mode_reg PROTO((enum machine_mode, rtx)); 1.1 root 759: 760: /* Copy given rtx to given temp reg and return that. */ 1.1.1.5 ! root 761: extern rtx copy_to_suggested_reg PROTO((rtx, rtx, enum machine_mode)); 1.1 root 762: 763: /* Copy a value to a register if it isn't already a register. 764: Args are mode (in case value is a constant) and the value. */ 1.1.1.5 ! root 765: extern rtx force_reg PROTO((enum machine_mode, rtx)); 1.1 root 766: 767: /* Return given rtx, copied into a new temp reg if it was in memory. */ 1.1.1.5 ! root 768: extern rtx force_not_mem PROTO((rtx)); 1.1 root 769: 770: /* Remove some bytes from the stack. An rtx says how many. */ 1.1.1.5 ! root 771: extern void adjust_stack PROTO((rtx)); 1.1 root 772: 773: /* Add some bytes to the stack. An rtx says how many. */ 1.1.1.5 ! root 774: extern void anti_adjust_stack PROTO((rtx)); 1.1 root 775: 1.1.1.3 root 776: /* This enum is used for the following two functions. */ 777: enum save_level {SAVE_BLOCK, SAVE_FUNCTION, SAVE_NONLOCAL}; 778: 779: /* Save the stack pointer at the specified level. */ 1.1.1.5 ! root 780: extern void emit_stack_save PROTO((enum save_level, rtx *, rtx)); 1.1.1.3 root 781: 782: /* Restore the stack pointer from a save area of the specified level. */ 1.1.1.5 ! root 783: extern void emit_stack_restore PROTO((enum save_level, rtx, rtx)); 1.1.1.3 root 784: 1.1 root 785: /* Allocate some space on the stack dynamically and return its address. An rtx 786: says how many bytes. */ 1.1.1.5 ! root 787: extern rtx allocate_dynamic_stack_space PROTO((rtx, rtx, int)); 1.1 root 788: 789: /* Emit code to copy function value to a new temp reg and return that reg. */ 790: extern rtx function_value (); 791: 792: /* Return an rtx that refers to the value returned by a library call 793: in its original home. This becomes invalid if any more code is emitted. */ 1.1.1.5 ! root 794: extern rtx hard_libcall_value PROTO((enum machine_mode)); 1.1 root 795: 796: /* Given an rtx, return an rtx for a value rounded up to a multiple 797: of STACK_BOUNDARY / BITS_PER_UNIT. */ 1.1.1.5 ! root 798: extern rtx round_push PROTO((rtx)); 1.1 root 799: 1.1.1.5 ! root 800: extern void emit_block_move PROTO((rtx, rtx, rtx, int)); 1.1 root 801: 1.1.1.5 ! root 802: extern rtx store_bit_field PROTO((rtx, int, int, enum machine_mode, rtx, int, int)); ! 803: extern rtx extract_bit_field PROTO((rtx, int, int, int, rtx, enum machine_mode, enum machine_mode, int, int)); ! 804: extern rtx expand_mult PROTO((enum machine_mode, rtx, rtx, rtx, int)); ! 805: extern rtx expand_mult_add PROTO((rtx, rtx, rtx, rtx,enum machine_mode, int)); 1.1 root 806: 1.1.1.5 ! root 807: extern rtx assemble_static_space PROTO((int)); 1.1 root 808: 809: /* Hook called by expand_expr for language-specific tree codes. 810: It is up to the language front end to install a hook 811: if it has any such codes that expand_expr needs to know about. */ 812: extern rtx (*lang_expand_expr) ();
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.