expr.h revision 52284
1274116Sdteske/* Definitions for code generation pass of GNU compiler. 2274116Sdteske Copyright (C) 1987, 91-98, 1999 Free Software Foundation, Inc. 3274116Sdteske 4274116SdteskeThis file is part of GNU CC. 5274116Sdteske 6274116SdteskeGNU CC is free software; you can redistribute it and/or modify 7274116Sdteskeit under the terms of the GNU General Public License as published by 8274116Sdteskethe Free Software Foundation; either version 2, or (at your option) 9274116Sdteskeany later version. 10274116Sdteske 11274116SdteskeGNU CC is distributed in the hope that it will be useful, 12274116Sdteskebut WITHOUT ANY WARRANTY; without even the implied warranty of 13274116SdteskeMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14274116SdteskeGNU General Public License for more details. 15274116Sdteske 16274116SdteskeYou should have received a copy of the GNU General Public License 17274116Sdteskealong with GNU CC; see the file COPYING. If not, write to 18274116Sdteskethe Free Software Foundation, 59 Temple Place - Suite 330, 19274116SdteskeBoston, MA 02111-1307, USA. */ 20274116Sdteske 21274116Sdteske/* The default branch cost is 1. */ 22274116Sdteske#ifndef BRANCH_COST 23274116Sdteske#define BRANCH_COST 1 24274116Sdteske#endif 25274116Sdteske 26274116Sdteske/* Macros to access the slots of a QUEUED rtx. 27274116Sdteske Here rather than in rtl.h because only the expansion pass 28274116Sdteske should ever encounter a QUEUED. */ 29274116Sdteske 30274116Sdteske/* The variable for which an increment is queued. */ 31274116Sdteske#define QUEUED_VAR(P) XEXP (P, 0) 32274116Sdteske/* If the increment has been emitted, this is the insn 33274116Sdteske that does the increment. It is zero before the increment is emitted. 34274116Sdteske If more than one insn is emitted, this is the first insn. */ 35274116Sdteske#define QUEUED_INSN(P) XEXP (P, 1) 36274116Sdteske/* If a pre-increment copy has been generated, this is the copy 37274116Sdteske (it is a temporary reg). Zero if no copy made yet. */ 38274116Sdteske#define QUEUED_COPY(P) XEXP (P, 2) 39274116Sdteske/* This is the body to use for the insn to do the increment. 40274116Sdteske It is used to emit the increment. */ 41274116Sdteske#define QUEUED_BODY(P) XEXP (P, 3) 42274116Sdteske/* Next QUEUED in the queue. */ 43274116Sdteske#define QUEUED_NEXT(P) XEXP (P, 4) 44274116Sdteske 45274116Sdteske/* This is the 4th arg to `expand_expr'. 46274116Sdteske EXPAND_SUM means it is ok to return a PLUS rtx or MULT rtx. 47274116Sdteske EXPAND_INITIALIZER is similar but also record any labels on forced_labels. 48274116Sdteske EXPAND_CONST_ADDRESS means it is ok to return a MEM whose address 49274116Sdteske is a constant that is not a legitimate address. 50274116Sdteske EXPAND_MEMORY_USE_* are explained below. */ 51274116Sdteskeenum expand_modifier {EXPAND_NORMAL, EXPAND_SUM, 52274116Sdteske EXPAND_CONST_ADDRESS, EXPAND_INITIALIZER, 53274116Sdteske EXPAND_MEMORY_USE_WO, EXPAND_MEMORY_USE_RW, 54274116Sdteske EXPAND_MEMORY_USE_BAD, EXPAND_MEMORY_USE_DONT}; 55274116Sdteske 56274116Sdteske/* Argument for chkr_* functions. 57274116Sdteske MEMORY_USE_RO: the pointer reads memory. 58274116Sdteske MEMORY_USE_WO: the pointer writes to memory. 59274116Sdteske MEMORY_USE_RW: the pointer modifies memory (ie it reads and writes). An 60 example is (*ptr)++ 61 MEMORY_USE_BAD: use this if you don't know the behavior of the pointer, or 62 if you know there are no pointers. Using an INDIRECT_REF 63 with MEMORY_USE_BAD will abort. 64 MEMORY_USE_TW: just test for writing, without update. Special. 65 MEMORY_USE_DONT: the memory is neither read nor written. This is used by 66 '->' and '.'. */ 67enum memory_use_mode {MEMORY_USE_BAD = 0, MEMORY_USE_RO = 1, 68 MEMORY_USE_WO = 2, MEMORY_USE_RW = 3, 69 MEMORY_USE_TW = 6, MEMORY_USE_DONT = 99}; 70 71/* List of labels that must never be deleted. */ 72extern rtx forced_labels; 73 74/* List (chain of EXPR_LISTs) of pseudo-regs of SAVE_EXPRs. 75 So we can mark them all live at the end of the function, if stupid. */ 76extern rtx save_expr_regs; 77 78extern int current_function_calls_alloca; 79extern int current_function_outgoing_args_size; 80 81/* This is the offset from the arg pointer to the place where the first 82 anonymous arg can be found, if there is one. */ 83extern rtx current_function_arg_offset_rtx; 84 85/* This is nonzero if the current function uses the constant pool. */ 86extern int current_function_uses_const_pool; 87 88/* This is nonzero if the current function uses pic_offset_table_rtx. */ 89extern int current_function_uses_pic_offset_table; 90 91/* The arg pointer hard register, or the pseudo into which it was copied. */ 92extern rtx current_function_internal_arg_pointer; 93 94/* This is nonzero if memory access checking be enabled in the current 95 function. */ 96extern int current_function_check_memory_usage; 97 98/* Under some ABIs, it is the caller's responsibility to pop arguments 99 pushed for function calls. A naive implementation would simply pop 100 the arguments immediately after each call. However, if several 101 function calls are made in a row, it is typically cheaper to pop 102 all the arguments after all of the calls are complete since a 103 single pop instruction can be used. Therefore, GCC attempts to 104 defer popping the arguments until absolutely necessary. (For 105 example, at the end of a conditional, the arguments must be popped, 106 since code outside the conditional won't know whether or not the 107 arguments need to be popped.) 108 109 When INHIBIT_DEFER_POP is non-zero, however, the compiler does not 110 attempt to defer pops. Instead, the stack is popped immediately 111 after each call. Rather then setting this variable directly, use 112 NO_DEFER_POP and OK_DEFER_POP. */ 113extern int inhibit_defer_pop; 114 115/* Prevent the compiler from deferring stack pops. See 116 inhibit_defer_pop for more information. */ 117#define NO_DEFER_POP (inhibit_defer_pop += 1) 118 119/* Allow the compiler to defer stack pops. See inhibit_defer_pop for 120 more information. */ 121#define OK_DEFER_POP (inhibit_defer_pop -= 1) 122 123/* Number of function calls seen so far in current function. */ 124 125extern int function_call_count; 126 127/* List (chain of EXPR_LIST) of stack slots that hold the current handlers 128 for nonlocal gotos. There is one for every nonlocal label in the function; 129 this list matches the one in nonlocal_labels. 130 Zero when function does not have nonlocal labels. */ 131 132extern rtx nonlocal_goto_handler_slots; 133 134/* RTX for stack slot that holds the stack pointer value to restore 135 for a nonlocal goto. 136 Zero when function does not have nonlocal labels. */ 137 138extern rtx nonlocal_goto_stack_level; 139 140/* List (chain of TREE_LIST) of LABEL_DECLs for all nonlocal labels 141 (labels to which there can be nonlocal gotos from nested functions) 142 in this function. */ 143 144#ifdef TREE_CODE /* Don't lose if tree.h not included. */ 145extern tree nonlocal_labels; 146#endif 147 148/* Number of units that we should eventually pop off the stack. 149 These are the arguments to function calls that have already returned. */ 150extern int pending_stack_adjust; 151 152/* When temporaries are created by TARGET_EXPRs, they are created at 153 this level of temp_slot_level, so that they can remain allocated 154 until no longer needed. CLEANUP_POINT_EXPRs define the lifetime 155 of TARGET_EXPRs. */ 156extern int target_temp_slot_level; 157 158/* Current level for normal temporaries. */ 159 160extern int temp_slot_level; 161 162#ifdef TREE_CODE /* Don't lose if tree.h not included. */ 163/* Structure to record the size of a sequence of arguments 164 as the sum of a tree-expression and a constant. */ 165 166struct args_size 167{ 168 HOST_WIDE_INT constant; 169 tree var; 170}; 171#endif 172 173/* Add the value of the tree INC to the `struct args_size' TO. */ 174 175#define ADD_PARM_SIZE(TO, INC) \ 176{ tree inc = (INC); \ 177 if (TREE_CODE (inc) == INTEGER_CST) \ 178 (TO).constant += TREE_INT_CST_LOW (inc); \ 179 else if ((TO).var == 0) \ 180 (TO).var = inc; \ 181 else \ 182 (TO).var = size_binop (PLUS_EXPR, (TO).var, inc); } 183 184#define SUB_PARM_SIZE(TO, DEC) \ 185{ tree dec = (DEC); \ 186 if (TREE_CODE (dec) == INTEGER_CST) \ 187 (TO).constant -= TREE_INT_CST_LOW (dec); \ 188 else if ((TO).var == 0) \ 189 (TO).var = size_binop (MINUS_EXPR, integer_zero_node, dec); \ 190 else \ 191 (TO).var = size_binop (MINUS_EXPR, (TO).var, dec); } 192 193/* Convert the implicit sum in a `struct args_size' into an rtx. */ 194#define ARGS_SIZE_RTX(SIZE) \ 195((SIZE).var == 0 ? GEN_INT ((SIZE).constant) \ 196 : expand_expr (size_binop (PLUS_EXPR, (SIZE).var, \ 197 size_int ((SIZE).constant)), \ 198 NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_BAD)) 199 200/* Convert the implicit sum in a `struct args_size' into a tree. */ 201#define ARGS_SIZE_TREE(SIZE) \ 202((SIZE).var == 0 ? size_int ((SIZE).constant) \ 203 : size_binop (PLUS_EXPR, (SIZE).var, size_int ((SIZE).constant))) 204 205/* Supply a default definition for FUNCTION_ARG_PADDING: 206 usually pad upward, but pad short args downward on 207 big-endian machines. */ 208 209enum direction {none, upward, downward}; /* Value has this type. */ 210 211#ifndef FUNCTION_ARG_PADDING 212#define FUNCTION_ARG_PADDING(MODE, TYPE) \ 213 (! BYTES_BIG_ENDIAN \ 214 ? upward \ 215 : (((MODE) == BLKmode \ 216 ? ((TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \ 217 && int_size_in_bytes (TYPE) < (PARM_BOUNDARY / BITS_PER_UNIT)) \ 218 : GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY) \ 219 ? downward : upward)) 220#endif 221 222/* Supply a default definition for FUNCTION_ARG_BOUNDARY. Normally, we let 223 FUNCTION_ARG_PADDING, which also pads the length, handle any needed 224 alignment. */ 225 226#ifndef FUNCTION_ARG_BOUNDARY 227#define FUNCTION_ARG_BOUNDARY(MODE, TYPE) PARM_BOUNDARY 228#endif 229 230/* Provide a default value for STRICT_ARGUMENT_NAMING. */ 231#ifndef STRICT_ARGUMENT_NAMING 232#define STRICT_ARGUMENT_NAMING 0 233#endif 234 235/* Provide a default value for PRETEND_OUTGOING_VARARGS_NAMED. */ 236#ifdef SETUP_INCOMING_VARARGS 237#ifndef PRETEND_OUTGOING_VARARGS_NAMED 238#define PRETEND_OUTGOING_VARARGS_NAMED 1 239#endif 240#else 241/* It is an error to define PRETEND_OUTGOING_VARARGS_NAMED without 242 defining SETUP_INCOMING_VARARGS. */ 243#define PRETEND_OUTGOING_VARARGS_NAMED 0 244#endif 245 246/* Nonzero if we do not know how to pass TYPE solely in registers. 247 We cannot do so in the following cases: 248 249 - if the type has variable size 250 - if the type is marked as addressable (it is required to be constructed 251 into the stack) 252 - if the padding and mode of the type is such that a copy into a register 253 would put it into the wrong part of the register. 254 255 Which padding can't be supported depends on the byte endianness. 256 257 A value in a register is implicitly padded at the most significant end. 258 On a big-endian machine, that is the lower end in memory. 259 So a value padded in memory at the upper end can't go in a register. 260 For a little-endian machine, the reverse is true. */ 261 262#ifndef MUST_PASS_IN_STACK 263#define MUST_PASS_IN_STACK(MODE,TYPE) \ 264 ((TYPE) != 0 \ 265 && (TREE_CODE (TYPE_SIZE (TYPE)) != INTEGER_CST \ 266 || TREE_ADDRESSABLE (TYPE) \ 267 || ((MODE) == BLKmode \ 268 && ! ((TYPE) != 0 && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \ 269 && 0 == (int_size_in_bytes (TYPE) \ 270 % (PARM_BOUNDARY / BITS_PER_UNIT))) \ 271 && (FUNCTION_ARG_PADDING (MODE, TYPE) \ 272 == (BYTES_BIG_ENDIAN ? upward : downward))))) 273#endif 274 275/* Nonzero if type TYPE should be returned in memory. 276 Most machines can use the following default definition. */ 277 278#ifndef RETURN_IN_MEMORY 279#define RETURN_IN_MEMORY(TYPE) (TYPE_MODE (TYPE) == BLKmode) 280#endif 281 282/* Supply a default definition of STACK_SAVEAREA_MODE for emit_stack_save. 283 Normally move_insn, so Pmode stack pointer. */ 284 285#ifndef STACK_SAVEAREA_MODE 286#define STACK_SAVEAREA_MODE(LEVEL) Pmode 287#endif 288 289/* Supply a default definition of STACK_SIZE_MODE for 290 allocate_dynamic_stack_space. Normally PLUS/MINUS, so word_mode. */ 291 292#ifndef STACK_SIZE_MODE 293#define STACK_SIZE_MODE word_mode 294#endif 295 296/* Provide default values for the macros controlling stack checking. */ 297 298#ifndef STACK_CHECK_BUILTIN 299#define STACK_CHECK_BUILTIN 0 300#endif 301 302/* The default interval is one page. */ 303#ifndef STACK_CHECK_PROBE_INTERVAL 304#define STACK_CHECK_PROBE_INTERVAL 4096 305#endif 306 307/* The default is to do a store into the stack. */ 308#ifndef STACK_CHECK_PROBE_LOAD 309#define STACK_CHECK_PROBE_LOAD 0 310#endif 311 312/* This value is arbitrary, but should be sufficient for most machines. */ 313#ifndef STACK_CHECK_PROTECT 314#define STACK_CHECK_PROTECT (75 * UNITS_PER_WORD) 315#endif 316 317/* Make the maximum frame size be the largest we can and still only need 318 one probe per function. */ 319#ifndef STACK_CHECK_MAX_FRAME_SIZE 320#define STACK_CHECK_MAX_FRAME_SIZE \ 321 (STACK_CHECK_PROBE_INTERVAL - UNITS_PER_WORD) 322#endif 323 324/* This is arbitrary, but should be large enough everywhere. */ 325#ifndef STACK_CHECK_FIXED_FRAME_SIZE 326#define STACK_CHECK_FIXED_FRAME_SIZE (4 * UNITS_PER_WORD) 327#endif 328 329/* Provide a reasonable default for the maximum size of an object to 330 allocate in the fixed frame. We may need to be able to make this 331 controllable by the user at some point. */ 332#ifndef STACK_CHECK_MAX_VAR_SIZE 333#define STACK_CHECK_MAX_VAR_SIZE (STACK_CHECK_MAX_FRAME_SIZE / 100) 334#endif 335 336/* Optabs are tables saying how to generate insn bodies 337 for various machine modes and numbers of operands. 338 Each optab applies to one operation. 339 For example, add_optab applies to addition. 340 341 The insn_code slot is the enum insn_code that says how to 342 generate an insn for this operation on a particular machine mode. 343 It is CODE_FOR_nothing if there is no such insn on the target machine. 344 345 The `lib_call' slot is the name of the library function that 346 can be used to perform the operation. 347 348 A few optabs, such as move_optab and cmp_optab, are used 349 by special code. */ 350 351/* Everything that uses expr.h needs to define enum insn_code 352 but we don't list it in the Makefile dependencies just for that. */ 353#include "insn-codes.h" 354 355typedef struct optab 356{ 357 enum rtx_code code; 358 struct { 359 enum insn_code insn_code; 360 rtx libfunc; 361 } handlers [NUM_MACHINE_MODES]; 362} * optab; 363 364/* Given an enum insn_code, access the function to construct 365 the body of that kind of insn. */ 366#ifdef FUNCTION_CONVERSION_BUG 367/* Some compilers fail to convert a function properly to a 368 pointer-to-function when used as an argument. 369 So produce the pointer-to-function directly. 370 Luckily, these compilers seem to work properly when you 371 call the pointer-to-function. */ 372#define GEN_FCN(CODE) (insn_gen_function[(int) (CODE)]) 373#else 374#define GEN_FCN(CODE) (*insn_gen_function[(int) (CODE)]) 375#endif 376 377extern rtx (*const insn_gen_function[]) PROTO ((rtx, ...)); 378 379extern optab add_optab; 380extern optab sub_optab; 381extern optab smul_optab; /* Signed and floating-point multiply */ 382extern optab smul_highpart_optab; /* Signed multiply, return high word */ 383extern optab umul_highpart_optab; 384extern optab smul_widen_optab; /* Signed multiply with result 385 one machine mode wider than args */ 386extern optab umul_widen_optab; 387extern optab sdiv_optab; /* Signed divide */ 388extern optab sdivmod_optab; /* Signed divide-and-remainder in one */ 389extern optab udiv_optab; 390extern optab udivmod_optab; 391extern optab smod_optab; /* Signed remainder */ 392extern optab umod_optab; 393extern optab flodiv_optab; /* Optab for floating divide. */ 394extern optab ftrunc_optab; /* Convert float to integer in float fmt */ 395extern optab and_optab; /* Logical and */ 396extern optab ior_optab; /* Logical or */ 397extern optab xor_optab; /* Logical xor */ 398extern optab ashl_optab; /* Arithmetic shift left */ 399extern optab ashr_optab; /* Arithmetic shift right */ 400extern optab lshr_optab; /* Logical shift right */ 401extern optab rotl_optab; /* Rotate left */ 402extern optab rotr_optab; /* Rotate right */ 403extern optab smin_optab; /* Signed and floating-point minimum value */ 404extern optab smax_optab; /* Signed and floating-point maximum value */ 405extern optab umin_optab; /* Unsigned minimum value */ 406extern optab umax_optab; /* Unsigned maximum value */ 407 408extern optab mov_optab; /* Move instruction. */ 409extern optab movstrict_optab; /* Move, preserving high part of register. */ 410 411extern optab cmp_optab; /* Compare insn; two operands. */ 412extern optab tst_optab; /* tst insn; compare one operand against 0 */ 413 414/* Unary operations */ 415extern optab neg_optab; /* Negation */ 416extern optab abs_optab; /* Abs value */ 417extern optab one_cmpl_optab; /* Bitwise not */ 418extern optab ffs_optab; /* Find first bit set */ 419extern optab sqrt_optab; /* Square root */ 420extern optab sin_optab; /* Sine */ 421extern optab cos_optab; /* Cosine */ 422extern optab strlen_optab; /* String length */ 423 424/* Tables of patterns for extending one integer mode to another. */ 425extern enum insn_code extendtab[MAX_MACHINE_MODE][MAX_MACHINE_MODE][2]; 426 427/* Tables of patterns for converting between fixed and floating point. */ 428extern enum insn_code fixtab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2]; 429extern enum insn_code fixtrunctab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2]; 430extern enum insn_code floattab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2]; 431 432/* Contains the optab used for each rtx code. */ 433extern optab code_to_optab[NUM_RTX_CODE + 1]; 434 435/* Passed to expand_binop and expand_unop to say which options to try to use 436 if the requested operation can't be open-coded on the requisite mode. 437 Either OPTAB_LIB or OPTAB_LIB_WIDEN says try using a library call. 438 Either OPTAB_WIDEN or OPTAB_LIB_WIDEN says try using a wider mode. 439 OPTAB_MUST_WIDEN says try widening and don't try anything else. */ 440 441enum optab_methods 442{ 443 OPTAB_DIRECT, 444 OPTAB_LIB, 445 OPTAB_WIDEN, 446 OPTAB_LIB_WIDEN, 447 OPTAB_MUST_WIDEN 448}; 449 450/* SYMBOL_REF rtx's for the library functions that are called 451 implicitly and not via optabs. */ 452 453extern rtx extendsfdf2_libfunc; 454extern rtx extendsfxf2_libfunc; 455extern rtx extendsftf2_libfunc; 456extern rtx extenddfxf2_libfunc; 457extern rtx extenddftf2_libfunc; 458 459extern rtx truncdfsf2_libfunc; 460extern rtx truncxfsf2_libfunc; 461extern rtx trunctfsf2_libfunc; 462extern rtx truncxfdf2_libfunc; 463extern rtx trunctfdf2_libfunc; 464 465extern rtx memcpy_libfunc; 466extern rtx bcopy_libfunc; 467extern rtx memcmp_libfunc; 468extern rtx bcmp_libfunc; 469extern rtx memset_libfunc; 470extern rtx bzero_libfunc; 471 472extern rtx throw_libfunc; 473extern rtx rethrow_libfunc; 474extern rtx sjthrow_libfunc; 475extern rtx sjpopnthrow_libfunc; 476extern rtx terminate_libfunc; 477extern rtx setjmp_libfunc; 478extern rtx longjmp_libfunc; 479extern rtx eh_rtime_match_libfunc; 480 481extern rtx eqhf2_libfunc; 482extern rtx nehf2_libfunc; 483extern rtx gthf2_libfunc; 484extern rtx gehf2_libfunc; 485extern rtx lthf2_libfunc; 486extern rtx lehf2_libfunc; 487 488extern rtx eqsf2_libfunc; 489extern rtx nesf2_libfunc; 490extern rtx gtsf2_libfunc; 491extern rtx gesf2_libfunc; 492extern rtx ltsf2_libfunc; 493extern rtx lesf2_libfunc; 494 495extern rtx eqdf2_libfunc; 496extern rtx nedf2_libfunc; 497extern rtx gtdf2_libfunc; 498extern rtx gedf2_libfunc; 499extern rtx ltdf2_libfunc; 500extern rtx ledf2_libfunc; 501 502extern rtx eqxf2_libfunc; 503extern rtx nexf2_libfunc; 504extern rtx gtxf2_libfunc; 505extern rtx gexf2_libfunc; 506extern rtx ltxf2_libfunc; 507extern rtx lexf2_libfunc; 508 509extern rtx eqtf2_libfunc; 510extern rtx netf2_libfunc; 511extern rtx gttf2_libfunc; 512extern rtx getf2_libfunc; 513extern rtx lttf2_libfunc; 514extern rtx letf2_libfunc; 515 516extern rtx floatsisf_libfunc; 517extern rtx floatdisf_libfunc; 518extern rtx floattisf_libfunc; 519 520extern rtx floatsidf_libfunc; 521extern rtx floatdidf_libfunc; 522extern rtx floattidf_libfunc; 523 524extern rtx floatsixf_libfunc; 525extern rtx floatdixf_libfunc; 526extern rtx floattixf_libfunc; 527 528extern rtx floatsitf_libfunc; 529extern rtx floatditf_libfunc; 530extern rtx floattitf_libfunc; 531 532extern rtx fixsfsi_libfunc; 533extern rtx fixsfdi_libfunc; 534extern rtx fixsfti_libfunc; 535 536extern rtx fixdfsi_libfunc; 537extern rtx fixdfdi_libfunc; 538extern rtx fixdfti_libfunc; 539 540extern rtx fixxfsi_libfunc; 541extern rtx fixxfdi_libfunc; 542extern rtx fixxfti_libfunc; 543 544extern rtx fixtfsi_libfunc; 545extern rtx fixtfdi_libfunc; 546extern rtx fixtfti_libfunc; 547 548extern rtx fixunssfsi_libfunc; 549extern rtx fixunssfdi_libfunc; 550extern rtx fixunssfti_libfunc; 551 552extern rtx fixunsdfsi_libfunc; 553extern rtx fixunsdfdi_libfunc; 554extern rtx fixunsdfti_libfunc; 555 556extern rtx fixunsxfsi_libfunc; 557extern rtx fixunsxfdi_libfunc; 558extern rtx fixunsxfti_libfunc; 559 560extern rtx fixunstfsi_libfunc; 561extern rtx fixunstfdi_libfunc; 562extern rtx fixunstfti_libfunc; 563 564/* For check-memory-usage. */ 565extern rtx chkr_check_addr_libfunc; 566extern rtx chkr_set_right_libfunc; 567extern rtx chkr_copy_bitmap_libfunc; 568extern rtx chkr_check_exec_libfunc; 569extern rtx chkr_check_str_libfunc; 570 571/* For instrument-functions. */ 572extern rtx profile_function_entry_libfunc; 573extern rtx profile_function_exit_libfunc; 574 575typedef rtx (*rtxfun) PROTO ((rtx)); 576 577/* Indexed by the rtx-code for a conditional (eg. EQ, LT,...) 578 gives the gen_function to make a branch to test that condition. */ 579 580extern rtxfun bcc_gen_fctn[NUM_RTX_CODE]; 581 582/* Indexed by the rtx-code for a conditional (eg. EQ, LT,...) 583 gives the insn code to make a store-condition insn 584 to test that condition. */ 585 586extern enum insn_code setcc_gen_code[NUM_RTX_CODE]; 587 588#ifdef HAVE_conditional_move 589/* Indexed by the machine mode, gives the insn code to make a conditional 590 move insn. */ 591 592extern enum insn_code movcc_gen_code[NUM_MACHINE_MODES]; 593#endif 594 595/* This array records the insn_code of insns to perform block moves. */ 596extern enum insn_code movstr_optab[NUM_MACHINE_MODES]; 597 598/* This array records the insn_code of insns to perform block clears. */ 599extern enum insn_code clrstr_optab[NUM_MACHINE_MODES]; 600 601/* Define functions given in optabs.c. */ 602 603/* Expand a binary operation given optab and rtx operands. */ 604extern rtx expand_binop PROTO((enum machine_mode, optab, rtx, rtx, rtx, 605 int, enum optab_methods)); 606 607/* Expand a binary operation with both signed and unsigned forms. */ 608extern rtx sign_expand_binop PROTO((enum machine_mode, optab, optab, rtx, 609 rtx, rtx, int, enum optab_methods)); 610 611/* Generate code to perform an operation on two operands with two results. */ 612extern int expand_twoval_binop PROTO((optab, rtx, rtx, rtx, rtx, int)); 613 614/* Expand a unary arithmetic operation given optab rtx operand. */ 615extern rtx expand_unop PROTO((enum machine_mode, optab, rtx, rtx, int)); 616 617/* Expand the absolute value operation. */ 618extern rtx expand_abs PROTO((enum machine_mode, rtx, rtx, int)); 619 620/* Expand the complex absolute value operation. */ 621extern rtx expand_complex_abs PROTO((enum machine_mode, rtx, rtx, int)); 622 623/* Generate an instruction with a given INSN_CODE with an output and 624 an input. */ 625extern void emit_unop_insn PROTO((int, rtx, rtx, enum rtx_code)); 626 627/* Emit code to perform a series of operations on a multi-word quantity, one 628 word at a time. */ 629extern rtx emit_no_conflict_block PROTO((rtx, rtx, rtx, rtx, rtx)); 630 631/* Emit code to make a call to a constant function or a library call. */ 632extern void emit_libcall_block PROTO((rtx, rtx, rtx, rtx)); 633 634/* Emit one rtl instruction to store zero in specified rtx. */ 635extern void emit_clr_insn PROTO((rtx)); 636 637/* Emit one rtl insn to store 1 in specified rtx assuming it contains 0. */ 638extern void emit_0_to_1_insn PROTO((rtx)); 639 640/* Emit one rtl insn to compare two rtx's. */ 641extern void emit_cmp_insn PROTO((rtx, rtx, enum rtx_code, rtx, 642 enum machine_mode, int, int)); 643 644/* Emit a pair of rtl insns to compare two rtx's and to jump 645 to a label if the comparison is true. */ 646extern void emit_cmp_and_jump_insns PROTO((rtx, rtx, enum rtx_code, rtx, 647 enum machine_mode, int, int, rtx)); 648 649/* Nonzero if a compare of mode MODE can be done straightforwardly 650 (without splitting it into pieces). */ 651extern int can_compare_p PROTO((enum machine_mode)); 652 653/* Emit a library call comparison between floating point X and Y. 654 COMPARISON is the rtl operator to compare with (EQ, NE, GT, etc.). */ 655extern void emit_float_lib_cmp PROTO((rtx, rtx, enum rtx_code)); 656 657/* Generate code to indirectly jump to a location given in the rtx LOC. */ 658extern void emit_indirect_jump PROTO((rtx)); 659 660#ifdef HAVE_conditional_move 661/* Emit a conditional move operation. */ 662rtx emit_conditional_move PROTO((rtx, enum rtx_code, rtx, rtx, 663 enum machine_mode, rtx, rtx, 664 enum machine_mode, int)); 665 666/* Return non-zero if the conditional move is supported. */ 667int can_conditionally_move_p PROTO((enum machine_mode mode)); 668 669#endif 670 671/* Create but don't emit one rtl instruction to add one rtx into another. 672 Modes must match; operands must meet the operation's predicates. 673 Likewise for subtraction and for just copying. 674 These do not call protect_from_queue; caller must do so. */ 675extern rtx gen_add2_insn PROTO((rtx, rtx)); 676extern rtx gen_sub2_insn PROTO((rtx, rtx)); 677extern rtx gen_move_insn PROTO((rtx, rtx)); 678extern int have_add2_insn PROTO((enum machine_mode)); 679extern int have_sub2_insn PROTO((enum machine_mode)); 680 681/* Return the INSN_CODE to use for an extend operation. */ 682extern enum insn_code can_extend_p PROTO((enum machine_mode, 683 enum machine_mode, int)); 684 685/* Generate the body of an insn to extend Y (with mode MFROM) 686 into X (with mode MTO). Do zero-extension if UNSIGNEDP is nonzero. */ 687extern rtx gen_extend_insn PROTO((rtx, rtx, enum machine_mode, 688 enum machine_mode, int)); 689 690/* Initialize the tables that control conversion between fixed and 691 floating values. */ 692extern void init_fixtab PROTO((void)); 693extern void init_floattab PROTO((void)); 694 695/* Generate code for a FLOAT_EXPR. */ 696extern void expand_float PROTO((rtx, rtx, int)); 697 698/* Generate code for a FIX_EXPR. */ 699extern void expand_fix PROTO((rtx, rtx, int)); 700 701/* Call this once to initialize the contents of the optabs 702 appropriately for the current target machine. */ 703extern void init_optabs PROTO((void)); 704 705/* Functions from expmed.c: */ 706 707/* Arguments MODE, RTX: return an rtx for the negation of that value. 708 May emit insns. */ 709extern rtx negate_rtx PROTO((enum machine_mode, rtx)); 710 711/* Expand a logical AND operation. */ 712extern rtx expand_and PROTO((rtx, rtx, rtx)); 713 714/* Emit a store-flag operation. */ 715extern rtx emit_store_flag PROTO((rtx, enum rtx_code, rtx, rtx, 716 enum machine_mode, int, int)); 717 718/* Like emit_store_flag, but always succeeds. */ 719extern rtx emit_store_flag_force PROTO((rtx, enum rtx_code, rtx, rtx, 720 enum machine_mode, int, int)); 721 722/* Functions from loop.c: */ 723 724/* Given a JUMP_INSN, return a description of the test being made. */ 725extern rtx get_condition PROTO((rtx, rtx *)); 726 727/* Generate a conditional trap instruction. */ 728extern rtx gen_cond_trap PROTO((enum rtx_code, rtx, rtx, rtx)); 729 730/* Functions from expr.c: */ 731 732/* This is run once per compilation to set up which modes can be used 733 directly in memory and to initialize the block move optab. */ 734extern void init_expr_once PROTO((void)); 735 736/* This is run at the start of compiling a function. */ 737extern void init_expr PROTO((void)); 738 739/* Use protect_from_queue to convert a QUEUED expression 740 into something that you can put immediately into an instruction. */ 741extern rtx protect_from_queue PROTO((rtx, int)); 742 743/* Perform all the pending incrementations. */ 744extern void emit_queue PROTO((void)); 745 746/* Tell if something has a queued subexpression. */ 747extern int queued_subexp_p PROTO((rtx)); 748 749/* Emit some rtl insns to move data between rtx's, converting machine modes. 750 Both modes must be floating or both fixed. */ 751extern void convert_move PROTO((rtx, rtx, int)); 752 753/* Convert an rtx to specified machine mode and return the result. */ 754extern rtx convert_to_mode PROTO((enum machine_mode, rtx, int)); 755 756/* Convert an rtx to MODE from OLDMODE and return the result. */ 757extern rtx convert_modes PROTO((enum machine_mode, enum machine_mode, rtx, int)); 758 759/* Emit code to move a block Y to a block X. */ 760extern rtx emit_block_move PROTO((rtx, rtx, rtx, int)); 761 762/* Copy all or part of a value X into registers starting at REGNO. 763 The number of registers to be filled is NREGS. */ 764extern void move_block_to_reg PROTO((int, rtx, int, enum machine_mode)); 765 766/* Copy all or part of a BLKmode value X out of registers starting at REGNO. 767 The number of registers to be filled is NREGS. */ 768extern void move_block_from_reg PROTO((int, rtx, int, int)); 769 770/* Load a BLKmode value into non-consecutive registers represented by a 771 PARALLEL. */ 772extern void emit_group_load PROTO((rtx, rtx, int, int)); 773/* Store a BLKmode value from non-consecutive registers represented by a 774 PARALLEL. */ 775extern void emit_group_store PROTO((rtx, rtx, int, int)); 776 777#ifdef TREE_CODE 778/* Copy BLKmode object from a set of registers. */ 779extern rtx copy_blkmode_from_reg PROTO((rtx,rtx,tree)); 780#endif 781 782/* Mark REG as holding a parameter for the next CALL_INSN. */ 783extern void use_reg PROTO((rtx *, rtx)); 784/* Mark NREGS consecutive regs, starting at REGNO, as holding parameters 785 for the next CALL_INSN. */ 786extern void use_regs PROTO((rtx *, int, int)); 787/* Mark a PARALLEL as holding a parameter for the next CALL_INSN. */ 788extern void use_group_regs PROTO((rtx *, rtx)); 789 790/* Write zeros through the storage of OBJECT. 791 If OBJECT has BLKmode, SIZE is its length in bytes and ALIGN is its 792 alignment. */ 793extern rtx clear_storage PROTO((rtx, rtx, int)); 794 795/* Emit insns to set X from Y. */ 796extern rtx emit_move_insn PROTO((rtx, rtx)); 797 798/* Emit insns to set X from Y, with no frills. */ 799extern rtx emit_move_insn_1 PROTO ((rtx, rtx)); 800 801/* Push a block of length SIZE (perhaps variable) 802 and return an rtx to address the beginning of the block. */ 803extern rtx push_block PROTO((rtx, int, int)); 804 805/* Make an operand to push something on the stack. */ 806extern rtx gen_push_operand PROTO((void)); 807 808#ifdef TREE_CODE 809/* Generate code to push something onto the stack, given its mode and type. */ 810extern void emit_push_insn PROTO((rtx, enum machine_mode, tree, rtx, int, 811 int, rtx, int, rtx, rtx, int)); 812 813/* Emit library call. */ 814extern void emit_library_call PVPROTO((rtx orgfun, int no_queue, 815 enum machine_mode outmode, int nargs, ...)); 816extern rtx emit_library_call_value PVPROTO((rtx orgfun, rtx value, int no_queue, 817 enum machine_mode outmode, int nargs, ...)); 818 819/* Expand an assignment that stores the value of FROM into TO. */ 820extern rtx expand_assignment PROTO((tree, tree, int, int)); 821 822/* Generate code for computing expression EXP, 823 and storing the value into TARGET. 824 If SUGGEST_REG is nonzero, copy the value through a register 825 and return that register, if that is possible. */ 826extern rtx store_expr PROTO((tree, rtx, int)); 827#endif 828 829/* Given an rtx that may include add and multiply operations, 830 generate them as insns and return a pseudo-reg containing the value. 831 Useful after calling expand_expr with 1 as sum_ok. */ 832extern rtx force_operand PROTO((rtx, rtx)); 833 834extern rtx expand_builtin_setjmp PROTO((rtx, rtx, rtx, rtx)); 835 836#ifdef TREE_CODE 837/* Generate code for computing expression EXP. 838 An rtx for the computed value is returned. The value is never null. 839 In the case of a void EXP, const0_rtx is returned. */ 840extern rtx expand_expr PROTO((tree, rtx, enum machine_mode, 841 enum expand_modifier)); 842#endif 843 844/* At the start of a function, record that we have no previously-pushed 845 arguments waiting to be popped. */ 846extern void init_pending_stack_adjust PROTO((void)); 847 848/* When exiting from function, if safe, clear out any pending stack adjust 849 so the adjustment won't get done. */ 850extern void clear_pending_stack_adjust PROTO((void)); 851 852/* Pop any previously-pushed arguments that have not been popped yet. */ 853extern void do_pending_stack_adjust PROTO((void)); 854 855#ifdef TREE_CODE 856/* Generate code to evaluate EXP and jump to LABEL if the value is zero. */ 857extern void jumpifnot PROTO((tree, rtx)); 858 859/* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */ 860extern void jumpif PROTO((tree, rtx)); 861 862/* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if 863 the result is zero, or IF_TRUE_LABEL if the result is one. */ 864extern void do_jump PROTO((tree, rtx, rtx)); 865#endif 866 867/* Generate rtl to compare two rtx's, will call emit_cmp_insn. */ 868extern rtx compare_from_rtx PROTO((rtx, rtx, enum rtx_code, int, 869 enum machine_mode, rtx, int)); 870 871/* Generate a tablejump instruction (used for switch statements). */ 872extern void do_tablejump PROTO((rtx, enum machine_mode, rtx, rtx, rtx)); 873 874#ifdef TREE_CODE 875/* rtl.h and tree.h were included. */ 876/* Return an rtx for the size in bytes of the value of an expr. */ 877extern rtx expr_size PROTO((tree)); 878 879extern rtx lookup_static_chain PROTO((tree)); 880 881/* Convert a stack slot address ADDR valid in function FNDECL 882 into an address valid in this function (using a static chain). */ 883extern rtx fix_lexical_addr PROTO((rtx, tree)); 884 885/* Return the address of the trampoline for entering nested fn FUNCTION. */ 886extern rtx trampoline_address PROTO((tree)); 887 888/* Return an rtx that refers to the value returned by a function 889 in its original home. This becomes invalid if any more code is emitted. */ 890extern rtx hard_function_value PROTO((tree, tree)); 891 892extern rtx prepare_call_address PROTO((rtx, tree, rtx *, int)); 893 894extern rtx expand_call PROTO((tree, rtx, int)); 895 896extern rtx expand_shift PROTO((enum tree_code, enum machine_mode, rtx, tree, rtx, int)); 897extern rtx expand_divmod PROTO((int, enum tree_code, enum machine_mode, rtx, rtx, rtx, int)); 898extern void locate_and_pad_parm PROTO((enum machine_mode, tree, int, tree, struct args_size *, struct args_size *, struct args_size *)); 899extern rtx expand_inline_function PROTO((tree, tree, rtx, int, tree, rtx)); 900/* Return the CODE_LABEL rtx for a LABEL_DECL, creating it if necessary. */ 901extern rtx label_rtx PROTO((tree)); 902#endif 903 904/* Indicate how an input argument register was promoted. */ 905extern rtx promoted_input_arg PROTO((int, enum machine_mode *, int *)); 906 907/* Return an rtx like arg but sans any constant terms. 908 Returns the original rtx if it has no constant terms. 909 The constant terms are added and stored via a second arg. */ 910extern rtx eliminate_constant_term PROTO((rtx, rtx *)); 911 912/* Convert arg to a valid memory address for specified machine mode, 913 by emitting insns to perform arithmetic if nec. */ 914extern rtx memory_address PROTO((enum machine_mode, rtx)); 915 916/* Like `memory_address' but pretent `flag_force_addr' is 0. */ 917extern rtx memory_address_noforce PROTO((enum machine_mode, rtx)); 918 919/* Return a memory reference like MEMREF, but with its mode changed 920 to MODE and its address changed to ADDR. 921 (VOIDmode means don't change the mode. 922 NULL for ADDR means don't change the address.) */ 923extern rtx change_address PROTO((rtx, enum machine_mode, rtx)); 924 925/* Return a memory reference like MEMREF, but which is known to have a 926 valid address. */ 927 928extern rtx validize_mem PROTO((rtx)); 929 930/* Assemble the static constant template for function entry trampolines. */ 931extern rtx assemble_trampoline_template PROTO((void)); 932 933/* Return 1 if two rtx's are equivalent in structure and elements. */ 934extern int rtx_equal_p PROTO((rtx, rtx)); 935 936/* Given rtx, return new rtx whose address won't be affected by 937 any side effects. It has been copied to a new temporary reg. */ 938extern rtx stabilize PROTO((rtx)); 939 940/* Given an rtx, copy all regs it refers to into new temps 941 and return a modified copy that refers to the new temps. */ 942extern rtx copy_all_regs PROTO((rtx)); 943 944/* Copy given rtx to a new temp reg and return that. */ 945extern rtx copy_to_reg PROTO((rtx)); 946 947/* Like copy_to_reg but always make the reg Pmode. */ 948extern rtx copy_addr_to_reg PROTO((rtx)); 949 950/* Like copy_to_reg but always make the reg the specified mode MODE. */ 951extern rtx copy_to_mode_reg PROTO((enum machine_mode, rtx)); 952 953/* Copy given rtx to given temp reg and return that. */ 954extern rtx copy_to_suggested_reg PROTO((rtx, rtx, enum machine_mode)); 955 956/* Copy a value to a register if it isn't already a register. 957 Args are mode (in case value is a constant) and the value. */ 958extern rtx force_reg PROTO((enum machine_mode, rtx)); 959 960/* Return given rtx, copied into a new temp reg if it was in memory. */ 961extern rtx force_not_mem PROTO((rtx)); 962 963#ifdef TREE_CODE 964/* Return mode and signedness to use when object is promoted. */ 965extern enum machine_mode promote_mode PROTO((tree, enum machine_mode, 966 int *, int)); 967#endif 968 969/* Remove some bytes from the stack. An rtx says how many. */ 970extern void adjust_stack PROTO((rtx)); 971 972/* Add some bytes to the stack. An rtx says how many. */ 973extern void anti_adjust_stack PROTO((rtx)); 974 975/* This enum is used for the following two functions. */ 976enum save_level {SAVE_BLOCK, SAVE_FUNCTION, SAVE_NONLOCAL}; 977 978/* Save the stack pointer at the specified level. */ 979extern void emit_stack_save PROTO((enum save_level, rtx *, rtx)); 980 981/* Restore the stack pointer from a save area of the specified level. */ 982extern void emit_stack_restore PROTO((enum save_level, rtx, rtx)); 983 984/* Allocate some space on the stack dynamically and return its address. An rtx 985 says how many bytes. */ 986extern rtx allocate_dynamic_stack_space PROTO((rtx, rtx, int)); 987 988/* Probe a range of stack addresses from FIRST to FIRST+SIZE, inclusive. 989 FIRST is a constant and size is a Pmode RTX. These are offsets from the 990 current stack pointer. STACK_GROWS_DOWNWARD says whether to add or 991 subtract from the stack. If SIZE is constant, this is done 992 with a fixed number of probes. Otherwise, we must make a loop. */ 993extern void probe_stack_range PROTO((HOST_WIDE_INT, rtx)); 994 995/* Return an rtx that refers to the value returned by a library call 996 in its original home. This becomes invalid if any more code is emitted. */ 997extern rtx hard_libcall_value PROTO((enum machine_mode)); 998 999/* Given an rtx, return an rtx for a value rounded up to a multiple 1000 of STACK_BOUNDARY / BITS_PER_UNIT. */ 1001extern rtx round_push PROTO((rtx)); 1002 1003extern rtx store_bit_field PROTO((rtx, int, int, enum machine_mode, rtx, int, int)); 1004extern rtx extract_bit_field PROTO((rtx, int, int, int, rtx, enum machine_mode, enum machine_mode, int, int)); 1005extern rtx expand_mult PROTO((enum machine_mode, rtx, rtx, rtx, int)); 1006extern rtx expand_mult_add PROTO((rtx, rtx, rtx, rtx,enum machine_mode, int)); 1007extern rtx expand_mult_highpart_adjust PROTO((enum machine_mode, rtx, rtx, rtx, rtx, int)); 1008 1009extern rtx assemble_static_space PROTO((int)); 1010 1011/* Hook called by expand_expr for language-specific tree codes. 1012 It is up to the language front end to install a hook 1013 if it has any such codes that expand_expr needs to know about. */ 1014extern rtx (*lang_expand_expr) PROTO ((union tree_node *, rtx, 1015 enum machine_mode, 1016 enum expand_modifier modifier)); 1017 1018#ifdef TREE_CODE 1019/* Hook called by output_constant for language-specific tree codes. 1020 It is up to the language front-end to install a hook if it has any 1021 such codes that output_constant needs to know about. Returns a 1022 language-independent constant equivalent to its input. */ 1023extern tree (*lang_expand_constant) PROTO((tree)); 1024#endif 1025 1026extern void init_all_optabs PROTO ((void)); 1027extern void init_mov_optab PROTO ((void)); 1028extern void do_jump_by_parts_equality_rtx PROTO((rtx, rtx, rtx)); 1029extern void do_jump_by_parts_greater_rtx PROTO ((enum machine_mode, int, 1030 rtx, rtx, rtx, rtx)); 1031 1032#ifdef TREE_CODE /* Don't lose if tree.h not included. */ 1033extern void mark_seen_cases PROTO ((tree, unsigned char *, 1034 long, int)); 1035#endif 1036