![[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. ! 2: Copyright (C) 1987, 1991 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: /* 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 ! 122: ! 123: #ifdef TREE_CODE /* Don't lose if tree.h not included. */ ! 124: /* Structure to record the size of a sequence of arguments ! 125: as the sum of a tree-expression and a constant. */ ! 126: ! 127: struct args_size ! 128: { ! 129: int constant; ! 130: tree var; ! 131: }; ! 132: #endif ! 133: ! 134: /* Add the value of the tree INC to the `struct args_size' TO. */ ! 135: ! 136: #define ADD_PARM_SIZE(TO, INC) \ ! 137: { tree inc = (INC); \ ! 138: if (TREE_CODE (inc) == INTEGER_CST) \ ! 139: (TO).constant += TREE_INT_CST_LOW (inc); \ ! 140: else if ((TO).var == 0) \ ! 141: (TO).var = inc; \ ! 142: else \ ! 143: (TO).var = size_binop (PLUS_EXPR, (TO).var, inc); } ! 144: ! 145: #define SUB_PARM_SIZE(TO, DEC) \ ! 146: { tree dec = (DEC); \ ! 147: if (TREE_CODE (dec) == INTEGER_CST) \ ! 148: (TO).constant -= TREE_INT_CST_LOW (dec); \ ! 149: else if ((TO).var == 0) \ ! 150: (TO).var = size_binop (MINUS_EXPR, integer_zero_node, dec); \ ! 151: else \ ! 152: (TO).var = size_binop (MINUS_EXPR, (TO).var, dec); } ! 153: ! 154: /* Convert the implicit sum in a `struct args_size' into an rtx. */ ! 155: #define ARGS_SIZE_RTX(SIZE) \ ! 156: ((SIZE).var == 0 ? gen_rtx (CONST_INT, VOIDmode, (SIZE).constant) \ ! 157: : expand_expr (size_binop (PLUS_EXPR, (SIZE).var, \ ! 158: size_int ((SIZE).constant)), \ ! 159: 0, VOIDmode, 0)) ! 160: ! 161: /* Convert the implicit sum in a `struct args_size' into a tree. */ ! 162: #define ARGS_SIZE_TREE(SIZE) \ ! 163: ((SIZE).var == 0 ? size_int ((SIZE).constant) \ ! 164: : size_binop (PLUS_EXPR, (SIZE).var, size_int ((SIZE).constant))) ! 165: ! 166: /* Supply a default definition for FUNCTION_ARG_PADDING: ! 167: usually pad upward, but pad short, non-BLKmode args downward on ! 168: big-endian machines. */ ! 169: ! 170: enum direction {none, upward, downward}; /* Value has this type. */ ! 171: ! 172: #ifndef FUNCTION_ARG_PADDING ! 173: #if BYTES_BIG_ENDIAN ! 174: #define FUNCTION_ARG_PADDING(MODE, TYPE) \ ! 175: (((MODE) == BLKmode \ ! 176: ? ((TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \ ! 177: && int_size_in_bytes (TYPE) < PARM_BOUNDARY / BITS_PER_UNIT) \ ! 178: : GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY) \ ! 179: ? downward : upward) ! 180: #else ! 181: #define FUNCTION_ARG_PADDING(MODE, TYPE) upward ! 182: #endif ! 183: #endif ! 184: ! 185: /* Supply a default definition for FUNCTION_ARG_BOUNDARY. Normally, we let ! 186: FUNCTION_ARG_PADDING, which also pads the length, handle any needed ! 187: alignment. */ ! 188: ! 189: #ifndef FUNCTION_ARG_BOUNDARY ! 190: #define FUNCTION_ARG_BOUNDARY(MODE, TYPE) PARM_BOUNDARY ! 191: #endif ! 192: ! 193: /* Nonzero if we do not know how to pass TYPE solely in registers. ! 194: We cannot do so in the following cases: ! 195: ! 196: - if the type has variable size ! 197: - if the type is marked as addressable (it is required to be constructed ! 198: into the stack) ! 199: - if the padding and mode of the type is such that a copy into a register ! 200: would put it into the wrong part of the register ! 201: - when STRICT_ALIGNMENT and the type is BLKmode and is is not ! 202: aligned to a boundary corresponding to what can be loaded into a ! 203: register. */ ! 204: ! 205: #ifdef STRICT_ALIGNMENT ! 206: #define MUST_PASS_IN_STACK_BAD_ALIGN(MODE,TYPE) \ ! 207: (MODE == BLKmode \ ! 208: && TYPE_ALIGN (TYPE) < (BIGGEST_ALIGNMENT < BITS_PER_WORD \ ! 209: ? BIGGEST_ALIGNMENT : BITS_PER_WORD)) ! 210: #else ! 211: #define MUST_PASS_IN_STACK_BAD_ALIGN(MODE,TYPE) 0 ! 212: #endif ! 213: ! 214: /* Which padding can't be supported depends on the byte endianness. */ ! 215: ! 216: /* A value in a register is implicitly padded at the most significant end. ! 217: On a big-endian machine, that is the lower end in memory. ! 218: So a value padded in memory at the upper end can't go in a register. ! 219: For a little-endian machine, the reverse is true. */ ! 220: ! 221: #if BYTES_BIG_ENDIAN ! 222: #define MUST_PASS_IN_STACK_BAD_PADDING upward ! 223: #else ! 224: #define MUST_PASS_IN_STACK_BAD_PADDING downward ! 225: #endif ! 226: ! 227: #define MUST_PASS_IN_STACK(MODE,TYPE) \ ! 228: ((TYPE) != 0 \ ! 229: && (TREE_CODE (TYPE_SIZE (TYPE)) != INTEGER_CST \ ! 230: || TREE_ADDRESSABLE (TYPE) \ ! 231: || ((MODE) == BLKmode \ ! 232: && (FUNCTION_ARG_PADDING (MODE, TYPE) \ ! 233: == MUST_PASS_IN_STACK_BAD_PADDING)) \ ! 234: || MUST_PASS_IN_STACK_BAD_ALIGN (MODE, TYPE))) ! 235: ! 236: /* Nonzero if type TYPE should be returned in memory ! 237: (even though its mode is not BLKmode). ! 238: Most machines can use the following default definition. */ ! 239: ! 240: #ifndef RETURN_IN_MEMORY ! 241: #define RETURN_IN_MEMORY(TYPE) 0 ! 242: #endif ! 243: ! 244: /* Optabs are tables saying how to generate insn bodies ! 245: for various machine modes and numbers of operands. ! 246: Each optab applies to one operation. ! 247: For example, add_optab applies to addition. ! 248: ! 249: The insn_code slot is the enum insn_code that says how to ! 250: generate an insn for this operation on a particular machine mode. ! 251: It is CODE_FOR_nothing if there is no such insn on the target machine. ! 252: ! 253: The `lib_call' slot is the name of the library function that ! 254: can be used to perform the operation. ! 255: ! 256: A few optabs, such as move_optab and cmp_optab, are used ! 257: by special code. */ ! 258: ! 259: /* Everything that uses expr.h needs to define enum insn_code ! 260: but we don't list it in the Makefile dependencies just for that. */ ! 261: #include "insn-codes.h" ! 262: ! 263: typedef struct optab ! 264: { ! 265: enum rtx_code code; ! 266: struct { ! 267: enum insn_code insn_code; ! 268: rtx libfunc; ! 269: } handlers [NUM_MACHINE_MODES]; ! 270: } * optab; ! 271: ! 272: /* Given an enum insn_code, access the function to construct ! 273: the body of that kind of insn. */ ! 274: #ifdef FUNCTION_CONVERSION_BUG ! 275: /* Some compilers fail to convert a function properly to a ! 276: pointer-to-function when used as an argument. ! 277: So produce the pointer-to-function directly. ! 278: Luckily, these compilers seem to work properly when you ! 279: call the pointer-to-function. */ ! 280: #define GEN_FCN(CODE) (insn_gen_function[(int) (CODE)]) ! 281: #else ! 282: #define GEN_FCN(CODE) (*insn_gen_function[(int) (CODE)]) ! 283: #endif ! 284: ! 285: extern rtx (*const insn_gen_function[]) (); ! 286: ! 287: extern optab add_optab; ! 288: extern optab sub_optab; ! 289: extern optab smul_optab; /* Signed multiply */ ! 290: extern optab smul_widen_optab; /* Signed multiply with result ! 291: one machine mode wider than args */ ! 292: extern optab umul_widen_optab; ! 293: extern optab sdiv_optab; /* Signed divide */ ! 294: extern optab sdivmod_optab; /* Signed divide-and-remainder in one */ ! 295: extern optab udiv_optab; ! 296: extern optab udivmod_optab; ! 297: extern optab smod_optab; /* Signed remainder */ ! 298: extern optab umod_optab; ! 299: extern optab flodiv_optab; /* Optab for floating divide. */ ! 300: extern optab ftrunc_optab; /* Convert float to integer in float fmt */ ! 301: extern optab and_optab; /* Logical and */ ! 302: extern optab ior_optab; /* Logical or */ ! 303: extern optab xor_optab; /* Logical xor */ ! 304: extern optab ashl_optab; /* Arithmetic shift left */ ! 305: extern optab ashr_optab; /* Arithmetic shift right */ ! 306: extern optab lshl_optab; /* Logical shift left */ ! 307: extern optab lshr_optab; /* Logical shift right */ ! 308: extern optab rotl_optab; /* Rotate left */ ! 309: extern optab rotr_optab; /* Rotate right */ ! 310: extern optab smin_optab; /* Signed minimum value */ ! 311: extern optab smax_optab; /* Signed maximum value */ ! 312: extern optab umin_optab; /* Unsigned minimum value */ ! 313: extern optab umax_optab; /* Unsigned maximum value */ ! 314: ! 315: extern optab mov_optab; /* Move instruction. */ ! 316: extern optab movstrict_optab; /* Move, preserving high part of register. */ ! 317: ! 318: extern optab cmp_optab; /* Compare insn; two operands. */ ! 319: extern optab tst_optab; /* tst insn; compare one operand against 0 */ ! 320: ! 321: /* Unary operations */ ! 322: extern optab neg_optab; /* Negation */ ! 323: extern optab abs_optab; /* Abs value */ ! 324: extern optab one_cmpl_optab; /* Bitwise not */ ! 325: extern optab ffs_optab; /* Find first bit set */ ! 326: ! 327: /* Passed to expand_binop and expand_unop to say which options to try to use ! 328: if the requested operation can't be open-coded on the requisite mode. ! 329: Either OPTAB_LIB or OPTAB_LIB_WIDEN says try using a library call. ! 330: Either OPTAB_WIDEN or OPTAB_LIB_WIDEN says try using a wider mode. ! 331: OPTAB_MUST_WIDEN says try widening and don't try anything else. */ ! 332: ! 333: enum optab_methods ! 334: { ! 335: OPTAB_DIRECT, ! 336: OPTAB_LIB, ! 337: OPTAB_WIDEN, ! 338: OPTAB_LIB_WIDEN, ! 339: OPTAB_MUST_WIDEN ! 340: }; ! 341: ! 342: /* SYMBOL_REF rtx's for the library functions that are called ! 343: implicitly and not via optabs. */ ! 344: ! 345: extern rtx extendsfdf2_libfunc; ! 346: extern rtx truncdfsf2_libfunc; ! 347: extern rtx memcpy_libfunc; ! 348: extern rtx bcopy_libfunc; ! 349: extern rtx memcmp_libfunc; ! 350: extern rtx bcmp_libfunc; ! 351: extern rtx memset_libfunc; ! 352: extern rtx bzero_libfunc; ! 353: extern rtx eqsf2_libfunc; ! 354: extern rtx nesf2_libfunc; ! 355: extern rtx gtsf2_libfunc; ! 356: extern rtx gesf2_libfunc; ! 357: extern rtx ltsf2_libfunc; ! 358: extern rtx lesf2_libfunc; ! 359: extern rtx eqdf2_libfunc; ! 360: extern rtx nedf2_libfunc; ! 361: extern rtx gtdf2_libfunc; ! 362: extern rtx gedf2_libfunc; ! 363: extern rtx ltdf2_libfunc; ! 364: extern rtx ledf2_libfunc; ! 365: extern rtx floatdisf_libfunc; ! 366: extern rtx floatsisf_libfunc; ! 367: extern rtx floatdidf_libfunc; ! 368: extern rtx floatsidf_libfunc; ! 369: extern rtx fixsfsi_libfunc; ! 370: extern rtx fixsfdi_libfunc; ! 371: extern rtx fixdfsi_libfunc; ! 372: extern rtx fixdfdi_libfunc; ! 373: extern rtx fixunssfsi_libfunc; ! 374: extern rtx fixunssfdi_libfunc; ! 375: extern rtx fixunsdfsi_libfunc; ! 376: extern rtx fixunsdfdi_libfunc; ! 377: ! 378: typedef rtx (*rtxfun) (); ! 379: ! 380: /* Indexed by the rtx-code for a conditional (eg. EQ, LT,...) ! 381: gives the gen_function to make a branch to test that condition. */ ! 382: ! 383: extern rtxfun bcc_gen_fctn[NUM_RTX_CODE]; ! 384: ! 385: /* Indexed by the rtx-code for a conditional (eg. EQ, LT,...) ! 386: gives the insn code to make a store-condition insn ! 387: to test that condition. */ ! 388: ! 389: extern enum insn_code setcc_gen_code[NUM_RTX_CODE]; ! 390: ! 391: /* Expand a binary operation given optab and rtx operands. */ ! 392: extern rtx expand_binop (); ! 393: ! 394: /* Expand a binary operation with both signed and unsigned forms. */ ! 395: extern rtx sign_expand_binop (); ! 396: ! 397: /* Expand a unary arithmetic operation given optab rtx operand. */ ! 398: extern rtx expand_unop (); ! 399: ! 400: /* Arguments MODE, RTX: return an rtx for the negation of that value. ! 401: May emit insns. */ ! 402: extern rtx negate_rtx (); ! 403: ! 404: /* Expand a logical AND operation. */ ! 405: extern rtx expand_and (); ! 406: ! 407: /* Emit a store-flag operation. */ ! 408: extern rtx emit_store_flag (); ! 409: ! 410: /* Return the CODE_LABEL rtx for a LABEL_DECL, creating it if necessary. */ ! 411: extern rtx label_rtx (); ! 412: ! 413: /* Given a JUMP_INSN, return a description of the test being made. */ ! 414: extern rtx get_condition (); ! 415: ! 416: /* Return the INSN_CODE to use for an extend operation. */ ! 417: extern enum insn_code can_extend_p (); ! 418: ! 419: /* Initialize the tables that control conversion between fixed and ! 420: floating values. */ ! 421: extern void init_fixtab (); ! 422: extern void init_floattab (); ! 423: ! 424: /* Generate code for a FIX_EXPR. */ ! 425: extern void expand_fix (); ! 426: ! 427: /* Generate code for a FLOAT_EXPR. */ ! 428: extern void expand_float (); ! 429: ! 430: /* Create but don't emit one rtl instruction to add one rtx into another. ! 431: Modes must match; operands must meet the operation's predicates. ! 432: Likewise for subtraction and for just copying. ! 433: These do not call protect_from_queue; caller must do so. */ ! 434: extern rtx gen_add2_insn (); ! 435: extern rtx gen_sub2_insn (); ! 436: extern rtx gen_move_insn (); ! 437: ! 438: /* Emit one rtl instruction to store zero in specified rtx. */ ! 439: extern void emit_clr_insn (); ! 440: ! 441: /* Emit one rtl insn to store 1 in specified rtx assuming it contains 0. */ ! 442: extern void emit_0_to_1_insn (); ! 443: ! 444: /* Emit one rtl insn to compare two rtx's. */ ! 445: extern void emit_cmp_insn (); ! 446: ! 447: /* Generate rtl to compate two rtx's, will call emit_cmp_insn. */ ! 448: extern rtx compare_from_rtx (); ! 449: ! 450: /* Emit some rtl insns to move data between rtx's, converting machine modes. ! 451: Both modes must be floating or both fixed. */ ! 452: extern void convert_move (); ! 453: ! 454: /* Convert an rtx to specified machine mode and return the result. */ ! 455: extern rtx convert_to_mode (); ! 456: ! 457: /* Emit code to push some arguments and call a library routine, ! 458: storing the value in a specified place. Calling sequence is ! 459: complicated. */ ! 460: extern void emit_library_call (); ! 461: ! 462: /* Given an rtx that may include add and multiply operations, ! 463: generate them as insns and return a pseudo-reg containing the value. ! 464: Useful after calling expand_expr with 1 as sum_ok. */ ! 465: extern rtx force_operand (); ! 466: ! 467: /* Return an rtx for the size in bytes of the value of an expr. */ ! 468: extern rtx expr_size (); ! 469: ! 470: /* Return an rtx for the sum of an rtx and an integer. */ ! 471: extern rtx plus_constant (); ! 472: ! 473: extern rtx lookup_static_chain (); ! 474: ! 475: /* Return an rtx like arg but sans any constant terms. ! 476: Returns the original rtx if it has no constant terms. ! 477: The constant terms are added and stored via a second arg. */ ! 478: extern rtx eliminate_constant_term (); ! 479: ! 480: /* Convert arg to a valid memory address for specified machine mode, ! 481: by emitting insns to perform arithmetic if nec. */ ! 482: extern rtx memory_address (); ! 483: ! 484: /* Like `memory_address' but pretent `flag_force_addr' is 0. */ ! 485: extern rtx memory_address_noforce (); ! 486: ! 487: /* Return a memory reference like MEMREF, but with its mode changed ! 488: to MODE and its address changed to ADDR. ! 489: (VOIDmode means don't change the mode. ! 490: NULL for ADDR means don't change the address.) */ ! 491: extern rtx change_address (); ! 492: ! 493: /* Return a memory reference like MEMREF, but which is known to have a ! 494: valid address. */ ! 495: ! 496: extern rtx validize_mem (); ! 497: ! 498: /* Convert a stack slot address ADDR valid in function FNDECL ! 499: into an address valid in this function (using a static chain). */ ! 500: extern rtx fix_lexical_addr (); ! 501: ! 502: /* Return the address of the trampoline for entering nested fn FUNCTION. */ ! 503: extern rtx trampoline_address (); ! 504: ! 505: /* Assemble the static constant template for function entry trampolines. */ ! 506: extern rtx assemble_trampoline_template (); ! 507: ! 508: /* Return 1 if two rtx's are equivalent in structure and elements. */ ! 509: extern int rtx_equal_p (); ! 510: ! 511: /* Given rtx, return new rtx whose address won't be affected by ! 512: any side effects. It has been copied to a new temporary reg. */ ! 513: extern rtx stabilize (); ! 514: ! 515: /* Given an rtx, copy all regs it refers to into new temps ! 516: and return a modified copy that refers to the new temps. */ ! 517: extern rtx copy_all_regs (); ! 518: ! 519: /* Copy given rtx to a new temp reg and return that. */ ! 520: extern rtx copy_to_reg (); ! 521: ! 522: /* Like copy_to_reg but always make the reg Pmode. */ ! 523: extern rtx copy_addr_to_reg (); ! 524: ! 525: /* Like copy_to_reg but always make the reg the specified mode MODE. */ ! 526: extern rtx copy_to_mode_reg (); ! 527: ! 528: /* Copy given rtx to given temp reg and return that. */ ! 529: extern rtx copy_to_suggested_reg (); ! 530: ! 531: /* Copy a value to a register if it isn't already a register. ! 532: Args are mode (in case value is a constant) and the value. */ ! 533: extern rtx force_reg (); ! 534: ! 535: /* Return given rtx, copied into a new temp reg if it was in memory. */ ! 536: extern rtx force_not_mem (); ! 537: ! 538: /* Remove some bytes from the stack. An rtx says how many. */ ! 539: extern void adjust_stack (); ! 540: ! 541: /* Add some bytes to the stack. An rtx says how many. */ ! 542: extern void anti_adjust_stack (); ! 543: ! 544: /* Allocate some space on the stack dynamically and return its address. An rtx ! 545: says how many bytes. */ ! 546: extern rtx allocate_dynamic_stack_space (); ! 547: ! 548: /* Emit code to copy function value to a new temp reg and return that reg. */ ! 549: extern rtx function_value (); ! 550: ! 551: /* Return an rtx that refers to the value returned by a function ! 552: in its original home. This becomes invalid if any more code is emitted. */ ! 553: extern rtx hard_function_value (); ! 554: ! 555: /* Return an rtx that refers to the value returned by a library call ! 556: in its original home. This becomes invalid if any more code is emitted. */ ! 557: extern rtx hard_libcall_value (); ! 558: ! 559: /* Emit code to copy function value to a specified place. */ ! 560: extern void copy_function_value (); ! 561: ! 562: /* Given an rtx, return an rtx for a value rounded up to a multiple ! 563: of STACK_BOUNDARY / BITS_PER_UNIT. */ ! 564: extern rtx round_push (); ! 565: ! 566: /* Push a block of length SIZE (perhaps variable) ! 567: and return an rtx to address the beginning of the block. */ ! 568: extern rtx push_block (); ! 569: ! 570: /* Generate code for computing expression EXP, ! 571: and storing the value into TARGET. ! 572: If SUGGEST_REG is nonzero, copy the value through a register ! 573: and return that register, if that is possible. */ ! 574: extern rtx store_expr (); ! 575: ! 576: extern rtx prepare_call_address (); ! 577: extern rtx expand_call (); ! 578: extern void emit_call_1 (); ! 579: ! 580: extern void emit_block_move (); ! 581: extern void emit_push_insn (); ! 582: extern void use_regs (); ! 583: extern void move_block_to_reg (); ! 584: ! 585: extern rtx store_bit_field (); ! 586: extern rtx extract_bit_field (); ! 587: extern rtx expand_shift (); ! 588: extern rtx expand_mult (); ! 589: extern rtx expand_divmod (); ! 590: extern rtx expand_mult_add (); ! 591: extern rtx expand_stmt_expr (); ! 592: extern rtx emit_no_conflict_block (); ! 593: extern void emit_libcall_block (); ! 594: ! 595: extern void jumpifnot (); ! 596: extern void jumpif (); ! 597: extern void do_jump (); ! 598: ! 599: extern rtx assemble_static_space (); ! 600: ! 601: extern void locate_and_pad_parm (); ! 602: ! 603: extern rtx expand_inline_function (); ! 604: ! 605: /* Hook called by expand_expr for language-specific tree codes. ! 606: It is up to the language front end to install a hook ! 607: if it has any such codes that expand_expr needs to know about. */ ! 608: extern rtx (*lang_expand_expr) ();
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.