expr.h revision 146895
1258945Sroberto/* Definitions for code generation pass of GNU compiler. 2258945Sroberto Copyright (C) 1987, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 3258945Sroberto 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. 4258945Sroberto 5258945SrobertoThis file is part of GCC. 6258945Sroberto 7258945SrobertoGCC is free software; you can redistribute it and/or modify it under 8258945Srobertothe terms of the GNU General Public License as published by the Free 9258945SrobertoSoftware Foundation; either version 2, or (at your option) any later 10258945Srobertoversion. 11258945Sroberto 12258945SrobertoGCC is distributed in the hope that it will be useful, but WITHOUT ANY 13258945SrobertoWARRANTY; without even the implied warranty of MERCHANTABILITY or 14258945SrobertoFITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15258945Srobertofor more details. 16258945Sroberto 17258945SrobertoYou should have received a copy of the GNU General Public License 18258945Srobertoalong with GCC; see the file COPYING. If not, write to the Free 19258945SrobertoSoftware Foundation, 59 Temple Place - Suite 330, Boston, MA 20258945Sroberto02111-1307, USA. */ 21258945Sroberto 22258945Sroberto/* The default branch cost is 1. */ 23258945Sroberto#ifndef BRANCH_COST 24258945Sroberto#define BRANCH_COST 1 25258945Sroberto#endif 26258945Sroberto 27258945Sroberto/* Macros to access the slots of a QUEUED rtx. 28258945Sroberto Here rather than in rtl.h because only the expansion pass 29258945Sroberto should ever encounter a QUEUED. */ 30258945Sroberto 31258945Sroberto/* The variable for which an increment is queued. */ 32258945Sroberto#define QUEUED_VAR(P) XEXP (P, 0) 33258945Sroberto/* If the increment has been emitted, this is the insn 34258945Sroberto that does the increment. It is zero before the increment is emitted. 35258945Sroberto If more than one insn is emitted, this is the first insn. */ 36258945Sroberto#define QUEUED_INSN(P) XEXP (P, 1) 37258945Sroberto/* If a pre-increment copy has been generated, this is the copy 38258945Sroberto (it is a temporary reg). Zero if no copy made yet. */ 39280849Scy#define QUEUED_COPY(P) XEXP (P, 2) 40258945Sroberto/* This is the body to use for the insn to do the increment. 41258945Sroberto It is used to emit the increment. */ 42258945Sroberto#define QUEUED_BODY(P) XEXP (P, 3) 43258945Sroberto/* Next QUEUED in the queue. */ 44258945Sroberto#define QUEUED_NEXT(P) XEXP (P, 4) 45258945Sroberto 46258945Sroberto/* This is the 4th arg to `expand_expr'. 47258945Sroberto EXPAND_STACK_PARM means we are possibly expanding a call param onto 48258945Sroberto the stack. Choosing a value of 2 isn't special; It just allows 49258945Sroberto some code optimization in store_expr. 50258945Sroberto EXPAND_SUM means it is ok to return a PLUS rtx or MULT rtx. 51258945Sroberto EXPAND_INITIALIZER is similar but also record any labels on forced_labels. 52258945Sroberto EXPAND_CONST_ADDRESS means it is ok to return a MEM whose address 53258945Sroberto is a constant that is not a legitimate address. 54258945Sroberto EXPAND_WRITE means we are only going to write to the resulting rtx. 55258945Sroberto EXPAND_MEMORY means we are interested in a memory result, even if 56258945Sroberto the memory is constant and we could have propagated a constant value. */ 57258945Srobertoenum expand_modifier {EXPAND_NORMAL = 0, EXPAND_STACK_PARM = 2, EXPAND_SUM, 58258945Sroberto EXPAND_CONST_ADDRESS, EXPAND_INITIALIZER, EXPAND_WRITE, 59258945Sroberto EXPAND_MEMORY}; 60258945Sroberto 61258945Sroberto/* Prevent the compiler from deferring stack pops. See 62258945Sroberto inhibit_defer_pop for more information. */ 63258945Sroberto#define NO_DEFER_POP (inhibit_defer_pop += 1) 64258945Sroberto 65258945Sroberto/* Allow the compiler to defer stack pops. See inhibit_defer_pop for 66258945Sroberto more information. */ 67258945Sroberto#define OK_DEFER_POP (inhibit_defer_pop -= 1) 68258945Sroberto 69280849Scy/* If a memory-to-memory move would take MOVE_RATIO or more simple 70258945Sroberto move-instruction sequences, we will do a movstr or libcall instead. */ 71280849Scy 72280849Scy#ifndef MOVE_RATIO 73280849Scy#if defined (HAVE_movstrqi) || defined (HAVE_movstrhi) || defined (HAVE_movstrsi) || defined (HAVE_movstrdi) || defined (HAVE_movstrti) 74280849Scy#define MOVE_RATIO 2 75280849Scy#else 76258945Sroberto/* If we are optimizing for space (-Os), cut down the default move ratio. */ 77258945Sroberto#define MOVE_RATIO (optimize_size ? 3 : 15) 78258945Sroberto#endif 79258945Sroberto#endif 80258945Sroberto 81258945Sroberto/* If a clear memory operation would take CLEAR_RATIO or more simple 82258945Sroberto move-instruction sequences, we will do a clrstr or libcall instead. */ 83258945Sroberto 84258945Sroberto#ifndef CLEAR_RATIO 85258945Sroberto#if defined (HAVE_clrstrqi) || defined (HAVE_clrstrhi) || defined (HAVE_clrstrsi) || defined (HAVE_clrstrdi) || defined (HAVE_clrstrti) 86280849Scy#define CLEAR_RATIO 2 87280849Scy#else 88280849Scy/* If we are optimizing for space, cut down the default clear ratio. */ 89280849Scy#define CLEAR_RATIO (optimize_size ? 3 : 15) 90258945Sroberto#endif 91280849Scy#endif 92258945Sroberto 93258945Srobertoenum direction {none, upward, downward}; 94258945Sroberto 95258945Sroberto/* Structure to record the size of a sequence of arguments 96258945Sroberto as the sum of a tree-expression and a constant. This structure is 97258945Sroberto also used to store offsets from the stack, which might be negative, 98280849Scy so the variable part must be ssizetype, not sizetype. */ 99280849Scy 100280849Scystruct args_size 101280849Scy{ 102280849Scy HOST_WIDE_INT constant; 103258945Sroberto tree var; 104280849Scy}; 105280849Scy 106280849Scy/* Package up various arg related fields of struct args for 107280849Scy locate_and_pad_parm. */ 108280849Scystruct locate_and_pad_arg_data 109280849Scy{ 110280849Scy /* Size of this argument on the stack, rounded up for any padding it 111280849Scy gets. If REG_PARM_STACK_SPACE is defined, then register parms are 112280849Scy counted here, otherwise they aren't. */ 113280849Scy struct args_size size; 114280849Scy /* Offset of this argument from beginning of stack-args. */ 115280849Scy struct args_size offset; 116280849Scy /* Offset to the start of the stack slot. Different from OFFSET 117280849Scy if this arg pads downward. */ 118280849Scy struct args_size slot_offset; 119280849Scy /* The amount that the stack pointer needs to be adjusted to 120280849Scy force alignment for the next argument. */ 121280849Scy struct args_size alignment_pad; 122280849Scy /* Which way we should pad this arg. */ 123280849Scy enum direction where_pad; 124280849Scy}; 125280849Scy 126280849Scy/* Add the value of the tree INC to the `struct args_size' TO. */ 127280849Scy 128280849Scy#define ADD_PARM_SIZE(TO, INC) \ 129280849Scydo { \ 130280849Scy tree inc = (INC); \ 131258945Sroberto if (host_integerp (inc, 0)) \ 132258945Sroberto (TO).constant += tree_low_cst (inc, 0); \ 133280849Scy else if ((TO).var == 0) \ 134280849Scy (TO).var = convert (ssizetype, inc); \ 135258945Sroberto else \ 136258945Sroberto (TO).var = size_binop (PLUS_EXPR, (TO).var, \ 137280849Scy convert (ssizetype, inc)); \ 138280849Scy} while (0) 139280849Scy 140280849Scy#define SUB_PARM_SIZE(TO, DEC) \ 141280849Scydo { \ 142280849Scy tree dec = (DEC); \ 143280849Scy if (host_integerp (dec, 0)) \ 144280849Scy (TO).constant -= tree_low_cst (dec, 0); \ 145280849Scy else if ((TO).var == 0) \ 146280849Scy (TO).var = size_binop (MINUS_EXPR, ssize_int (0), \ 147280849Scy convert (ssizetype, dec)); \ 148280849Scy else \ 149280849Scy (TO).var = size_binop (MINUS_EXPR, (TO).var, \ 150280849Scy convert (ssizetype, dec)); \ 151280849Scy} while (0) 152280849Scy 153280849Scy/* Convert the implicit sum in a `struct args_size' into a tree 154280849Scy of type ssizetype. */ 155280849Scy#define ARGS_SIZE_TREE(SIZE) \ 156258945Sroberto((SIZE).var == 0 ? ssize_int ((SIZE).constant) \ 157258945Sroberto : size_binop (PLUS_EXPR, convert (ssizetype, (SIZE).var), \ 158258945Sroberto ssize_int ((SIZE).constant))) 159258945Sroberto 160280849Scy/* Convert the implicit sum in a `struct args_size' into an rtx. */ 161258945Sroberto#define ARGS_SIZE_RTX(SIZE) \ 162258945Sroberto((SIZE).var == 0 ? GEN_INT ((SIZE).constant) \ 163258945Sroberto : expand_expr (ARGS_SIZE_TREE (SIZE), NULL_RTX, VOIDmode, 0)) 164258945Sroberto 165280849Scy/* Supply a default definition for FUNCTION_ARG_PADDING: 166258945Sroberto usually pad upward, but pad short args downward on 167280849Scy big-endian machines. */ 168280849Scy 169258945Sroberto#define DEFAULT_FUNCTION_ARG_PADDING(MODE, TYPE) \ 170280849Scy (! BYTES_BIG_ENDIAN \ 171280849Scy ? upward \ 172280849Scy : (((MODE) == BLKmode \ 173280849Scy ? ((TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \ 174280849Scy && int_size_in_bytes (TYPE) < (PARM_BOUNDARY / BITS_PER_UNIT)) \ 175280849Scy : GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY) \ 176280849Scy ? downward : upward)) 177280849Scy 178280849Scy#ifndef FUNCTION_ARG_PADDING 179280849Scy#define FUNCTION_ARG_PADDING(MODE, TYPE) \ 180258945Sroberto DEFAULT_FUNCTION_ARG_PADDING ((MODE), (TYPE)) 181258945Sroberto#endif 182258945Sroberto 183280849Scy/* Supply a default definition for FUNCTION_ARG_BOUNDARY. Normally, we let 184258945Sroberto FUNCTION_ARG_PADDING, which also pads the length, handle any needed 185280849Scy alignment. */ 186258945Sroberto 187280849Scy#ifndef FUNCTION_ARG_BOUNDARY 188258945Sroberto#define FUNCTION_ARG_BOUNDARY(MODE, TYPE) PARM_BOUNDARY 189280849Scy#endif 190280849Scy 191280849Scytree split_complex_types (tree); 192280849Scytree split_complex_values (tree); 193280849Scy 194280849Scy/* Nonzero if we do not know how to pass TYPE solely in registers. */ 195280849Scyextern bool default_must_pass_in_stack (enum machine_mode, tree); 196280849Scy#ifndef MUST_PASS_IN_STACK 197280849Scy#define MUST_PASS_IN_STACK(MODE,TYPE) default_must_pass_in_stack(MODE, TYPE) 198280849Scy#endif 199280849Scy 200280849Scy/* Supply a default definition of STACK_SAVEAREA_MODE for emit_stack_save. 201280849Scy Normally move_insn, so Pmode stack pointer. */ 202280849Scy 203280849Scy#ifndef STACK_SAVEAREA_MODE 204280849Scy#define STACK_SAVEAREA_MODE(LEVEL) Pmode 205280849Scy#endif 206280849Scy 207280849Scy/* Supply a default definition of STACK_SIZE_MODE for 208280849Scy allocate_dynamic_stack_space. Normally PLUS/MINUS, so word_mode. */ 209280849Scy 210280849Scy#ifndef STACK_SIZE_MODE 211280849Scy#define STACK_SIZE_MODE word_mode 212280849Scy#endif 213280849Scy 214280849Scy/* Provide default values for the macros controlling stack checking. */ 215280849Scy 216280849Scy#ifndef STACK_CHECK_BUILTIN 217280849Scy#define STACK_CHECK_BUILTIN 0 218280849Scy#endif 219258945Sroberto 220258945Sroberto/* The default interval is one page. */ 221258945Sroberto#ifndef STACK_CHECK_PROBE_INTERVAL 222258945Sroberto#define STACK_CHECK_PROBE_INTERVAL 4096 223258945Sroberto#endif 224258945Sroberto 225258945Sroberto/* The default is to do a store into the stack. */ 226258945Sroberto#ifndef STACK_CHECK_PROBE_LOAD 227258945Sroberto#define STACK_CHECK_PROBE_LOAD 0 228258945Sroberto#endif 229280849Scy 230258945Sroberto/* This value is arbitrary, but should be sufficient for most machines. */ 231258945Sroberto#ifndef STACK_CHECK_PROTECT 232258945Sroberto#define STACK_CHECK_PROTECT (75 * UNITS_PER_WORD) 233280849Scy#endif 234258945Sroberto 235258945Sroberto/* Make the maximum frame size be the largest we can and still only need 236258945Sroberto one probe per function. */ 237258945Sroberto#ifndef STACK_CHECK_MAX_FRAME_SIZE 238258945Sroberto#define STACK_CHECK_MAX_FRAME_SIZE \ 239280849Scy (STACK_CHECK_PROBE_INTERVAL - UNITS_PER_WORD) 240258945Sroberto#endif 241280849Scy 242280849Scy/* This is arbitrary, but should be large enough everywhere. */ 243258945Sroberto#ifndef STACK_CHECK_FIXED_FRAME_SIZE 244280849Scy#define STACK_CHECK_FIXED_FRAME_SIZE (4 * UNITS_PER_WORD) 245258945Sroberto#endif 246258945Sroberto 247280849Scy/* Provide a reasonable default for the maximum size of an object to 248258945Sroberto allocate in the fixed frame. We may need to be able to make this 249258945Sroberto controllable by the user at some point. */ 250280849Scy#ifndef STACK_CHECK_MAX_VAR_SIZE 251280849Scy#define STACK_CHECK_MAX_VAR_SIZE (STACK_CHECK_MAX_FRAME_SIZE / 100) 252258945Sroberto#endif 253258945Sroberto 254280849Scy/* Functions from optabs.c, commonly used, and without need for the optabs 255280849Scy tables: */ 256258945Sroberto 257258945Sroberto/* Passed to expand_simple_binop and expand_binop to say which options 258258945Sroberto to try to use if the requested operation can't be open-coded on the 259258945Sroberto requisite mode. Either OPTAB_LIB or OPTAB_LIB_WIDEN says try using 260280849Scy a library call. Either OPTAB_WIDEN or OPTAB_LIB_WIDEN says try 261258945Sroberto using a wider mode. OPTAB_MUST_WIDEN says try widening and don't 262280849Scy try anything else. */ 263280849Scy 264258945Srobertoenum optab_methods 265280849Scy{ 266280849Scy OPTAB_DIRECT, 267280849Scy OPTAB_LIB, 268280849Scy OPTAB_WIDEN, 269280849Scy OPTAB_LIB_WIDEN, 270280849Scy OPTAB_MUST_WIDEN 271280849Scy}; 272280849Scy 273258945Sroberto/* Generate code for a simple binary or unary operation. "Simple" in 274258945Sroberto this case means "can be unambiguously described by a (mode, code) 275280849Scy pair and mapped to a single optab." */ 276280849Scyextern rtx expand_simple_binop (enum machine_mode, enum rtx_code, rtx, 277258945Sroberto rtx, rtx, int, enum optab_methods); 278258945Srobertoextern rtx expand_simple_unop (enum machine_mode, enum rtx_code, rtx, rtx, 279258945Sroberto int); 280258945Sroberto 281280849Scy/* Report whether the machine description contains an insn which can 282258945Sroberto perform the operation described by CODE and MODE. */ 283280849Scyextern int have_insn_for (enum rtx_code, enum machine_mode); 284280849Scy 285280849Scy/* Emit code to make a call to a constant function or a library call. */ 286280849Scyextern void emit_libcall_block (rtx, rtx, rtx, rtx); 287280849Scy 288280849Scy/* Create but don't emit one rtl instruction to perform certain operations. 289280849Scy Modes must match; operands must meet the operation's predicates. 290258945Sroberto Likewise for subtraction and for just copying. 291258945Sroberto These do not call protect_from_queue; caller must do so. */ 292280849Scyextern rtx gen_add2_insn (rtx, rtx); 293280849Scyextern rtx gen_add3_insn (rtx, rtx, rtx); 294258945Srobertoextern rtx gen_sub2_insn (rtx, rtx); 295258945Srobertoextern rtx gen_sub3_insn (rtx, rtx, rtx); 296258945Srobertoextern rtx gen_move_insn (rtx, rtx); 297258945Srobertoextern int have_add2_insn (rtx, rtx); 298280849Scyextern int have_sub2_insn (rtx, rtx); 299258945Sroberto 300280849Scy/* Emit a pair of rtl insns to compare two rtx's and to jump 301280849Scy to a label if the comparison is true. */ 302280849Scyextern void emit_cmp_and_jump_insns (rtx, rtx, enum rtx_code, rtx, 303258945Sroberto enum machine_mode, int, rtx); 304280849Scy 305258945Sroberto/* Generate code to indirectly jump to a location given in the rtx LOC. */ 306280849Scyextern void emit_indirect_jump (rtx); 307258945Sroberto 308258945Sroberto#ifdef HAVE_conditional_move 309280849Scy/* Emit a conditional move operation. */ 310280849Scyrtx emit_conditional_move (rtx, enum rtx_code, rtx, rtx, enum machine_mode, 311280849Scy rtx, rtx, enum machine_mode, int); 312258945Sroberto 313258945Sroberto/* Return nonzero if the conditional move is supported. */ 314280849Scyint can_conditionally_move_p (enum machine_mode mode); 315280849Scy 316258945Sroberto#endif 317258945Srobertortx emit_conditional_add (rtx, enum rtx_code, rtx, rtx, enum machine_mode, 318258945Sroberto rtx, rtx, enum machine_mode, int); 319258945Sroberto 320280849Scy 321258945Sroberto/* Functions from expmed.c: */ 322280849Scy 323280849Scy/* Arguments MODE, RTX: return an rtx for the negation of that value. 324280849Scy May emit insns. */ 325258945Srobertoextern rtx negate_rtx (enum machine_mode, rtx); 326280849Scy 327258945Sroberto/* Expand a logical AND operation. */ 328280849Scyextern rtx expand_and (enum machine_mode, rtx, rtx, rtx); 329258945Sroberto 330258945Sroberto/* Emit a store-flag operation. */ 331280849Scyextern rtx emit_store_flag (rtx, enum rtx_code, rtx, rtx, enum machine_mode, 332280849Scy int, int); 333280849Scy 334280849Scy/* Like emit_store_flag, but always succeeds. */ 335280849Scyextern rtx emit_store_flag_force (rtx, enum rtx_code, rtx, rtx, 336258945Sroberto enum machine_mode, int, int); 337280849Scy 338280849Scy/* Functions from loop.c: */ 339280849Scy 340258945Sroberto/* Given an insn and condition, return a canonical description of 341258945Sroberto the test being made. */ 342280849Scyextern rtx canonicalize_condition (rtx, rtx, int, rtx *, rtx, int); 343280849Scy 344258945Sroberto/* Given a JUMP_INSN, return a canonical description of the test 345258945Sroberto being made. */ 346258945Srobertoextern rtx get_condition (rtx, rtx *, int); 347258945Sroberto 348280849Scy/* Generate a conditional trap instruction. */ 349258945Srobertoextern rtx gen_cond_trap (enum rtx_code, rtx, rtx, rtx); 350280849Scy 351280849Scy/* Functions from builtins.c: */ 352280849Scyextern rtx expand_builtin (tree, rtx, rtx, enum machine_mode, int); 353280849Scyextern tree std_build_builtin_va_list (void); 354280849Scyextern void std_expand_builtin_va_start (tree, rtx); 355280849Scyextern rtx std_expand_builtin_va_arg (tree, tree); 356280849Scyextern rtx expand_builtin_va_arg (tree, tree); 357258945Srobertoextern rtx default_expand_builtin (tree, rtx, rtx, enum machine_mode, int); 358258945Srobertoextern void expand_builtin_setjmp_setup (rtx, rtx); 359280849Scyextern void expand_builtin_setjmp_receiver (rtx); 360280849Scyextern void expand_builtin_longjmp (rtx, rtx); 361258945Srobertoextern rtx expand_builtin_saveregs (void); 362258945Srobertoextern void expand_builtin_trap (void); 363258945Srobertoextern HOST_WIDE_INT get_varargs_alias_set (void); 364258945Srobertoextern HOST_WIDE_INT get_frame_alias_set (void); 365258945Srobertoextern void record_base_value (unsigned int, rtx, int); 366258945Srobertoextern void record_alias_subset (HOST_WIDE_INT, HOST_WIDE_INT); 367258945Srobertoextern HOST_WIDE_INT new_alias_set (void); 368258945Srobertoextern int can_address_p (tree); 369280849Scy 370280849Scy/* Functions from expr.c: */ 371280849Scy 372280849Scy/* This is run once per compilation to set up which modes can be used 373258945Sroberto directly in memory and to initialize the block move optab. */ 374258945Srobertoextern void init_expr_once (void); 375280849Scy 376258945Sroberto/* This is run at the start of compiling a function. */ 377258945Srobertoextern void init_expr (void); 378258945Sroberto 379258945Sroberto/* This is run at the end of compiling a function. */ 380258945Srobertoextern void finish_expr_for_function (void); 381280849Scy 382280849Scy/* Use protect_from_queue to convert a QUEUED expression 383280849Scy into something that you can put immediately into an instruction. */ 384280849Scyextern rtx protect_from_queue (rtx, int); 385280849Scy 386280849Scy/* Perform all the pending incrementations. */ 387280849Scyextern void emit_queue (void); 388280849Scy 389280849Scy/* Tell if something has a queued subexpression. */ 390280849Scyextern int queued_subexp_p (rtx); 391280849Scy 392280849Scy/* Emit some rtl insns to move data between rtx's, converting machine modes. 393280849Scy Both modes must be floating or both fixed. */ 394280849Scyextern void convert_move (rtx, rtx, int); 395280849Scy 396280849Scy/* Convert an rtx to specified machine mode and return the result. */ 397280849Scyextern rtx convert_to_mode (enum machine_mode, rtx, int); 398258945Sroberto 399258945Sroberto/* Convert an rtx to MODE from OLDMODE and return the result. */ 400280849Scyextern rtx convert_modes (enum machine_mode, enum machine_mode, rtx, int); 401280849Scy 402280849Scy/* Emit code to move a block Y to a block X. */ 403280849Scy 404280849Scyenum block_op_methods 405280849Scy{ 406280849Scy BLOCK_OP_NORMAL, 407280849Scy BLOCK_OP_NO_LIBCALL, 408280849Scy BLOCK_OP_CALL_PARM 409280849Scy}; 410280849Scy 411280849Scyextern void init_block_move_fn (const char *); 412258945Srobertoextern void init_block_clear_fn (const char *); 413280849Scy 414258945Srobertoextern rtx emit_block_move (rtx, rtx, rtx, enum block_op_methods); 415280849Scy 416280849Scy/* Copy all or part of a value X into registers starting at REGNO. 417280849Scy The number of registers to be filled is NREGS. */ 418280849Scyextern void move_block_to_reg (int, rtx, int, enum machine_mode); 419280849Scy 420280849Scy/* Copy all or part of a BLKmode value X out of registers starting at REGNO. 421280849Scy The number of registers to be filled is NREGS. */ 422280849Scyextern void move_block_from_reg (int, rtx, int); 423280849Scy 424280849Scy/* Generate a non-consecutive group of registers represented by a PARALLEL. */ 425280849Scyextern rtx gen_group_rtx (rtx); 426280849Scy 427280849Scy/* Load a BLKmode value into non-consecutive registers represented by a 428280849Scy PARALLEL. */ 429280849Scyextern void emit_group_load (rtx, rtx, tree, int); 430258945Sroberto 431280849Scy/* Move a non-consecutive group of registers represented by a PARALLEL into 432280849Scy a non-consecutive group of registers represented by a PARALLEL. */ 433280849Scyextern void emit_group_move (rtx, rtx); 434280849Scy 435280849Scy/* Store a BLKmode value from non-consecutive registers represented by a 436280849Scy PARALLEL. */ 437280849Scyextern void emit_group_store (rtx, rtx, tree, int); 438258945Sroberto 439258945Sroberto/* Copy BLKmode object from a set of registers. */ 440280849Scyextern rtx copy_blkmode_from_reg (rtx, rtx, tree); 441280849Scy 442258945Sroberto/* Mark REG as holding a parameter for the next CALL_INSN. */ 443258945Srobertoextern void use_reg (rtx *, rtx); 444258945Sroberto 445258945Sroberto/* Mark NREGS consecutive regs, starting at REGNO, as holding parameters 446280849Scy for the next CALL_INSN. */ 447258945Srobertoextern void use_regs (rtx *, int, int); 448280849Scy 449280849Scy/* Mark a PARALLEL as holding a parameter for the next CALL_INSN. */ 450280849Scyextern void use_group_regs (rtx *, rtx); 451280849Scy 452280849Scy/* Write zeros through the storage of OBJECT. 453280849Scy If OBJECT has BLKmode, SIZE is its length in bytes. */ 454280849Scyextern rtx clear_storage (rtx, rtx); 455280849Scy 456280849Scy/* Determine whether the LEN bytes can be moved by using several move 457280849Scy instructions. Return nonzero if a call to move_by_pieces should 458280849Scy succeed. */ 459258945Srobertoextern int can_move_by_pieces (unsigned HOST_WIDE_INT, unsigned int); 460280849Scy 461280849Scy/* Return nonzero if it is desirable to store LEN bytes generated by 462280849Scy CONSTFUN with several move instructions by store_by_pieces 463280849Scy function. CONSTFUNDATA is a pointer which will be passed as argument 464280849Scy in every CONSTFUN call. 465280849Scy ALIGN is maximum alignment we can assume. */ 466280849Scyextern int can_store_by_pieces (unsigned HOST_WIDE_INT, 467280849Scy rtx (*) (void *, HOST_WIDE_INT, 468280849Scy enum machine_mode), 469280849Scy void *, unsigned int); 470258945Sroberto 471258945Sroberto/* Generate several move instructions to store LEN bytes generated by 472280849Scy CONSTFUN to block TO. (A MEM rtx with BLKmode). CONSTFUNDATA is a 473280849Scy pointer which will be passed as argument in every CONSTFUN call. 474258945Sroberto ALIGN is maximum alignment we can assume. 475258945Sroberto Returns TO + LEN. */ 476258945Srobertoextern rtx store_by_pieces (rtx, unsigned HOST_WIDE_INT, 477258945Sroberto rtx (*) (void *, HOST_WIDE_INT, enum machine_mode), 478280849Scy void *, unsigned int, int); 479258945Sroberto 480280849Scy/* Emit insns to set X from Y. */ 481280849Scyextern rtx emit_move_insn (rtx, rtx); 482258945Sroberto 483280849Scy/* Emit insns to set X from Y, with no frills. */ 484258945Srobertoextern rtx emit_move_insn_1 (rtx, rtx); 485280849Scy 486280849Scy/* Push a block of length SIZE (perhaps variable) 487258945Sroberto and return an rtx to address the beginning of the block. */ 488258945Srobertoextern rtx push_block (rtx, int, int); 489280849Scy 490280849Scy/* Generate code to push something onto the stack, given its mode and type. */ 491258945Srobertoextern void emit_push_insn (rtx, enum machine_mode, tree, rtx, unsigned int, 492258945Sroberto int, rtx, int, rtx, rtx, int, rtx); 493280849Scy 494280849Scy/* Expand an assignment that stores the value of FROM into TO. */ 495258945Srobertoextern rtx expand_assignment (tree, tree, int); 496258945Sroberto 497258945Sroberto/* Generate code for computing expression EXP, 498258945Sroberto and storing the value into TARGET. 499280849Scy If SUGGEST_REG is nonzero, copy the value through a register 500258945Sroberto and return that register, if that is possible. */ 501280849Scyextern rtx store_expr (tree, rtx, int); 502280849Scy 503280849Scy/* Given an rtx that may include add and multiply operations, 504280849Scy generate them as insns and return a pseudo-reg containing the value. 505280849Scy Useful after calling expand_expr with 1 as sum_ok. */ 506280849Scyextern rtx force_operand (rtx, rtx); 507258945Sroberto 508280849Scy/* Return an object on the placeholder list that matches EXP, a 509258945Sroberto PLACEHOLDER_EXPR. An object "matches" if it is of the type of the 510280849Scy PLACEHOLDER_EXPR or a pointer type to it. For further information, see 511280849Scy tree.def. If no such object is found, abort. If PLIST is nonzero, it is 512258945Sroberto a location which initially points to a starting location in the 513280849Scy placeholder list (zero means start of the list) and where a pointer into 514280849Scy the placeholder list at which the object is found is placed. */ 515280849Scyextern tree find_placeholder (tree, tree *); 516280849Scy 517280849Scy/* Generate code for computing expression EXP. 518258945Sroberto An rtx for the computed value is returned. The value is never null. 519280849Scy In the case of a void EXP, const0_rtx is returned. */ 520280849Scy#define expand_expr(EXP, TARGET, MODE, MODIFIER) \ 521280849Scy expand_expr_real((EXP), (TARGET), (MODE), (MODIFIER), NULL) 522280849Scyextern rtx expand_expr_real (tree, rtx, enum machine_mode, 523280849Scy enum expand_modifier, rtx *); 524258945Sroberto 525280849Scy/* At the start of a function, record that we have no previously-pushed 526280849Scy arguments waiting to be popped. */ 527280849Scyextern void init_pending_stack_adjust (void); 528280849Scy 529280849Scy/* Discard any pending stack adjustment. */ 530280849Scyextern void discard_pending_stack_adjust (void); 531280849Scy 532280849Scy/* When exiting from function, if safe, clear out any pending stack adjust 533280849Scy so the adjustment won't get done. */ 534280849Scyextern void clear_pending_stack_adjust (void); 535280849Scy 536280849Scy/* Pop any previously-pushed arguments that have not been popped yet. */ 537280849Scyextern void do_pending_stack_adjust (void); 538280849Scy 539280849Scy/* Return the tree node and offset if a given argument corresponds to 540280849Scy a string constant. */ 541280849Scyextern tree string_constant (tree, tree *); 542280849Scy 543280849Scy/* Generate code to evaluate EXP and jump to LABEL if the value is zero. */ 544280849Scyextern void jumpifnot (tree, rtx); 545280849Scy 546280849Scy/* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */ 547280849Scyextern void jumpif (tree, rtx); 548280849Scy 549280849Scy/* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if 550280849Scy the result is zero, or IF_TRUE_LABEL if the result is one. */ 551280849Scyextern void do_jump (tree, rtx, rtx); 552280849Scy 553280849Scy/* Generate rtl to compare two rtx's, will call emit_cmp_insn. */ 554280849Scyextern rtx compare_from_rtx (rtx, rtx, enum rtx_code, int, enum machine_mode, 555280849Scy rtx); 556280849Scyextern void do_compare_rtx_and_jump (rtx, rtx, enum rtx_code, int, 557280849Scy enum machine_mode, rtx, rtx, rtx); 558280849Scy 559280849Scy/* Two different ways of generating switch statements. */ 560280849Scyextern int try_casesi (tree, tree, tree, tree, rtx, rtx); 561280849Scyextern int try_tablejump (tree, tree, tree, tree, rtx, rtx); 562280849Scy 563258945Sroberto/* Smallest number of adjacent cases before we use a jump table. 564258945Sroberto XXX Should be a target hook. */ 565280849Scyextern unsigned int case_values_threshold (void); 566280849Scy 567258945Sroberto 568258945Sroberto/* rtl.h and tree.h were included. */ 569258945Sroberto/* Return an rtx for the size in bytes of the value of an expr. */ 570258945Srobertoextern rtx expr_size (tree); 571280849Scy 572258945Sroberto/* Return a wide integer for the size in bytes of the value of EXP, or -1 573280849Scy if the size can vary or is larger than an integer. */ 574280849Scyextern HOST_WIDE_INT int_expr_size (tree); 575280849Scy 576280849Scyextern rtx lookup_static_chain (tree); 577280849Scy 578280849Scy/* Convert a stack slot address ADDR valid in function FNDECL 579280849Scy into an address valid in this function (using a static chain). */ 580280849Scyextern rtx fix_lexical_addr (rtx, tree); 581280849Scy 582280849Scy/* Return the address of the trampoline for entering nested fn FUNCTION. */ 583280849Scyextern rtx trampoline_address (tree); 584280849Scy 585280849Scy/* Return an rtx that refers to the value returned by a function 586280849Scy in its original home. This becomes invalid if any more code is emitted. */ 587280849Scyextern rtx hard_function_value (tree, tree, int); 588258945Sroberto 589280849Scyextern rtx prepare_call_address (rtx, tree, rtx *, int, int); 590280849Scy 591258945Srobertoextern rtx expand_call (tree, rtx, int); 592258945Sroberto 593280849Scy#ifdef TREE_CODE 594280849Scyextern rtx expand_shift (enum tree_code, enum machine_mode, rtx, tree, rtx, 595280849Scy int); 596280849Scyextern rtx expand_divmod (int, enum tree_code, enum machine_mode, rtx, rtx, 597280849Scy rtx, int); 598280849Scy#endif 599280849Scy 600280849Scyextern void locate_and_pad_parm (enum machine_mode, tree, int, int, tree, 601280849Scy struct args_size *, 602258945Sroberto struct locate_and_pad_arg_data *); 603258945Srobertoextern rtx expand_inline_function (tree, tree, rtx, int, tree, rtx); 604258945Sroberto 605258945Sroberto/* Return the CODE_LABEL rtx for a LABEL_DECL, creating it if necessary. */ 606258945Srobertoextern rtx label_rtx (tree); 607258945Sroberto 608258945Sroberto/* As label_rtx, but additionally the label is placed on the forced label 609258945Sroberto list of its containing function (i.e. it is treated as reachable even 610258945Sroberto if how is not obvious). */ 611258945Srobertoextern rtx force_label_rtx (tree); 612258945Sroberto 613258945Sroberto/* Indicate how an input argument register was promoted. */ 614258945Srobertoextern rtx promoted_input_arg (unsigned int, enum machine_mode *, int *); 615258945Sroberto 616258945Sroberto/* Return an rtx like arg but sans any constant terms. 617258945Sroberto Returns the original rtx if it has no constant terms. 618258945Sroberto The constant terms are added and stored via a second arg. */ 619258945Srobertoextern rtx eliminate_constant_term (rtx, rtx *); 620258945Sroberto 621258945Sroberto/* Convert arg to a valid memory address for specified machine mode, 622258945Sroberto by emitting insns to perform arithmetic if nec. */ 623258945Srobertoextern 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