expr.h revision 18334
1124758Semax/* Definitions for code generation pass of GNU compiler. 2124758Semax Copyright (C) 1987, 91, 92, 93, 94, 1995 Free Software Foundation, Inc. 3124758Semax 4124758SemaxThis file is part of GNU CC. 5124758Semax 6124758SemaxGNU CC is free software; you can redistribute it and/or modify 7124758Semaxit under the terms of the GNU General Public License as published by 8124758Semaxthe Free Software Foundation; either version 2, or (at your option) 9124758Semaxany later version. 10124758Semax 11124758SemaxGNU CC is distributed in the hope that it will be useful, 12124758Semaxbut WITHOUT ANY WARRANTY; without even the implied warranty of 13124758SemaxMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14124758SemaxGNU General Public License for more details. 15124758Semax 16124758SemaxYou should have received a copy of the GNU General Public License 17124758Semaxalong with GNU CC; see the file COPYING. If not, write to 18124758Semaxthe Free Software Foundation, 59 Temple Place - Suite 330, 19124758SemaxBoston, MA 02111-1307, USA. */ 20124758Semax 21124758Semax 22124758Semax#ifndef __STDC__ 23124758Semax#ifndef const 24124758Semax#define const 25124758Semax#endif 26124758Semax#endif 27124758Semax 28124758Semax/* The default branch cost is 1. */ 29124758Semax#ifndef BRANCH_COST 30124758Semax#define BRANCH_COST 1 31124758Semax#endif 32124758Semax 33124758Semax/* Macros to access the slots of a QUEUED rtx. 34124758Semax Here rather than in rtl.h because only the expansion pass 35124758Semax should ever encounter a QUEUED. */ 36124758Semax 37124758Semax/* The variable for which an increment is queued. */ 38124758Semax#define QUEUED_VAR(P) XEXP (P, 0) 39139721Semax/* If the increment has been emitted, this is the insn 40124758Semax that does the increment. It is zero before the increment is emitted. */ 41124758Semax#define QUEUED_INSN(P) XEXP (P, 1) 42124758Semax/* If a pre-increment copy has been generated, this is the copy 43124758Semax (it is a temporary reg). Zero if no copy made yet. */ 44124758Semax#define QUEUED_COPY(P) XEXP (P, 2) 45124758Semax/* This is the body to use for the insn to do the increment. 46124758Semax It is used to emit the increment. */ 47344146Shselasky#define QUEUED_BODY(P) XEXP (P, 3) 48344146Shselasky/* Next QUEUED in the queue. */ 49344146Shselasky#define QUEUED_NEXT(P) XEXP (P, 4) 50344146Shselasky 51344146Shselasky/* This is the 4th arg to `expand_expr'. 52344146Shselasky EXPAND_SUM means it is ok to return a PLUS rtx or MULT rtx. 53344146Shselasky EXPAND_INITIALIZER is similar but also record any labels on forced_labels. 54344146Shselasky EXPAND_CONST_ADDRESS means it is ok to return a MEM whose address 55344146Shselasky is a constant that is not a legitimate address. */ 56344146Shselaskyenum expand_modifier {EXPAND_NORMAL, EXPAND_SUM, 57344146Shselasky EXPAND_CONST_ADDRESS, EXPAND_INITIALIZER}; 58344146Shselasky 59344146Shselasky/* List of labels that must never be deleted. */ 60344146Shselaskyextern rtx forced_labels; 61344146Shselasky 62344146Shselasky/* List (chain of EXPR_LISTs) of pseudo-regs of SAVE_EXPRs. 63344146Shselasky So we can mark them all live at the end of the function, if stupid. */ 64344146Shselaskyextern rtx save_expr_regs; 65344146Shselasky 66344146Shselaskyextern int current_function_calls_alloca; 67344146Shselaskyextern int current_function_outgoing_args_size; 68344146Shselasky 69344146Shselasky/* This is the offset from the arg pointer to the place where the first 70344146Shselasky anonymous arg can be found, if there is one. */ 71344146Shselaskyextern rtx current_function_arg_offset_rtx; 72344146Shselasky 73344146Shselasky/* This is nonzero if the current function uses the constant pool. */ 74344146Shselaskyextern int current_function_uses_const_pool; 75344146Shselasky 76344146Shselasky/* This is nonzero if the current function uses pic_offset_table_rtx. */ 77344146Shselaskyextern int current_function_uses_pic_offset_table; 78344146Shselasky 79344146Shselasky/* The arg pointer hard register, or the pseudo into which it was copied. */ 80344146Shselaskyextern rtx current_function_internal_arg_pointer; 81344146Shselasky 82344146Shselasky/* Nonzero means stack pops must not be deferred, and deferred stack 83344146Shselasky pops must not be output. It is nonzero inside a function call, 84344146Shselasky inside a conditional expression, inside a statement expression, 85344146Shselasky and in other cases as well. */ 86344146Shselaskyextern int inhibit_defer_pop; 87344146Shselasky 88344146Shselasky/* Number of function calls seen so far in current function. */ 89344146Shselasky 90344146Shselaskyextern int function_call_count; 91344146Shselasky 92344146Shselasky/* RTX for stack slot that holds the current handler for nonlocal gotos. 93344146Shselasky Zero when function does not have nonlocal labels. */ 94344146Shselasky 95344146Shselaskyextern rtx nonlocal_goto_handler_slot; 96344146Shselasky 97344146Shselasky/* RTX for stack slot that holds the stack pointer value to restore 98344146Shselasky for a nonlocal goto. 99344146Shselasky Zero when function does not have nonlocal labels. */ 100344146Shselasky 101344146Shselaskyextern rtx nonlocal_goto_stack_level; 102344146Shselasky 103344146Shselasky/* List (chain of TREE_LIST) of LABEL_DECLs for all nonlocal labels 104344146Shselasky (labels to which there can be nonlocal gotos from nested functions) 105344146Shselasky in this function. */ 106344146Shselasky 107344146Shselasky#ifdef TREE_CODE /* Don't lose if tree.h not included. */ 108344146Shselaskyextern tree nonlocal_labels; 109344146Shselasky#endif 110344146Shselasky 111344146Shselasky#define NO_DEFER_POP (inhibit_defer_pop += 1) 112344146Shselasky#define OK_DEFER_POP (inhibit_defer_pop -= 1) 113344146Shselasky 114344146Shselasky/* Number of units that we should eventually pop off the stack. 115344146Shselasky These are the arguments to function calls that have already returned. */ 116344146Shselaskyextern int pending_stack_adjust; 117344146Shselasky 118344146Shselasky/* A list of all cleanups which belong to the arguments of 119344146Shselasky function calls being expanded by expand_call. */ 120344146Shselasky#ifdef TREE_CODE /* Don't lose if tree.h not included. */ 121344146Shselaskyextern tree cleanups_this_call; 122344146Shselasky#endif 123344146Shselasky 124344146Shselasky/* When temporaries are created by TARGET_EXPRs, they are created at 125344146Shselasky this level of temp_slot_level, so that they can remain allocated 126344146Shselasky until no longer needed. CLEANUP_POINT_EXPRs define the lifetime 127344146Shselasky of TARGET_EXPRs. */ 128344146Shselaskyextern int target_temp_slot_level; 129344146Shselasky 130344146Shselasky#ifdef TREE_CODE /* Don't lose if tree.h not included. */ 131344146Shselasky/* Structure to record the size of a sequence of arguments 132344146Shselasky as the sum of a tree-expression and a constant. */ 133344146Shselasky 134344146Shselaskystruct args_size 135344146Shselasky{ 136344146Shselasky int constant; 137344146Shselasky tree var; 138344146Shselasky}; 139344146Shselasky#endif 140344146Shselasky 141344146Shselasky/* Add the value of the tree INC to the `struct args_size' TO. */ 142344146Shselasky 143344146Shselasky#define ADD_PARM_SIZE(TO, INC) \ 144344146Shselasky{ tree inc = (INC); \ 145344146Shselasky if (TREE_CODE (inc) == INTEGER_CST) \ 146344146Shselasky (TO).constant += TREE_INT_CST_LOW (inc); \ 147344146Shselasky else if ((TO).var == 0) \ 148344146Shselasky (TO).var = inc; \ 149344146Shselasky else \ 150344146Shselasky (TO).var = size_binop (PLUS_EXPR, (TO).var, inc); } 151344146Shselasky 152344146Shselasky#define SUB_PARM_SIZE(TO, DEC) \ 153344146Shselasky{ tree dec = (DEC); \ 154344146Shselasky if (TREE_CODE (dec) == INTEGER_CST) \ 155344146Shselasky (TO).constant -= TREE_INT_CST_LOW (dec); \ 156344146Shselasky else if ((TO).var == 0) \ 157344146Shselasky (TO).var = size_binop (MINUS_EXPR, integer_zero_node, dec); \ 158344146Shselasky else \ 159344146Shselasky (TO).var = size_binop (MINUS_EXPR, (TO).var, dec); } 160344146Shselasky 161344146Shselasky/* Convert the implicit sum in a `struct args_size' into an rtx. */ 162344146Shselasky#define ARGS_SIZE_RTX(SIZE) \ 163344146Shselasky((SIZE).var == 0 ? GEN_INT ((SIZE).constant) \ 164344146Shselasky : expand_expr (size_binop (PLUS_EXPR, (SIZE).var, \ 165344146Shselasky size_int ((SIZE).constant)), \ 166344146Shselasky NULL_RTX, VOIDmode, 0)) 167344146Shselasky 168344146Shselasky/* Convert the implicit sum in a `struct args_size' into a tree. */ 169344146Shselasky#define ARGS_SIZE_TREE(SIZE) \ 170344146Shselasky((SIZE).var == 0 ? size_int ((SIZE).constant) \ 171344146Shselasky : size_binop (PLUS_EXPR, (SIZE).var, size_int ((SIZE).constant))) 172124758Semax 173124758Semax/* Supply a default definition for FUNCTION_ARG_PADDING: 174124758Semax usually pad upward, but pad short args downward on 175124758Semax big-endian machines. */ 176124758Semax 177124758Semaxenum direction {none, upward, downward}; /* Value has this type. */ 178124758Semax 179124758Semax#ifndef FUNCTION_ARG_PADDING 180124758Semax#define FUNCTION_ARG_PADDING(MODE, TYPE) \ 181124758Semax (! BYTES_BIG_ENDIAN \ 182124758Semax ? upward \ 183124758Semax : (((MODE) == BLKmode \ 184124758Semax ? ((TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \ 185124758Semax && int_size_in_bytes (TYPE) < (PARM_BOUNDARY / BITS_PER_UNIT)) \ 186124758Semax : GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY) \ 187139721Semax ? downward : upward)) 188139721Semax#endif 189124758Semax 190124758Semax/* Supply a default definition for FUNCTION_ARG_BOUNDARY. Normally, we let 191124758Semax FUNCTION_ARG_PADDING, which also pads the length, handle any needed 192124758Semax alignment. */ 193124758Semax 194124758Semax#ifndef FUNCTION_ARG_BOUNDARY 195124758Semax#define FUNCTION_ARG_BOUNDARY(MODE, TYPE) PARM_BOUNDARY 196124758Semax#endif 197124758Semax 198124758Semax/* Nonzero if we do not know how to pass TYPE solely in registers. 199124758Semax We cannot do so in the following cases: 200124758Semax 201124758Semax - if the type has variable size 202124758Semax - if the type is marked as addressable (it is required to be constructed 203124758Semax into the stack) 204124758Semax - if the padding and mode of the type is such that a copy into a register 205124758Semax would put it into the wrong part of the register. 206124758Semax 207124758Semax Which padding can't be supported depends on the byte endianness. 208124758Semax 209124758Semax A value in a register is implicitly padded at the most significant end. 210124758Semax On a big-endian machine, that is the lower end in memory. 211124758Semax So a value padded in memory at the upper end can't go in a register. 212124758Semax For a little-endian machine, the reverse is true. */ 213124758Semax 214124758Semax#define MUST_PASS_IN_STACK(MODE,TYPE) \ 215124758Semax ((TYPE) != 0 \ 216124758Semax && (TREE_CODE (TYPE_SIZE (TYPE)) != INTEGER_CST \ 217124758Semax || TREE_ADDRESSABLE (TYPE) \ 218124758Semax || ((MODE) == BLKmode \ 219124758Semax && ! ((TYPE) != 0 && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \ 220124758Semax && 0 == (int_size_in_bytes (TYPE) \ 221124758Semax % (PARM_BOUNDARY / BITS_PER_UNIT))) \ 222124758Semax && (FUNCTION_ARG_PADDING (MODE, TYPE) \ 223124758Semax == (BYTES_BIG_ENDIAN ? upward : downward))))) 224124758Semax 225124758Semax/* Nonzero if type TYPE should be returned in memory. 226124758Semax Most machines can use the following default definition. */ 227124758Semax 228124758Semax#ifndef RETURN_IN_MEMORY 229124758Semax#define RETURN_IN_MEMORY(TYPE) (TYPE_MODE (TYPE) == BLKmode) 230124758Semax#endif 231124758Semax 232124758Semax/* Optabs are tables saying how to generate insn bodies 233124758Semax for various machine modes and numbers of operands. 234124758Semax Each optab applies to one operation. 235124758Semax For example, add_optab applies to addition. 236124758Semax 237124758Semax The insn_code slot is the enum insn_code that says how to 238124758Semax generate an insn for this operation on a particular machine mode. 239124758Semax It is CODE_FOR_nothing if there is no such insn on the target machine. 240124758Semax 241124758Semax The `lib_call' slot is the name of the library function that 242124758Semax can be used to perform the operation. 243124758Semax 244124758Semax A few optabs, such as move_optab and cmp_optab, are used 245124758Semax by special code. */ 246124758Semax 247124758Semax/* Everything that uses expr.h needs to define enum insn_code 248124758Semax but we don't list it in the Makefile dependencies just for that. */ 249124758Semax#include "insn-codes.h" 250124758Semax 251124758Semaxtypedef struct optab 252124758Semax{ 253124758Semax enum rtx_code code; 254124758Semax struct { 255124758Semax enum insn_code insn_code; 256124758Semax rtx libfunc; 257124758Semax } handlers [NUM_MACHINE_MODES]; 258124758Semax} * optab; 259124758Semax 260124758Semax/* Given an enum insn_code, access the function to construct 261124758Semax the body of that kind of insn. */ 262124758Semax#ifdef FUNCTION_CONVERSION_BUG 263124758Semax/* Some compilers fail to convert a function properly to a 264124758Semax pointer-to-function when used as an argument. 265124758Semax So produce the pointer-to-function directly. 266124758Semax Luckily, these compilers seem to work properly when you 267124758Semax call the pointer-to-function. */ 268124758Semax#define GEN_FCN(CODE) (insn_gen_function[(int) (CODE)]) 269124758Semax#else 270124758Semax#define GEN_FCN(CODE) (*insn_gen_function[(int) (CODE)]) 271124758Semax#endif 272124758Semax 273124758Semaxextern rtx (*const insn_gen_function[]) (); 274124758Semax 275124758Semaxextern optab add_optab; 276124758Semaxextern optab sub_optab; 277124758Semaxextern optab smul_optab; /* Signed and floating-point multiply */ 278124758Semaxextern optab smul_highpart_optab; /* Signed multiply, return high word */ 279124758Semaxextern optab umul_highpart_optab; 280124758Semaxextern optab smul_widen_optab; /* Signed multiply with result 281124758Semax one machine mode wider than args */ 282124758Semaxextern optab umul_widen_optab; 283124758Semaxextern optab sdiv_optab; /* Signed divide */ 284124758Semaxextern optab sdivmod_optab; /* Signed divide-and-remainder in one */ 285124758Semaxextern optab udiv_optab; 286124758Semaxextern optab udivmod_optab; 287124758Semaxextern optab smod_optab; /* Signed remainder */ 288124758Semaxextern optab umod_optab; 289124758Semaxextern optab flodiv_optab; /* Optab for floating divide. */ 290124758Semaxextern optab ftrunc_optab; /* Convert float to integer in float fmt */ 291124758Semaxextern optab and_optab; /* Logical and */ 292124758Semaxextern optab ior_optab; /* Logical or */ 293124758Semaxextern optab xor_optab; /* Logical xor */ 294124758Semaxextern optab ashl_optab; /* Arithmetic shift left */ 295124758Semaxextern optab ashr_optab; /* Arithmetic shift right */ 296124758Semaxextern optab lshr_optab; /* Logical shift right */ 297124758Semaxextern optab rotl_optab; /* Rotate left */ 298124758Semaxextern optab rotr_optab; /* Rotate right */ 299124758Semaxextern optab smin_optab; /* Signed and floating-point minimum value */ 300124758Semaxextern optab smax_optab; /* Signed and floating-point maximum value */ 301124758Semaxextern optab umin_optab; /* Unsigned minimum value */ 302124758Semaxextern optab umax_optab; /* Unsigned maximum value */ 303124758Semax 304124758Semaxextern optab mov_optab; /* Move instruction. */ 305124758Semaxextern optab movstrict_optab; /* Move, preserving high part of register. */ 306124758Semax 307139721Semaxextern optab cmp_optab; /* Compare insn; two operands. */ 308139721Semaxextern optab tst_optab; /* tst insn; compare one operand against 0 */ 309139721Semax 310124758Semax/* Unary operations */ 311124758Semaxextern optab neg_optab; /* Negation */ 312124758Semaxextern optab abs_optab; /* Abs value */ 313139721Semaxextern optab one_cmpl_optab; /* Bitwise not */ 314139721Semaxextern optab ffs_optab; /* Find first bit set */ 315139721Semaxextern optab sqrt_optab; /* Square root */ 316139721Semaxextern optab sin_optab; /* Sine */ 317139721Semaxextern optab cos_optab; /* Cosine */ 318139721Semaxextern optab strlen_optab; /* String length */ 319139721Semax 320139721Semax/* Tables of patterns for extending one integer mode to another. */ 321139721Semaxextern enum insn_code extendtab[MAX_MACHINE_MODE][MAX_MACHINE_MODE][2]; 322139721Semax 323139721Semax/* Tables of patterns for converting between fixed and floating point. */ 324139721Semaxextern enum insn_code fixtab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2]; 325139721Semaxextern enum insn_code fixtrunctab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2]; 326139721Semaxextern enum insn_code floattab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2]; 327139721Semax 328139721Semax/* Contains the optab used for each rtx code. */ 329139721Semaxextern optab code_to_optab[NUM_RTX_CODE + 1]; 330139721Semax 331139721Semax/* Passed to expand_binop and expand_unop to say which options to try to use 332139721Semax if the requested operation can't be open-coded on the requisite mode. 333139721Semax Either OPTAB_LIB or OPTAB_LIB_WIDEN says try using a library call. 334124758Semax Either OPTAB_WIDEN or OPTAB_LIB_WIDEN says try using a wider mode. 335124758Semax OPTAB_MUST_WIDEN says try widening and don't try anything else. */ 336124758Semax 337124758Semaxenum optab_methods 338124758Semax{ 339124758Semax OPTAB_DIRECT, 340124758Semax OPTAB_LIB, 341124758Semax OPTAB_WIDEN, 342124758Semax OPTAB_LIB_WIDEN, 343124758Semax OPTAB_MUST_WIDEN 344124758Semax}; 345139721Semax 346139721Semax/* SYMBOL_REF rtx's for the library functions that are called 347139721Semax implicitly and not via optabs. */ 348139721Semax 349139721Semaxextern rtx extendsfdf2_libfunc; 350344146Shselaskyextern rtx extendsfxf2_libfunc; 351344146Shselaskyextern rtx extendsftf2_libfunc; 352124758Semaxextern rtx extenddfxf2_libfunc; 353124758Semaxextern rtx extenddftf2_libfunc; 354124758Semax 355124758Semaxextern rtx truncdfsf2_libfunc; 356124758Semaxextern rtx truncxfsf2_libfunc; 357124758Semaxextern rtx trunctfsf2_libfunc; 358124758Semaxextern rtx truncxfdf2_libfunc; 359124758Semaxextern rtx trunctfdf2_libfunc; 360124758Semax 361124758Semaxextern rtx memcpy_libfunc; 362124758Semaxextern rtx bcopy_libfunc; 363124758Semaxextern rtx memcmp_libfunc; 364124758Semaxextern rtx bcmp_libfunc; 365124758Semaxextern rtx memset_libfunc; 366124758Semaxextern rtx bzero_libfunc; 367124758Semax 368124758Semaxextern rtx eqhf2_libfunc; 369124758Semaxextern rtx nehf2_libfunc; 370124758Semaxextern rtx gthf2_libfunc; 371124758Semaxextern rtx gehf2_libfunc; 372124758Semaxextern rtx lthf2_libfunc; 373124758Semaxextern rtx lehf2_libfunc; 374124758Semax 375124758Semaxextern rtx eqsf2_libfunc; 376124758Semaxextern rtx nesf2_libfunc; 377124758Semaxextern rtx gtsf2_libfunc; 378124758Semaxextern rtx gesf2_libfunc; 379extern rtx ltsf2_libfunc; 380extern rtx lesf2_libfunc; 381 382extern rtx eqdf2_libfunc; 383extern rtx nedf2_libfunc; 384extern rtx gtdf2_libfunc; 385extern rtx gedf2_libfunc; 386extern rtx ltdf2_libfunc; 387extern rtx ledf2_libfunc; 388 389extern rtx eqxf2_libfunc; 390extern rtx nexf2_libfunc; 391extern rtx gtxf2_libfunc; 392extern rtx gexf2_libfunc; 393extern rtx ltxf2_libfunc; 394extern rtx lexf2_libfunc; 395 396extern rtx eqtf2_libfunc; 397extern rtx netf2_libfunc; 398extern rtx gttf2_libfunc; 399extern rtx getf2_libfunc; 400extern rtx lttf2_libfunc; 401extern rtx letf2_libfunc; 402 403extern rtx floatsisf_libfunc; 404extern rtx floatdisf_libfunc; 405extern rtx floattisf_libfunc; 406 407extern rtx floatsidf_libfunc; 408extern rtx floatdidf_libfunc; 409extern rtx floattidf_libfunc; 410 411extern rtx floatsixf_libfunc; 412extern rtx floatdixf_libfunc; 413extern rtx floattixf_libfunc; 414 415extern rtx floatsitf_libfunc; 416extern rtx floatditf_libfunc; 417extern rtx floattitf_libfunc; 418 419extern rtx fixsfsi_libfunc; 420extern rtx fixsfdi_libfunc; 421extern rtx fixsfti_libfunc; 422 423extern rtx fixdfsi_libfunc; 424extern rtx fixdfdi_libfunc; 425extern rtx fixdfti_libfunc; 426 427extern rtx fixxfsi_libfunc; 428extern rtx fixxfdi_libfunc; 429extern rtx fixxfti_libfunc; 430 431extern rtx fixtfsi_libfunc; 432extern rtx fixtfdi_libfunc; 433extern rtx fixtfti_libfunc; 434 435extern rtx fixunssfsi_libfunc; 436extern rtx fixunssfdi_libfunc; 437extern rtx fixunssfti_libfunc; 438 439extern rtx fixunsdfsi_libfunc; 440extern rtx fixunsdfdi_libfunc; 441extern rtx fixunsdfti_libfunc; 442 443extern rtx fixunsxfsi_libfunc; 444extern rtx fixunsxfdi_libfunc; 445extern rtx fixunsxfti_libfunc; 446 447extern rtx fixunstfsi_libfunc; 448extern rtx fixunstfdi_libfunc; 449extern rtx fixunstfti_libfunc; 450 451typedef rtx (*rtxfun) (); 452 453/* Indexed by the rtx-code for a conditional (eg. EQ, LT,...) 454 gives the gen_function to make a branch to test that condition. */ 455 456extern rtxfun bcc_gen_fctn[NUM_RTX_CODE]; 457 458/* Indexed by the rtx-code for a conditional (eg. EQ, LT,...) 459 gives the insn code to make a store-condition insn 460 to test that condition. */ 461 462extern enum insn_code setcc_gen_code[NUM_RTX_CODE]; 463 464#ifdef HAVE_conditional_move 465/* Indexed by the the machine mode, gives the insn code to make a conditional 466 move insn. */ 467 468extern enum insn_code movcc_gen_code[NUM_MACHINE_MODES]; 469#endif 470 471/* This array records the insn_code of insns to perform block moves. */ 472extern enum insn_code movstr_optab[NUM_MACHINE_MODES]; 473 474/* Define functions given in optabs.c. */ 475 476/* Expand a binary operation given optab and rtx operands. */ 477extern rtx expand_binop PROTO((enum machine_mode, optab, rtx, rtx, rtx, 478 int, enum optab_methods)); 479 480/* Expand a binary operation with both signed and unsigned forms. */ 481extern 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. */ 485extern int expand_twoval_binop PROTO((optab, rtx, rtx, rtx, rtx, int)); 486 487/* Expand a unary arithmetic operation given optab rtx operand. */ 488extern rtx expand_unop PROTO((enum machine_mode, optab, rtx, rtx, int)); 489 490/* Expand the absolute value operation. */ 491extern rtx expand_abs PROTO((enum machine_mode, rtx, rtx, int, int)); 492 493/* Expand the complex absolute value operation. */ 494extern rtx expand_complex_abs PROTO((enum machine_mode, rtx, rtx, int)); 495 496/* Generate an instruction with a given INSN_CODE with an output and 497 an input. */ 498extern 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. */ 502extern rtx emit_no_conflict_block PROTO((rtx, rtx, rtx, rtx, rtx)); 503 504/* Emit code to make a call to a constant function or a library call. */ 505extern void emit_libcall_block PROTO((rtx, rtx, rtx, rtx)); 506 507/* Emit one rtl instruction to store zero in specified rtx. */ 508extern void emit_clr_insn PROTO((rtx)); 509 510/* Emit one rtl insn to store 1 in specified rtx assuming it contains 0. */ 511extern void emit_0_to_1_insn PROTO((rtx)); 512 513/* Emit one rtl insn to compare two rtx's. */ 514extern 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). */ 519extern int can_compare_p PROTO((enum machine_mode)); 520 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.). */ 523extern void emit_float_lib_cmp PROTO((rtx, rtx, enum rtx_code)); 524 525/* Generate code to indirectly jump to a location given in the rtx LOC. */ 526extern void emit_indirect_jump PROTO((rtx)); 527 528#ifdef HAVE_conditional_move 529/* Emit a conditional move operation. */ 530rtx emit_conditional_move PROTO((rtx, enum rtx_code, rtx, rtx, 531 enum machine_mode, rtx, rtx, 532 enum machine_mode, int)); 533 534/* Return non-zero if the conditional move is supported. */ 535int can_conditionally_move_p PROTO((enum machine_mode mode)); 536#endif 537 538/* Create but don't emit one rtl instruction to add one rtx into another. 539 Modes must match; operands must meet the operation's predicates. 540 Likewise for subtraction and for just copying. 541 These do not call protect_from_queue; caller must do so. */ 542extern rtx gen_add2_insn PROTO((rtx, rtx)); 543extern rtx gen_sub2_insn PROTO((rtx, rtx)); 544extern rtx gen_move_insn PROTO((rtx, rtx)); 545extern int have_add2_insn PROTO((enum machine_mode)); 546extern int have_sub2_insn PROTO((enum machine_mode)); 547 548/* Return the INSN_CODE to use for an extend operation. */ 549extern enum insn_code can_extend_p PROTO((enum machine_mode, 550 enum machine_mode, int)); 551 552/* Generate the body of an insn to extend Y (with mode MFROM) 553 into X (with mode MTO). Do zero-extension if UNSIGNEDP is nonzero. */ 554extern rtx gen_extend_insn PROTO((rtx, rtx, enum machine_mode, 555 enum machine_mode, int)); 556 557/* Initialize the tables that control conversion between fixed and 558 floating values. */ 559extern void init_fixtab PROTO((void)); 560extern void init_floattab PROTO((void)); 561 562/* Generate code for a FLOAT_EXPR. */ 563extern void expand_float PROTO((rtx, rtx, int)); 564 565/* Generate code for a FIX_EXPR. */ 566extern void expand_fix PROTO((rtx, rtx, int)); 567 568/* Call this once to initialize the contents of the optabs 569 appropriately for the current target machine. */ 570extern void init_optabs PROTO((void)); 571 572/* Functions from expmed.c: */ 573 574/* Arguments MODE, RTX: return an rtx for the negation of that value. 575 May emit insns. */ 576extern rtx negate_rtx PROTO((enum machine_mode, rtx)); 577 578/* Expand a logical AND operation. */ 579extern rtx expand_and PROTO((rtx, rtx, rtx)); 580 581/* Emit a store-flag operation. */ 582extern rtx emit_store_flag PROTO((rtx, enum rtx_code, rtx, rtx, 583 enum machine_mode, int, int)); 584 585/* Functions from loop.c: */ 586 587/* Given a JUMP_INSN, return a description of the test being made. */ 588extern rtx get_condition PROTO((rtx, rtx *)); 589 590/* Functions from expr.c: */ 591 592/* This is run once per compilation to set up which modes can be used 593 directly in memory and to initialize the block move optab. */ 594extern void init_expr_once PROTO((void)); 595 596/* This is run at the start of compiling a function. */ 597extern void init_expr PROTO((void)); 598 599/* Use protect_from_queue to convert a QUEUED expression 600 into something that you can put immediately into an instruction. */ 601extern rtx protect_from_queue PROTO((rtx, int)); 602 603/* Perform all the pending incrementations. */ 604extern void emit_queue PROTO((void)); 605 606/* Emit some rtl insns to move data between rtx's, converting machine modes. 607 Both modes must be floating or both fixed. */ 608extern void convert_move PROTO((rtx, rtx, int)); 609 610/* Convert an rtx to specified machine mode and return the result. */ 611extern rtx convert_to_mode PROTO((enum machine_mode, rtx, int)); 612 613/* Convert an rtx to MODE from OLDMODE and return the result. */ 614extern rtx convert_modes PROTO((enum machine_mode, enum machine_mode, rtx, int)); 615 616/* Emit code to move a block Y to a block X. */ 617extern void emit_block_move PROTO((rtx, rtx, rtx, int)); 618 619/* Copy all or part of a value X into registers starting at REGNO. 620 The number of registers to be filled is NREGS. */ 621extern void move_block_to_reg PROTO((int, rtx, int, enum machine_mode)); 622 623/* Copy all or part of a BLKmode value X out of registers starting at REGNO. 624 The number of registers to be filled is NREGS. */ 625extern void move_block_from_reg PROTO((int, rtx, int, int)); 626 627/* Mark REG as holding a parameter for the next CALL_INSN. */ 628extern void use_reg PROTO((rtx*, rtx)); 629/* Mark NREGS consecutive regs, starting at REGNO, as holding parameters 630 for the next CALL_INSN. */ 631extern void use_regs PROTO((rtx*, int, int)); 632 633/* Write zeros through the storage of OBJECT. 634 If OBJECT has BLKmode, SIZE is its length in bytes. */ 635extern void clear_storage PROTO((rtx, rtx)); 636 637/* Emit insns to set X from Y. */ 638extern rtx emit_move_insn PROTO((rtx, rtx)); 639 640/* Emit insns to set X from Y, with no frills. */ 641extern rtx emit_move_insn_1 PROTO ((rtx, rtx)); 642 643/* Push a block of length SIZE (perhaps variable) 644 and return an rtx to address the beginning of the block. */ 645extern rtx push_block PROTO((rtx, int, int)); 646 647/* Make an operand to push something on the stack. */ 648extern rtx gen_push_operand PROTO((void)); 649 650#ifdef TREE_CODE 651/* Generate code to push something onto the stack, given its mode and type. */ 652extern void emit_push_insn PROTO((rtx, enum machine_mode, tree, rtx, int, 653 int, rtx, int, rtx, rtx)); 654 655/* Emit library call. */ 656extern void emit_library_call PVPROTO((rtx orgfun, int no_queue, 657 enum machine_mode outmode, int nargs, ...)); 658extern rtx emit_library_call_value PVPROTO((rtx orgfun, rtx value, int no_queue, 659 enum machine_mode outmode, int nargs, ...)); 660 661/* Expand an assignment that stores the value of FROM into TO. */ 662extern rtx expand_assignment PROTO((tree, tree, int, int)); 663 664/* Generate code for computing expression EXP, 665 and storing the value into TARGET. 666 If SUGGEST_REG is nonzero, copy the value through a register 667 and return that register, if that is possible. */ 668extern rtx store_expr PROTO((tree, rtx, int)); 669#endif 670 671/* Given an rtx that may include add and multiply operations, 672 generate them as insns and return a pseudo-reg containing the value. 673 Useful after calling expand_expr with 1 as sum_ok. */ 674extern rtx force_operand PROTO((rtx, rtx)); 675 676#ifdef TREE_CODE 677/* Generate code for computing expression EXP. 678 An rtx for the computed value is returned. The value is never null. 679 In the case of a void EXP, const0_rtx is returned. */ 680extern rtx expand_expr PROTO((tree, rtx, enum machine_mode, 681 enum expand_modifier)); 682#endif 683 684/* At the start of a function, record that we have no previously-pushed 685 arguments waiting to be popped. */ 686extern void init_pending_stack_adjust PROTO((void)); 687 688/* When exiting from function, if safe, clear out any pending stack adjust 689 so the adjustment won't get done. */ 690extern void clear_pending_stack_adjust PROTO((void)); 691 692/* Pop any previously-pushed arguments that have not been popped yet. */ 693extern void do_pending_stack_adjust PROTO((void)); 694 695#ifdef TREE_CODE 696/* Expand all cleanups up to OLD_CLEANUPS. */ 697extern void expand_cleanups_to PROTO((tree)); 698 699/* Generate code to evaluate EXP and jump to LABEL if the value is zero. */ 700extern void jumpifnot PROTO((tree, rtx)); 701 702/* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */ 703extern void jumpif PROTO((tree, rtx)); 704 705/* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if 706 the result is zero, or IF_TRUE_LABEL if the result is one. */ 707extern void do_jump PROTO((tree, rtx, rtx)); 708#endif 709 710/* Generate rtl to compare two rtx's, will call emit_cmp_insn. */ 711extern rtx compare_from_rtx PROTO((rtx, rtx, enum rtx_code, int, 712 enum machine_mode, rtx, int)); 713 714/* Generate a tablejump instruction (used for switch statements). */ 715extern void do_tablejump PROTO((rtx, enum machine_mode, rtx, rtx, rtx)); 716 717#ifdef TREE_CODE 718/* rtl.h and tree.h were included. */ 719/* Return an rtx for the size in bytes of the value of an expr. */ 720extern rtx expr_size PROTO((tree)); 721 722extern rtx lookup_static_chain PROTO((tree)); 723 724/* Convert a stack slot address ADDR valid in function FNDECL 725 into an address valid in this function (using a static chain). */ 726extern rtx fix_lexical_addr PROTO((rtx, tree)); 727 728/* Return the address of the trampoline for entering nested fn FUNCTION. */ 729extern rtx trampoline_address PROTO((tree)); 730 731/* Return an rtx that refers to the value returned by a function 732 in its original home. This becomes invalid if any more code is emitted. */ 733extern rtx hard_function_value PROTO((tree, tree)); 734 735extern rtx prepare_call_address PROTO((rtx, tree, rtx *, int)); 736 737extern rtx expand_call PROTO((tree, rtx, int)); 738 739extern rtx expand_shift PROTO((enum tree_code, enum machine_mode, rtx, tree, rtx, int)); 740extern rtx expand_divmod PROTO((int, enum tree_code, enum machine_mode, rtx, rtx, rtx, int)); 741extern void locate_and_pad_parm PROTO((enum machine_mode, tree, int, tree, struct args_size *, struct args_size *, struct args_size *)); 742extern rtx expand_inline_function PROTO((tree, tree, rtx, int, tree, rtx)); 743/* Return the CODE_LABEL rtx for a LABEL_DECL, creating it if necessary. */ 744extern rtx label_rtx PROTO((tree)); 745#endif 746 747/* Indicate how an input argument register was promoted. */ 748extern rtx promoted_input_arg PROTO((int, enum machine_mode *, int *)); 749 750/* Return an rtx like arg but sans any constant terms. 751 Returns the original rtx if it has no constant terms. 752 The constant terms are added and stored via a second arg. */ 753extern rtx eliminate_constant_term PROTO((rtx, rtx *)); 754 755/* Convert arg to a valid memory address for specified machine mode, 756 by emitting insns to perform arithmetic if nec. */ 757extern rtx memory_address PROTO((enum machine_mode, rtx)); 758 759/* Like `memory_address' but pretent `flag_force_addr' is 0. */ 760extern rtx memory_address_noforce PROTO((enum machine_mode, rtx)); 761 762/* Return a memory reference like MEMREF, but with its mode changed 763 to MODE and its address changed to ADDR. 764 (VOIDmode means don't change the mode. 765 NULL for ADDR means don't change the address.) */ 766extern rtx change_address PROTO((rtx, enum machine_mode, rtx)); 767 768/* Return a memory reference like MEMREF, but which is known to have a 769 valid address. */ 770 771extern rtx validize_mem PROTO((rtx)); 772 773/* Assemble the static constant template for function entry trampolines. */ 774extern rtx assemble_trampoline_template PROTO((void)); 775 776/* Return 1 if two rtx's are equivalent in structure and elements. */ 777extern int rtx_equal_p PROTO((rtx, rtx)); 778 779/* Given rtx, return new rtx whose address won't be affected by 780 any side effects. It has been copied to a new temporary reg. */ 781extern rtx stabilize PROTO((rtx)); 782 783/* Given an rtx, copy all regs it refers to into new temps 784 and return a modified copy that refers to the new temps. */ 785extern rtx copy_all_regs PROTO((rtx)); 786 787/* Copy given rtx to a new temp reg and return that. */ 788extern rtx copy_to_reg PROTO((rtx)); 789 790/* Like copy_to_reg but always make the reg Pmode. */ 791extern rtx copy_addr_to_reg PROTO((rtx)); 792 793/* Like copy_to_reg but always make the reg the specified mode MODE. */ 794extern rtx copy_to_mode_reg PROTO((enum machine_mode, rtx)); 795 796/* Copy given rtx to given temp reg and return that. */ 797extern rtx copy_to_suggested_reg PROTO((rtx, rtx, enum machine_mode)); 798 799/* Copy a value to a register if it isn't already a register. 800 Args are mode (in case value is a constant) and the value. */ 801extern rtx force_reg PROTO((enum machine_mode, rtx)); 802 803/* Return given rtx, copied into a new temp reg if it was in memory. */ 804extern rtx force_not_mem PROTO((rtx)); 805 806#ifdef TREE_CODE 807/* Return mode and signedness to use when object is promoted. */ 808extern enum machine_mode promote_mode PROTO((tree, enum machine_mode, 809 int *, int)); 810#endif 811 812/* Remove some bytes from the stack. An rtx says how many. */ 813extern void adjust_stack PROTO((rtx)); 814 815/* Add some bytes to the stack. An rtx says how many. */ 816extern void anti_adjust_stack PROTO((rtx)); 817 818/* This enum is used for the following two functions. */ 819enum save_level {SAVE_BLOCK, SAVE_FUNCTION, SAVE_NONLOCAL}; 820 821/* Save the stack pointer at the specified level. */ 822extern void emit_stack_save PROTO((enum save_level, rtx *, rtx)); 823 824/* Restore the stack pointer from a save area of the specified level. */ 825extern void emit_stack_restore PROTO((enum save_level, rtx, rtx)); 826 827/* Allocate some space on the stack dynamically and return its address. An rtx 828 says how many bytes. */ 829extern rtx allocate_dynamic_stack_space PROTO((rtx, rtx, int)); 830 831/* Emit code to copy function value to a new temp reg and return that reg. */ 832extern rtx function_value (); 833 834/* Return an rtx that refers to the value returned by a library call 835 in its original home. This becomes invalid if any more code is emitted. */ 836extern rtx hard_libcall_value PROTO((enum machine_mode)); 837 838/* Given an rtx, return an rtx for a value rounded up to a multiple 839 of STACK_BOUNDARY / BITS_PER_UNIT. */ 840extern rtx round_push PROTO((rtx)); 841 842extern void emit_block_move PROTO((rtx, rtx, rtx, int)); 843 844extern rtx store_bit_field PROTO((rtx, int, int, enum machine_mode, rtx, int, int)); 845extern rtx extract_bit_field PROTO((rtx, int, int, int, rtx, enum machine_mode, enum machine_mode, int, int)); 846extern rtx expand_mult PROTO((enum machine_mode, rtx, rtx, rtx, int)); 847extern rtx expand_mult_add PROTO((rtx, rtx, rtx, rtx,enum machine_mode, int)); 848 849extern rtx assemble_static_space PROTO((int)); 850 851/* Hook called by expand_expr for language-specific tree codes. 852 It is up to the language front end to install a hook 853 if it has any such codes that expand_expr needs to know about. */ 854extern rtx (*lang_expand_expr) (); 855