expr.h revision 103445
1/* Definitions for code generation pass of GNU compiler. 2 Copyright (C) 1987, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 3 1999, 2000 Free Software Foundation, Inc. 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify it under 8the terms of the GNU General Public License as published by the Free 9Software Foundation; either version 2, or (at your option) any later 10version. 11 12GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13WARRANTY; without even the implied warranty of MERCHANTABILITY or 14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING. If not, write to the Free 19Software Foundation, 59 Temple Place - Suite 330, Boston, MA 2002111-1307, USA. */ 21 22/* The default branch cost is 1. */ 23#ifndef BRANCH_COST 24#define BRANCH_COST 1 25#endif 26 27/* Macros to access the slots of a QUEUED rtx. 28 Here rather than in rtl.h because only the expansion pass 29 should ever encounter a QUEUED. */ 30 31/* The variable for which an increment is queued. */ 32#define QUEUED_VAR(P) XEXP (P, 0) 33/* If the increment has been emitted, this is the insn 34 that does the increment. It is zero before the increment is emitted. 35 If more than one insn is emitted, this is the first insn. */ 36#define QUEUED_INSN(P) XEXP (P, 1) 37/* If a pre-increment copy has been generated, this is the copy 38 (it is a temporary reg). Zero if no copy made yet. */ 39#define QUEUED_COPY(P) XEXP (P, 2) 40/* This is the body to use for the insn to do the increment. 41 It is used to emit the increment. */ 42#define QUEUED_BODY(P) XEXP (P, 3) 43/* Next QUEUED in the queue. */ 44#define QUEUED_NEXT(P) XEXP (P, 4) 45 46/* This is the 4th arg to `expand_expr'. 47 EXPAND_SUM means it is ok to return a PLUS rtx or MULT rtx. 48 EXPAND_INITIALIZER is similar but also record any labels on forced_labels. 49 EXPAND_CONST_ADDRESS means it is ok to return a MEM whose address 50 is a constant that is not a legitimate address. 51 EXPAND_WRITE means we are only going to write to the resulting rtx. */ 52enum expand_modifier {EXPAND_NORMAL, EXPAND_SUM, EXPAND_CONST_ADDRESS, 53 EXPAND_INITIALIZER, EXPAND_WRITE}; 54 55/* Prevent the compiler from deferring stack pops. See 56 inhibit_defer_pop for more information. */ 57#define NO_DEFER_POP (inhibit_defer_pop += 1) 58 59/* Allow the compiler to defer stack pops. See inhibit_defer_pop for 60 more information. */ 61#define OK_DEFER_POP (inhibit_defer_pop -= 1) 62 63#ifdef TREE_CODE /* Don't lose if tree.h not included. */ 64/* Structure to record the size of a sequence of arguments 65 as the sum of a tree-expression and a constant. This structure is 66 also used to store offsets from the stack, which might be negative, 67 so the variable part must be ssizetype, not sizetype. */ 68 69struct args_size 70{ 71 HOST_WIDE_INT constant; 72 tree var; 73}; 74#endif 75 76/* Add the value of the tree INC to the `struct args_size' TO. */ 77 78#define ADD_PARM_SIZE(TO, INC) \ 79do { \ 80 tree inc = (INC); \ 81 if (host_integerp (inc, 0)) \ 82 (TO).constant += tree_low_cst (inc, 0); \ 83 else if ((TO).var == 0) \ 84 (TO).var = convert (ssizetype, inc); \ 85 else \ 86 (TO).var = size_binop (PLUS_EXPR, (TO).var, \ 87 convert (ssizetype, inc)); \ 88} while (0) 89 90#define SUB_PARM_SIZE(TO, DEC) \ 91do { \ 92 tree dec = (DEC); \ 93 if (host_integerp (dec, 0)) \ 94 (TO).constant -= tree_low_cst (dec, 0); \ 95 else if ((TO).var == 0) \ 96 (TO).var = size_binop (MINUS_EXPR, ssize_int (0), \ 97 convert (ssizetype, dec)); \ 98 else \ 99 (TO).var = size_binop (MINUS_EXPR, (TO).var, \ 100 convert (ssizetype, dec)); \ 101} while (0) 102 103/* Convert the implicit sum in a `struct args_size' into a tree 104 of type ssizetype. */ 105#define ARGS_SIZE_TREE(SIZE) \ 106((SIZE).var == 0 ? ssize_int ((SIZE).constant) \ 107 : size_binop (PLUS_EXPR, convert (ssizetype, (SIZE).var), \ 108 ssize_int ((SIZE).constant))) 109 110/* Convert the implicit sum in a `struct args_size' into an rtx. */ 111#define ARGS_SIZE_RTX(SIZE) \ 112((SIZE).var == 0 ? GEN_INT ((SIZE).constant) \ 113 : expand_expr (ARGS_SIZE_TREE (SIZE), NULL_RTX, VOIDmode, 0)) 114 115/* Supply a default definition for FUNCTION_ARG_PADDING: 116 usually pad upward, but pad short args downward on 117 big-endian machines. */ 118 119enum direction {none, upward, downward}; /* Value has this type. */ 120 121#ifndef FUNCTION_ARG_PADDING 122#define FUNCTION_ARG_PADDING(MODE, TYPE) \ 123 (! BYTES_BIG_ENDIAN \ 124 ? upward \ 125 : (((MODE) == BLKmode \ 126 ? ((TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \ 127 && int_size_in_bytes (TYPE) < (PARM_BOUNDARY / BITS_PER_UNIT)) \ 128 : GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY) \ 129 ? downward : upward)) 130#endif 131 132/* Supply a default definition for FUNCTION_ARG_BOUNDARY. Normally, we let 133 FUNCTION_ARG_PADDING, which also pads the length, handle any needed 134 alignment. */ 135 136#ifndef FUNCTION_ARG_BOUNDARY 137#define FUNCTION_ARG_BOUNDARY(MODE, TYPE) PARM_BOUNDARY 138#endif 139 140/* Provide a default value for STRICT_ARGUMENT_NAMING. */ 141#ifndef STRICT_ARGUMENT_NAMING 142#define STRICT_ARGUMENT_NAMING 0 143#endif 144 145/* Provide a default value for PRETEND_OUTGOING_VARARGS_NAMED. */ 146#ifdef SETUP_INCOMING_VARARGS 147#ifndef PRETEND_OUTGOING_VARARGS_NAMED 148#define PRETEND_OUTGOING_VARARGS_NAMED 1 149#endif 150#else 151/* It is an error to define PRETEND_OUTGOING_VARARGS_NAMED without 152 defining SETUP_INCOMING_VARARGS. */ 153#define PRETEND_OUTGOING_VARARGS_NAMED 0 154#endif 155 156/* Nonzero if we do not know how to pass TYPE solely in registers. 157 We cannot do so in the following cases: 158 159 - if the type has variable size 160 - if the type is marked as addressable (it is required to be constructed 161 into the stack) 162 - if the padding and mode of the type is such that a copy into a register 163 would put it into the wrong part of the register. 164 165 Which padding can't be supported depends on the byte endianness. 166 167 A value in a register is implicitly padded at the most significant end. 168 On a big-endian machine, that is the lower end in memory. 169 So a value padded in memory at the upper end can't go in a register. 170 For a little-endian machine, the reverse is true. */ 171 172#ifndef MUST_PASS_IN_STACK 173#define MUST_PASS_IN_STACK(MODE,TYPE) \ 174 ((TYPE) != 0 \ 175 && (TREE_CODE (TYPE_SIZE (TYPE)) != INTEGER_CST \ 176 || TREE_ADDRESSABLE (TYPE) \ 177 || ((MODE) == BLKmode \ 178 && ! ((TYPE) != 0 && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \ 179 && 0 == (int_size_in_bytes (TYPE) \ 180 % (PARM_BOUNDARY / BITS_PER_UNIT))) \ 181 && (FUNCTION_ARG_PADDING (MODE, TYPE) \ 182 == (BYTES_BIG_ENDIAN ? upward : downward))))) 183#endif 184 185/* Nonzero if type TYPE should be returned in memory. 186 Most machines can use the following default definition. */ 187 188#ifndef RETURN_IN_MEMORY 189#define RETURN_IN_MEMORY(TYPE) (TYPE_MODE (TYPE) == BLKmode) 190#endif 191 192/* Supply a default definition of STACK_SAVEAREA_MODE for emit_stack_save. 193 Normally move_insn, so Pmode stack pointer. */ 194 195#ifndef STACK_SAVEAREA_MODE 196#define STACK_SAVEAREA_MODE(LEVEL) Pmode 197#endif 198 199/* Supply a default definition of STACK_SIZE_MODE for 200 allocate_dynamic_stack_space. Normally PLUS/MINUS, so word_mode. */ 201 202#ifndef STACK_SIZE_MODE 203#define STACK_SIZE_MODE word_mode 204#endif 205 206/* Provide default values for the macros controlling stack checking. */ 207 208#ifndef STACK_CHECK_BUILTIN 209#define STACK_CHECK_BUILTIN 0 210#endif 211 212/* The default interval is one page. */ 213#ifndef STACK_CHECK_PROBE_INTERVAL 214#define STACK_CHECK_PROBE_INTERVAL 4096 215#endif 216 217/* The default is to do a store into the stack. */ 218#ifndef STACK_CHECK_PROBE_LOAD 219#define STACK_CHECK_PROBE_LOAD 0 220#endif 221 222/* This value is arbitrary, but should be sufficient for most machines. */ 223#ifndef STACK_CHECK_PROTECT 224#define STACK_CHECK_PROTECT (75 * UNITS_PER_WORD) 225#endif 226 227/* Make the maximum frame size be the largest we can and still only need 228 one probe per function. */ 229#ifndef STACK_CHECK_MAX_FRAME_SIZE 230#define STACK_CHECK_MAX_FRAME_SIZE \ 231 (STACK_CHECK_PROBE_INTERVAL - UNITS_PER_WORD) 232#endif 233 234/* This is arbitrary, but should be large enough everywhere. */ 235#ifndef STACK_CHECK_FIXED_FRAME_SIZE 236#define STACK_CHECK_FIXED_FRAME_SIZE (4 * UNITS_PER_WORD) 237#endif 238 239/* Provide a reasonable default for the maximum size of an object to 240 allocate in the fixed frame. We may need to be able to make this 241 controllable by the user at some point. */ 242#ifndef STACK_CHECK_MAX_VAR_SIZE 243#define STACK_CHECK_MAX_VAR_SIZE (STACK_CHECK_MAX_FRAME_SIZE / 100) 244#endif 245 246/* Functions from optabs.c, commonly used, and without need for the optabs 247 tables: */ 248 249/* Passed to expand_simple_binop and expand_binop to say which options 250 to try to use if the requested operation can't be open-coded on the 251 requisite mode. Either OPTAB_LIB or OPTAB_LIB_WIDEN says try using 252 a library call. Either OPTAB_WIDEN or OPTAB_LIB_WIDEN says try 253 using a wider mode. OPTAB_MUST_WIDEN says try widening and don't 254 try anything else. */ 255 256enum optab_methods 257{ 258 OPTAB_DIRECT, 259 OPTAB_LIB, 260 OPTAB_WIDEN, 261 OPTAB_LIB_WIDEN, 262 OPTAB_MUST_WIDEN 263}; 264 265/* Generate code for a simple binary or unary operation. "Simple" in 266 this case means "can be unambiguously described by a (mode, code) 267 pair and mapped to a single optab." */ 268extern rtx expand_simple_binop PARAMS ((enum machine_mode, enum rtx_code, rtx, 269 rtx, rtx, int, enum optab_methods)); 270extern rtx expand_simple_unop PARAMS ((enum machine_mode, enum rtx_code, 271 rtx, rtx, int)); 272 273/* Report whether the machine description contains an insn which can 274 perform the operation described by CODE and MODE. */ 275extern int have_insn_for PARAMS ((enum rtx_code, enum machine_mode)); 276 277/* Emit code to make a call to a constant function or a library call. */ 278extern void emit_libcall_block PARAMS ((rtx, rtx, rtx, rtx)); 279 280/* Create but don't emit one rtl instruction to perform certain operations. 281 Modes must match; operands must meet the operation's predicates. 282 Likewise for subtraction and for just copying. 283 These do not call protect_from_queue; caller must do so. */ 284extern rtx gen_add2_insn PARAMS ((rtx, rtx)); 285extern rtx gen_add3_insn PARAMS ((rtx, rtx, rtx)); 286extern rtx gen_sub2_insn PARAMS ((rtx, rtx)); 287extern rtx gen_sub3_insn PARAMS ((rtx, rtx, rtx)); 288extern rtx gen_move_insn PARAMS ((rtx, rtx)); 289extern int have_add2_insn PARAMS ((rtx, rtx)); 290extern int have_sub2_insn PARAMS ((rtx, rtx)); 291 292/* Emit a pair of rtl insns to compare two rtx's and to jump 293 to a label if the comparison is true. */ 294extern void emit_cmp_and_jump_insns PARAMS ((rtx, rtx, enum rtx_code, rtx, 295 enum machine_mode, int, rtx)); 296 297/* Generate code to indirectly jump to a location given in the rtx LOC. */ 298extern void emit_indirect_jump PARAMS ((rtx)); 299 300#ifdef HAVE_conditional_move 301/* Emit a conditional move operation. */ 302rtx emit_conditional_move PARAMS ((rtx, enum rtx_code, rtx, rtx, 303 enum machine_mode, rtx, rtx, 304 enum machine_mode, int)); 305 306/* Return non-zero if the conditional move is supported. */ 307int can_conditionally_move_p PARAMS ((enum machine_mode mode)); 308 309#endif 310 311 312/* Functions from expmed.c: */ 313 314/* Arguments MODE, RTX: return an rtx for the negation of that value. 315 May emit insns. */ 316extern rtx negate_rtx PARAMS ((enum machine_mode, rtx)); 317 318/* Expand a logical AND operation. */ 319extern rtx expand_and PARAMS ((enum machine_mode, rtx, rtx, rtx)); 320 321/* Emit a store-flag operation. */ 322extern rtx emit_store_flag PARAMS ((rtx, enum rtx_code, rtx, rtx, 323 enum machine_mode, int, int)); 324 325/* Like emit_store_flag, but always succeeds. */ 326extern rtx emit_store_flag_force PARAMS ((rtx, enum rtx_code, rtx, rtx, 327 enum machine_mode, int, int)); 328 329/* Functions from loop.c: */ 330 331/* Given an insn and condition, return a canonical description of 332 the test being made. */ 333extern rtx canonicalize_condition PARAMS ((rtx, rtx, int, rtx *, rtx)); 334 335/* Given a JUMP_INSN, return a canonical description of the test 336 being made. */ 337extern rtx get_condition PARAMS ((rtx, rtx *)); 338 339/* Generate a conditional trap instruction. */ 340extern rtx gen_cond_trap PARAMS ((enum rtx_code, rtx, rtx, rtx)); 341 342/* Functions from builtins.c: */ 343extern rtx expand_builtin PARAMS ((tree, rtx, rtx, enum machine_mode, int)); 344extern void std_expand_builtin_va_start PARAMS ((int, tree, rtx)); 345extern rtx std_expand_builtin_va_arg PARAMS ((tree, tree)); 346extern rtx expand_builtin_va_arg PARAMS ((tree, tree)); 347extern void default_init_builtins PARAMS ((void)); 348extern rtx default_expand_builtin PARAMS ((tree, rtx, rtx, 349 enum machine_mode, int)); 350extern void expand_builtin_setjmp_setup PARAMS ((rtx, rtx)); 351extern void expand_builtin_setjmp_receiver PARAMS ((rtx)); 352extern void expand_builtin_longjmp PARAMS ((rtx, rtx)); 353extern rtx expand_builtin_saveregs PARAMS ((void)); 354extern void expand_builtin_trap PARAMS ((void)); 355extern HOST_WIDE_INT get_varargs_alias_set PARAMS ((void)); 356extern HOST_WIDE_INT get_frame_alias_set PARAMS ((void)); 357extern void record_base_value PARAMS ((unsigned int, rtx, int)); 358extern void record_alias_subset PARAMS ((HOST_WIDE_INT, 359 HOST_WIDE_INT)); 360extern HOST_WIDE_INT new_alias_set PARAMS ((void)); 361extern int can_address_p PARAMS ((tree)); 362 363/* Functions from expr.c: */ 364 365/* This is run once per compilation to set up which modes can be used 366 directly in memory and to initialize the block move optab. */ 367extern void init_expr_once PARAMS ((void)); 368 369/* This is run at the start of compiling a function. */ 370extern void init_expr PARAMS ((void)); 371 372/* This function is run once to initialize stor-layout.c. */ 373 374extern void init_stor_layout_once PARAMS ((void)); 375 376/* This is run at the end of compiling a function. */ 377extern void finish_expr_for_function PARAMS ((void)); 378 379/* Use protect_from_queue to convert a QUEUED expression 380 into something that you can put immediately into an instruction. */ 381extern rtx protect_from_queue PARAMS ((rtx, int)); 382 383/* Perform all the pending incrementations. */ 384extern void emit_queue PARAMS ((void)); 385 386/* Tell if something has a queued subexpression. */ 387extern int queued_subexp_p PARAMS ((rtx)); 388 389/* Emit some rtl insns to move data between rtx's, converting machine modes. 390 Both modes must be floating or both fixed. */ 391extern void convert_move PARAMS ((rtx, rtx, int)); 392 393/* Convert an rtx to specified machine mode and return the result. */ 394extern rtx convert_to_mode PARAMS ((enum machine_mode, rtx, int)); 395 396/* Convert an rtx to MODE from OLDMODE and return the result. */ 397extern rtx convert_modes PARAMS ((enum machine_mode, enum machine_mode, 398 rtx, int)); 399 400/* Emit code to move a block Y to a block X. */ 401extern rtx emit_block_move PARAMS ((rtx, rtx, rtx)); 402 403/* Copy all or part of a value X into registers starting at REGNO. 404 The number of registers to be filled is NREGS. */ 405extern void move_block_to_reg PARAMS ((int, rtx, int, enum machine_mode)); 406 407/* Copy all or part of a BLKmode value X out of registers starting at REGNO. 408 The number of registers to be filled is NREGS. */ 409extern void move_block_from_reg PARAMS ((int, rtx, int, int)); 410 411/* Load a BLKmode value into non-consecutive registers represented by a 412 PARALLEL. */ 413extern void emit_group_load PARAMS ((rtx, rtx, int)); 414 415/* Store a BLKmode value from non-consecutive registers represented by a 416 PARALLEL. */ 417extern void emit_group_store PARAMS ((rtx, rtx, int)); 418 419#ifdef TREE_CODE 420/* Copy BLKmode object from a set of registers. */ 421extern rtx copy_blkmode_from_reg PARAMS ((rtx,rtx,tree)); 422#endif 423 424/* Mark REG as holding a parameter for the next CALL_INSN. */ 425extern void use_reg PARAMS ((rtx *, rtx)); 426 427/* Mark NREGS consecutive regs, starting at REGNO, as holding parameters 428 for the next CALL_INSN. */ 429extern void use_regs PARAMS ((rtx *, int, int)); 430 431/* Mark a PARALLEL as holding a parameter for the next CALL_INSN. */ 432extern void use_group_regs PARAMS ((rtx *, rtx)); 433 434/* Write zeros through the storage of OBJECT. 435 If OBJECT has BLKmode, SIZE is its length in bytes. */ 436extern rtx clear_storage PARAMS ((rtx, rtx)); 437 438/* Return non-zero if it is desirable to store LEN bytes generated by 439 CONSTFUN with several move instructions by store_by_pieces 440 function. CONSTFUNDATA is a pointer which will be passed as argument 441 in every CONSTFUN call. 442 ALIGN is maximum alignment we can assume. */ 443extern int can_store_by_pieces PARAMS ((unsigned HOST_WIDE_INT, 444 rtx (*) (PTR, HOST_WIDE_INT, 445 enum machine_mode), 446 PTR, unsigned int)); 447 448/* Generate several move instructions to store LEN bytes generated by 449 CONSTFUN to block TO. (A MEM rtx with BLKmode). CONSTFUNDATA is a 450 pointer which will be passed as argument in every CONSTFUN call. 451 ALIGN is maximum alignment we can assume. */ 452extern void store_by_pieces PARAMS ((rtx, unsigned HOST_WIDE_INT, 453 rtx (*) (PTR, HOST_WIDE_INT, 454 enum machine_mode), 455 PTR, unsigned int)); 456 457/* Emit insns to set X from Y. */ 458extern rtx emit_move_insn PARAMS ((rtx, rtx)); 459 460/* Emit insns to set X from Y, with no frills. */ 461extern rtx emit_move_insn_1 PARAMS ((rtx, rtx)); 462 463/* Push a block of length SIZE (perhaps variable) 464 and return an rtx to address the beginning of the block. */ 465extern rtx push_block PARAMS ((rtx, int, int)); 466 467#ifdef TREE_CODE 468/* Generate code to push something onto the stack, given its mode and type. */ 469extern void emit_push_insn PARAMS ((rtx, enum machine_mode, tree, rtx, 470 unsigned int, int, rtx, int, rtx, rtx, 471 int, rtx)); 472 473/* Expand an assignment that stores the value of FROM into TO. */ 474extern rtx expand_assignment PARAMS ((tree, tree, int, int)); 475 476/* Generate code for computing expression EXP, 477 and storing the value into TARGET. 478 If SUGGEST_REG is nonzero, copy the value through a register 479 and return that register, if that is possible. */ 480extern rtx store_expr PARAMS ((tree, rtx, int)); 481#endif 482 483/* Given an rtx that may include add and multiply operations, 484 generate them as insns and return a pseudo-reg containing the value. 485 Useful after calling expand_expr with 1 as sum_ok. */ 486extern rtx force_operand PARAMS ((rtx, rtx)); 487 488/* Return an object on the placeholder list that matches EXP, a 489 PLACEHOLDER_EXPR. An object "matches" if it is of the type of the 490 PLACEHOLDER_EXPR or a pointer type to it. For further information, see 491 tree.def. If no such object is found, abort. If PLIST is nonzero, it is 492 a location which initially points to a starting location in the 493 placeholder list (zero means start of the list) and where a pointer into 494 the placeholder list at which the object is found is placed. */ 495extern tree find_placeholder PARAMS ((tree, tree *)); 496 497/* Generate code for computing expression EXP. 498 An rtx for the computed value is returned. The value is never null. 499 In the case of a void EXP, const0_rtx is returned. */ 500extern rtx expand_expr PARAMS ((tree, rtx, enum machine_mode, 501 enum expand_modifier)); 502 503/* At the start of a function, record that we have no previously-pushed 504 arguments waiting to be popped. */ 505extern void init_pending_stack_adjust PARAMS ((void)); 506 507/* When exiting from function, if safe, clear out any pending stack adjust 508 so the adjustment won't get done. */ 509extern void clear_pending_stack_adjust PARAMS ((void)); 510 511/* Pop any previously-pushed arguments that have not been popped yet. */ 512extern void do_pending_stack_adjust PARAMS ((void)); 513 514#ifdef TREE_CODE 515/* Return the tree node and offset if a given argument corresponds to 516 a string constant. */ 517extern tree string_constant PARAMS ((tree, tree *)); 518 519/* Generate code to evaluate EXP and jump to LABEL if the value is zero. */ 520extern void jumpifnot PARAMS ((tree, rtx)); 521 522/* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */ 523extern void jumpif PARAMS ((tree, rtx)); 524 525/* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if 526 the result is zero, or IF_TRUE_LABEL if the result is one. */ 527extern void do_jump PARAMS ((tree, rtx, rtx)); 528#endif 529 530/* Generate rtl to compare two rtx's, will call emit_cmp_insn. */ 531extern rtx compare_from_rtx PARAMS ((rtx, rtx, enum rtx_code, int, 532 enum machine_mode, rtx)); 533extern void do_compare_rtx_and_jump PARAMS ((rtx, rtx, enum rtx_code, int, 534 enum machine_mode, rtx, 535 rtx, rtx)); 536 537/* Two different ways of generating switch statements. */ 538extern int try_casesi PARAMS ((tree, tree, tree, tree, rtx, rtx)); 539extern int try_tablejump PARAMS ((tree, tree, tree, tree, rtx, rtx)); 540 541/* Smallest number of adjacent cases before we use a jump table. 542 XXX Should be a target hook. */ 543extern unsigned int case_values_threshold PARAMS ((void)); 544 545 546#ifdef TREE_CODE 547/* rtl.h and tree.h were included. */ 548/* Return an rtx for the size in bytes of the value of an expr. */ 549extern rtx expr_size PARAMS ((tree)); 550 551/* Return a wide integer for the size in bytes of the value of EXP, or -1 552 if the size can vary or is larger than an integer. */ 553extern HOST_WIDE_INT int_expr_size PARAMS ((tree)); 554 555extern rtx lookup_static_chain PARAMS ((tree)); 556 557/* Convert a stack slot address ADDR valid in function FNDECL 558 into an address valid in this function (using a static chain). */ 559extern rtx fix_lexical_addr PARAMS ((rtx, tree)); 560 561/* Return the address of the trampoline for entering nested fn FUNCTION. */ 562extern rtx trampoline_address PARAMS ((tree)); 563 564/* Return an rtx that refers to the value returned by a function 565 in its original home. This becomes invalid if any more code is emitted. */ 566extern rtx hard_function_value PARAMS ((tree, tree, int)); 567 568extern rtx prepare_call_address PARAMS ((rtx, tree, rtx *, int, int)); 569 570extern rtx expand_call PARAMS ((tree, rtx, int)); 571 572extern rtx expand_shift PARAMS ((enum tree_code, enum machine_mode, rtx, tree, 573 rtx, int)); 574extern rtx expand_divmod PARAMS ((int, enum tree_code, enum machine_mode, rtx, 575 rtx, rtx, int)); 576extern void locate_and_pad_parm PARAMS ((enum machine_mode, tree, int, tree, 577 struct args_size *, 578 struct args_size *, 579 struct args_size *, 580 struct args_size *)); 581extern rtx expand_inline_function PARAMS ((tree, tree, rtx, int, tree, rtx)); 582 583/* Return the CODE_LABEL rtx for a LABEL_DECL, creating it if necessary. */ 584extern rtx label_rtx PARAMS ((tree)); 585#endif 586 587/* Indicate how an input argument register was promoted. */ 588extern rtx promoted_input_arg PARAMS ((unsigned int, enum machine_mode *, 589 int *)); 590 591/* Return an rtx like arg but sans any constant terms. 592 Returns the original rtx if it has no constant terms. 593 The constant terms are added and stored via a second arg. */ 594extern rtx eliminate_constant_term PARAMS ((rtx, rtx *)); 595 596/* Convert arg to a valid memory address for specified machine mode, 597 by emitting insns to perform arithmetic if nec. */ 598extern rtx memory_address PARAMS ((enum machine_mode, rtx)); 599 600/* Like `memory_address' but pretent `flag_force_addr' is 0. */ 601extern rtx memory_address_noforce PARAMS ((enum machine_mode, rtx)); 602 603/* Set the alias set of MEM to SET. */ 604extern void set_mem_alias_set PARAMS ((rtx, HOST_WIDE_INT)); 605 606/* Set the alignment of MEM to ALIGN bits. */ 607extern void set_mem_align PARAMS ((rtx, unsigned int)); 608 609/* Set the expr for MEM to EXPR. */ 610extern void set_mem_expr PARAMS ((rtx, tree)); 611 612/* Set the offset for MEM to OFFSET. */ 613extern void set_mem_offset PARAMS ((rtx, rtx)); 614 615/* Set the size for MEM to SIZE. */ 616extern void set_mem_size PARAMS ((rtx, rtx)); 617 618/* Return a memory reference like MEMREF, but with its mode changed 619 to MODE and its address changed to ADDR. 620 (VOIDmode means don't change the mode. 621 NULL for ADDR means don't change the address.) */ 622extern rtx change_address PARAMS ((rtx, enum machine_mode, rtx)); 623 624/* Return a memory reference like MEMREF, but with its mode changed 625 to MODE and its address offset by OFFSET bytes. */ 626#define adjust_address(MEMREF, MODE, OFFSET) \ 627 adjust_address_1 (MEMREF, MODE, OFFSET, 1, 1) 628 629/* Likewise, but the reference is not required to be valid. */ 630#define adjust_address_nv(MEMREF, MODE, OFFSET) \ 631 adjust_address_1 (MEMREF, MODE, OFFSET, 0, 1) 632 633/* Return a memory reference like MEMREF, but with its mode changed 634 to MODE and its address changed to ADDR, which is assumed to be 635 increased by OFFSET bytes from MEMREF. */ 636#define adjust_automodify_address(MEMREF, MODE, ADDR, OFFSET) \ 637 adjust_automodify_address_1 (MEMREF, MODE, ADDR, OFFSET, 1) 638 639/* Likewise, but the reference is not required to be valid. */ 640#define adjust_automodify_address_nv(MEMREF, MODE, ADDR, OFFSET) \ 641 adjust_automodify_address_1 (MEMREF, MODE, ADDR, OFFSET, 0) 642 643extern rtx adjust_address_1 PARAMS ((rtx, enum machine_mode, HOST_WIDE_INT, 644 int, int)); 645extern rtx adjust_automodify_address_1 PARAMS ((rtx, enum machine_mode, 646 rtx, HOST_WIDE_INT, int)); 647 648/* Return a memory reference like MEMREF, but whose address is changed by 649 adding OFFSET, an RTX, to it. POW2 is the highest power of two factor 650 known to be in OFFSET (possibly 1). */ 651extern rtx offset_address PARAMS ((rtx, rtx, HOST_WIDE_INT)); 652 653/* Return a memory reference like MEMREF, but with its address changed to 654 ADDR. The caller is asserting that the actual piece of memory pointed 655 to is the same, just the form of the address is being changed, such as 656 by putting something into a register. */ 657extern rtx replace_equiv_address PARAMS ((rtx, rtx)); 658 659/* Likewise, but the reference is not required to be valid. */ 660extern rtx replace_equiv_address_nv PARAMS ((rtx, rtx)); 661 662/* Return a memory reference like MEMREF, but with its mode widened to 663 MODE and adjusted by OFFSET. */ 664extern rtx widen_memory_access PARAMS ((rtx, enum machine_mode, HOST_WIDE_INT)); 665 666/* Return a memory reference like MEMREF, but which is known to have a 667 valid address. */ 668extern rtx validize_mem PARAMS ((rtx)); 669 670#ifdef TREE_CODE 671/* Given REF, either a MEM or a REG, and T, either the type of X or 672 the expression corresponding to REF, set RTX_UNCHANGING_P if 673 appropriate. */ 674extern void maybe_set_unchanging PARAMS ((rtx, tree)); 675 676/* Given REF, a MEM, and T, either the type of X or the expression 677 corresponding to REF, set the memory attributes. OBJECTP is nonzero 678 if we are making a new object of this type. */ 679extern void set_mem_attributes PARAMS ((rtx, tree, int)); 680#endif 681 682/* Assemble the static constant template for function entry trampolines. */ 683extern rtx assemble_trampoline_template PARAMS ((void)); 684 685/* Given rtx, return new rtx whose address won't be affected by 686 any side effects. It has been copied to a new temporary reg. */ 687extern rtx stabilize PARAMS ((rtx)); 688 689/* Given an rtx, copy all regs it refers to into new temps 690 and return a modified copy that refers to the new temps. */ 691extern rtx copy_all_regs PARAMS ((rtx)); 692 693/* Copy given rtx to a new temp reg and return that. */ 694extern rtx copy_to_reg PARAMS ((rtx)); 695 696/* Like copy_to_reg but always make the reg Pmode. */ 697extern rtx copy_addr_to_reg PARAMS ((rtx)); 698 699/* Like copy_to_reg but always make the reg the specified mode MODE. */ 700extern rtx copy_to_mode_reg PARAMS ((enum machine_mode, rtx)); 701 702/* Copy given rtx to given temp reg and return that. */ 703extern rtx copy_to_suggested_reg PARAMS ((rtx, rtx, enum machine_mode)); 704 705/* Copy a value to a register if it isn't already a register. 706 Args are mode (in case value is a constant) and the value. */ 707extern rtx force_reg PARAMS ((enum machine_mode, rtx)); 708 709/* Return given rtx, copied into a new temp reg if it was in memory. */ 710extern rtx force_not_mem PARAMS ((rtx)); 711 712#ifdef TREE_CODE 713/* Return mode and signedness to use when object is promoted. */ 714extern enum machine_mode promote_mode PARAMS ((tree, enum machine_mode, 715 int *, int)); 716#endif 717 718/* Remove some bytes from the stack. An rtx says how many. */ 719extern void adjust_stack PARAMS ((rtx)); 720 721/* Add some bytes to the stack. An rtx says how many. */ 722extern void anti_adjust_stack PARAMS ((rtx)); 723 724/* This enum is used for the following two functions. */ 725enum save_level {SAVE_BLOCK, SAVE_FUNCTION, SAVE_NONLOCAL}; 726 727/* Save the stack pointer at the specified level. */ 728extern void emit_stack_save PARAMS ((enum save_level, rtx *, rtx)); 729 730/* Restore the stack pointer from a save area of the specified level. */ 731extern void emit_stack_restore PARAMS ((enum save_level, rtx, rtx)); 732 733/* Allocate some space on the stack dynamically and return its address. An rtx 734 says how many bytes. */ 735extern rtx allocate_dynamic_stack_space PARAMS ((rtx, rtx, int)); 736 737/* Probe a range of stack addresses from FIRST to FIRST+SIZE, inclusive. 738 FIRST is a constant and size is a Pmode RTX. These are offsets from the 739 current stack pointer. STACK_GROWS_DOWNWARD says whether to add or 740 subtract from the stack. If SIZE is constant, this is done 741 with a fixed number of probes. Otherwise, we must make a loop. */ 742extern void probe_stack_range PARAMS ((HOST_WIDE_INT, rtx)); 743 744/* Return an rtx that refers to the value returned by a library call 745 in its original home. This becomes invalid if any more code is emitted. */ 746extern rtx hard_libcall_value PARAMS ((enum machine_mode)); 747 748/* Given an rtx, return an rtx for a value rounded up to a multiple 749 of STACK_BOUNDARY / BITS_PER_UNIT. */ 750extern rtx round_push PARAMS ((rtx)); 751 752/* Return the mode desired by operand N of a particular bitfield 753 insert/extract insn, or MAX_MACHINE_MODE if no such insn is 754 available. */ 755 756enum extraction_pattern { EP_insv, EP_extv, EP_extzv }; 757extern enum machine_mode 758mode_for_extraction PARAMS ((enum extraction_pattern, int)); 759 760extern rtx store_bit_field PARAMS ((rtx, unsigned HOST_WIDE_INT, 761 unsigned HOST_WIDE_INT, 762 enum machine_mode, rtx, HOST_WIDE_INT)); 763extern rtx extract_bit_field PARAMS ((rtx, unsigned HOST_WIDE_INT, 764 unsigned HOST_WIDE_INT, int, rtx, 765 enum machine_mode, enum machine_mode, 766 HOST_WIDE_INT)); 767extern rtx expand_mult PARAMS ((enum machine_mode, rtx, rtx, rtx, int)); 768extern rtx expand_mult_add PARAMS ((rtx, rtx, rtx, rtx,enum machine_mode, int)); 769extern rtx expand_mult_highpart_adjust PARAMS ((enum machine_mode, rtx, rtx, rtx, rtx, int)); 770 771extern rtx assemble_static_space PARAMS ((int)); 772 773/* Hook called by expand_expr for language-specific tree codes. 774 It is up to the language front end to install a hook 775 if it has any such codes that expand_expr needs to know about. */ 776extern rtx (*lang_expand_expr) PARAMS ((union tree_node *, rtx, 777 enum machine_mode, 778 enum expand_modifier modifier)); 779 780extern int safe_from_p PARAMS ((rtx, tree, int)); 781 782/* Call this once to initialize the contents of the optabs 783 appropriately for the current target machine. */ 784extern void init_optabs PARAMS ((void)); 785extern void init_all_optabs PARAMS ((void)); 786 787/* Call this to initialize an optab function entry. */ 788extern rtx init_one_libfunc PARAMS ((const char *)); 789 790extern void do_jump_by_parts_equality_rtx PARAMS ((rtx, rtx, rtx)); 791extern void do_jump_by_parts_greater_rtx PARAMS ((enum machine_mode, 792 int, rtx, rtx, rtx, 793 rtx)); 794 795#ifdef TREE_CODE /* Don't lose if tree.h not included. */ 796extern void mark_seen_cases PARAMS ((tree, unsigned char *, 797 HOST_WIDE_INT, int)); 798#endif 799