expr.h revision 96263
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 551extern rtx lookup_static_chain PARAMS ((tree)); 552 553/* Convert a stack slot address ADDR valid in function FNDECL 554 into an address valid in this function (using a static chain). */ 555extern rtx fix_lexical_addr PARAMS ((rtx, tree)); 556 557/* Return the address of the trampoline for entering nested fn FUNCTION. */ 558extern rtx trampoline_address PARAMS ((tree)); 559 560/* Return an rtx that refers to the value returned by a function 561 in its original home. This becomes invalid if any more code is emitted. */ 562extern rtx hard_function_value PARAMS ((tree, tree, int)); 563 564extern rtx prepare_call_address PARAMS ((rtx, tree, rtx *, int, int)); 565 566extern rtx expand_call PARAMS ((tree, rtx, int)); 567 568extern rtx expand_shift PARAMS ((enum tree_code, enum machine_mode, rtx, tree, 569 rtx, int)); 570extern rtx expand_divmod PARAMS ((int, enum tree_code, enum machine_mode, rtx, 571 rtx, rtx, int)); 572extern void locate_and_pad_parm PARAMS ((enum machine_mode, tree, int, tree, 573 struct args_size *, 574 struct args_size *, 575 struct args_size *, 576 struct args_size *)); 577extern rtx expand_inline_function PARAMS ((tree, tree, rtx, int, tree, rtx)); 578 579/* Return the CODE_LABEL rtx for a LABEL_DECL, creating it if necessary. */ 580extern rtx label_rtx PARAMS ((tree)); 581#endif 582 583/* Indicate how an input argument register was promoted. */ 584extern rtx promoted_input_arg PARAMS ((unsigned int, enum machine_mode *, 585 int *)); 586 587/* Return an rtx like arg but sans any constant terms. 588 Returns the original rtx if it has no constant terms. 589 The constant terms are added and stored via a second arg. */ 590extern rtx eliminate_constant_term PARAMS ((rtx, rtx *)); 591 592/* Convert arg to a valid memory address for specified machine mode, 593 by emitting insns to perform arithmetic if nec. */ 594extern rtx memory_address PARAMS ((enum machine_mode, rtx)); 595 596/* Like `memory_address' but pretent `flag_force_addr' is 0. */ 597extern rtx memory_address_noforce PARAMS ((enum machine_mode, rtx)); 598 599/* Set the alias set of MEM to SET. */ 600extern void set_mem_alias_set PARAMS ((rtx, HOST_WIDE_INT)); 601 602/* Set the alignment of MEM to ALIGN bits. */ 603extern void set_mem_align PARAMS ((rtx, unsigned int)); 604 605/* Set the expr for MEM to EXPR. */ 606extern void set_mem_expr PARAMS ((rtx, tree)); 607 608/* Set the offset for MEM to OFFSET. */ 609extern void set_mem_offset PARAMS ((rtx, rtx)); 610 611/* Return a memory reference like MEMREF, but with its mode changed 612 to MODE and its address changed to ADDR. 613 (VOIDmode means don't change the mode. 614 NULL for ADDR means don't change the address.) */ 615extern rtx change_address PARAMS ((rtx, enum machine_mode, rtx)); 616 617/* Return a memory reference like MEMREF, but with its mode changed 618 to MODE and its address offset by OFFSET bytes. */ 619#define adjust_address(MEMREF, MODE, OFFSET) \ 620 adjust_address_1 (MEMREF, MODE, OFFSET, 1, 1) 621 622/* Likewise, but the reference is not required to be valid. */ 623#define adjust_address_nv(MEMREF, MODE, OFFSET) \ 624 adjust_address_1 (MEMREF, MODE, OFFSET, 0, 1) 625 626/* Return a memory reference like MEMREF, but with its mode changed 627 to MODE and its address changed to ADDR, which is assumed to be 628 increased by OFFSET bytes from MEMREF. */ 629#define adjust_automodify_address(MEMREF, MODE, ADDR, OFFSET) \ 630 adjust_automodify_address_1 (MEMREF, MODE, ADDR, OFFSET, 1) 631 632/* Likewise, but the reference is not required to be valid. */ 633#define adjust_automodify_address_nv(MEMREF, MODE, ADDR, OFFSET) \ 634 adjust_automodify_address_1 (MEMREF, MODE, ADDR, OFFSET, 0) 635 636extern rtx adjust_address_1 PARAMS ((rtx, enum machine_mode, HOST_WIDE_INT, 637 int, int)); 638extern rtx adjust_automodify_address_1 PARAMS ((rtx, enum machine_mode, 639 rtx, HOST_WIDE_INT, int)); 640 641/* Return a memory reference like MEMREF, but whose address is changed by 642 adding OFFSET, an RTX, to it. POW2 is the highest power of two factor 643 known to be in OFFSET (possibly 1). */ 644extern rtx offset_address PARAMS ((rtx, rtx, HOST_WIDE_INT)); 645 646/* Return a memory reference like MEMREF, but with its address changed to 647 ADDR. The caller is asserting that the actual piece of memory pointed 648 to is the same, just the form of the address is being changed, such as 649 by putting something into a register. */ 650extern rtx replace_equiv_address PARAMS ((rtx, rtx)); 651 652/* Likewise, but the reference is not required to be valid. */ 653extern rtx replace_equiv_address_nv PARAMS ((rtx, rtx)); 654 655/* Return a memory reference like MEMREF, but with its mode widened to 656 MODE and adjusted by OFFSET. */ 657extern rtx widen_memory_access PARAMS ((rtx, enum machine_mode, HOST_WIDE_INT)); 658 659/* Return a memory reference like MEMREF, but which is known to have a 660 valid address. */ 661extern rtx validize_mem PARAMS ((rtx)); 662 663#ifdef TREE_CODE 664/* Given REF, either a MEM or a REG, and T, either the type of X or 665 the expression corresponding to REF, set RTX_UNCHANGING_P if 666 appropriate. */ 667extern void maybe_set_unchanging PARAMS ((rtx, tree)); 668 669/* Given REF, a MEM, and T, either the type of X or the expression 670 corresponding to REF, set the memory attributes. OBJECTP is nonzero 671 if we are making a new object of this type. */ 672extern void set_mem_attributes PARAMS ((rtx, tree, int)); 673#endif 674 675/* Assemble the static constant template for function entry trampolines. */ 676extern rtx assemble_trampoline_template PARAMS ((void)); 677 678/* Given rtx, return new rtx whose address won't be affected by 679 any side effects. It has been copied to a new temporary reg. */ 680extern rtx stabilize PARAMS ((rtx)); 681 682/* Given an rtx, copy all regs it refers to into new temps 683 and return a modified copy that refers to the new temps. */ 684extern rtx copy_all_regs PARAMS ((rtx)); 685 686/* Copy given rtx to a new temp reg and return that. */ 687extern rtx copy_to_reg PARAMS ((rtx)); 688 689/* Like copy_to_reg but always make the reg Pmode. */ 690extern rtx copy_addr_to_reg PARAMS ((rtx)); 691 692/* Like copy_to_reg but always make the reg the specified mode MODE. */ 693extern rtx copy_to_mode_reg PARAMS ((enum machine_mode, rtx)); 694 695/* Copy given rtx to given temp reg and return that. */ 696extern rtx copy_to_suggested_reg PARAMS ((rtx, rtx, enum machine_mode)); 697 698/* Copy a value to a register if it isn't already a register. 699 Args are mode (in case value is a constant) and the value. */ 700extern rtx force_reg PARAMS ((enum machine_mode, rtx)); 701 702/* Return given rtx, copied into a new temp reg if it was in memory. */ 703extern rtx force_not_mem PARAMS ((rtx)); 704 705#ifdef TREE_CODE 706/* Return mode and signedness to use when object is promoted. */ 707extern enum machine_mode promote_mode PARAMS ((tree, enum machine_mode, 708 int *, int)); 709#endif 710 711/* Remove some bytes from the stack. An rtx says how many. */ 712extern void adjust_stack PARAMS ((rtx)); 713 714/* Add some bytes to the stack. An rtx says how many. */ 715extern void anti_adjust_stack PARAMS ((rtx)); 716 717/* This enum is used for the following two functions. */ 718enum save_level {SAVE_BLOCK, SAVE_FUNCTION, SAVE_NONLOCAL}; 719 720/* Save the stack pointer at the specified level. */ 721extern void emit_stack_save PARAMS ((enum save_level, rtx *, rtx)); 722 723/* Restore the stack pointer from a save area of the specified level. */ 724extern void emit_stack_restore PARAMS ((enum save_level, rtx, rtx)); 725 726/* Allocate some space on the stack dynamically and return its address. An rtx 727 says how many bytes. */ 728extern rtx allocate_dynamic_stack_space PARAMS ((rtx, rtx, int)); 729 730/* Probe a range of stack addresses from FIRST to FIRST+SIZE, inclusive. 731 FIRST is a constant and size is a Pmode RTX. These are offsets from the 732 current stack pointer. STACK_GROWS_DOWNWARD says whether to add or 733 subtract from the stack. If SIZE is constant, this is done 734 with a fixed number of probes. Otherwise, we must make a loop. */ 735extern void probe_stack_range PARAMS ((HOST_WIDE_INT, rtx)); 736 737/* Return an rtx that refers to the value returned by a library call 738 in its original home. This becomes invalid if any more code is emitted. */ 739extern rtx hard_libcall_value PARAMS ((enum machine_mode)); 740 741/* Given an rtx, return an rtx for a value rounded up to a multiple 742 of STACK_BOUNDARY / BITS_PER_UNIT. */ 743extern rtx round_push PARAMS ((rtx)); 744 745/* Return the mode desired by operand N of a particular bitfield 746 insert/extract insn, or MAX_MACHINE_MODE if no such insn is 747 available. */ 748 749enum extraction_pattern { EP_insv, EP_extv, EP_extzv }; 750extern enum machine_mode 751mode_for_extraction PARAMS ((enum extraction_pattern, int)); 752 753extern rtx store_bit_field PARAMS ((rtx, unsigned HOST_WIDE_INT, 754 unsigned HOST_WIDE_INT, 755 enum machine_mode, rtx, HOST_WIDE_INT)); 756extern rtx extract_bit_field PARAMS ((rtx, unsigned HOST_WIDE_INT, 757 unsigned HOST_WIDE_INT, int, rtx, 758 enum machine_mode, enum machine_mode, 759 HOST_WIDE_INT)); 760extern rtx expand_mult PARAMS ((enum machine_mode, rtx, rtx, rtx, int)); 761extern rtx expand_mult_add PARAMS ((rtx, rtx, rtx, rtx,enum machine_mode, int)); 762extern rtx expand_mult_highpart_adjust PARAMS ((enum machine_mode, rtx, rtx, rtx, rtx, int)); 763 764extern rtx assemble_static_space PARAMS ((int)); 765 766/* Hook called by expand_expr for language-specific tree codes. 767 It is up to the language front end to install a hook 768 if it has any such codes that expand_expr needs to know about. */ 769extern rtx (*lang_expand_expr) PARAMS ((union tree_node *, rtx, 770 enum machine_mode, 771 enum expand_modifier modifier)); 772 773extern int safe_from_p PARAMS ((rtx, tree, int)); 774 775/* Call this once to initialize the contents of the optabs 776 appropriately for the current target machine. */ 777extern void init_optabs PARAMS ((void)); 778extern void init_all_optabs PARAMS ((void)); 779 780/* Call this to initialize an optab function entry. */ 781extern rtx init_one_libfunc PARAMS ((const char *)); 782 783extern void do_jump_by_parts_equality_rtx PARAMS ((rtx, rtx, rtx)); 784extern void do_jump_by_parts_greater_rtx PARAMS ((enum machine_mode, 785 int, rtx, rtx, rtx, 786 rtx)); 787 788#ifdef TREE_CODE /* Don't lose if tree.h not included. */ 789extern void mark_seen_cases PARAMS ((tree, unsigned char *, 790 HOST_WIDE_INT, int)); 791#endif 792