expr.h revision 146895
198937Sdes/* Definitions for code generation pass of GNU compiler. 298937Sdes Copyright (C) 1987, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 398937Sdes 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. 498937Sdes 598937SdesThis file is part of GCC. 698937Sdes 798937SdesGCC is free software; you can redistribute it and/or modify it under 898937Sdesthe terms of the GNU General Public License as published by the Free 998937SdesSoftware Foundation; either version 2, or (at your option) any later 1098937Sdesversion. 1198937Sdes 1298937SdesGCC is distributed in the hope that it will be useful, but WITHOUT ANY 1398937SdesWARRANTY; without even the implied warranty of MERCHANTABILITY or 1498937SdesFITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 1598937Sdesfor more details. 1698937Sdes 1798937SdesYou should have received a copy of the GNU General Public License 1898937Sdesalong with GCC; see the file COPYING. If not, write to the Free 1998937SdesSoftware Foundation, 59 Temple Place - Suite 330, Boston, MA 2098937Sdes02111-1307, USA. */ 2198937Sdes 2298937Sdes/* The default branch cost is 1. */ 2398937Sdes#ifndef BRANCH_COST 2498937Sdes#define BRANCH_COST 1 2598937Sdes#endif 2698937Sdes 2798937Sdes/* Macros to access the slots of a QUEUED rtx. 2898937Sdes Here rather than in rtl.h because only the expansion pass 2998937Sdes should ever encounter a QUEUED. */ 3098937Sdes 3198937Sdes/* The variable for which an increment is queued. */ 3298937Sdes#define QUEUED_VAR(P) XEXP (P, 0) 3398937Sdes/* If the increment has been emitted, this is the insn 3498937Sdes that does the increment. It is zero before the increment is emitted. 35162852Sdes If more than one insn is emitted, this is the first insn. */ 3698937Sdes#define QUEUED_INSN(P) XEXP (P, 1) 3798937Sdes/* If a pre-increment copy has been generated, this is the copy 38162852Sdes (it is a temporary reg). Zero if no copy made yet. */ 39162852Sdes#define QUEUED_COPY(P) XEXP (P, 2) 40162852Sdes/* This is the body to use for the insn to do the increment. 41162852Sdes It is used to emit the increment. */ 42162852Sdes#define QUEUED_BODY(P) XEXP (P, 3) 43162852Sdes/* Next QUEUED in the queue. */ 44162852Sdes#define QUEUED_NEXT(P) XEXP (P, 4) 45162852Sdes 46162852Sdes/* This is the 4th arg to `expand_expr'. 47162852Sdes EXPAND_STACK_PARM means we are possibly expanding a call param onto 4898937Sdes the stack. Choosing a value of 2 isn't special; It just allows 4998937Sdes some code optimization in store_expr. 5098937Sdes EXPAND_SUM means it is ok to return a PLUS rtx or MULT rtx. 5198937Sdes EXPAND_INITIALIZER is similar but also record any labels on forced_labels. 5298937Sdes EXPAND_CONST_ADDRESS means it is ok to return a MEM whose address 53147001Sdes is a constant that is not a legitimate address. 5498937Sdes EXPAND_WRITE means we are only going to write to the resulting rtx. 5598937Sdes EXPAND_MEMORY means we are interested in a memory result, even if 5698937Sdes the memory is constant and we could have propagated a constant value. */ 5798937Sdesenum expand_modifier {EXPAND_NORMAL = 0, EXPAND_STACK_PARM = 2, EXPAND_SUM, 5898937Sdes EXPAND_CONST_ADDRESS, EXPAND_INITIALIZER, EXPAND_WRITE, 59124208Sdes EXPAND_MEMORY}; 6098937Sdes 61124208Sdes/* Prevent the compiler from deferring stack pops. See 62124208Sdes inhibit_defer_pop for more information. */ 6398937Sdes#define NO_DEFER_POP (inhibit_defer_pop += 1) 64113908Sdes 65113908Sdes/* Allow the compiler to defer stack pops. See inhibit_defer_pop for 66124208Sdes more information. */ 6798937Sdes#define OK_DEFER_POP (inhibit_defer_pop -= 1) 6898937Sdes 69124208Sdes/* If a memory-to-memory move would take MOVE_RATIO or more simple 70124208Sdes move-instruction sequences, we will do a movstr or libcall instead. */ 7198937Sdes 7298937Sdes#ifndef MOVE_RATIO 73124208Sdes#if defined (HAVE_movstrqi) || defined (HAVE_movstrhi) || defined (HAVE_movstrsi) || defined (HAVE_movstrdi) || defined (HAVE_movstrti) 74124208Sdes#define MOVE_RATIO 2 7598937Sdes#else 7698937Sdes/* If we are optimizing for space (-Os), cut down the default move ratio. */ 7798937Sdes#define MOVE_RATIO (optimize_size ? 3 : 15) 7898937Sdes#endif 79124208Sdes#endif 8098937Sdes 8198937Sdes/* If a clear memory operation would take CLEAR_RATIO or more simple 8298937Sdes move-instruction sequences, we will do a clrstr or libcall instead. */ 83113908Sdes 8498937Sdes#ifndef CLEAR_RATIO 8598937Sdes#if defined (HAVE_clrstrqi) || defined (HAVE_clrstrhi) || defined (HAVE_clrstrsi) || defined (HAVE_clrstrdi) || defined (HAVE_clrstrti) 8698937Sdes#define CLEAR_RATIO 2 8798937Sdes#else 88124208Sdes/* If we are optimizing for space, cut down the default clear ratio. */ 8998937Sdes#define CLEAR_RATIO (optimize_size ? 3 : 15) 90126274Sdes#endif 91124208Sdes#endif 9298937Sdes 9398937Sdesenum direction {none, upward, downward}; 9498937Sdes 9598937Sdes/* Structure to record the size of a sequence of arguments 9698937Sdes as the sum of a tree-expression and a constant. This structure is 9798937Sdes also used to store offsets from the stack, which might be negative, 9898937Sdes so the variable part must be ssizetype, not sizetype. */ 9998937Sdes 100113908Sdesstruct args_size 101113908Sdes{ 102113908Sdes HOST_WIDE_INT constant; 103113908Sdes tree var; 104113908Sdes}; 105124208Sdes 106124208Sdes/* Package up various arg related fields of struct args for 107126274Sdes locate_and_pad_parm. */ 10898937Sdesstruct locate_and_pad_arg_data 10998937Sdes{ 110126274Sdes /* Size of this argument on the stack, rounded up for any padding it 111126274Sdes gets. If REG_PARM_STACK_SPACE is defined, then register parms are 11298937Sdes counted here, otherwise they aren't. */ 11398937Sdes struct args_size size; 11498937Sdes /* Offset of this argument from beginning of stack-args. */ 115 struct args_size offset; 116 /* Offset to the start of the stack slot. Different from OFFSET 117 if this arg pads downward. */ 118 struct args_size slot_offset; 119 /* The amount that the stack pointer needs to be adjusted to 120 force alignment for the next argument. */ 121 struct args_size alignment_pad; 122 /* Which way we should pad this arg. */ 123 enum direction where_pad; 124}; 125 126/* Add the value of the tree INC to the `struct args_size' TO. */ 127 128#define ADD_PARM_SIZE(TO, INC) \ 129do { \ 130 tree inc = (INC); \ 131 if (host_integerp (inc, 0)) \ 132 (TO).constant += tree_low_cst (inc, 0); \ 133 else if ((TO).var == 0) \ 134 (TO).var = convert (ssizetype, inc); \ 135 else \ 136 (TO).var = size_binop (PLUS_EXPR, (TO).var, \ 137 convert (ssizetype, inc)); \ 138} while (0) 139 140#define SUB_PARM_SIZE(TO, DEC) \ 141do { \ 142 tree dec = (DEC); \ 143 if (host_integerp (dec, 0)) \ 144 (TO).constant -= tree_low_cst (dec, 0); \ 145 else if ((TO).var == 0) \ 146 (TO).var = size_binop (MINUS_EXPR, ssize_int (0), \ 147 convert (ssizetype, dec)); \ 148 else \ 149 (TO).var = size_binop (MINUS_EXPR, (TO).var, \ 150 convert (ssizetype, dec)); \ 151} while (0) 152 153/* Convert the implicit sum in a `struct args_size' into a tree 154 of type ssizetype. */ 155#define ARGS_SIZE_TREE(SIZE) \ 156((SIZE).var == 0 ? ssize_int ((SIZE).constant) \ 157 : size_binop (PLUS_EXPR, convert (ssizetype, (SIZE).var), \ 158 ssize_int ((SIZE).constant))) 159 160/* Convert the implicit sum in a `struct args_size' into an rtx. */ 161#define ARGS_SIZE_RTX(SIZE) \ 162((SIZE).var == 0 ? GEN_INT ((SIZE).constant) \ 163 : expand_expr (ARGS_SIZE_TREE (SIZE), NULL_RTX, VOIDmode, 0)) 164 165/* Supply a default definition for FUNCTION_ARG_PADDING: 166 usually pad upward, but pad short args downward on 167 big-endian machines. */ 168 169#define DEFAULT_FUNCTION_ARG_PADDING(MODE, TYPE) \ 170 (! BYTES_BIG_ENDIAN \ 171 ? upward \ 172 : (((MODE) == BLKmode \ 173 ? ((TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \ 174 && int_size_in_bytes (TYPE) < (PARM_BOUNDARY / BITS_PER_UNIT)) \ 175 : GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY) \ 176 ? downward : upward)) 177 178#ifndef FUNCTION_ARG_PADDING 179#define FUNCTION_ARG_PADDING(MODE, TYPE) \ 180 DEFAULT_FUNCTION_ARG_PADDING ((MODE), (TYPE)) 181#endif 182 183/* Supply a default definition for FUNCTION_ARG_BOUNDARY. Normally, we let 184 FUNCTION_ARG_PADDING, which also pads the length, handle any needed 185 alignment. */ 186 187#ifndef FUNCTION_ARG_BOUNDARY 188#define FUNCTION_ARG_BOUNDARY(MODE, TYPE) PARM_BOUNDARY 189#endif 190 191tree split_complex_types (tree); 192tree split_complex_values (tree); 193 194/* Nonzero if we do not know how to pass TYPE solely in registers. */ 195extern bool default_must_pass_in_stack (enum machine_mode, tree); 196#ifndef MUST_PASS_IN_STACK 197#define MUST_PASS_IN_STACK(MODE,TYPE) default_must_pass_in_stack(MODE, TYPE) 198#endif 199 200/* Supply a default definition of STACK_SAVEAREA_MODE for emit_stack_save. 201 Normally move_insn, so Pmode stack pointer. */ 202 203#ifndef STACK_SAVEAREA_MODE 204#define STACK_SAVEAREA_MODE(LEVEL) Pmode 205#endif 206 207/* Supply a default definition of STACK_SIZE_MODE for 208 allocate_dynamic_stack_space. Normally PLUS/MINUS, so word_mode. */ 209 210#ifndef STACK_SIZE_MODE 211#define STACK_SIZE_MODE word_mode 212#endif 213 214/* Provide default values for the macros controlling stack checking. */ 215 216#ifndef STACK_CHECK_BUILTIN 217#define STACK_CHECK_BUILTIN 0 218#endif 219 220/* The default interval is one page. */ 221#ifndef STACK_CHECK_PROBE_INTERVAL 222#define STACK_CHECK_PROBE_INTERVAL 4096 223#endif 224 225/* The default is to do a store into the stack. */ 226#ifndef STACK_CHECK_PROBE_LOAD 227#define STACK_CHECK_PROBE_LOAD 0 228#endif 229 230/* This value is arbitrary, but should be sufficient for most machines. */ 231#ifndef STACK_CHECK_PROTECT 232#define STACK_CHECK_PROTECT (75 * UNITS_PER_WORD) 233#endif 234 235/* Make the maximum frame size be the largest we can and still only need 236 one probe per function. */ 237#ifndef STACK_CHECK_MAX_FRAME_SIZE 238#define STACK_CHECK_MAX_FRAME_SIZE \ 239 (STACK_CHECK_PROBE_INTERVAL - UNITS_PER_WORD) 240#endif 241 242/* This is arbitrary, but should be large enough everywhere. */ 243#ifndef STACK_CHECK_FIXED_FRAME_SIZE 244#define STACK_CHECK_FIXED_FRAME_SIZE (4 * UNITS_PER_WORD) 245#endif 246 247/* Provide a reasonable default for the maximum size of an object to 248 allocate in the fixed frame. We may need to be able to make this 249 controllable by the user at some point. */ 250#ifndef STACK_CHECK_MAX_VAR_SIZE 251#define STACK_CHECK_MAX_VAR_SIZE (STACK_CHECK_MAX_FRAME_SIZE / 100) 252#endif 253 254/* Functions from optabs.c, commonly used, and without need for the optabs 255 tables: */ 256 257/* Passed to expand_simple_binop and expand_binop to say which options 258 to try to use if the requested operation can't be open-coded on the 259 requisite mode. Either OPTAB_LIB or OPTAB_LIB_WIDEN says try using 260 a library call. Either OPTAB_WIDEN or OPTAB_LIB_WIDEN says try 261 using a wider mode. OPTAB_MUST_WIDEN says try widening and don't 262 try anything else. */ 263 264enum optab_methods 265{ 266 OPTAB_DIRECT, 267 OPTAB_LIB, 268 OPTAB_WIDEN, 269 OPTAB_LIB_WIDEN, 270 OPTAB_MUST_WIDEN 271}; 272 273/* Generate code for a simple binary or unary operation. "Simple" in 274 this case means "can be unambiguously described by a (mode, code) 275 pair and mapped to a single optab." */ 276extern rtx expand_simple_binop (enum machine_mode, enum rtx_code, rtx, 277 rtx, rtx, int, enum optab_methods); 278extern rtx expand_simple_unop (enum machine_mode, enum rtx_code, rtx, rtx, 279 int); 280 281/* Report whether the machine description contains an insn which can 282 perform the operation described by CODE and MODE. */ 283extern int have_insn_for (enum rtx_code, enum machine_mode); 284 285/* Emit code to make a call to a constant function or a library call. */ 286extern void emit_libcall_block (rtx, rtx, rtx, rtx); 287 288/* Create but don't emit one rtl instruction to perform certain operations. 289 Modes must match; operands must meet the operation's predicates. 290 Likewise for subtraction and for just copying. 291 These do not call protect_from_queue; caller must do so. */ 292extern rtx gen_add2_insn (rtx, rtx); 293extern rtx gen_add3_insn (rtx, rtx, rtx); 294extern rtx gen_sub2_insn (rtx, rtx); 295extern rtx gen_sub3_insn (rtx, rtx, rtx); 296extern rtx gen_move_insn (rtx, rtx); 297extern int have_add2_insn (rtx, rtx); 298extern int have_sub2_insn (rtx, rtx); 299 300/* Emit a pair of rtl insns to compare two rtx's and to jump 301 to a label if the comparison is true. */ 302extern void emit_cmp_and_jump_insns (rtx, rtx, enum rtx_code, rtx, 303 enum machine_mode, int, rtx); 304 305/* Generate code to indirectly jump to a location given in the rtx LOC. */ 306extern void emit_indirect_jump (rtx); 307 308#ifdef HAVE_conditional_move 309/* Emit a conditional move operation. */ 310rtx emit_conditional_move (rtx, enum rtx_code, rtx, rtx, enum machine_mode, 311 rtx, rtx, enum machine_mode, int); 312 313/* Return nonzero if the conditional move is supported. */ 314int can_conditionally_move_p (enum machine_mode mode); 315 316#endif 317rtx emit_conditional_add (rtx, enum rtx_code, rtx, rtx, enum machine_mode, 318 rtx, rtx, enum machine_mode, int); 319 320 321/* Functions from expmed.c: */ 322 323/* Arguments MODE, RTX: return an rtx for the negation of that value. 324 May emit insns. */ 325extern rtx negate_rtx (enum machine_mode, rtx); 326 327/* Expand a logical AND operation. */ 328extern rtx expand_and (enum machine_mode, rtx, rtx, rtx); 329 330/* Emit a store-flag operation. */ 331extern rtx emit_store_flag (rtx, enum rtx_code, rtx, rtx, enum machine_mode, 332 int, int); 333 334/* Like emit_store_flag, but always succeeds. */ 335extern rtx emit_store_flag_force (rtx, enum rtx_code, rtx, rtx, 336 enum machine_mode, int, int); 337 338/* Functions from loop.c: */ 339 340/* Given an insn and condition, return a canonical description of 341 the test being made. */ 342extern rtx canonicalize_condition (rtx, rtx, int, rtx *, rtx, int); 343 344/* Given a JUMP_INSN, return a canonical description of the test 345 being made. */ 346extern rtx get_condition (rtx, rtx *, int); 347 348/* Generate a conditional trap instruction. */ 349extern rtx gen_cond_trap (enum rtx_code, rtx, rtx, rtx); 350 351/* Functions from builtins.c: */ 352extern rtx expand_builtin (tree, rtx, rtx, enum machine_mode, int); 353extern tree std_build_builtin_va_list (void); 354extern void std_expand_builtin_va_start (tree, rtx); 355extern rtx std_expand_builtin_va_arg (tree, tree); 356extern rtx expand_builtin_va_arg (tree, tree); 357extern rtx default_expand_builtin (tree, rtx, rtx, enum machine_mode, int); 358extern void expand_builtin_setjmp_setup (rtx, rtx); 359extern void expand_builtin_setjmp_receiver (rtx); 360extern void expand_builtin_longjmp (rtx, rtx); 361extern rtx expand_builtin_saveregs (void); 362extern void expand_builtin_trap (void); 363extern HOST_WIDE_INT get_varargs_alias_set (void); 364extern HOST_WIDE_INT get_frame_alias_set (void); 365extern void record_base_value (unsigned int, rtx, int); 366extern void record_alias_subset (HOST_WIDE_INT, HOST_WIDE_INT); 367extern HOST_WIDE_INT new_alias_set (void); 368extern int can_address_p (tree); 369 370/* Functions from expr.c: */ 371 372/* This is run once per compilation to set up which modes can be used 373 directly in memory and to initialize the block move optab. */ 374extern void init_expr_once (void); 375 376/* This is run at the start of compiling a function. */ 377extern void init_expr (void); 378 379/* This is run at the end of compiling a function. */ 380extern void finish_expr_for_function (void); 381 382/* Use protect_from_queue to convert a QUEUED expression 383 into something that you can put immediately into an instruction. */ 384extern rtx protect_from_queue (rtx, int); 385 386/* Perform all the pending incrementations. */ 387extern void emit_queue (void); 388 389/* Tell if something has a queued subexpression. */ 390extern int queued_subexp_p (rtx); 391 392/* Emit some rtl insns to move data between rtx's, converting machine modes. 393 Both modes must be floating or both fixed. */ 394extern void convert_move (rtx, rtx, int); 395 396/* Convert an rtx to specified machine mode and return the result. */ 397extern rtx convert_to_mode (enum machine_mode, rtx, int); 398 399/* Convert an rtx to MODE from OLDMODE and return the result. */ 400extern rtx convert_modes (enum machine_mode, enum machine_mode, rtx, int); 401 402/* Emit code to move a block Y to a block X. */ 403 404enum block_op_methods 405{ 406 BLOCK_OP_NORMAL, 407 BLOCK_OP_NO_LIBCALL, 408 BLOCK_OP_CALL_PARM 409}; 410 411extern void init_block_move_fn (const char *); 412extern void init_block_clear_fn (const char *); 413 414extern rtx emit_block_move (rtx, rtx, rtx, enum block_op_methods); 415 416/* Copy all or part of a value X into registers starting at REGNO. 417 The number of registers to be filled is NREGS. */ 418extern void move_block_to_reg (int, rtx, int, enum machine_mode); 419 420/* Copy all or part of a BLKmode value X out of registers starting at REGNO. 421 The number of registers to be filled is NREGS. */ 422extern void move_block_from_reg (int, rtx, int); 423 424/* Generate a non-consecutive group of registers represented by a PARALLEL. */ 425extern rtx gen_group_rtx (rtx); 426 427/* Load a BLKmode value into non-consecutive registers represented by a 428 PARALLEL. */ 429extern void emit_group_load (rtx, rtx, tree, int); 430 431/* Move a non-consecutive group of registers represented by a PARALLEL into 432 a non-consecutive group of registers represented by a PARALLEL. */ 433extern void emit_group_move (rtx, rtx); 434 435/* Store a BLKmode value from non-consecutive registers represented by a 436 PARALLEL. */ 437extern void emit_group_store (rtx, rtx, tree, int); 438 439/* Copy BLKmode object from a set of registers. */ 440extern rtx copy_blkmode_from_reg (rtx, rtx, tree); 441 442/* Mark REG as holding a parameter for the next CALL_INSN. */ 443extern void use_reg (rtx *, rtx); 444 445/* Mark NREGS consecutive regs, starting at REGNO, as holding parameters 446 for the next CALL_INSN. */ 447extern void use_regs (rtx *, int, int); 448 449/* Mark a PARALLEL as holding a parameter for the next CALL_INSN. */ 450extern void use_group_regs (rtx *, rtx); 451 452/* Write zeros through the storage of OBJECT. 453 If OBJECT has BLKmode, SIZE is its length in bytes. */ 454extern rtx clear_storage (rtx, rtx); 455 456/* Determine whether the LEN bytes can be moved by using several move 457 instructions. Return nonzero if a call to move_by_pieces should 458 succeed. */ 459extern int can_move_by_pieces (unsigned HOST_WIDE_INT, unsigned int); 460 461/* Return nonzero if it is desirable to store LEN bytes generated by 462 CONSTFUN with several move instructions by store_by_pieces 463 function. CONSTFUNDATA is a pointer which will be passed as argument 464 in every CONSTFUN call. 465 ALIGN is maximum alignment we can assume. */ 466extern int can_store_by_pieces (unsigned HOST_WIDE_INT, 467 rtx (*) (void *, HOST_WIDE_INT, 468 enum machine_mode), 469 void *, unsigned int); 470 471/* Generate several move instructions to store LEN bytes generated by 472 CONSTFUN to block TO. (A MEM rtx with BLKmode). CONSTFUNDATA is a 473 pointer which will be passed as argument in every CONSTFUN call. 474 ALIGN is maximum alignment we can assume. 475 Returns TO + LEN. */ 476extern rtx store_by_pieces (rtx, unsigned HOST_WIDE_INT, 477 rtx (*) (void *, HOST_WIDE_INT, enum machine_mode), 478 void *, unsigned int, int); 479 480/* Emit insns to set X from Y. */ 481extern rtx emit_move_insn (rtx, rtx); 482 483/* Emit insns to set X from Y, with no frills. */ 484extern rtx emit_move_insn_1 (rtx, rtx); 485 486/* Push a block of length SIZE (perhaps variable) 487 and return an rtx to address the beginning of the block. */ 488extern rtx push_block (rtx, int, int); 489 490/* Generate code to push something onto the stack, given its mode and type. */ 491extern void emit_push_insn (rtx, enum machine_mode, tree, rtx, unsigned int, 492 int, rtx, int, rtx, rtx, int, rtx); 493 494/* Expand an assignment that stores the value of FROM into TO. */ 495extern rtx expand_assignment (tree, tree, int); 496 497/* Generate code for computing expression EXP, 498 and storing the value into TARGET. 499 If SUGGEST_REG is nonzero, copy the value through a register 500 and return that register, if that is possible. */ 501extern rtx store_expr (tree, rtx, int); 502 503/* Given an rtx that may include add and multiply operations, 504 generate them as insns and return a pseudo-reg containing the value. 505 Useful after calling expand_expr with 1 as sum_ok. */ 506extern rtx force_operand (rtx, rtx); 507 508/* Return an object on the placeholder list that matches EXP, a 509 PLACEHOLDER_EXPR. An object "matches" if it is of the type of the 510 PLACEHOLDER_EXPR or a pointer type to it. For further information, see 511 tree.def. If no such object is found, abort. If PLIST is nonzero, it is 512 a location which initially points to a starting location in the 513 placeholder list (zero means start of the list) and where a pointer into 514 the placeholder list at which the object is found is placed. */ 515extern tree find_placeholder (tree, tree *); 516 517/* Generate code for computing expression EXP. 518 An rtx for the computed value is returned. The value is never null. 519 In the case of a void EXP, const0_rtx is returned. */ 520#define expand_expr(EXP, TARGET, MODE, MODIFIER) \ 521 expand_expr_real((EXP), (TARGET), (MODE), (MODIFIER), NULL) 522extern rtx expand_expr_real (tree, rtx, enum machine_mode, 523 enum expand_modifier, rtx *); 524 525/* At the start of a function, record that we have no previously-pushed 526 arguments waiting to be popped. */ 527extern void init_pending_stack_adjust (void); 528 529/* Discard any pending stack adjustment. */ 530extern void discard_pending_stack_adjust (void); 531 532/* When exiting from function, if safe, clear out any pending stack adjust 533 so the adjustment won't get done. */ 534extern void clear_pending_stack_adjust (void); 535 536/* Pop any previously-pushed arguments that have not been popped yet. */ 537extern void do_pending_stack_adjust (void); 538 539/* Return the tree node and offset if a given argument corresponds to 540 a string constant. */ 541extern tree string_constant (tree, tree *); 542 543/* Generate code to evaluate EXP and jump to LABEL if the value is zero. */ 544extern void jumpifnot (tree, rtx); 545 546/* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */ 547extern void jumpif (tree, rtx); 548 549/* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if 550 the result is zero, or IF_TRUE_LABEL if the result is one. */ 551extern void do_jump (tree, rtx, rtx); 552 553/* Generate rtl to compare two rtx's, will call emit_cmp_insn. */ 554extern rtx compare_from_rtx (rtx, rtx, enum rtx_code, int, enum machine_mode, 555 rtx); 556extern void do_compare_rtx_and_jump (rtx, rtx, enum rtx_code, int, 557 enum machine_mode, rtx, rtx, rtx); 558 559/* Two different ways of generating switch statements. */ 560extern int try_casesi (tree, tree, tree, tree, rtx, rtx); 561extern int try_tablejump (tree, tree, tree, tree, rtx, rtx); 562 563/* Smallest number of adjacent cases before we use a jump table. 564 XXX Should be a target hook. */ 565extern unsigned int case_values_threshold (void); 566 567 568/* rtl.h and tree.h were included. */ 569/* Return an rtx for the size in bytes of the value of an expr. */ 570extern rtx expr_size (tree); 571 572/* Return a wide integer for the size in bytes of the value of EXP, or -1 573 if the size can vary or is larger than an integer. */ 574extern HOST_WIDE_INT int_expr_size (tree); 575 576extern rtx lookup_static_chain (tree); 577 578/* Convert a stack slot address ADDR valid in function FNDECL 579 into an address valid in this function (using a static chain). */ 580extern rtx fix_lexical_addr (rtx, tree); 581 582/* Return the address of the trampoline for entering nested fn FUNCTION. */ 583extern rtx trampoline_address (tree); 584 585/* Return an rtx that refers to the value returned by a function 586 in its original home. This becomes invalid if any more code is emitted. */ 587extern rtx hard_function_value (tree, tree, int); 588 589extern rtx prepare_call_address (rtx, tree, rtx *, int, int); 590 591extern rtx expand_call (tree, rtx, int); 592 593#ifdef TREE_CODE 594extern rtx expand_shift (enum tree_code, enum machine_mode, rtx, tree, rtx, 595 int); 596extern rtx expand_divmod (int, enum tree_code, enum machine_mode, rtx, rtx, 597 rtx, int); 598#endif 599 600extern void locate_and_pad_parm (enum machine_mode, tree, int, int, tree, 601 struct args_size *, 602 struct locate_and_pad_arg_data *); 603extern rtx expand_inline_function (tree, tree, rtx, int, tree, rtx); 604 605/* Return the CODE_LABEL rtx for a LABEL_DECL, creating it if necessary. */ 606extern rtx label_rtx (tree); 607 608/* As label_rtx, but additionally the label is placed on the forced label 609 list of its containing function (i.e. it is treated as reachable even 610 if how is not obvious). */ 611extern rtx force_label_rtx (tree); 612 613/* Indicate how an input argument register was promoted. */ 614extern rtx promoted_input_arg (unsigned int, enum machine_mode *, int *); 615 616/* Return an rtx like arg but sans any constant terms. 617 Returns the original rtx if it has no constant terms. 618 The constant terms are added and stored via a second arg. */ 619extern rtx eliminate_constant_term (rtx, rtx *); 620 621/* Convert arg to a valid memory address for specified machine mode, 622 by emitting insns to perform arithmetic if nec. */ 623extern rtx memory_address (enum machine_mode, rtx); 624 625/* Like `memory_address' but pretent `flag_force_addr' is 0. */ 626extern rtx memory_address_noforce (enum machine_mode, rtx); 627 628/* Set the alias set of MEM to SET. */ 629extern void set_mem_alias_set (rtx, HOST_WIDE_INT); 630 631/* Set the alignment of MEM to ALIGN bits. */ 632extern void set_mem_align (rtx, unsigned int); 633 634/* Set the expr for MEM to EXPR. */ 635extern void set_mem_expr (rtx, tree); 636 637/* Set the offset for MEM to OFFSET. */ 638extern void set_mem_offset (rtx, rtx); 639 640/* Set the size for MEM to SIZE. */ 641extern void set_mem_size (rtx, rtx); 642 643/* Return a memory reference like MEMREF, but with its mode changed 644 to MODE and its address changed to ADDR. 645 (VOIDmode means don't change the mode. 646 NULL for ADDR means don't change the address.) */ 647extern rtx change_address (rtx, enum machine_mode, rtx); 648 649/* Return a memory reference like MEMREF, but with its mode changed 650 to MODE and its address offset by OFFSET bytes. */ 651#define adjust_address(MEMREF, MODE, OFFSET) \ 652 adjust_address_1 (MEMREF, MODE, OFFSET, 1, 1) 653 654/* Likewise, but the reference is not required to be valid. */ 655#define adjust_address_nv(MEMREF, MODE, OFFSET) \ 656 adjust_address_1 (MEMREF, MODE, OFFSET, 0, 1) 657 658/* Return a memory reference like MEMREF, but with its mode changed 659 to MODE and its address changed to ADDR, which is assumed to be 660 increased by OFFSET bytes from MEMREF. */ 661#define adjust_automodify_address(MEMREF, MODE, ADDR, OFFSET) \ 662 adjust_automodify_address_1 (MEMREF, MODE, ADDR, OFFSET, 1) 663 664/* Likewise, but the reference is not required to be valid. */ 665#define adjust_automodify_address_nv(MEMREF, MODE, ADDR, OFFSET) \ 666 adjust_automodify_address_1 (MEMREF, MODE, ADDR, OFFSET, 0) 667 668extern rtx adjust_address_1 (rtx, enum machine_mode, HOST_WIDE_INT, int, int); 669extern rtx adjust_automodify_address_1 (rtx, enum machine_mode, rtx, 670 HOST_WIDE_INT, int); 671 672/* Return a memory reference like MEMREF, but whose address is changed by 673 adding OFFSET, an RTX, to it. POW2 is the highest power of two factor 674 known to be in OFFSET (possibly 1). */ 675extern rtx offset_address (rtx, rtx, unsigned HOST_WIDE_INT); 676 677/* Return a memory reference like MEMREF, but with its address changed to 678 ADDR. The caller is asserting that the actual piece of memory pointed 679 to is the same, just the form of the address is being changed, such as 680 by putting something into a register. */ 681extern rtx replace_equiv_address (rtx, rtx); 682 683/* Likewise, but the reference is not required to be valid. */ 684extern rtx replace_equiv_address_nv (rtx, rtx); 685 686/* Return a memory reference like MEMREF, but with its mode widened to 687 MODE and adjusted by OFFSET. */ 688extern rtx widen_memory_access (rtx, enum machine_mode, HOST_WIDE_INT); 689 690/* Return a memory reference like MEMREF, but which is known to have a 691 valid address. */ 692extern rtx validize_mem (rtx); 693 694/* Given REF, either a MEM or a REG, and T, either the type of X or 695 the expression corresponding to REF, set RTX_UNCHANGING_P if 696 appropriate. */ 697extern void maybe_set_unchanging (rtx, tree); 698 699/* Given REF, a MEM, and T, either the type of X or the expression 700 corresponding to REF, set the memory attributes. OBJECTP is nonzero 701 if we are making a new object of this type. */ 702extern void set_mem_attributes (rtx, tree, int); 703 704/* Similar, except that BITPOS has not yet been applied to REF, so if 705 we alter MEM_OFFSET according to T then we should subtract BITPOS 706 expecting that it'll be added back in later. */ 707extern void set_mem_attributes_minus_bitpos (rtx, tree, int, HOST_WIDE_INT); 708 709/* Assemble the static constant template for function entry trampolines. */ 710extern rtx assemble_trampoline_template (void); 711 712/* Given rtx, return new rtx whose address won't be affected by 713 any side effects. It has been copied to a new temporary reg. */ 714extern rtx stabilize (rtx); 715 716/* Given an rtx, copy all regs it refers to into new temps 717 and return a modified copy that refers to the new temps. */ 718extern rtx copy_all_regs (rtx); 719 720/* Copy given rtx to a new temp reg and return that. */ 721extern rtx copy_to_reg (rtx); 722 723/* Like copy_to_reg but always make the reg Pmode. */ 724extern rtx copy_addr_to_reg (rtx); 725 726/* Like copy_to_reg but always make the reg the specified mode MODE. */ 727extern rtx copy_to_mode_reg (enum machine_mode, rtx); 728 729/* Copy given rtx to given temp reg and return that. */ 730extern rtx copy_to_suggested_reg (rtx, rtx, enum machine_mode); 731 732/* Copy a value to a register if it isn't already a register. 733 Args are mode (in case value is a constant) and the value. */ 734extern rtx force_reg (enum machine_mode, rtx); 735 736/* Return given rtx, copied into a new temp reg if it was in memory. */ 737extern rtx force_not_mem (rtx); 738 739/* Return mode and signedness to use when object is promoted. */ 740extern enum machine_mode promote_mode (tree, enum machine_mode, int *, int); 741 742/* Remove some bytes from the stack. An rtx says how many. */ 743extern void adjust_stack (rtx); 744 745/* Add some bytes to the stack. An rtx says how many. */ 746extern void anti_adjust_stack (rtx); 747 748/* This enum is used for the following two functions. */ 749enum save_level {SAVE_BLOCK, SAVE_FUNCTION, SAVE_NONLOCAL}; 750 751/* Save the stack pointer at the specified level. */ 752extern void emit_stack_save (enum save_level, rtx *, rtx); 753 754/* Restore the stack pointer from a save area of the specified level. */ 755extern void emit_stack_restore (enum save_level, rtx, rtx); 756 757/* Allocate some space on the stack dynamically and return its address. An rtx 758 says how many bytes. */ 759extern rtx allocate_dynamic_stack_space (rtx, rtx, int); 760 761/* Probe a range of stack addresses from FIRST to FIRST+SIZE, inclusive. 762 FIRST is a constant and size is a Pmode RTX. These are offsets from the 763 current stack pointer. STACK_GROWS_DOWNWARD says whether to add or 764 subtract from the stack. If SIZE is constant, this is done 765 with a fixed number of probes. Otherwise, we must make a loop. */ 766extern void probe_stack_range (HOST_WIDE_INT, rtx); 767 768/* Return an rtx that refers to the value returned by a library call 769 in its original home. This becomes invalid if any more code is emitted. */ 770extern rtx hard_libcall_value (enum machine_mode); 771 772/* Given an rtx, return an rtx for a value rounded up to a multiple 773 of STACK_BOUNDARY / BITS_PER_UNIT. */ 774extern rtx round_push (rtx); 775 776/* Return the mode desired by operand N of a particular bitfield 777 insert/extract insn, or MAX_MACHINE_MODE if no such insn is 778 available. */ 779 780enum extraction_pattern { EP_insv, EP_extv, EP_extzv }; 781extern enum machine_mode 782mode_for_extraction (enum extraction_pattern, int); 783 784extern rtx store_bit_field (rtx, unsigned HOST_WIDE_INT, 785 unsigned HOST_WIDE_INT, enum machine_mode, rtx, 786 HOST_WIDE_INT); 787extern rtx extract_bit_field (rtx, unsigned HOST_WIDE_INT, 788 unsigned HOST_WIDE_INT, int, rtx, 789 enum machine_mode, enum machine_mode, 790 HOST_WIDE_INT); 791extern rtx expand_mult (enum machine_mode, rtx, rtx, rtx, int); 792extern bool const_mult_add_overflow_p (rtx, rtx, rtx, enum machine_mode, int); 793extern rtx expand_mult_add (rtx, rtx, rtx, rtx,enum machine_mode, int); 794extern rtx expand_mult_highpart_adjust (enum machine_mode, rtx, rtx, rtx, rtx, int); 795 796extern rtx assemble_static_space (unsigned HOST_WIDE_INT); 797extern int safe_from_p (rtx, tree, int); 798 799/* Call this once to initialize the contents of the optabs 800 appropriately for the current target machine. */ 801extern void init_optabs (void); 802extern void init_all_optabs (void); 803 804/* Call this to initialize an optab function entry. */ 805extern rtx init_one_libfunc (const char *); 806 807extern void do_jump_by_parts_equality_rtx (rtx, rtx, rtx); 808extern void do_jump_by_parts_greater_rtx (enum machine_mode, int, rtx, rtx, 809 rtx, rtx); 810 811extern void mark_seen_cases (tree, unsigned char *, HOST_WIDE_INT, int); 812 813extern int vector_mode_valid_p (enum machine_mode); 814 815extern tree placeholder_list; 816