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