1 /* Definitions for code generation pass of GNU compiler.
2 Copyright (C) 1987, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* The default branch cost is 1. */
27 /* Macros to access the slots of a QUEUED rtx.
28 Here rather than in rtl.h because only the expansion pass
29 should ever encounter a QUEUED. */
31 /* The variable for which an increment is queued. */
32 #define QUEUED_VAR(P) XEXP (P, 0)
33 /* If the increment has been emitted, this is the insn
34 that does the increment. It is zero before the increment is emitted.
35 If more than one insn is emitted, this is the first insn. */
36 #define QUEUED_INSN(P) XEXP (P, 1)
37 /* If a pre-increment copy has been generated, this is the copy
38 (it is a temporary reg). Zero if no copy made yet. */
39 #define QUEUED_COPY(P) XEXP (P, 2)
40 /* This is the body to use for the insn to do the increment.
41 It is used to emit the increment. */
42 #define QUEUED_BODY(P) XEXP (P, 3)
43 /* Next QUEUED in the queue. */
44 #define QUEUED_NEXT(P) XEXP (P, 4)
46 /* This is the 4th arg to `expand_expr'.
47 EXPAND_SUM means it is ok to return a PLUS rtx or MULT rtx.
48 EXPAND_INITIALIZER is similar but also record any labels on forced_labels.
49 EXPAND_CONST_ADDRESS means it is ok to return a MEM whose address
50 is a constant that is not a legitimate address.
51 EXPAND_MEMORY_USE_* are explained below. */
52 enum expand_modifier {EXPAND_NORMAL, EXPAND_SUM,
53 EXPAND_CONST_ADDRESS, EXPAND_INITIALIZER,
54 EXPAND_MEMORY_USE_WO, EXPAND_MEMORY_USE_RW,
55 EXPAND_MEMORY_USE_BAD, EXPAND_MEMORY_USE_DONT};
57 /* Argument for chkr_* functions.
58 MEMORY_USE_RO: the pointer reads memory.
59 MEMORY_USE_WO: the pointer writes to memory.
60 MEMORY_USE_RW: the pointer modifies memory (ie it reads and writes). An
62 MEMORY_USE_BAD: use this if you don't know the behavior of the pointer, or
63 if you know there are no pointers. Using an INDIRECT_REF
64 with MEMORY_USE_BAD will abort.
65 MEMORY_USE_TW: just test for writing, without update. Special.
66 MEMORY_USE_DONT: the memory is neither read nor written. This is used by
68 enum memory_use_mode {MEMORY_USE_BAD = 0, MEMORY_USE_RO = 1,
69 MEMORY_USE_WO = 2, MEMORY_USE_RW = 3,
70 MEMORY_USE_TW = 6, MEMORY_USE_DONT = 99};
72 /* Prevent the compiler from deferring stack pops. See
73 inhibit_defer_pop for more information. */
74 #define NO_DEFER_POP (inhibit_defer_pop += 1)
76 /* Allow the compiler to defer stack pops. See inhibit_defer_pop for
78 #define OK_DEFER_POP (inhibit_defer_pop -= 1)
80 #ifdef TREE_CODE /* Don't lose if tree.h not included. */
81 /* Structure to record the size of a sequence of arguments
82 as the sum of a tree-expression and a constant. This structure is
83 also used to store offsets from the stack, which might be negative,
84 so the variable part must be ssizetype, not sizetype. */
88 HOST_WIDE_INT constant;
93 /* Add the value of the tree INC to the `struct args_size' TO. */
95 #define ADD_PARM_SIZE(TO, INC) \
97 if (host_integerp (inc, 0)) \
98 (TO).constant += tree_low_cst (inc, 0); \
99 else if ((TO).var == 0) \
102 (TO).var = size_binop (PLUS_EXPR, (TO).var, inc); }
104 #define SUB_PARM_SIZE(TO, DEC) \
105 { tree dec = (DEC); \
106 if (host_integerp (dec, 0)) \
107 (TO).constant -= tree_low_cst (dec, 0); \
108 else if ((TO).var == 0) \
109 (TO).var = size_binop (MINUS_EXPR, ssize_int (0), dec); \
111 (TO).var = size_binop (MINUS_EXPR, (TO).var, dec); }
113 /* Convert the implicit sum in a `struct args_size' into a tree
114 of type ssizetype. */
115 #define ARGS_SIZE_TREE(SIZE) \
116 ((SIZE).var == 0 ? ssize_int ((SIZE).constant) \
117 : size_binop (PLUS_EXPR, (SIZE).var, ssize_int ((SIZE).constant)))
119 /* Convert the implicit sum in a `struct args_size' into an rtx. */
120 #define ARGS_SIZE_RTX(SIZE) \
121 ((SIZE).var == 0 ? GEN_INT ((SIZE).constant) \
122 : expand_expr (ARGS_SIZE_TREE (SIZE), NULL_RTX, VOIDmode, \
123 EXPAND_MEMORY_USE_BAD))
125 /* Supply a default definition for FUNCTION_ARG_PADDING:
126 usually pad upward, but pad short args downward on
127 big-endian machines. */
129 enum direction {none, upward, downward}; /* Value has this type. */
131 #ifndef FUNCTION_ARG_PADDING
132 #define FUNCTION_ARG_PADDING(MODE, TYPE) \
133 (! BYTES_BIG_ENDIAN \
135 : (((MODE) == BLKmode \
136 ? ((TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \
137 && int_size_in_bytes (TYPE) < (PARM_BOUNDARY / BITS_PER_UNIT)) \
138 : GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY) \
139 ? downward : upward))
142 /* Supply a default definition for FUNCTION_ARG_BOUNDARY. Normally, we let
143 FUNCTION_ARG_PADDING, which also pads the length, handle any needed
146 #ifndef FUNCTION_ARG_BOUNDARY
147 #define FUNCTION_ARG_BOUNDARY(MODE, TYPE) PARM_BOUNDARY
150 /* Provide a default value for STRICT_ARGUMENT_NAMING. */
151 #ifndef STRICT_ARGUMENT_NAMING
152 #define STRICT_ARGUMENT_NAMING 0
155 /* Provide a default value for PRETEND_OUTGOING_VARARGS_NAMED. */
156 #ifdef SETUP_INCOMING_VARARGS
157 #ifndef PRETEND_OUTGOING_VARARGS_NAMED
158 #define PRETEND_OUTGOING_VARARGS_NAMED 1
161 /* It is an error to define PRETEND_OUTGOING_VARARGS_NAMED without
162 defining SETUP_INCOMING_VARARGS. */
163 #define PRETEND_OUTGOING_VARARGS_NAMED 0
166 /* Nonzero if we do not know how to pass TYPE solely in registers.
167 We cannot do so in the following cases:
169 - if the type has variable size
170 - if the type is marked as addressable (it is required to be constructed
172 - if the padding and mode of the type is such that a copy into a register
173 would put it into the wrong part of the register.
175 Which padding can't be supported depends on the byte endianness.
177 A value in a register is implicitly padded at the most significant end.
178 On a big-endian machine, that is the lower end in memory.
179 So a value padded in memory at the upper end can't go in a register.
180 For a little-endian machine, the reverse is true. */
182 #ifndef MUST_PASS_IN_STACK
183 #define MUST_PASS_IN_STACK(MODE,TYPE) \
185 && (TREE_CODE (TYPE_SIZE (TYPE)) != INTEGER_CST \
186 || TREE_ADDRESSABLE (TYPE) \
187 || ((MODE) == BLKmode \
188 && ! ((TYPE) != 0 && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \
189 && 0 == (int_size_in_bytes (TYPE) \
190 % (PARM_BOUNDARY / BITS_PER_UNIT))) \
191 && (FUNCTION_ARG_PADDING (MODE, TYPE) \
192 == (BYTES_BIG_ENDIAN ? upward : downward)))))
195 /* Nonzero if type TYPE should be returned in memory.
196 Most machines can use the following default definition. */
198 #ifndef RETURN_IN_MEMORY
199 #define RETURN_IN_MEMORY(TYPE) (TYPE_MODE (TYPE) == BLKmode)
202 /* Supply a default definition of STACK_SAVEAREA_MODE for emit_stack_save.
203 Normally move_insn, so Pmode stack pointer. */
205 #ifndef STACK_SAVEAREA_MODE
206 #define STACK_SAVEAREA_MODE(LEVEL) Pmode
209 /* Supply a default definition of STACK_SIZE_MODE for
210 allocate_dynamic_stack_space. Normally PLUS/MINUS, so word_mode. */
212 #ifndef STACK_SIZE_MODE
213 #define STACK_SIZE_MODE word_mode
216 /* Provide default values for the macros controlling stack checking. */
218 #ifndef STACK_CHECK_BUILTIN
219 #define STACK_CHECK_BUILTIN 0
222 /* The default interval is one page. */
223 #ifndef STACK_CHECK_PROBE_INTERVAL
224 #define STACK_CHECK_PROBE_INTERVAL 4096
227 /* The default is to do a store into the stack. */
228 #ifndef STACK_CHECK_PROBE_LOAD
229 #define STACK_CHECK_PROBE_LOAD 0
232 /* This value is arbitrary, but should be sufficient for most machines. */
233 #ifndef STACK_CHECK_PROTECT
234 #define STACK_CHECK_PROTECT (75 * UNITS_PER_WORD)
237 /* Make the maximum frame size be the largest we can and still only need
238 one probe per function. */
239 #ifndef STACK_CHECK_MAX_FRAME_SIZE
240 #define STACK_CHECK_MAX_FRAME_SIZE \
241 (STACK_CHECK_PROBE_INTERVAL - UNITS_PER_WORD)
244 /* This is arbitrary, but should be large enough everywhere. */
245 #ifndef STACK_CHECK_FIXED_FRAME_SIZE
246 #define STACK_CHECK_FIXED_FRAME_SIZE (4 * UNITS_PER_WORD)
249 /* Provide a reasonable default for the maximum size of an object to
250 allocate in the fixed frame. We may need to be able to make this
251 controllable by the user at some point. */
252 #ifndef STACK_CHECK_MAX_VAR_SIZE
253 #define STACK_CHECK_MAX_VAR_SIZE (STACK_CHECK_MAX_FRAME_SIZE / 100)
256 /* Functions from optabs.c, commonly used, and without need for the optabs
259 /* Emit code to make a call to a constant function or a library call. */
260 extern void emit_libcall_block PARAMS ((rtx, rtx, rtx, rtx));
262 /* Create but don't emit one rtl instruction to perform certain operations.
263 Modes must match; operands must meet the operation's predicates.
264 Likewise for subtraction and for just copying.
265 These do not call protect_from_queue; caller must do so. */
266 extern rtx gen_add2_insn PARAMS ((rtx, rtx));
267 extern rtx gen_add3_insn PARAMS ((rtx, rtx, rtx));
268 extern rtx gen_sub2_insn PARAMS ((rtx, rtx));
269 extern rtx gen_move_insn PARAMS ((rtx, rtx));
270 extern int have_add2_insn PARAMS ((rtx, rtx));
271 extern int have_sub2_insn PARAMS ((rtx, rtx));
273 /* Emit a pair of rtl insns to compare two rtx's and to jump
274 to a label if the comparison is true. */
275 extern void emit_cmp_and_jump_insns PARAMS ((rtx, rtx, enum rtx_code, rtx,
276 enum machine_mode, int,
279 /* Generate code to indirectly jump to a location given in the rtx LOC. */
280 extern void emit_indirect_jump PARAMS ((rtx));
282 #ifdef HAVE_conditional_move
283 /* Emit a conditional move operation. */
284 rtx emit_conditional_move PARAMS ((rtx, enum rtx_code, rtx, rtx,
285 enum machine_mode, rtx, rtx,
286 enum machine_mode, int));
288 /* Return non-zero if the conditional move is supported. */
289 int can_conditionally_move_p PARAMS ((enum machine_mode mode));
294 /* Functions from expmed.c: */
296 /* Arguments MODE, RTX: return an rtx for the negation of that value.
298 extern rtx negate_rtx PARAMS ((enum machine_mode, rtx));
300 /* Expand a logical AND operation. */
301 extern rtx expand_and PARAMS ((rtx, rtx, rtx));
303 /* Emit a store-flag operation. */
304 extern rtx emit_store_flag PARAMS ((rtx, enum rtx_code, rtx, rtx,
305 enum machine_mode, int, int));
307 /* Like emit_store_flag, but always succeeds. */
308 extern rtx emit_store_flag_force PARAMS ((rtx, enum rtx_code, rtx, rtx,
309 enum machine_mode, int, int));
311 /* Functions from loop.c: */
313 /* Given an insn and condition, return a canonical description of
314 the test being made. */
315 extern rtx canonicalize_condition PARAMS ((rtx, rtx, int, rtx *, rtx));
317 /* Given a JUMP_INSN, return a canonical description of the test
319 extern rtx get_condition PARAMS ((rtx, rtx *));
321 /* Generate a conditional trap instruction. */
322 extern rtx gen_cond_trap PARAMS ((enum rtx_code, rtx, rtx, rtx));
324 /* Functions from builtins.c: */
326 extern rtx expand_builtin PARAMS ((tree, rtx, rtx, enum machine_mode, int));
327 extern void std_expand_builtin_va_start PARAMS ((int, tree, rtx));
328 extern rtx std_expand_builtin_va_arg PARAMS ((tree, tree));
329 extern rtx expand_builtin_va_arg PARAMS ((tree, tree));
330 extern void default_init_builtins PARAMS ((void));
331 extern rtx default_expand_builtin PARAMS ((tree, rtx, rtx,
332 enum machine_mode, int));
335 extern void expand_builtin_setjmp_setup PARAMS ((rtx, rtx));
336 extern void expand_builtin_setjmp_receiver PARAMS ((rtx));
337 extern void expand_builtin_longjmp PARAMS ((rtx, rtx));
338 extern rtx expand_builtin_saveregs PARAMS ((void));
339 extern HOST_WIDE_INT get_varargs_alias_set PARAMS ((void));
340 extern HOST_WIDE_INT get_frame_alias_set PARAMS ((void));
341 extern void record_base_value PARAMS ((unsigned int, rtx, int));
342 extern void record_alias_subset PARAMS ((HOST_WIDE_INT,
344 extern HOST_WIDE_INT new_alias_set PARAMS ((void));
346 /* Functions from expr.c: */
348 /* This is run once per compilation to set up which modes can be used
349 directly in memory and to initialize the block move optab. */
350 extern void init_expr_once PARAMS ((void));
352 /* This is run at the start of compiling a function. */
353 extern void init_expr PARAMS ((void));
355 /* This function is run once to initialize stor-layout.c. */
357 extern void init_stor_layout_once PARAMS ((void));
359 /* This is run at the end of compiling a function. */
360 extern void finish_expr_for_function PARAMS ((void));
362 /* Use protect_from_queue to convert a QUEUED expression
363 into something that you can put immediately into an instruction. */
364 extern rtx protect_from_queue PARAMS ((rtx, int));
366 /* Perform all the pending incrementations. */
367 extern void emit_queue PARAMS ((void));
369 /* Tell if something has a queued subexpression. */
370 extern int queued_subexp_p PARAMS ((rtx));
372 /* Emit some rtl insns to move data between rtx's, converting machine modes.
373 Both modes must be floating or both fixed. */
374 extern void convert_move PARAMS ((rtx, rtx, int));
376 /* Convert an rtx to specified machine mode and return the result. */
377 extern rtx convert_to_mode PARAMS ((enum machine_mode, rtx, int));
379 /* Convert an rtx to MODE from OLDMODE and return the result. */
380 extern rtx convert_modes PARAMS ((enum machine_mode, enum machine_mode,
383 /* Emit code to move a block Y to a block X. */
384 extern rtx emit_block_move PARAMS ((rtx, rtx, rtx, unsigned int));
386 /* Copy all or part of a value X into registers starting at REGNO.
387 The number of registers to be filled is NREGS. */
388 extern void move_block_to_reg PARAMS ((int, rtx, int, enum machine_mode));
390 /* Copy all or part of a BLKmode value X out of registers starting at REGNO.
391 The number of registers to be filled is NREGS. */
392 extern void move_block_from_reg PARAMS ((int, rtx, int, int));
394 /* Load a BLKmode value into non-consecutive registers represented by a
396 extern void emit_group_load PARAMS ((rtx, rtx, int, unsigned int));
398 /* Store a BLKmode value from non-consecutive registers represented by a
400 extern void emit_group_store PARAMS ((rtx, rtx, int, unsigned int));
403 /* Copy BLKmode object from a set of registers. */
404 extern rtx copy_blkmode_from_reg PARAMS ((rtx,rtx,tree));
407 /* Mark REG as holding a parameter for the next CALL_INSN. */
408 extern void use_reg PARAMS ((rtx *, rtx));
410 /* Mark NREGS consecutive regs, starting at REGNO, as holding parameters
411 for the next CALL_INSN. */
412 extern void use_regs PARAMS ((rtx *, int, int));
414 /* Mark a PARALLEL as holding a parameter for the next CALL_INSN. */
415 extern void use_group_regs PARAMS ((rtx *, rtx));
417 /* Write zeros through the storage of OBJECT.
418 If OBJECT has BLKmode, SIZE is its length in bytes and ALIGN is its
420 extern rtx clear_storage PARAMS ((rtx, rtx, unsigned int));
422 /* Return non-zero if it is desirable to store LEN bytes generated by
423 CONSTFUN with several move instructions by store_by_pieces
424 function. CONSTFUNDATA is a pointer which will be passed as argument
425 in every CONSTFUN call.
426 ALIGN is maximum alignment we can assume. */
427 extern int can_store_by_pieces PARAMS ((unsigned HOST_WIDE_INT,
428 rtx (*) (PTR, HOST_WIDE_INT,
432 /* Generate several move instructions to store LEN bytes generated by
433 CONSTFUN to block TO. (A MEM rtx with BLKmode). CONSTFUNDATA is a
434 pointer which will be passed as argument in every CONSTFUN call.
435 ALIGN is maximum alignment we can assume. */
436 extern void store_by_pieces PARAMS ((rtx, unsigned HOST_WIDE_INT,
437 rtx (*) (PTR, HOST_WIDE_INT,
441 /* Emit insns to set X from Y. */
442 extern rtx emit_move_insn PARAMS ((rtx, rtx));
444 /* Emit insns to set X from Y, with no frills. */
445 extern rtx emit_move_insn_1 PARAMS ((rtx, rtx));
447 /* Push a block of length SIZE (perhaps variable)
448 and return an rtx to address the beginning of the block. */
449 extern rtx push_block PARAMS ((rtx, int, int));
452 /* Generate code to push something onto the stack, given its mode and type. */
453 extern void emit_push_insn PARAMS ((rtx, enum machine_mode, tree, rtx,
454 unsigned int, int, rtx, int, rtx, rtx,
457 /* Expand an assignment that stores the value of FROM into TO. */
458 extern rtx expand_assignment PARAMS ((tree, tree, int, int));
460 /* Generate code for computing expression EXP,
461 and storing the value into TARGET.
462 If SUGGEST_REG is nonzero, copy the value through a register
463 and return that register, if that is possible. */
464 extern rtx store_expr PARAMS ((tree, rtx, int));
467 /* Given an rtx that may include add and multiply operations,
468 generate them as insns and return a pseudo-reg containing the value.
469 Useful after calling expand_expr with 1 as sum_ok. */
470 extern rtx force_operand PARAMS ((rtx, rtx));
473 /* Generate code for computing expression EXP.
474 An rtx for the computed value is returned. The value is never null.
475 In the case of a void EXP, const0_rtx is returned. */
476 extern rtx expand_expr PARAMS ((tree, rtx, enum machine_mode,
477 enum expand_modifier));
480 /* At the start of a function, record that we have no previously-pushed
481 arguments waiting to be popped. */
482 extern void init_pending_stack_adjust PARAMS ((void));
484 /* When exiting from function, if safe, clear out any pending stack adjust
485 so the adjustment won't get done. */
486 extern void clear_pending_stack_adjust PARAMS ((void));
488 /* Pop any previously-pushed arguments that have not been popped yet. */
489 extern void do_pending_stack_adjust PARAMS ((void));
492 /* Return the tree node and offset if a given argument corresponds to
493 a string constant. */
494 extern tree string_constant PARAMS ((tree, tree *));
496 /* Generate code to evaluate EXP and jump to LABEL if the value is zero. */
497 extern void jumpifnot PARAMS ((tree, rtx));
499 /* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */
500 extern void jumpif PARAMS ((tree, rtx));
502 /* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if
503 the result is zero, or IF_TRUE_LABEL if the result is one. */
504 extern void do_jump PARAMS ((tree, rtx, rtx));
507 /* Generate rtl to compare two rtx's, will call emit_cmp_insn. */
508 extern rtx compare_from_rtx PARAMS ((rtx, rtx, enum rtx_code, int,
509 enum machine_mode, rtx, unsigned int));
510 extern void do_compare_rtx_and_jump PARAMS ((rtx, rtx, enum rtx_code, int,
511 enum machine_mode, rtx,
512 unsigned int, rtx, rtx));
514 /* Generate a tablejump instruction (used for switch statements). */
515 extern void do_tablejump PARAMS ((rtx, enum machine_mode, rtx, rtx, rtx));
518 /* rtl.h and tree.h were included. */
519 /* Return an rtx for the size in bytes of the value of an expr. */
520 extern rtx expr_size PARAMS ((tree));
522 extern rtx lookup_static_chain PARAMS ((tree));
524 /* Convert a stack slot address ADDR valid in function FNDECL
525 into an address valid in this function (using a static chain). */
526 extern rtx fix_lexical_addr PARAMS ((rtx, tree));
528 /* Return the address of the trampoline for entering nested fn FUNCTION. */
529 extern rtx trampoline_address PARAMS ((tree));
531 /* Return an rtx that refers to the value returned by a function
532 in its original home. This becomes invalid if any more code is emitted. */
533 extern rtx hard_function_value PARAMS ((tree, tree, int));
535 extern rtx prepare_call_address PARAMS ((rtx, tree, rtx *, int, int));
537 extern rtx expand_call PARAMS ((tree, rtx, int));
539 extern rtx expand_shift PARAMS ((enum tree_code, enum machine_mode, rtx, tree,
541 extern rtx expand_divmod PARAMS ((int, enum tree_code, enum machine_mode, rtx,
543 extern void locate_and_pad_parm PARAMS ((enum machine_mode, tree, int, tree,
547 struct args_size *));
548 extern rtx expand_inline_function PARAMS ((tree, tree, rtx, int, tree, rtx));
550 /* Return the CODE_LABEL rtx for a LABEL_DECL, creating it if necessary. */
551 extern rtx label_rtx PARAMS ((tree));
554 /* Indicate how an input argument register was promoted. */
555 extern rtx promoted_input_arg PARAMS ((unsigned int, enum machine_mode *,
558 /* Return an rtx like arg but sans any constant terms.
559 Returns the original rtx if it has no constant terms.
560 The constant terms are added and stored via a second arg. */
561 extern rtx eliminate_constant_term PARAMS ((rtx, rtx *));
563 /* Convert arg to a valid memory address for specified machine mode,
564 by emitting insns to perform arithmetic if nec. */
565 extern rtx memory_address PARAMS ((enum machine_mode, rtx));
567 /* Like `memory_address' but pretent `flag_force_addr' is 0. */
568 extern rtx memory_address_noforce PARAMS ((enum machine_mode, rtx));
570 /* Return a memory reference like MEMREF, but with its mode changed
571 to MODE and its address changed to ADDR.
572 (VOIDmode means don't change the mode.
573 NULL for ADDR means don't change the address.)
574 VALIDATE is nonzero if the returned memory location is required to be
576 extern rtx change_address_1 PARAMS ((rtx, enum machine_mode, rtx, int));
578 #define change_address(MEMREF, MODE, ADDR) \
579 change_address_1 (MEMREF, MODE, ADDR, 1)
581 /* Return a memory reference like MEMREF, but with its mode changed
582 to MODE and its address offset by OFFSET bytes. */
583 extern rtx adjust_address PARAMS ((rtx, enum machine_mode, HOST_WIDE_INT));
585 /* Likewise, but the reference is not required to be valid. */
586 extern rtx adjust_address_nv PARAMS ((rtx, enum machine_mode, HOST_WIDE_INT));
588 /* Return a memory reference like MEMREF, but with its address changed to
589 ADDR. The caller is asserting that the actual piece of memory pointed
590 to is the same, just the form of the address is being changed, such as
591 by putting something into a register. */
592 extern rtx replace_equiv_address PARAMS ((rtx, rtx));
594 /* Likewise, but the reference is not required to be valid. */
595 extern rtx replace_equiv_address_nv PARAMS ((rtx, rtx));
597 /* Return a memory reference like MEMREF, but which is known to have a
599 extern rtx validize_mem PARAMS ((rtx));
602 /* Given REF, either a MEM or a REG, and T, either the type of X or
603 the expression corresponding to REF, set RTX_UNCHANGING_P if
605 extern void maybe_set_unchanging PARAMS ((rtx, tree));
607 /* Given REF, a MEM, and T, either the type of X or the expression
608 corresponding to REF, set the memory attributes. OBJECTP is nonzero
609 if we are making a new object of this type. */
610 extern void set_mem_attributes PARAMS ((rtx, tree, int));
613 /* Assemble the static constant template for function entry trampolines. */
614 extern rtx assemble_trampoline_template PARAMS ((void));
616 /* Given rtx, return new rtx whose address won't be affected by
617 any side effects. It has been copied to a new temporary reg. */
618 extern rtx stabilize PARAMS ((rtx));
620 /* Given an rtx, copy all regs it refers to into new temps
621 and return a modified copy that refers to the new temps. */
622 extern rtx copy_all_regs PARAMS ((rtx));
624 /* Copy given rtx to a new temp reg and return that. */
625 extern rtx copy_to_reg PARAMS ((rtx));
627 /* Like copy_to_reg but always make the reg Pmode. */
628 extern rtx copy_addr_to_reg PARAMS ((rtx));
630 /* Like copy_to_reg but always make the reg the specified mode MODE. */
631 extern rtx copy_to_mode_reg PARAMS ((enum machine_mode, rtx));
633 /* Copy given rtx to given temp reg and return that. */
634 extern rtx copy_to_suggested_reg PARAMS ((rtx, rtx, enum machine_mode));
636 /* Copy a value to a register if it isn't already a register.
637 Args are mode (in case value is a constant) and the value. */
638 extern rtx force_reg PARAMS ((enum machine_mode, rtx));
640 /* Return given rtx, copied into a new temp reg if it was in memory. */
641 extern rtx force_not_mem PARAMS ((rtx));
644 /* Return mode and signedness to use when object is promoted. */
645 extern enum machine_mode promote_mode PARAMS ((tree, enum machine_mode,
649 /* Remove some bytes from the stack. An rtx says how many. */
650 extern void adjust_stack PARAMS ((rtx));
652 /* Add some bytes to the stack. An rtx says how many. */
653 extern void anti_adjust_stack PARAMS ((rtx));
655 /* This enum is used for the following two functions. */
656 enum save_level {SAVE_BLOCK, SAVE_FUNCTION, SAVE_NONLOCAL};
658 /* Save the stack pointer at the specified level. */
659 extern void emit_stack_save PARAMS ((enum save_level, rtx *, rtx));
661 /* Restore the stack pointer from a save area of the specified level. */
662 extern void emit_stack_restore PARAMS ((enum save_level, rtx, rtx));
664 /* Allocate some space on the stack dynamically and return its address. An rtx
665 says how many bytes. */
666 extern rtx allocate_dynamic_stack_space PARAMS ((rtx, rtx, int));
668 /* Probe a range of stack addresses from FIRST to FIRST+SIZE, inclusive.
669 FIRST is a constant and size is a Pmode RTX. These are offsets from the
670 current stack pointer. STACK_GROWS_DOWNWARD says whether to add or
671 subtract from the stack. If SIZE is constant, this is done
672 with a fixed number of probes. Otherwise, we must make a loop. */
673 extern void probe_stack_range PARAMS ((HOST_WIDE_INT, rtx));
675 /* Return an rtx that refers to the value returned by a library call
676 in its original home. This becomes invalid if any more code is emitted. */
677 extern rtx hard_libcall_value PARAMS ((enum machine_mode));
679 /* Given an rtx, return an rtx for a value rounded up to a multiple
680 of STACK_BOUNDARY / BITS_PER_UNIT. */
681 extern rtx round_push PARAMS ((rtx));
683 extern rtx store_bit_field PARAMS ((rtx, unsigned HOST_WIDE_INT,
684 unsigned HOST_WIDE_INT,
685 enum machine_mode, rtx,
686 unsigned int, HOST_WIDE_INT));
687 extern rtx extract_bit_field PARAMS ((rtx, unsigned HOST_WIDE_INT,
688 unsigned HOST_WIDE_INT, int, rtx,
689 enum machine_mode, enum machine_mode,
690 unsigned int, HOST_WIDE_INT));
691 extern rtx expand_mult PARAMS ((enum machine_mode, rtx, rtx, rtx, int));
692 extern rtx expand_mult_add PARAMS ((rtx, rtx, rtx, rtx,enum machine_mode, int));
693 extern rtx expand_mult_highpart_adjust PARAMS ((enum machine_mode, rtx, rtx, rtx, rtx, int));
695 extern rtx assemble_static_space PARAMS ((int));
697 /* Hook called by expand_expr for language-specific tree codes.
698 It is up to the language front end to install a hook
699 if it has any such codes that expand_expr needs to know about. */
700 extern rtx (*lang_expand_expr) PARAMS ((union tree_node *, rtx,
702 enum expand_modifier modifier));
705 /* Hook called by output_constant for language-specific tree codes.
706 It is up to the language front-end to install a hook if it has any
707 such codes that output_constant needs to know about. Returns a
708 language-independent constant equivalent to its input. */
709 extern tree (*lang_expand_constant) PARAMS ((tree));
711 extern int safe_from_p PARAMS ((rtx, tree, int));
713 /* Hook called by safe_from_p for language-specific tree codes. It is
714 up to the language front-end to install a hook if it has any such
715 codes that safe_from_p needs to know about. Since same_from_p will
716 recursively explore the TREE_OPERANDs of an expression, this hook
717 should not reexamine those pieces. This routine may recursively
718 call safe_from_p; it should always pass `0' as the TOP_P
720 extern int (*lang_safe_from_p) PARAMS ((rtx, tree));
723 /* Call this once to initialize the contents of the optabs
724 appropriately for the current target machine. */
725 extern void init_optabs PARAMS ((void));
726 extern void init_all_optabs PARAMS ((void));
728 /* Call this to initialize an optab function entry. */
729 extern rtx init_one_libfunc PARAMS ((const char *));
731 extern void do_jump_by_parts_equality_rtx PARAMS ((rtx, rtx, rtx));
732 extern void do_jump_by_parts_greater_rtx PARAMS ((enum machine_mode,
736 #ifdef TREE_CODE /* Don't lose if tree.h not included. */
737 extern void mark_seen_cases PARAMS ((tree, unsigned char *,
738 HOST_WIDE_INT, int));