expr.h revision 74473
1193323Sed/* Definitions for code generation pass of GNU compiler. 2193323Sed Copyright (C) 1987, 91-98, 1999 Free Software Foundation, Inc. 3193323Sed 4193323SedThis file is part of GNU CC. 5193323Sed 6193323SedGNU CC is free software; you can redistribute it and/or modify 7193323Sedit under the terms of the GNU General Public License as published by 8193323Sedthe Free Software Foundation; either version 2, or (at your option) 9193323Sedany later version. 10193323Sed 11193323SedGNU CC is distributed in the hope that it will be useful, 12193323Sedbut WITHOUT ANY WARRANTY; without even the implied warranty of 13193323SedMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14193323SedGNU General Public License for more details. 15193323Sed 16193323SedYou should have received a copy of the GNU General Public License 17193323Sedalong with GNU CC; see the file COPYING. If not, write to 18193323Sedthe Free Software Foundation, 59 Temple Place - Suite 330, 19193323SedBoston, MA 02111-1307, USA. */ 20193323Sed 21193323Sed/* The default branch cost is 1. */ 22198090Srdivacky#ifndef BRANCH_COST 23193323Sed#define BRANCH_COST 1 24193323Sed#endif 25193323Sed 26193323Sed/* Macros to access the slots of a QUEUED rtx. 27193323Sed Here rather than in rtl.h because only the expansion pass 28193323Sed should ever encounter a QUEUED. */ 29193323Sed 30193323Sed/* The variable for which an increment is queued. */ 31193323Sed#define QUEUED_VAR(P) XEXP (P, 0) 32193323Sed/* If the increment has been emitted, this is the insn 33193323Sed that does the increment. It is zero before the increment is emitted. 34193323Sed If more than one insn is emitted, this is the first insn. */ 35193323Sed#define QUEUED_INSN(P) XEXP (P, 1) 36193323Sed/* If a pre-increment copy has been generated, this is the copy 37193323Sed (it is a temporary reg). Zero if no copy made yet. */ 38193323Sed#define QUEUED_COPY(P) XEXP (P, 2) 39193323Sed/* This is the body to use for the insn to do the increment. 40193323Sed It is used to emit the increment. */ 41193323Sed#define QUEUED_BODY(P) XEXP (P, 3) 42193323Sed/* Next QUEUED in the queue. */ 43193323Sed#define QUEUED_NEXT(P) XEXP (P, 4) 44198090Srdivacky 45193323Sed/* This is the 4th arg to `expand_expr'. 46193323Sed EXPAND_SUM means it is ok to return a PLUS rtx or MULT rtx. 47193323Sed EXPAND_INITIALIZER is similar but also record any labels on forced_labels. 48193323Sed EXPAND_CONST_ADDRESS means it is ok to return a MEM whose address 49193323Sed is a constant that is not a legitimate address. 50193323Sed EXPAND_MEMORY_USE_* are explained below. */ 51193323Sedenum expand_modifier {EXPAND_NORMAL, EXPAND_SUM, 52193323Sed EXPAND_CONST_ADDRESS, EXPAND_INITIALIZER, 53193323Sed EXPAND_MEMORY_USE_WO, EXPAND_MEMORY_USE_RW, 54193323Sed EXPAND_MEMORY_USE_BAD, EXPAND_MEMORY_USE_DONT}; 55193323Sed 56193323Sed/* Argument for chkr_* functions. 57193323Sed MEMORY_USE_RO: the pointer reads memory. 58193323Sed MEMORY_USE_WO: the pointer writes to memory. 59193323Sed MEMORY_USE_RW: the pointer modifies memory (ie it reads and writes). An 60193323Sed example is (*ptr)++ 61193323Sed MEMORY_USE_BAD: use this if you don't know the behavior of the pointer, or 62193323Sed if you know there are no pointers. Using an INDIRECT_REF 63198090Srdivacky with MEMORY_USE_BAD will abort. 64198090Srdivacky MEMORY_USE_TW: just test for writing, without update. Special. 65198090Srdivacky MEMORY_USE_DONT: the memory is neither read nor written. This is used by 66198090Srdivacky '->' and '.'. */ 67198090Srdivackyenum memory_use_mode {MEMORY_USE_BAD = 0, MEMORY_USE_RO = 1, 68193323Sed MEMORY_USE_WO = 2, MEMORY_USE_RW = 3, 69193323Sed MEMORY_USE_TW = 6, MEMORY_USE_DONT = 99}; 70193323Sed 71193323Sed/* List of labels that must never be deleted. */ 72193323Sedextern rtx forced_labels; 73193323Sed 74193323Sed/* List (chain of EXPR_LISTs) of pseudo-regs of SAVE_EXPRs. 75193323Sed So we can mark them all live at the end of the function, if stupid. */ 76193323Sedextern rtx save_expr_regs; 77193323Sed 78193323Sedextern int current_function_calls_alloca; 79193323Sedextern int current_function_outgoing_args_size; 80193323Sed 81193323Sed/* This is the offset from the arg pointer to the place where the first 82193323Sed anonymous arg can be found, if there is one. */ 83193323Sedextern rtx current_function_arg_offset_rtx; 84193323Sed 85198090Srdivacky/* This is nonzero if the current function uses the constant pool. */ 86198090Srdivackyextern int current_function_uses_const_pool; 87193323Sed 88193323Sed/* This is nonzero if the current function uses pic_offset_table_rtx. */ 89193323Sedextern int current_function_uses_pic_offset_table; 90198090Srdivacky 91198090Srdivacky/* The arg pointer hard register, or the pseudo into which it was copied. */ 92193323Sedextern rtx current_function_internal_arg_pointer; 93198090Srdivacky 94198090Srdivacky/* This is nonzero if memory access checking be enabled in the current 95198090Srdivacky function. */ 96193323Sedextern int current_function_check_memory_usage; 97198090Srdivacky 98193323Sed/* Under some ABIs, it is the caller's responsibility to pop arguments 99193323Sed pushed for function calls. A naive implementation would simply pop 100193323Sed the arguments immediately after each call. However, if several 101193323Sed function calls are made in a row, it is typically cheaper to pop 102193323Sed all the arguments after all of the calls are complete since a 103193323Sed single pop instruction can be used. Therefore, GCC attempts to 104193323Sed defer popping the arguments until absolutely necessary. (For 105193323Sed example, at the end of a conditional, the arguments must be popped, 106193323Sed since code outside the conditional won't know whether or not the 107193323Sed arguments need to be popped.) 108193323Sed 109193323Sed When INHIBIT_DEFER_POP is non-zero, however, the compiler does not 110193323Sed attempt to defer pops. Instead, the stack is popped immediately 111193323Sed after each call. Rather then setting this variable directly, use 112193323Sed NO_DEFER_POP and OK_DEFER_POP. */ 113193323Sedextern int inhibit_defer_pop; 114193323Sed 115193323Sed/* Prevent the compiler from deferring stack pops. See 116193323Sed inhibit_defer_pop for more information. */ 117193323Sed#define NO_DEFER_POP (inhibit_defer_pop += 1) 118193323Sed 119193323Sed/* Allow the compiler to defer stack pops. See inhibit_defer_pop for 120193323Sed more information. */ 121193323Sed#define OK_DEFER_POP (inhibit_defer_pop -= 1) 122193323Sed 123193323Sed/* Number of function calls seen so far in current function. */ 124193323Sed 125193323Sedextern int function_call_count; 126193323Sed 127193323Sed/* List (chain of EXPR_LIST) of stack slots that hold the current handlers 128193323Sed for nonlocal gotos. There is one for every nonlocal label in the function; 129193323Sed this list matches the one in nonlocal_labels. 130198090Srdivacky Zero when function does not have nonlocal labels. */ 131198090Srdivacky 132193323Sedextern rtx nonlocal_goto_handler_slots; 133193323Sed 134193323Sed/* RTX for stack slot that holds the stack pointer value to restore 135198090Srdivacky for a nonlocal goto. 136198090Srdivacky Zero when function does not have nonlocal labels. */ 137193323Sed 138198090Srdivackyextern rtx nonlocal_goto_stack_level; 139198090Srdivacky 140198090Srdivacky/* List (chain of TREE_LIST) of LABEL_DECLs for all nonlocal labels 141193323Sed (labels to which there can be nonlocal gotos from nested functions) 142198090Srdivacky in this function. */ 143193323Sed 144193323Sed#ifdef TREE_CODE /* Don't lose if tree.h not included. */ 145193323Sedextern tree nonlocal_labels; 146193323Sed#endif 147193323Sed 148193323Sed/* Number of units that we should eventually pop off the stack. 149193323Sed These are the arguments to function calls that have already returned. */ 150193323Sedextern int pending_stack_adjust; 151193323Sed 152193323Sed/* When temporaries are created by TARGET_EXPRs, they are created at 153193323Sed this level of temp_slot_level, so that they can remain allocated 154193323Sed until no longer needed. CLEANUP_POINT_EXPRs define the lifetime 155193323Sed of TARGET_EXPRs. */ 156193323Sedextern int target_temp_slot_level; 157193323Sed 158193323Sed/* Current level for normal temporaries. */ 159193323Sed 160193323Sedextern int temp_slot_level; 161193323Sed 162193323Sed#ifdef TREE_CODE /* Don't lose if tree.h not included. */ 163193323Sed/* Structure to record the size of a sequence of arguments 164193323Sed as the sum of a tree-expression and a constant. */ 165193323Sed 166193323Sedstruct args_size 167193323Sed{ 168193323Sed HOST_WIDE_INT constant; 169193323Sed tree var; 170193323Sed}; 171193323Sed#endif 172193323Sed 173193323Sed/* Add the value of the tree INC to the `struct args_size' TO. */ 174193323Sed 175193323Sed#define ADD_PARM_SIZE(TO, INC) \ 176193323Sed{ tree inc = (INC); \ 177193323Sed if (TREE_CODE (inc) == INTEGER_CST) \ 178193323Sed (TO).constant += TREE_INT_CST_LOW (inc); \ 179193323Sed else if ((TO).var == 0) \ 180193323Sed (TO).var = inc; \ 181193323Sed else \ 182193323Sed (TO).var = size_binop (PLUS_EXPR, (TO).var, inc); } 183193323Sed 184193323Sed#define SUB_PARM_SIZE(TO, DEC) \ 185193323Sed{ tree dec = (DEC); \ 186193323Sed if (TREE_CODE (dec) == INTEGER_CST) \ 187193323Sed (TO).constant -= TREE_INT_CST_LOW (dec); \ 188193323Sed else if ((TO).var == 0) \ 189193323Sed (TO).var = size_binop (MINUS_EXPR, integer_zero_node, dec); \ 190193323Sed else \ 191193323Sed (TO).var = size_binop (MINUS_EXPR, (TO).var, dec); } 192193323Sed 193193323Sed/* Convert the implicit sum in a `struct args_size' into an rtx. */ 194193323Sed#define ARGS_SIZE_RTX(SIZE) \ 195193323Sed((SIZE).var == 0 ? GEN_INT ((SIZE).constant) \ 196193323Sed : expand_expr (size_binop (PLUS_EXPR, (SIZE).var, \ 197193323Sed size_int ((SIZE).constant)), \ 198193323Sed NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_BAD)) 199193323Sed 200193323Sed/* Convert the implicit sum in a `struct args_size' into a tree. */ 201193323Sed#define ARGS_SIZE_TREE(SIZE) \ 202193323Sed((SIZE).var == 0 ? size_int ((SIZE).constant) \ 203193323Sed : size_binop (PLUS_EXPR, (SIZE).var, size_int ((SIZE).constant))) 204193323Sed 205193323Sed/* Supply a default definition for FUNCTION_ARG_PADDING: 206193323Sed usually pad upward, but pad short args downward on 207193323Sed big-endian machines. */ 208193323Sed 209193323Sedenum direction {none, upward, downward}; /* Value has this type. */ 210193323Sed 211193323Sed#ifndef FUNCTION_ARG_PADDING 212193323Sed#define FUNCTION_ARG_PADDING(MODE, TYPE) \ 213193323Sed (! BYTES_BIG_ENDIAN \ 214193323Sed ? upward \ 215193323Sed : (((MODE) == BLKmode \ 216193323Sed ? ((TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \ 217193323Sed && int_size_in_bytes (TYPE) < (PARM_BOUNDARY / BITS_PER_UNIT)) \ 218193323Sed : GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY) \ 219193323Sed ? downward : upward)) 220193323Sed#endif 221193323Sed 222193323Sed/* Supply a default definition for FUNCTION_ARG_BOUNDARY. Normally, we let 223193323Sed FUNCTION_ARG_PADDING, which also pads the length, handle any needed 224193323Sed alignment. */ 225193323Sed 226193323Sed#ifndef FUNCTION_ARG_BOUNDARY 227193323Sed#define FUNCTION_ARG_BOUNDARY(MODE, TYPE) PARM_BOUNDARY 228193323Sed#endif 229193323Sed 230193323Sed/* Provide a default value for STRICT_ARGUMENT_NAMING. */ 231193323Sed#ifndef STRICT_ARGUMENT_NAMING 232193323Sed#define STRICT_ARGUMENT_NAMING 0 233193323Sed#endif 234193323Sed 235193323Sed/* Provide a default value for PRETEND_OUTGOING_VARARGS_NAMED. */ 236193323Sed#ifdef SETUP_INCOMING_VARARGS 237193323Sed#ifndef PRETEND_OUTGOING_VARARGS_NAMED 238193323Sed#define PRETEND_OUTGOING_VARARGS_NAMED 1 239193323Sed#endif 240193323Sed#else 241193323Sed/* It is an error to define PRETEND_OUTGOING_VARARGS_NAMED without 242193323Sed defining SETUP_INCOMING_VARARGS. */ 243193323Sed#define PRETEND_OUTGOING_VARARGS_NAMED 0 244193323Sed#endif 245193323Sed 246193323Sed/* Nonzero if we do not know how to pass TYPE solely in registers. 247193323Sed We cannot do so in the following cases: 248193323Sed 249193323Sed - if the type has variable size 250193323Sed - if the type is marked as addressable (it is required to be constructed 251193323Sed into the stack) 252193323Sed - if the padding and mode of the type is such that a copy into a register 253193323Sed would put it into the wrong part of the register. 254193323Sed 255193323Sed Which padding can't be supported depends on the byte endianness. 256193323Sed 257193323Sed A value in a register is implicitly padded at the most significant end. 258193323Sed On a big-endian machine, that is the lower end in memory. 259193323Sed So a value padded in memory at the upper end can't go in a register. 260193323Sed For a little-endian machine, the reverse is true. */ 261193323Sed 262193323Sed#ifndef MUST_PASS_IN_STACK 263193323Sed#define MUST_PASS_IN_STACK(MODE,TYPE) \ 264193323Sed ((TYPE) != 0 \ 265193323Sed && (TREE_CODE (TYPE_SIZE (TYPE)) != INTEGER_CST \ 266193323Sed || TREE_ADDRESSABLE (TYPE) \ 267193323Sed || ((MODE) == BLKmode \ 268193323Sed && ! ((TYPE) != 0 && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \ 269193323Sed && 0 == (int_size_in_bytes (TYPE) \ 270193323Sed % (PARM_BOUNDARY / BITS_PER_UNIT))) \ 271193323Sed && (FUNCTION_ARG_PADDING (MODE, TYPE) \ 272193323Sed == (BYTES_BIG_ENDIAN ? upward : downward))))) 273193323Sed#endif 274198090Srdivacky 275193323Sed/* Nonzero if type TYPE should be returned in memory. 276193323Sed Most machines can use the following default definition. */ 277193323Sed 278193323Sed#ifndef RETURN_IN_MEMORY 279193323Sed#define RETURN_IN_MEMORY(TYPE) (TYPE_MODE (TYPE) == BLKmode) 280193323Sed#endif 281198090Srdivacky 282198090Srdivacky/* Supply a default definition of STACK_SAVEAREA_MODE for emit_stack_save. 283198090Srdivacky Normally move_insn, so Pmode stack pointer. */ 284198090Srdivacky 285198090Srdivacky#ifndef STACK_SAVEAREA_MODE 286193323Sed#define STACK_SAVEAREA_MODE(LEVEL) Pmode 287193323Sed#endif 288198090Srdivacky 289193323Sed/* Supply a default definition of STACK_SIZE_MODE for 290193323Sed allocate_dynamic_stack_space. Normally PLUS/MINUS, so word_mode. */ 291198090Srdivacky 292193323Sed#ifndef STACK_SIZE_MODE 293198090Srdivacky#define STACK_SIZE_MODE word_mode 294198090Srdivacky#endif 295198090Srdivacky 296198090Srdivacky/* Provide default values for the macros controlling stack checking. */ 297193323Sed 298198090Srdivacky#ifndef STACK_CHECK_BUILTIN 299198090Srdivacky#define STACK_CHECK_BUILTIN 0 300193323Sed#endif 301198090Srdivacky 302198090Srdivacky/* The default interval is one page. */ 303198090Srdivacky#ifndef STACK_CHECK_PROBE_INTERVAL 304193323Sed#define STACK_CHECK_PROBE_INTERVAL 4096 305193323Sed#endif 306193323Sed 307198090Srdivacky/* The default is to do a store into the stack. */ 308193323Sed#ifndef STACK_CHECK_PROBE_LOAD 309193323Sed#define STACK_CHECK_PROBE_LOAD 0 310198090Srdivacky#endif 311193323Sed 312198090Srdivacky/* This value is arbitrary, but should be sufficient for most machines. */ 313198090Srdivacky#ifndef STACK_CHECK_PROTECT 314198090Srdivacky#define STACK_CHECK_PROTECT (75 * UNITS_PER_WORD) 315198090Srdivacky#endif 316193323Sed 317198090Srdivacky/* Make the maximum frame size be the largest we can and still only need 318198090Srdivacky one probe per function. */ 319193323Sed#ifndef STACK_CHECK_MAX_FRAME_SIZE 320198090Srdivacky#define STACK_CHECK_MAX_FRAME_SIZE \ 321198090Srdivacky (STACK_CHECK_PROBE_INTERVAL - UNITS_PER_WORD) 322198090Srdivacky#endif 323193323Sed 324193323Sed/* This is arbitrary, but should be large enough everywhere. */ 325198090Srdivacky#ifndef STACK_CHECK_FIXED_FRAME_SIZE 326193323Sed#define STACK_CHECK_FIXED_FRAME_SIZE (4 * UNITS_PER_WORD) 327193323Sed#endif 328193323Sed 329193323Sed/* Provide a reasonable default for the maximum size of an object to 330193323Sed allocate in the fixed frame. We may need to be able to make this 331193323Sed controllable by the user at some point. */ 332193323Sed#ifndef STACK_CHECK_MAX_VAR_SIZE 333193323Sed#define STACK_CHECK_MAX_VAR_SIZE (STACK_CHECK_MAX_FRAME_SIZE / 100) 334193323Sed#endif 335193323Sed 336193323Sed/* Optabs are tables saying how to generate insn bodies 337193323Sed for various machine modes and numbers of operands. 338193323Sed Each optab applies to one operation. 339193323Sed For example, add_optab applies to addition. 340193323Sed 341193323Sed The insn_code slot is the enum insn_code that says how to 342193323Sed generate an insn for this operation on a particular machine mode. 343198090Srdivacky It is CODE_FOR_nothing if there is no such insn on the target machine. 344193323Sed 345198090Srdivacky The `lib_call' slot is the name of the library function that 346193323Sed can be used to perform the operation. 347193323Sed 348193323Sed A few optabs, such as move_optab and cmp_optab, are used 349193323Sed by special code. */ 350193323Sed 351193323Sed/* Everything that uses expr.h needs to define enum insn_code 352198090Srdivacky but we don't list it in the Makefile dependencies just for that. */ 353193323Sed#include "insn-codes.h" 354198090Srdivacky 355193323Sedtypedef struct optab 356193323Sed{ 357193323Sed enum rtx_code code; 358193323Sed struct { 359193323Sed enum insn_code insn_code; 360193323Sed rtx libfunc; 361198090Srdivacky } handlers [NUM_MACHINE_MODES]; 362193323Sed} * optab; 363198090Srdivacky 364193323Sed/* Given an enum insn_code, access the function to construct 365193323Sed the body of that kind of insn. */ 366193323Sed#ifdef FUNCTION_CONVERSION_BUG 367193323Sed/* Some compilers fail to convert a function properly to a 368193323Sed pointer-to-function when used as an argument. 369198090Srdivacky So produce the pointer-to-function directly. 370193323Sed Luckily, these compilers seem to work properly when you 371198090Srdivacky call the pointer-to-function. */ 372193323Sed#define GEN_FCN(CODE) (insn_gen_function[(int) (CODE)]) 373193323Sed#else 374193323Sed#define GEN_FCN(CODE) (*insn_gen_function[(int) (CODE)]) 375193323Sed#endif 376193323Sed 377193323Sedextern rtx (*const insn_gen_function[]) PROTO ((rtx, ...)); 378193323Sed 379193323Sedextern optab add_optab; 380193323Sedextern optab sub_optab; 381193323Sedextern optab smul_optab; /* Signed and floating-point multiply */ 382193323Sedextern optab smul_highpart_optab; /* Signed multiply, return high word */ 383193323Sedextern optab umul_highpart_optab; 384193323Sedextern optab smul_widen_optab; /* Signed multiply with result 385193323Sed one machine mode wider than args */ 386193323Sedextern optab umul_widen_optab; 387193323Sedextern optab sdiv_optab; /* Signed divide */ 388193323Sedextern optab sdivmod_optab; /* Signed divide-and-remainder in one */ 389193323Sedextern optab udiv_optab; 390193323Sedextern optab udivmod_optab; 391193323Sedextern optab smod_optab; /* Signed remainder */ 392193323Sedextern optab umod_optab; 393193323Sedextern optab flodiv_optab; /* Optab for floating divide. */ 394193323Sedextern optab ftrunc_optab; /* Convert float to integer in float fmt */ 395193323Sedextern optab and_optab; /* Logical and */ 396193323Sedextern optab ior_optab; /* Logical or */ 397193323Sedextern optab xor_optab; /* Logical xor */ 398193323Sedextern optab ashl_optab; /* Arithmetic shift left */ 399193323Sedextern optab ashr_optab; /* Arithmetic shift right */ 400193323Sedextern optab lshr_optab; /* Logical shift right */ 401193323Sedextern optab rotl_optab; /* Rotate left */ 402193323Sedextern optab rotr_optab; /* Rotate right */ 403193323Sedextern optab smin_optab; /* Signed and floating-point minimum value */ 404193323Sedextern optab smax_optab; /* Signed and floating-point maximum value */ 405193323Sedextern optab umin_optab; /* Unsigned minimum value */ 406193323Sedextern optab umax_optab; /* Unsigned maximum value */ 407193323Sed 408193323Sedextern optab mov_optab; /* Move instruction. */ 409193323Sedextern optab movstrict_optab; /* Move, preserving high part of register. */ 410193323Sed 411193323Sedextern optab cmp_optab; /* Compare insn; two operands. */ 412193323Sedextern optab tst_optab; /* tst insn; compare one operand against 0 */ 413193323Sed 414193323Sed/* Unary operations */ 415193323Sedextern optab neg_optab; /* Negation */ 416193323Sedextern optab abs_optab; /* Abs value */ 417193323Sedextern optab one_cmpl_optab; /* Bitwise not */ 418193323Sedextern optab ffs_optab; /* Find first bit set */ 419193323Sedextern optab sqrt_optab; /* Square root */ 420193323Sedextern optab sin_optab; /* Sine */ 421193323Sedextern optab cos_optab; /* Cosine */ 422193323Sedextern optab strlen_optab; /* String length */ 423193323Sed 424193323Sed/* Tables of patterns for extending one integer mode to another. */ 425193323Sedextern enum insn_code extendtab[MAX_MACHINE_MODE][MAX_MACHINE_MODE][2]; 426193323Sed 427193323Sed/* Tables of patterns for converting between fixed and floating point. */ 428193323Sedextern enum insn_code fixtab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2]; 429193323Sedextern enum insn_code fixtrunctab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2]; 430193323Sedextern enum insn_code floattab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2]; 431193323Sed 432193323Sed/* Contains the optab used for each rtx code. */ 433193323Sedextern optab code_to_optab[NUM_RTX_CODE + 1]; 434193323Sed 435193323Sed/* Passed to expand_binop and expand_unop to say which options to try to use 436193323Sed if the requested operation can't be open-coded on the requisite mode. 437193323Sed Either OPTAB_LIB or OPTAB_LIB_WIDEN says try using a library call. 438193323Sed Either OPTAB_WIDEN or OPTAB_LIB_WIDEN says try using a wider mode. 439193323Sed OPTAB_MUST_WIDEN says try widening and don't try anything else. */ 440193323Sed 441193323Sedenum optab_methods 442193323Sed{ 443193323Sed OPTAB_DIRECT, 444193323Sed OPTAB_LIB, 445193323Sed OPTAB_WIDEN, 446193323Sed OPTAB_LIB_WIDEN, 447193323Sed OPTAB_MUST_WIDEN 448193323Sed}; 449193323Sed 450193323Sed/* SYMBOL_REF rtx's for the library functions that are called 451193323Sed implicitly and not via optabs. */ 452193323Sed 453193323Sedextern rtx extendsfdf2_libfunc; 454193323Sedextern rtx extendsfxf2_libfunc; 455193323Sedextern rtx extendsftf2_libfunc; 456193323Sedextern rtx extenddfxf2_libfunc; 457193323Sedextern rtx extenddftf2_libfunc; 458193323Sed 459193323Sedextern rtx truncdfsf2_libfunc; 460193323Sedextern rtx truncxfsf2_libfunc; 461193323Sedextern rtx trunctfsf2_libfunc; 462193323Sedextern rtx truncxfdf2_libfunc; 463193323Sedextern rtx trunctfdf2_libfunc; 464193323Sed 465193323Sedextern rtx memcpy_libfunc; 466193323Sedextern rtx bcopy_libfunc; 467193323Sedextern rtx memcmp_libfunc; 468193323Sedextern rtx bcmp_libfunc; 469193323Sedextern rtx memset_libfunc; 470193323Sedextern rtx bzero_libfunc; 471193323Sed 472193323Sedextern rtx throw_libfunc; 473193323Sedextern rtx rethrow_libfunc; 474193323Sedextern rtx sjthrow_libfunc; 475193323Sedextern rtx sjpopnthrow_libfunc; 476193323Sedextern rtx terminate_libfunc; 477193323Sedextern rtx setjmp_libfunc; 478193323Sedextern rtx longjmp_libfunc; 479193323Sedextern rtx eh_rtime_match_libfunc; 480193323Sed 481193323Sedextern rtx eqhf2_libfunc; 482193323Sedextern rtx nehf2_libfunc; 483193323Sedextern rtx gthf2_libfunc; 484193323Sedextern rtx gehf2_libfunc; 485193323Sedextern rtx lthf2_libfunc; 486193323Sedextern rtx lehf2_libfunc; 487193323Sed 488193323Sedextern rtx eqsf2_libfunc; 489193323Sedextern rtx nesf2_libfunc; 490193323Sedextern rtx gtsf2_libfunc; 491193323Sedextern rtx gesf2_libfunc; 492193323Sedextern rtx ltsf2_libfunc; 493193323Sedextern rtx lesf2_libfunc; 494193323Sed 495193323Sedextern rtx eqdf2_libfunc; 496193323Sedextern rtx nedf2_libfunc; 497193323Sedextern rtx gtdf2_libfunc; 498193323Sedextern rtx gedf2_libfunc; 499193323Sedextern rtx ltdf2_libfunc; 500193323Sedextern rtx ledf2_libfunc; 501193323Sed 502193323Sedextern rtx eqxf2_libfunc; 503193323Sedextern rtx nexf2_libfunc; 504193323Sedextern rtx gtxf2_libfunc; 505193323Sedextern rtx gexf2_libfunc; 506193323Sedextern rtx ltxf2_libfunc; 507193323Sedextern rtx lexf2_libfunc; 508193323Sed 509193323Sedextern rtx eqtf2_libfunc; 510193323Sedextern rtx netf2_libfunc; 511193323Sedextern rtx gttf2_libfunc; 512193323Sedextern rtx getf2_libfunc; 513193323Sedextern rtx lttf2_libfunc; 514193323Sedextern rtx letf2_libfunc; 515193323Sed 516193323Sedextern rtx floatsisf_libfunc; 517193323Sedextern rtx floatdisf_libfunc; 518193323Sedextern rtx floattisf_libfunc; 519193323Sed 520193323Sedextern rtx floatsidf_libfunc; 521193323Sedextern rtx floatdidf_libfunc; 522193323Sedextern rtx floattidf_libfunc; 523193323Sed 524193323Sedextern rtx floatsixf_libfunc; 525193323Sedextern rtx floatdixf_libfunc; 526193323Sedextern rtx floattixf_libfunc; 527193323Sed 528193323Sedextern rtx floatsitf_libfunc; 529193323Sedextern rtx floatditf_libfunc; 530193323Sedextern rtx floattitf_libfunc; 531193323Sed 532193323Sedextern rtx fixsfsi_libfunc; 533193323Sedextern rtx fixsfdi_libfunc; 534193323Sedextern rtx fixsfti_libfunc; 535193323Sed 536193323Sedextern rtx fixdfsi_libfunc; 537193323Sedextern rtx fixdfdi_libfunc; 538193323Sedextern rtx fixdfti_libfunc; 539193323Sed 540193323Sedextern rtx fixxfsi_libfunc; 541193323Sedextern rtx fixxfdi_libfunc; 542193323Sedextern rtx fixxfti_libfunc; 543193323Sed 544193323Sedextern rtx fixtfsi_libfunc; 545193323Sedextern rtx fixtfdi_libfunc; 546193323Sedextern rtx fixtfti_libfunc; 547193323Sed 548193323Sedextern rtx fixunssfsi_libfunc; 549193323Sedextern rtx fixunssfdi_libfunc; 550193323Sedextern rtx fixunssfti_libfunc; 551193323Sed 552193323Sedextern rtx fixunsdfsi_libfunc; 553193323Sedextern rtx fixunsdfdi_libfunc; 554193323Sedextern rtx fixunsdfti_libfunc; 555193323Sed 556193323Sedextern rtx fixunsxfsi_libfunc; 557193323Sedextern rtx fixunsxfdi_libfunc; 558193323Sedextern rtx fixunsxfti_libfunc; 559193323Sed 560193323Sedextern rtx fixunstfsi_libfunc; 561193323Sedextern rtx fixunstfdi_libfunc; 562193323Sedextern rtx fixunstfti_libfunc; 563193323Sed 564193323Sed/* For check-memory-usage. */ 565193323Sedextern rtx chkr_check_addr_libfunc; 566193323Sedextern rtx chkr_set_right_libfunc; 567193323Sedextern rtx chkr_copy_bitmap_libfunc; 568193323Sedextern rtx chkr_check_exec_libfunc; 569193323Sedextern rtx chkr_check_str_libfunc; 570193323Sed 571193323Sed/* For instrument-functions. */ 572193323Sedextern rtx profile_function_entry_libfunc; 573193323Sedextern rtx profile_function_exit_libfunc; 574193323Sed 575193323Sedtypedef rtx (*rtxfun) PROTO ((rtx)); 576193323Sed 577193323Sed/* Indexed by the rtx-code for a conditional (eg. EQ, LT,...) 578193323Sed gives the gen_function to make a branch to test that condition. */ 579193323Sed 580193323Sedextern rtxfun bcc_gen_fctn[NUM_RTX_CODE]; 581193323Sed 582193323Sed/* Indexed by the rtx-code for a conditional (eg. EQ, LT,...) 583193323Sed gives the insn code to make a store-condition insn 584193323Sed to test that condition. */ 585193323Sed 586193323Sedextern enum insn_code setcc_gen_code[NUM_RTX_CODE]; 587193323Sed 588193323Sed#ifdef HAVE_conditional_move 589193323Sed/* Indexed by the machine mode, gives the insn code to make a conditional 590 move insn. */ 591 592extern enum insn_code movcc_gen_code[NUM_MACHINE_MODES]; 593#endif 594 595/* This array records the insn_code of insns to perform block moves. */ 596extern enum insn_code movstr_optab[NUM_MACHINE_MODES]; 597 598/* This array records the insn_code of insns to perform block clears. */ 599extern enum insn_code clrstr_optab[NUM_MACHINE_MODES]; 600 601/* Define functions given in optabs.c. */ 602 603/* Expand a binary operation given optab and rtx operands. */ 604extern rtx expand_binop PROTO((enum machine_mode, optab, rtx, rtx, rtx, 605 int, enum optab_methods)); 606 607/* Expand a binary operation with both signed and unsigned forms. */ 608extern rtx sign_expand_binop PROTO((enum machine_mode, optab, optab, rtx, 609 rtx, rtx, int, enum optab_methods)); 610 611/* Generate code to perform an operation on two operands with two results. */ 612extern int expand_twoval_binop PROTO((optab, rtx, rtx, rtx, rtx, int)); 613 614/* Expand a unary arithmetic operation given optab rtx operand. */ 615extern rtx expand_unop PROTO((enum machine_mode, optab, rtx, rtx, int)); 616 617/* Expand the absolute value operation. */ 618extern rtx expand_abs PROTO((enum machine_mode, rtx, rtx, int)); 619 620/* Expand the complex absolute value operation. */ 621extern rtx expand_complex_abs PROTO((enum machine_mode, rtx, rtx, int)); 622 623/* Generate an instruction with a given INSN_CODE with an output and 624 an input. */ 625extern void emit_unop_insn PROTO((int, rtx, rtx, enum rtx_code)); 626 627/* Emit code to perform a series of operations on a multi-word quantity, one 628 word at a time. */ 629extern rtx emit_no_conflict_block PROTO((rtx, rtx, rtx, rtx, rtx)); 630 631/* Emit code to make a call to a constant function or a library call. */ 632extern void emit_libcall_block PROTO((rtx, rtx, rtx, rtx)); 633 634/* Emit one rtl instruction to store zero in specified rtx. */ 635extern void emit_clr_insn PROTO((rtx)); 636 637/* Emit one rtl insn to store 1 in specified rtx assuming it contains 0. */ 638extern void emit_0_to_1_insn PROTO((rtx)); 639 640/* Emit one rtl insn to compare two rtx's. */ 641extern void emit_cmp_insn PROTO((rtx, rtx, enum rtx_code, rtx, 642 enum machine_mode, int, int)); 643 644/* Emit a pair of rtl insns to compare two rtx's and to jump 645 to a label if the comparison is true. */ 646extern void emit_cmp_and_jump_insns PROTO((rtx, rtx, enum rtx_code, rtx, 647 enum machine_mode, int, int, rtx)); 648 649/* Nonzero if a compare of mode MODE can be done straightforwardly 650 (without splitting it into pieces). */ 651extern int can_compare_p PROTO((enum machine_mode)); 652 653/* Emit a library call comparison between floating point X and Y. 654 COMPARISON is the rtl operator to compare with (EQ, NE, GT, etc.). */ 655extern void emit_float_lib_cmp PROTO((rtx, rtx, enum rtx_code)); 656 657/* Generate code to indirectly jump to a location given in the rtx LOC. */ 658extern void emit_indirect_jump PROTO((rtx)); 659 660#ifdef HAVE_conditional_move 661/* Emit a conditional move operation. */ 662rtx emit_conditional_move PROTO((rtx, enum rtx_code, rtx, rtx, 663 enum machine_mode, rtx, rtx, 664 enum machine_mode, int)); 665 666/* Return non-zero if the conditional move is supported. */ 667int can_conditionally_move_p PROTO((enum machine_mode mode)); 668 669#endif 670 671/* Create but don't emit one rtl instruction to add one rtx into another. 672 Modes must match; operands must meet the operation's predicates. 673 Likewise for subtraction and for just copying. 674 These do not call protect_from_queue; caller must do so. */ 675extern rtx gen_add2_insn PROTO((rtx, rtx)); 676extern rtx gen_sub2_insn PROTO((rtx, rtx)); 677extern rtx gen_move_insn PROTO((rtx, rtx)); 678extern int have_add2_insn PROTO((enum machine_mode)); 679extern int have_sub2_insn PROTO((enum machine_mode)); 680 681/* Return the INSN_CODE to use for an extend operation. */ 682extern enum insn_code can_extend_p PROTO((enum machine_mode, 683 enum machine_mode, int)); 684 685/* Generate the body of an insn to extend Y (with mode MFROM) 686 into X (with mode MTO). Do zero-extension if UNSIGNEDP is nonzero. */ 687extern rtx gen_extend_insn PROTO((rtx, rtx, enum machine_mode, 688 enum machine_mode, int)); 689 690/* Initialize the tables that control conversion between fixed and 691 floating values. */ 692extern void init_fixtab PROTO((void)); 693extern void init_floattab PROTO((void)); 694 695/* Generate code for a FLOAT_EXPR. */ 696extern void expand_float PROTO((rtx, rtx, int)); 697 698/* Generate code for a FIX_EXPR. */ 699extern void expand_fix PROTO((rtx, rtx, int)); 700 701/* Call this once to initialize the contents of the optabs 702 appropriately for the current target machine. */ 703extern void init_optabs PROTO((void)); 704 705/* Functions from expmed.c: */ 706 707/* Arguments MODE, RTX: return an rtx for the negation of that value. 708 May emit insns. */ 709extern rtx negate_rtx PROTO((enum machine_mode, rtx)); 710 711/* Expand a logical AND operation. */ 712extern rtx expand_and PROTO((rtx, rtx, rtx)); 713 714/* Emit a store-flag operation. */ 715extern rtx emit_store_flag PROTO((rtx, enum rtx_code, rtx, rtx, 716 enum machine_mode, int, int)); 717 718/* Like emit_store_flag, but always succeeds. */ 719extern rtx emit_store_flag_force PROTO((rtx, enum rtx_code, rtx, rtx, 720 enum machine_mode, int, int)); 721 722/* Functions from loop.c: */ 723 724/* Given a JUMP_INSN, return a description of the test being made. */ 725extern rtx get_condition PROTO((rtx, rtx *)); 726 727/* Generate a conditional trap instruction. */ 728extern rtx gen_cond_trap PROTO((enum rtx_code, rtx, rtx, rtx)); 729 730/* Functions from expr.c: */ 731 732/* This is run once per compilation to set up which modes can be used 733 directly in memory and to initialize the block move optab. */ 734extern void init_expr_once PROTO((void)); 735 736/* This is run at the start of compiling a function. */ 737extern void init_expr PROTO((void)); 738 739/* Use protect_from_queue to convert a QUEUED expression 740 into something that you can put immediately into an instruction. */ 741extern rtx protect_from_queue PROTO((rtx, int)); 742 743/* Perform all the pending incrementations. */ 744extern void emit_queue PROTO((void)); 745 746/* Tell if something has a queued subexpression. */ 747extern int queued_subexp_p PROTO((rtx)); 748 749/* Emit some rtl insns to move data between rtx's, converting machine modes. 750 Both modes must be floating or both fixed. */ 751extern void convert_move PROTO((rtx, rtx, int)); 752 753/* Convert an rtx to specified machine mode and return the result. */ 754extern rtx convert_to_mode PROTO((enum machine_mode, rtx, int)); 755 756/* Convert an rtx to MODE from OLDMODE and return the result. */ 757extern rtx convert_modes PROTO((enum machine_mode, enum machine_mode, rtx, int)); 758 759/* Emit code to move a block Y to a block X. */ 760extern rtx emit_block_move PROTO((rtx, rtx, rtx, int)); 761 762/* Copy all or part of a value X into registers starting at REGNO. 763 The number of registers to be filled is NREGS. */ 764extern void move_block_to_reg PROTO((int, rtx, int, enum machine_mode)); 765 766/* Copy all or part of a BLKmode value X out of registers starting at REGNO. 767 The number of registers to be filled is NREGS. */ 768extern void move_block_from_reg PROTO((int, rtx, int, int)); 769 770/* Load a BLKmode value into non-consecutive registers represented by a 771 PARALLEL. */ 772extern void emit_group_load PROTO((rtx, rtx, int, int)); 773/* Store a BLKmode value from non-consecutive registers represented by a 774 PARALLEL. */ 775extern void emit_group_store PROTO((rtx, rtx, int, int)); 776 777#ifdef TREE_CODE 778/* Copy BLKmode object from a set of registers. */ 779extern rtx copy_blkmode_from_reg PROTO((rtx,rtx,tree)); 780#endif 781 782/* Mark REG as holding a parameter for the next CALL_INSN. */ 783extern void use_reg PROTO((rtx *, rtx)); 784/* Mark NREGS consecutive regs, starting at REGNO, as holding parameters 785 for the next CALL_INSN. */ 786extern void use_regs PROTO((rtx *, int, int)); 787/* Mark a PARALLEL as holding a parameter for the next CALL_INSN. */ 788extern void use_group_regs PROTO((rtx *, rtx)); 789 790/* Write zeros through the storage of OBJECT. 791 If OBJECT has BLKmode, SIZE is its length in bytes and ALIGN is its 792 alignment. */ 793extern rtx clear_storage PROTO((rtx, rtx, int)); 794 795/* Emit insns to set X from Y. */ 796extern rtx emit_move_insn PROTO((rtx, rtx)); 797 798/* Emit insns to set X from Y, with no frills. */ 799extern rtx emit_move_insn_1 PROTO ((rtx, rtx)); 800 801/* Push a block of length SIZE (perhaps variable) 802 and return an rtx to address the beginning of the block. */ 803extern rtx push_block PROTO((rtx, int, int)); 804 805/* Make an operand to push something on the stack. */ 806extern rtx gen_push_operand PROTO((void)); 807 808#ifdef TREE_CODE 809/* Generate code to push something onto the stack, given its mode and type. */ 810extern void emit_push_insn PROTO((rtx, enum machine_mode, tree, rtx, int, 811 int, rtx, int, rtx, rtx, int)); 812 813/* Emit library call. */ 814extern void emit_library_call PVPROTO((rtx orgfun, int no_queue, 815 enum machine_mode outmode, int nargs, ...)); 816extern rtx emit_library_call_value PVPROTO((rtx orgfun, rtx value, int no_queue, 817 enum machine_mode outmode, int nargs, ...)); 818 819/* Expand an assignment that stores the value of FROM into TO. */ 820extern rtx expand_assignment PROTO((tree, tree, int, int)); 821 822/* Generate code for computing expression EXP, 823 and storing the value into TARGET. 824 If SUGGEST_REG is nonzero, copy the value through a register 825 and return that register, if that is possible. */ 826extern rtx store_expr PROTO((tree, rtx, int)); 827#endif 828 829/* Given an rtx that may include add and multiply operations, 830 generate them as insns and return a pseudo-reg containing the value. 831 Useful after calling expand_expr with 1 as sum_ok. */ 832extern rtx force_operand PROTO((rtx, rtx)); 833 834extern rtx expand_builtin_setjmp PROTO((rtx, rtx, rtx, rtx)); 835 836#ifdef TREE_CODE 837/* Generate code for computing expression EXP. 838 An rtx for the computed value is returned. The value is never null. 839 In the case of a void EXP, const0_rtx is returned. */ 840extern rtx expand_expr PROTO((tree, rtx, enum machine_mode, 841 enum expand_modifier)); 842#endif 843 844/* At the start of a function, record that we have no previously-pushed 845 arguments waiting to be popped. */ 846extern void init_pending_stack_adjust PROTO((void)); 847 848/* When exiting from function, if safe, clear out any pending stack adjust 849 so the adjustment won't get done. */ 850extern void clear_pending_stack_adjust PROTO((void)); 851 852/* Pop any previously-pushed arguments that have not been popped yet. */ 853extern void do_pending_stack_adjust PROTO((void)); 854 855#ifdef TREE_CODE 856/* Generate code to evaluate EXP and jump to LABEL if the value is zero. */ 857extern void jumpifnot PROTO((tree, rtx)); 858 859/* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */ 860extern void jumpif PROTO((tree, rtx)); 861 862/* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if 863 the result is zero, or IF_TRUE_LABEL if the result is one. */ 864extern void do_jump PROTO((tree, rtx, rtx)); 865#endif 866 867/* Generate rtl to compare two rtx's, will call emit_cmp_insn. */ 868extern rtx compare_from_rtx PROTO((rtx, rtx, enum rtx_code, int, 869 enum machine_mode, rtx, int)); 870 871/* Generate a tablejump instruction (used for switch statements). */ 872extern void do_tablejump PROTO((rtx, enum machine_mode, rtx, rtx, rtx)); 873 874#ifdef TREE_CODE 875/* rtl.h and tree.h were included. */ 876/* Return an rtx for the size in bytes of the value of an expr. */ 877extern rtx expr_size PROTO((tree)); 878 879extern rtx lookup_static_chain PROTO((tree)); 880 881/* Convert a stack slot address ADDR valid in function FNDECL 882 into an address valid in this function (using a static chain). */ 883extern rtx fix_lexical_addr PROTO((rtx, tree)); 884 885/* Return the address of the trampoline for entering nested fn FUNCTION. */ 886extern rtx trampoline_address PROTO((tree)); 887 888/* Return an rtx that refers to the value returned by a function 889 in its original home. This becomes invalid if any more code is emitted. */ 890extern rtx hard_function_value PROTO((tree, tree)); 891 892extern rtx prepare_call_address PROTO((rtx, tree, rtx *, int)); 893 894extern rtx expand_call PROTO((tree, rtx, int)); 895 896extern rtx expand_shift PROTO((enum tree_code, enum machine_mode, rtx, tree, rtx, int)); 897extern rtx expand_divmod PROTO((int, enum tree_code, enum machine_mode, rtx, rtx, rtx, int)); 898extern void locate_and_pad_parm PROTO((enum machine_mode, tree, int, tree, struct args_size *, struct args_size *, struct args_size *)); 899extern rtx expand_inline_function PROTO((tree, tree, rtx, int, tree, rtx)); 900/* Return the CODE_LABEL rtx for a LABEL_DECL, creating it if necessary. */ 901extern rtx label_rtx PROTO((tree)); 902#endif 903 904/* Indicate how an input argument register was promoted. */ 905extern rtx promoted_input_arg PROTO((int, enum machine_mode *, int *)); 906 907/* Return an rtx like arg but sans any constant terms. 908 Returns the original rtx if it has no constant terms. 909 The constant terms are added and stored via a second arg. */ 910extern rtx eliminate_constant_term PROTO((rtx, rtx *)); 911 912/* Convert arg to a valid memory address for specified machine mode, 913 by emitting insns to perform arithmetic if nec. */ 914extern rtx memory_address PROTO((enum machine_mode, rtx)); 915 916/* Like `memory_address' but pretent `flag_force_addr' is 0. */ 917extern rtx memory_address_noforce PROTO((enum machine_mode, rtx)); 918 919/* Return a memory reference like MEMREF, but with its mode changed 920 to MODE and its address changed to ADDR. 921 (VOIDmode means don't change the mode. 922 NULL for ADDR means don't change the address.) */ 923extern rtx change_address PROTO((rtx, enum machine_mode, rtx)); 924 925/* Return a memory reference like MEMREF, but which is known to have a 926 valid address. */ 927 928extern rtx validize_mem PROTO((rtx)); 929 930/* Assemble the static constant template for function entry trampolines. */ 931extern rtx assemble_trampoline_template PROTO((void)); 932 933/* Return 1 if two rtx's are equivalent in structure and elements. */ 934extern int rtx_equal_p PROTO((rtx, rtx)); 935 936/* Given rtx, return new rtx whose address won't be affected by 937 any side effects. It has been copied to a new temporary reg. */ 938extern rtx stabilize PROTO((rtx)); 939 940/* Given an rtx, copy all regs it refers to into new temps 941 and return a modified copy that refers to the new temps. */ 942extern rtx copy_all_regs PROTO((rtx)); 943 944/* Copy given rtx to a new temp reg and return that. */ 945extern rtx copy_to_reg PROTO((rtx)); 946 947/* Like copy_to_reg but always make the reg Pmode. */ 948extern rtx copy_addr_to_reg PROTO((rtx)); 949 950/* Like copy_to_reg but always make the reg the specified mode MODE. */ 951extern rtx copy_to_mode_reg PROTO((enum machine_mode, rtx)); 952 953/* Copy given rtx to given temp reg and return that. */ 954extern rtx copy_to_suggested_reg PROTO((rtx, rtx, enum machine_mode)); 955 956/* Copy a value to a register if it isn't already a register. 957 Args are mode (in case value is a constant) and the value. */ 958extern rtx force_reg PROTO((enum machine_mode, rtx)); 959 960/* Return given rtx, copied into a new temp reg if it was in memory. */ 961extern rtx force_not_mem PROTO((rtx)); 962 963#ifdef TREE_CODE 964/* Return mode and signedness to use when object is promoted. */ 965extern enum machine_mode promote_mode PROTO((tree, enum machine_mode, 966 int *, int)); 967#endif 968 969/* Remove some bytes from the stack. An rtx says how many. */ 970extern void adjust_stack PROTO((rtx)); 971 972/* Add some bytes to the stack. An rtx says how many. */ 973extern void anti_adjust_stack PROTO((rtx)); 974 975/* This enum is used for the following two functions. */ 976enum save_level {SAVE_BLOCK, SAVE_FUNCTION, SAVE_NONLOCAL}; 977 978/* Save the stack pointer at the specified level. */ 979extern void emit_stack_save PROTO((enum save_level, rtx *, rtx)); 980 981/* Restore the stack pointer from a save area of the specified level. */ 982extern void emit_stack_restore PROTO((enum save_level, rtx, rtx)); 983 984/* Allocate some space on the stack dynamically and return its address. An rtx 985 says how many bytes. */ 986extern rtx allocate_dynamic_stack_space PROTO((rtx, rtx, int)); 987 988/* Probe a range of stack addresses from FIRST to FIRST+SIZE, inclusive. 989 FIRST is a constant and size is a Pmode RTX. These are offsets from the 990 current stack pointer. STACK_GROWS_DOWNWARD says whether to add or 991 subtract from the stack. If SIZE is constant, this is done 992 with a fixed number of probes. Otherwise, we must make a loop. */ 993extern void probe_stack_range PROTO((HOST_WIDE_INT, rtx)); 994 995/* Return an rtx that refers to the value returned by a library call 996 in its original home. This becomes invalid if any more code is emitted. */ 997extern rtx hard_libcall_value PROTO((enum machine_mode)); 998 999/* Given an rtx, return an rtx for a value rounded up to a multiple 1000 of STACK_BOUNDARY / BITS_PER_UNIT. */ 1001extern rtx round_push PROTO((rtx)); 1002 1003extern rtx store_bit_field PROTO((rtx, int, int, enum machine_mode, rtx, int, int)); 1004extern rtx extract_bit_field PROTO((rtx, int, int, int, rtx, enum machine_mode, enum machine_mode, int, int)); 1005extern rtx expand_mult PROTO((enum machine_mode, rtx, rtx, rtx, int)); 1006extern rtx expand_mult_add PROTO((rtx, rtx, rtx, rtx,enum machine_mode, int)); 1007extern rtx expand_mult_highpart_adjust PROTO((enum machine_mode, rtx, rtx, rtx, rtx, int)); 1008 1009extern rtx assemble_static_space PROTO((int)); 1010 1011/* Hook called by expand_expr for language-specific tree codes. 1012 It is up to the language front end to install a hook 1013 if it has any such codes that expand_expr needs to know about. */ 1014extern rtx (*lang_expand_expr) PROTO ((union tree_node *, rtx, 1015 enum machine_mode, 1016 enum expand_modifier modifier)); 1017 1018#ifdef TREE_CODE 1019/* Hook called by output_constant for language-specific tree codes. 1020 It is up to the language front-end to install a hook if it has any 1021 such codes that output_constant needs to know about. Returns a 1022 language-independent constant equivalent to its input. */ 1023extern tree (*lang_expand_constant) PROTO((tree)); 1024#endif 1025 1026extern void init_all_optabs PROTO ((void)); 1027extern void init_mov_optab PROTO ((void)); 1028extern void do_jump_by_parts_equality_rtx PROTO((rtx, rtx, rtx)); 1029extern void do_jump_by_parts_greater_rtx PROTO ((enum machine_mode, int, 1030 rtx, rtx, rtx, rtx)); 1031 1032#ifdef TREE_CODE /* Don't lose if tree.h not included. */ 1033extern void mark_seen_cases PROTO ((tree, unsigned char *, 1034 long, int)); 1035#endif 1036