1 /* Expands front end tree to back end RTL for GCC.
2 Copyright (C) 1987, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 /* This file handles the generation of rtl code from tree structure
23 at the level of the function as a whole.
24 It creates the rtl expressions for parameters and auto variables
25 and has full responsibility for allocating stack slots.
27 `expand_function_start' is called at the beginning of a function,
28 before the function body is parsed, and `expand_function_end' is
29 called after parsing the body.
31 Call `assign_stack_local' to allocate a stack slot for a local variable.
32 This is usually done during the RTL generation for the function body,
33 but it can also be done in the reload pass when a pseudo-register does
34 not get a hard register. */
38 #include "coretypes.h"
49 #include "hard-reg-set.h"
50 #include "insn-config.h"
53 #include "basic-block.h"
58 #include "integrate.h"
59 #include "langhooks.h"
61 #include "cfglayout.h"
63 #ifndef LOCAL_ALIGNMENT
64 #define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT
67 #ifndef STACK_ALIGNMENT_NEEDED
68 #define STACK_ALIGNMENT_NEEDED 1
71 #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
73 /* Some systems use __main in a way incompatible with its use in gcc, in these
74 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
75 give the same symbol without quotes for an alternative entry point. You
76 must define both, or neither. */
78 #define NAME__MAIN "__main"
81 /* Round a value to the lowest integer less than it that is a multiple of
82 the required alignment. Avoid using division in case the value is
83 negative. Assume the alignment is a power of two. */
84 #define FLOOR_ROUND(VALUE,ALIGN) ((VALUE) & ~((ALIGN) - 1))
86 /* Similar, but round to the next highest integer that meets the
88 #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
90 /* NEED_SEPARATE_AP means that we cannot derive ap from the value of fp
91 during rtl generation. If they are different register numbers, this is
92 always true. It may also be true if
93 FIRST_PARM_OFFSET - STARTING_FRAME_OFFSET is not a constant during rtl
94 generation. See fix_lexical_addr for details. */
96 #if ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM
97 #define NEED_SEPARATE_AP
100 /* Nonzero if function being compiled doesn't contain any calls
101 (ignoring the prologue and epilogue). This is set prior to
102 local register allocation and is valid for the remaining
104 int current_function_is_leaf
;
106 /* Nonzero if function being compiled doesn't modify the stack pointer
107 (ignoring the prologue and epilogue). This is only valid after
108 life_analysis has run. */
109 int current_function_sp_is_unchanging
;
111 /* Nonzero if the function being compiled is a leaf function which only
112 uses leaf registers. This is valid after reload (specifically after
113 sched2) and is useful only if the port defines LEAF_REGISTERS. */
114 int current_function_uses_only_leaf_regs
;
116 /* Nonzero once virtual register instantiation has been done.
117 assign_stack_local uses frame_pointer_rtx when this is nonzero.
118 calls.c:emit_library_call_value_1 uses it to set up
119 post-instantiation libcalls. */
120 int virtuals_instantiated
;
122 /* Assign unique numbers to labels generated for profiling, debugging, etc. */
123 static GTY(()) int funcdef_no
;
125 /* These variables hold pointers to functions to create and destroy
126 target specific, per-function data structures. */
127 struct machine_function
* (*init_machine_status
) (void);
129 /* The currently compiled function. */
130 struct function
*cfun
= 0;
132 /* These arrays record the INSN_UIDs of the prologue and epilogue insns. */
133 static GTY(()) varray_type prologue
;
134 static GTY(()) varray_type epilogue
;
136 /* Array of INSN_UIDs to hold the INSN_UIDs for each sibcall epilogue
138 static GTY(()) varray_type sibcall_epilogue
;
140 /* In order to evaluate some expressions, such as function calls returning
141 structures in memory, we need to temporarily allocate stack locations.
142 We record each allocated temporary in the following structure.
144 Associated with each temporary slot is a nesting level. When we pop up
145 one level, all temporaries associated with the previous level are freed.
146 Normally, all temporaries are freed after the execution of the statement
147 in which they were created. However, if we are inside a ({...}) grouping,
148 the result may be in a temporary and hence must be preserved. If the
149 result could be in a temporary, we preserve it if we can determine which
150 one it is in. If we cannot determine which temporary may contain the
151 result, all temporaries are preserved. A temporary is preserved by
152 pretending it was allocated at the previous nesting level.
154 Automatic variables are also assigned temporary slots, at the nesting
155 level where they are defined. They are marked a "kept" so that
156 free_temp_slots will not free them. */
158 struct temp_slot
GTY(())
160 /* Points to next temporary slot. */
161 struct temp_slot
*next
;
162 /* Points to previous temporary slot. */
163 struct temp_slot
*prev
;
165 /* The rtx to used to reference the slot. */
167 /* The rtx used to represent the address if not the address of the
168 slot above. May be an EXPR_LIST if multiple addresses exist. */
170 /* The alignment (in bits) of the slot. */
172 /* The size, in units, of the slot. */
174 /* The type of the object in the slot, or zero if it doesn't correspond
175 to a type. We use this to determine whether a slot can be reused.
176 It can be reused if objects of the type of the new slot will always
177 conflict with objects of the type of the old slot. */
179 /* Nonzero if this temporary is currently in use. */
181 /* Nonzero if this temporary has its address taken. */
183 /* Nesting level at which this slot is being used. */
185 /* Nonzero if this should survive a call to free_temp_slots. */
187 /* The offset of the slot from the frame_pointer, including extra space
188 for alignment. This info is for combine_temp_slots. */
189 HOST_WIDE_INT base_offset
;
190 /* The size of the slot, including extra space for alignment. This
191 info is for combine_temp_slots. */
192 HOST_WIDE_INT full_size
;
195 /* Forward declarations. */
197 static rtx
assign_stack_local_1 (enum machine_mode
, HOST_WIDE_INT
, int,
199 static struct temp_slot
*find_temp_slot_from_address (rtx
);
200 static void instantiate_decls (tree
, int);
201 static void instantiate_decls_1 (tree
, int);
202 static void instantiate_decl (rtx
, HOST_WIDE_INT
, int);
203 static rtx
instantiate_new_reg (rtx
, HOST_WIDE_INT
*);
204 static int instantiate_virtual_regs_1 (rtx
*, rtx
, int);
205 static void pad_to_arg_alignment (struct args_size
*, int, struct args_size
*);
206 static void pad_below (struct args_size
*, enum machine_mode
, tree
);
207 static void reorder_blocks_1 (rtx
, tree
, varray_type
*);
208 static void reorder_fix_fragments (tree
);
209 static int all_blocks (tree
, tree
*);
210 static tree
*get_block_vector (tree
, int *);
211 extern tree
debug_find_var_in_block_tree (tree
, tree
);
212 /* We always define `record_insns' even if it's not used so that we
213 can always export `prologue_epilogue_contains'. */
214 static void record_insns (rtx
, varray_type
*) ATTRIBUTE_UNUSED
;
215 static int contains (rtx
, varray_type
);
217 static void emit_return_into_block (basic_block
, rtx
);
219 static void purge_single_hard_subreg_set (rtx
);
220 #if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX)
221 static rtx
keep_stack_depressed (rtx
);
223 static void prepare_function_start (tree
);
224 static void do_clobber_return_reg (rtx
, void *);
225 static void do_use_return_reg (rtx
, void *);
226 static void instantiate_virtual_regs_lossage (rtx
);
227 static void set_insn_locators (rtx
, int) ATTRIBUTE_UNUSED
;
229 /* Pointer to chain of `struct function' for containing functions. */
230 struct function
*outer_function_chain
;
232 /* Given a function decl for a containing function,
233 return the `struct function' for it. */
236 find_function_data (tree decl
)
240 for (p
= outer_function_chain
; p
; p
= p
->outer
)
247 /* Save the current context for compilation of a nested function.
248 This is called from language-specific code. The caller should use
249 the enter_nested langhook to save any language-specific state,
250 since this function knows only about language-independent
254 push_function_context_to (tree context
)
260 if (context
== current_function_decl
)
261 cfun
->contains_functions
= 1;
264 struct function
*containing
= find_function_data (context
);
265 containing
->contains_functions
= 1;
270 init_dummy_function_start ();
273 p
->outer
= outer_function_chain
;
274 outer_function_chain
= p
;
276 lang_hooks
.function
.enter_nested (p
);
282 push_function_context (void)
284 push_function_context_to (current_function_decl
);
287 /* Restore the last saved context, at the end of a nested function.
288 This function is called from language-specific code. */
291 pop_function_context_from (tree context ATTRIBUTE_UNUSED
)
293 struct function
*p
= outer_function_chain
;
296 outer_function_chain
= p
->outer
;
298 current_function_decl
= p
->decl
;
301 restore_emit_status (p
);
303 lang_hooks
.function
.leave_nested (p
);
305 /* Reset variables that have known state during rtx generation. */
306 rtx_equal_function_value_matters
= 1;
307 virtuals_instantiated
= 0;
308 generating_concat_p
= 1;
312 pop_function_context (void)
314 pop_function_context_from (current_function_decl
);
317 /* Clear out all parts of the state in F that can safely be discarded
318 after the function has been parsed, but not compiled, to let
319 garbage collection reclaim the memory. */
322 free_after_parsing (struct function
*f
)
324 /* f->expr->forced_labels is used by code generation. */
325 /* f->emit->regno_reg_rtx is used by code generation. */
326 /* f->varasm is used by code generation. */
327 /* f->eh->eh_return_stub_label is used by code generation. */
329 lang_hooks
.function
.final (f
);
333 /* Clear out all parts of the state in F that can safely be discarded
334 after the function has been compiled, to let garbage collection
335 reclaim the memory. */
338 free_after_compilation (struct function
*f
)
346 f
->x_avail_temp_slots
= NULL
;
347 f
->x_used_temp_slots
= NULL
;
348 f
->arg_offset_rtx
= NULL
;
349 f
->return_rtx
= NULL
;
350 f
->internal_arg_pointer
= NULL
;
351 f
->x_nonlocal_goto_handler_labels
= NULL
;
352 f
->x_return_label
= NULL
;
353 f
->x_naked_return_label
= NULL
;
354 f
->x_stack_slot_list
= NULL
;
355 f
->x_tail_recursion_reentry
= NULL
;
356 f
->x_arg_pointer_save_area
= NULL
;
357 f
->x_parm_birth_insn
= NULL
;
358 f
->original_arg_vector
= NULL
;
359 f
->original_decl_initial
= NULL
;
360 f
->epilogue_delay_list
= NULL
;
363 /* Allocate fixed slots in the stack frame of the current function. */
365 /* Return size needed for stack frame based on slots so far allocated in
367 This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY;
368 the caller may have to do that. */
371 get_func_frame_size (struct function
*f
)
373 #ifdef FRAME_GROWS_DOWNWARD
374 return -f
->x_frame_offset
;
376 return f
->x_frame_offset
;
380 /* Return size needed for stack frame based on slots so far allocated.
381 This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY;
382 the caller may have to do that. */
384 get_frame_size (void)
386 return get_func_frame_size (cfun
);
389 /* Allocate a stack slot of SIZE bytes and return a MEM rtx for it
390 with machine mode MODE.
392 ALIGN controls the amount of alignment for the address of the slot:
393 0 means according to MODE,
394 -1 means use BIGGEST_ALIGNMENT and round size to multiple of that,
395 -2 means use BITS_PER_UNIT,
396 positive specifies alignment boundary in bits.
398 We do not round to stack_boundary here.
400 FUNCTION specifies the function to allocate in. */
403 assign_stack_local_1 (enum machine_mode mode
, HOST_WIDE_INT size
, int align
,
404 struct function
*function
)
407 int bigend_correction
= 0;
409 int frame_off
, frame_alignment
, frame_phase
;
416 alignment
= BIGGEST_ALIGNMENT
;
418 alignment
= GET_MODE_ALIGNMENT (mode
);
420 /* Allow the target to (possibly) increase the alignment of this
422 type
= lang_hooks
.types
.type_for_mode (mode
, 0);
424 alignment
= LOCAL_ALIGNMENT (type
, alignment
);
426 alignment
/= BITS_PER_UNIT
;
428 else if (align
== -1)
430 alignment
= BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
;
431 size
= CEIL_ROUND (size
, alignment
);
433 else if (align
== -2)
434 alignment
= 1; /* BITS_PER_UNIT / BITS_PER_UNIT */
436 alignment
= align
/ BITS_PER_UNIT
;
438 #ifdef FRAME_GROWS_DOWNWARD
439 function
->x_frame_offset
-= size
;
442 /* Ignore alignment we can't do with expected alignment of the boundary. */
443 if (alignment
* BITS_PER_UNIT
> PREFERRED_STACK_BOUNDARY
)
444 alignment
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
446 if (function
->stack_alignment_needed
< alignment
* BITS_PER_UNIT
)
447 function
->stack_alignment_needed
= alignment
* BITS_PER_UNIT
;
449 /* Calculate how many bytes the start of local variables is off from
451 frame_alignment
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
452 frame_off
= STARTING_FRAME_OFFSET
% frame_alignment
;
453 frame_phase
= frame_off
? frame_alignment
- frame_off
: 0;
455 /* Round the frame offset to the specified alignment. The default is
456 to always honor requests to align the stack but a port may choose to
457 do its own stack alignment by defining STACK_ALIGNMENT_NEEDED. */
458 if (STACK_ALIGNMENT_NEEDED
462 /* We must be careful here, since FRAME_OFFSET might be negative and
463 division with a negative dividend isn't as well defined as we might
464 like. So we instead assume that ALIGNMENT is a power of two and
465 use logical operations which are unambiguous. */
466 #ifdef FRAME_GROWS_DOWNWARD
467 function
->x_frame_offset
468 = (FLOOR_ROUND (function
->x_frame_offset
- frame_phase
, alignment
)
471 function
->x_frame_offset
472 = (CEIL_ROUND (function
->x_frame_offset
- frame_phase
, alignment
)
477 /* On a big-endian machine, if we are allocating more space than we will use,
478 use the least significant bytes of those that are allocated. */
479 if (BYTES_BIG_ENDIAN
&& mode
!= BLKmode
)
480 bigend_correction
= size
- GET_MODE_SIZE (mode
);
482 /* If we have already instantiated virtual registers, return the actual
483 address relative to the frame pointer. */
484 if (function
== cfun
&& virtuals_instantiated
)
485 addr
= plus_constant (frame_pointer_rtx
,
487 (frame_offset
+ bigend_correction
488 + STARTING_FRAME_OFFSET
, Pmode
));
490 addr
= plus_constant (virtual_stack_vars_rtx
,
492 (function
->x_frame_offset
+ bigend_correction
,
495 #ifndef FRAME_GROWS_DOWNWARD
496 function
->x_frame_offset
+= size
;
499 x
= gen_rtx_MEM (mode
, addr
);
501 function
->x_stack_slot_list
502 = gen_rtx_EXPR_LIST (VOIDmode
, x
, function
->x_stack_slot_list
);
507 /* Wrapper around assign_stack_local_1; assign a local stack slot for the
511 assign_stack_local (enum machine_mode mode
, HOST_WIDE_INT size
, int align
)
513 return assign_stack_local_1 (mode
, size
, align
, cfun
);
517 /* Removes temporary slot TEMP from LIST. */
520 cut_slot_from_list (struct temp_slot
*temp
, struct temp_slot
**list
)
523 temp
->next
->prev
= temp
->prev
;
525 temp
->prev
->next
= temp
->next
;
529 temp
->prev
= temp
->next
= NULL
;
532 /* Inserts temporary slot TEMP to LIST. */
535 insert_slot_to_list (struct temp_slot
*temp
, struct temp_slot
**list
)
539 (*list
)->prev
= temp
;
544 /* Returns the list of used temp slots at LEVEL. */
546 static struct temp_slot
**
547 temp_slots_at_level (int level
)
551 if (!used_temp_slots
)
552 VARRAY_GENERIC_PTR_INIT (used_temp_slots
, 3, "used_temp_slots");
554 while (level
>= (int) VARRAY_ACTIVE_SIZE (used_temp_slots
))
555 VARRAY_PUSH_GENERIC_PTR (used_temp_slots
, NULL
);
557 return (struct temp_slot
**) &VARRAY_GENERIC_PTR (used_temp_slots
, level
);
560 /* Returns the maximal temporary slot level. */
563 max_slot_level (void)
565 if (!used_temp_slots
)
568 return VARRAY_ACTIVE_SIZE (used_temp_slots
) - 1;
571 /* Moves temporary slot TEMP to LEVEL. */
574 move_slot_to_level (struct temp_slot
*temp
, int level
)
576 cut_slot_from_list (temp
, temp_slots_at_level (temp
->level
));
577 insert_slot_to_list (temp
, temp_slots_at_level (level
));
581 /* Make temporary slot TEMP available. */
584 make_slot_available (struct temp_slot
*temp
)
586 cut_slot_from_list (temp
, temp_slots_at_level (temp
->level
));
587 insert_slot_to_list (temp
, &avail_temp_slots
);
592 /* Allocate a temporary stack slot and record it for possible later
595 MODE is the machine mode to be given to the returned rtx.
597 SIZE is the size in units of the space required. We do no rounding here
598 since assign_stack_local will do any required rounding.
600 KEEP is 1 if this slot is to be retained after a call to
601 free_temp_slots. Automatic variables for a block are allocated
602 with this flag. KEEP is 2 if we allocate a longer term temporary,
603 whose lifetime is controlled by CLEANUP_POINT_EXPRs. KEEP is 3
604 if we are to allocate something at an inner level to be treated as
605 a variable in the block (e.g., a SAVE_EXPR).
607 TYPE is the type that will be used for the stack slot. */
610 assign_stack_temp_for_type (enum machine_mode mode
, HOST_WIDE_INT size
, int keep
,
614 struct temp_slot
*p
, *best_p
= 0, *selected
= NULL
, **pp
;
617 /* If SIZE is -1 it means that somebody tried to allocate a temporary
618 of a variable size. */
623 align
= BIGGEST_ALIGNMENT
;
625 align
= GET_MODE_ALIGNMENT (mode
);
628 type
= lang_hooks
.types
.type_for_mode (mode
, 0);
631 align
= LOCAL_ALIGNMENT (type
, align
);
633 /* Try to find an available, already-allocated temporary of the proper
634 mode which meets the size and alignment requirements. Choose the
635 smallest one with the closest alignment. */
636 for (p
= avail_temp_slots
; p
; p
= p
->next
)
638 if (p
->align
>= align
&& p
->size
>= size
&& GET_MODE (p
->slot
) == mode
639 && objects_must_conflict_p (p
->type
, type
)
640 && (best_p
== 0 || best_p
->size
> p
->size
641 || (best_p
->size
== p
->size
&& best_p
->align
> p
->align
)))
643 if (p
->align
== align
&& p
->size
== size
)
646 cut_slot_from_list (selected
, &avail_temp_slots
);
654 /* Make our best, if any, the one to use. */
658 cut_slot_from_list (selected
, &avail_temp_slots
);
660 /* If there are enough aligned bytes left over, make them into a new
661 temp_slot so that the extra bytes don't get wasted. Do this only
662 for BLKmode slots, so that we can be sure of the alignment. */
663 if (GET_MODE (best_p
->slot
) == BLKmode
)
665 int alignment
= best_p
->align
/ BITS_PER_UNIT
;
666 HOST_WIDE_INT rounded_size
= CEIL_ROUND (size
, alignment
);
668 if (best_p
->size
- rounded_size
>= alignment
)
670 p
= ggc_alloc (sizeof (struct temp_slot
));
671 p
->in_use
= p
->addr_taken
= 0;
672 p
->size
= best_p
->size
- rounded_size
;
673 p
->base_offset
= best_p
->base_offset
+ rounded_size
;
674 p
->full_size
= best_p
->full_size
- rounded_size
;
675 p
->slot
= gen_rtx_MEM (BLKmode
,
676 plus_constant (XEXP (best_p
->slot
, 0),
678 p
->align
= best_p
->align
;
680 p
->type
= best_p
->type
;
681 insert_slot_to_list (p
, &avail_temp_slots
);
683 stack_slot_list
= gen_rtx_EXPR_LIST (VOIDmode
, p
->slot
,
686 best_p
->size
= rounded_size
;
687 best_p
->full_size
= rounded_size
;
692 /* If we still didn't find one, make a new temporary. */
695 HOST_WIDE_INT frame_offset_old
= frame_offset
;
697 p
= ggc_alloc (sizeof (struct temp_slot
));
699 /* We are passing an explicit alignment request to assign_stack_local.
700 One side effect of that is assign_stack_local will not round SIZE
701 to ensure the frame offset remains suitably aligned.
703 So for requests which depended on the rounding of SIZE, we go ahead
704 and round it now. We also make sure ALIGNMENT is at least
705 BIGGEST_ALIGNMENT. */
706 if (mode
== BLKmode
&& align
< BIGGEST_ALIGNMENT
)
708 p
->slot
= assign_stack_local (mode
,
710 ? CEIL_ROUND (size
, (int) align
/ BITS_PER_UNIT
)
716 /* The following slot size computation is necessary because we don't
717 know the actual size of the temporary slot until assign_stack_local
718 has performed all the frame alignment and size rounding for the
719 requested temporary. Note that extra space added for alignment
720 can be either above or below this stack slot depending on which
721 way the frame grows. We include the extra space if and only if it
722 is above this slot. */
723 #ifdef FRAME_GROWS_DOWNWARD
724 p
->size
= frame_offset_old
- frame_offset
;
729 /* Now define the fields used by combine_temp_slots. */
730 #ifdef FRAME_GROWS_DOWNWARD
731 p
->base_offset
= frame_offset
;
732 p
->full_size
= frame_offset_old
- frame_offset
;
734 p
->base_offset
= frame_offset_old
;
735 p
->full_size
= frame_offset
- frame_offset_old
;
749 p
->level
= target_temp_slot_level
;
754 p
->level
= var_temp_slot_level
;
759 p
->level
= temp_slot_level
;
763 pp
= temp_slots_at_level (p
->level
);
764 insert_slot_to_list (p
, pp
);
766 /* Create a new MEM rtx to avoid clobbering MEM flags of old slots. */
767 slot
= gen_rtx_MEM (mode
, XEXP (p
->slot
, 0));
768 stack_slot_list
= gen_rtx_EXPR_LIST (VOIDmode
, slot
, stack_slot_list
);
770 /* If we know the alias set for the memory that will be used, use
771 it. If there's no TYPE, then we don't know anything about the
772 alias set for the memory. */
773 set_mem_alias_set (slot
, type
? get_alias_set (type
) : 0);
774 set_mem_align (slot
, align
);
776 /* If a type is specified, set the relevant flags. */
779 RTX_UNCHANGING_P (slot
) = (lang_hooks
.honor_readonly
780 && TYPE_READONLY (type
));
781 MEM_VOLATILE_P (slot
) = TYPE_VOLATILE (type
);
782 MEM_SET_IN_STRUCT_P (slot
, AGGREGATE_TYPE_P (type
));
788 /* Allocate a temporary stack slot and record it for possible later
789 reuse. First three arguments are same as in preceding function. */
792 assign_stack_temp (enum machine_mode mode
, HOST_WIDE_INT size
, int keep
)
794 return assign_stack_temp_for_type (mode
, size
, keep
, NULL_TREE
);
797 /* Assign a temporary.
798 If TYPE_OR_DECL is a decl, then we are doing it on behalf of the decl
799 and so that should be used in error messages. In either case, we
800 allocate of the given type.
801 KEEP is as for assign_stack_temp.
802 MEMORY_REQUIRED is 1 if the result must be addressable stack memory;
803 it is 0 if a register is OK.
804 DONT_PROMOTE is 1 if we should not promote values in register
808 assign_temp (tree type_or_decl
, int keep
, int memory_required
,
809 int dont_promote ATTRIBUTE_UNUSED
)
812 enum machine_mode mode
;
817 if (DECL_P (type_or_decl
))
818 decl
= type_or_decl
, type
= TREE_TYPE (decl
);
820 decl
= NULL
, type
= type_or_decl
;
822 mode
= TYPE_MODE (type
);
824 unsignedp
= TYPE_UNSIGNED (type
);
827 if (mode
== BLKmode
|| memory_required
)
829 HOST_WIDE_INT size
= int_size_in_bytes (type
);
833 /* Zero sized arrays are GNU C extension. Set size to 1 to avoid
834 problems with allocating the stack space. */
838 /* Unfortunately, we don't yet know how to allocate variable-sized
839 temporaries. However, sometimes we have a fixed upper limit on
840 the size (which is stored in TYPE_ARRAY_MAX_SIZE) and can use that
841 instead. This is the case for Chill variable-sized strings. */
842 if (size
== -1 && TREE_CODE (type
) == ARRAY_TYPE
843 && TYPE_ARRAY_MAX_SIZE (type
) != NULL_TREE
844 && host_integerp (TYPE_ARRAY_MAX_SIZE (type
), 1))
845 size
= tree_low_cst (TYPE_ARRAY_MAX_SIZE (type
), 1);
847 /* If we still haven't been able to get a size, see if the language
848 can compute a maximum size. */
850 && (size_tree
= lang_hooks
.types
.max_size (type
)) != 0
851 && host_integerp (size_tree
, 1))
852 size
= tree_low_cst (size_tree
, 1);
854 /* The size of the temporary may be too large to fit into an integer. */
855 /* ??? Not sure this should happen except for user silliness, so limit
856 this to things that aren't compiler-generated temporaries. The
857 rest of the time we'll abort in assign_stack_temp_for_type. */
858 if (decl
&& size
== -1
859 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
)
861 error ("%Jsize of variable '%D' is too large", decl
, decl
);
865 tmp
= assign_stack_temp_for_type (mode
, size
, keep
, type
);
871 mode
= promote_mode (type
, mode
, &unsignedp
, 0);
874 return gen_reg_rtx (mode
);
877 /* Combine temporary stack slots which are adjacent on the stack.
879 This allows for better use of already allocated stack space. This is only
880 done for BLKmode slots because we can be sure that we won't have alignment
881 problems in this case. */
884 combine_temp_slots (void)
886 struct temp_slot
*p
, *q
, *next
, *next_q
;
889 /* We can't combine slots, because the information about which slot
890 is in which alias set will be lost. */
891 if (flag_strict_aliasing
)
894 /* If there are a lot of temp slots, don't do anything unless
895 high levels of optimization. */
896 if (! flag_expensive_optimizations
)
897 for (p
= avail_temp_slots
, num_slots
= 0; p
; p
= p
->next
, num_slots
++)
898 if (num_slots
> 100 || (num_slots
> 10 && optimize
== 0))
901 for (p
= avail_temp_slots
; p
; p
= next
)
907 if (GET_MODE (p
->slot
) != BLKmode
)
910 for (q
= p
->next
; q
; q
= next_q
)
916 if (GET_MODE (q
->slot
) != BLKmode
)
919 if (p
->base_offset
+ p
->full_size
== q
->base_offset
)
921 /* Q comes after P; combine Q into P. */
923 p
->full_size
+= q
->full_size
;
926 else if (q
->base_offset
+ q
->full_size
== p
->base_offset
)
928 /* P comes after Q; combine P into Q. */
930 q
->full_size
+= p
->full_size
;
935 cut_slot_from_list (q
, &avail_temp_slots
);
938 /* Either delete P or advance past it. */
940 cut_slot_from_list (p
, &avail_temp_slots
);
944 /* Find the temp slot corresponding to the object at address X. */
946 static struct temp_slot
*
947 find_temp_slot_from_address (rtx x
)
953 for (i
= max_slot_level (); i
>= 0; i
--)
954 for (p
= *temp_slots_at_level (i
); p
; p
= p
->next
)
956 if (XEXP (p
->slot
, 0) == x
958 || (GET_CODE (x
) == PLUS
959 && XEXP (x
, 0) == virtual_stack_vars_rtx
960 && GET_CODE (XEXP (x
, 1)) == CONST_INT
961 && INTVAL (XEXP (x
, 1)) >= p
->base_offset
962 && INTVAL (XEXP (x
, 1)) < p
->base_offset
+ p
->full_size
))
965 else if (p
->address
!= 0 && GET_CODE (p
->address
) == EXPR_LIST
)
966 for (next
= p
->address
; next
; next
= XEXP (next
, 1))
967 if (XEXP (next
, 0) == x
)
971 /* If we have a sum involving a register, see if it points to a temp
973 if (GET_CODE (x
) == PLUS
&& REG_P (XEXP (x
, 0))
974 && (p
= find_temp_slot_from_address (XEXP (x
, 0))) != 0)
976 else if (GET_CODE (x
) == PLUS
&& REG_P (XEXP (x
, 1))
977 && (p
= find_temp_slot_from_address (XEXP (x
, 1))) != 0)
983 /* Indicate that NEW is an alternate way of referring to the temp slot
984 that previously was known by OLD. */
987 update_temp_slot_address (rtx old
, rtx
new)
991 if (rtx_equal_p (old
, new))
994 p
= find_temp_slot_from_address (old
);
996 /* If we didn't find one, see if both OLD is a PLUS. If so, and NEW
997 is a register, see if one operand of the PLUS is a temporary
998 location. If so, NEW points into it. Otherwise, if both OLD and
999 NEW are a PLUS and if there is a register in common between them.
1000 If so, try a recursive call on those values. */
1003 if (GET_CODE (old
) != PLUS
)
1008 update_temp_slot_address (XEXP (old
, 0), new);
1009 update_temp_slot_address (XEXP (old
, 1), new);
1012 else if (GET_CODE (new) != PLUS
)
1015 if (rtx_equal_p (XEXP (old
, 0), XEXP (new, 0)))
1016 update_temp_slot_address (XEXP (old
, 1), XEXP (new, 1));
1017 else if (rtx_equal_p (XEXP (old
, 1), XEXP (new, 0)))
1018 update_temp_slot_address (XEXP (old
, 0), XEXP (new, 1));
1019 else if (rtx_equal_p (XEXP (old
, 0), XEXP (new, 1)))
1020 update_temp_slot_address (XEXP (old
, 1), XEXP (new, 0));
1021 else if (rtx_equal_p (XEXP (old
, 1), XEXP (new, 1)))
1022 update_temp_slot_address (XEXP (old
, 0), XEXP (new, 0));
1027 /* Otherwise add an alias for the temp's address. */
1028 else if (p
->address
== 0)
1032 if (GET_CODE (p
->address
) != EXPR_LIST
)
1033 p
->address
= gen_rtx_EXPR_LIST (VOIDmode
, p
->address
, NULL_RTX
);
1035 p
->address
= gen_rtx_EXPR_LIST (VOIDmode
, new, p
->address
);
1039 /* If X could be a reference to a temporary slot, mark the fact that its
1040 address was taken. */
1043 mark_temp_addr_taken (rtx x
)
1045 struct temp_slot
*p
;
1050 /* If X is not in memory or is at a constant address, it cannot be in
1051 a temporary slot. */
1052 if (!MEM_P (x
) || CONSTANT_P (XEXP (x
, 0)))
1055 p
= find_temp_slot_from_address (XEXP (x
, 0));
1060 /* If X could be a reference to a temporary slot, mark that slot as
1061 belonging to the to one level higher than the current level. If X
1062 matched one of our slots, just mark that one. Otherwise, we can't
1063 easily predict which it is, so upgrade all of them. Kept slots
1064 need not be touched.
1066 This is called when an ({...}) construct occurs and a statement
1067 returns a value in memory. */
1070 preserve_temp_slots (rtx x
)
1072 struct temp_slot
*p
= 0, *next
;
1074 /* If there is no result, we still might have some objects whose address
1075 were taken, so we need to make sure they stay around. */
1078 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1083 move_slot_to_level (p
, temp_slot_level
- 1);
1089 /* If X is a register that is being used as a pointer, see if we have
1090 a temporary slot we know it points to. To be consistent with
1091 the code below, we really should preserve all non-kept slots
1092 if we can't find a match, but that seems to be much too costly. */
1093 if (REG_P (x
) && REG_POINTER (x
))
1094 p
= find_temp_slot_from_address (x
);
1096 /* If X is not in memory or is at a constant address, it cannot be in
1097 a temporary slot, but it can contain something whose address was
1099 if (p
== 0 && (!MEM_P (x
) || CONSTANT_P (XEXP (x
, 0))))
1101 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1106 move_slot_to_level (p
, temp_slot_level
- 1);
1112 /* First see if we can find a match. */
1114 p
= find_temp_slot_from_address (XEXP (x
, 0));
1118 /* Move everything at our level whose address was taken to our new
1119 level in case we used its address. */
1120 struct temp_slot
*q
;
1122 if (p
->level
== temp_slot_level
)
1124 for (q
= *temp_slots_at_level (temp_slot_level
); q
; q
= next
)
1128 if (p
!= q
&& q
->addr_taken
)
1129 move_slot_to_level (q
, temp_slot_level
- 1);
1132 move_slot_to_level (p
, temp_slot_level
- 1);
1138 /* Otherwise, preserve all non-kept slots at this level. */
1139 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1144 move_slot_to_level (p
, temp_slot_level
- 1);
1148 /* Free all temporaries used so far. This is normally called at the
1149 end of generating code for a statement. */
1152 free_temp_slots (void)
1154 struct temp_slot
*p
, *next
;
1156 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1161 make_slot_available (p
);
1164 combine_temp_slots ();
1167 /* Push deeper into the nesting level for stack temporaries. */
1170 push_temp_slots (void)
1175 /* Pop a temporary nesting level. All slots in use in the current level
1179 pop_temp_slots (void)
1181 struct temp_slot
*p
, *next
;
1183 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1186 make_slot_available (p
);
1189 combine_temp_slots ();
1194 /* Initialize temporary slots. */
1197 init_temp_slots (void)
1199 /* We have not allocated any temporaries yet. */
1200 avail_temp_slots
= 0;
1201 used_temp_slots
= 0;
1202 temp_slot_level
= 0;
1203 var_temp_slot_level
= 0;
1204 target_temp_slot_level
= 0;
1207 /* These routines are responsible for converting virtual register references
1208 to the actual hard register references once RTL generation is complete.
1210 The following four variables are used for communication between the
1211 routines. They contain the offsets of the virtual registers from their
1212 respective hard registers. */
1214 static int in_arg_offset
;
1215 static int var_offset
;
1216 static int dynamic_offset
;
1217 static int out_arg_offset
;
1218 static int cfa_offset
;
1220 /* In most machines, the stack pointer register is equivalent to the bottom
1223 #ifndef STACK_POINTER_OFFSET
1224 #define STACK_POINTER_OFFSET 0
1227 /* If not defined, pick an appropriate default for the offset of dynamically
1228 allocated memory depending on the value of ACCUMULATE_OUTGOING_ARGS,
1229 REG_PARM_STACK_SPACE, and OUTGOING_REG_PARM_STACK_SPACE. */
1231 #ifndef STACK_DYNAMIC_OFFSET
1233 /* The bottom of the stack points to the actual arguments. If
1234 REG_PARM_STACK_SPACE is defined, this includes the space for the register
1235 parameters. However, if OUTGOING_REG_PARM_STACK space is not defined,
1236 stack space for register parameters is not pushed by the caller, but
1237 rather part of the fixed stack areas and hence not included in
1238 `current_function_outgoing_args_size'. Nevertheless, we must allow
1239 for it when allocating stack dynamic objects. */
1241 #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE)
1242 #define STACK_DYNAMIC_OFFSET(FNDECL) \
1243 ((ACCUMULATE_OUTGOING_ARGS \
1244 ? (current_function_outgoing_args_size + REG_PARM_STACK_SPACE (FNDECL)) : 0)\
1245 + (STACK_POINTER_OFFSET)) \
1248 #define STACK_DYNAMIC_OFFSET(FNDECL) \
1249 ((ACCUMULATE_OUTGOING_ARGS ? current_function_outgoing_args_size : 0) \
1250 + (STACK_POINTER_OFFSET))
1254 /* On most machines, the CFA coincides with the first incoming parm. */
1256 #ifndef ARG_POINTER_CFA_OFFSET
1257 #define ARG_POINTER_CFA_OFFSET(FNDECL) FIRST_PARM_OFFSET (FNDECL)
1261 /* Convert a SET of a hard subreg to a set of the appropriate hard
1262 register. A subroutine of purge_hard_subreg_sets. */
1265 purge_single_hard_subreg_set (rtx pattern
)
1267 rtx reg
= SET_DEST (pattern
);
1268 enum machine_mode mode
= GET_MODE (SET_DEST (pattern
));
1271 if (GET_CODE (reg
) == SUBREG
&& REG_P (SUBREG_REG (reg
))
1272 && REGNO (SUBREG_REG (reg
)) < FIRST_PSEUDO_REGISTER
)
1274 offset
= subreg_regno_offset (REGNO (SUBREG_REG (reg
)),
1275 GET_MODE (SUBREG_REG (reg
)),
1278 reg
= SUBREG_REG (reg
);
1282 if (REG_P (reg
) && REGNO (reg
) < FIRST_PSEUDO_REGISTER
)
1284 reg
= gen_rtx_REG (mode
, REGNO (reg
) + offset
);
1285 SET_DEST (pattern
) = reg
;
1289 /* Eliminate all occurrences of SETs of hard subregs from INSNS. The
1290 only such SETs that we expect to see are those left in because
1291 integrate can't handle sets of parts of a return value register.
1293 We don't use alter_subreg because we only want to eliminate subregs
1294 of hard registers. */
1297 purge_hard_subreg_sets (rtx insn
)
1299 for (; insn
; insn
= NEXT_INSN (insn
))
1303 rtx pattern
= PATTERN (insn
);
1304 switch (GET_CODE (pattern
))
1307 if (GET_CODE (SET_DEST (pattern
)) == SUBREG
)
1308 purge_single_hard_subreg_set (pattern
);
1313 for (j
= XVECLEN (pattern
, 0) - 1; j
>= 0; j
--)
1315 rtx inner_pattern
= XVECEXP (pattern
, 0, j
);
1316 if (GET_CODE (inner_pattern
) == SET
1317 && GET_CODE (SET_DEST (inner_pattern
)) == SUBREG
)
1318 purge_single_hard_subreg_set (inner_pattern
);
1329 /* Pass through the INSNS of function FNDECL and convert virtual register
1330 references to hard register references. */
1333 instantiate_virtual_regs (void)
1337 /* Compute the offsets to use for this function. */
1338 in_arg_offset
= FIRST_PARM_OFFSET (current_function_decl
);
1339 var_offset
= STARTING_FRAME_OFFSET
;
1340 dynamic_offset
= STACK_DYNAMIC_OFFSET (current_function_decl
);
1341 out_arg_offset
= STACK_POINTER_OFFSET
;
1342 cfa_offset
= ARG_POINTER_CFA_OFFSET (current_function_decl
);
1344 /* Scan all variables and parameters of this function. For each that is
1345 in memory, instantiate all virtual registers if the result is a valid
1346 address. If not, we do it later. That will handle most uses of virtual
1347 regs on many machines. */
1348 instantiate_decls (current_function_decl
, 1);
1350 /* Initialize recognition, indicating that volatile is OK. */
1353 /* Scan through all the insns, instantiating every virtual register still
1355 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1356 if (GET_CODE (insn
) == INSN
|| GET_CODE (insn
) == JUMP_INSN
1357 || GET_CODE (insn
) == CALL_INSN
)
1359 instantiate_virtual_regs_1 (&PATTERN (insn
), insn
, 1);
1360 if (INSN_DELETED_P (insn
))
1362 instantiate_virtual_regs_1 (®_NOTES (insn
), NULL_RTX
, 0);
1363 /* Instantiate any virtual registers in CALL_INSN_FUNCTION_USAGE. */
1364 if (GET_CODE (insn
) == CALL_INSN
)
1365 instantiate_virtual_regs_1 (&CALL_INSN_FUNCTION_USAGE (insn
),
1368 /* Past this point all ASM statements should match. Verify that
1369 to avoid failures later in the compilation process. */
1370 if (asm_noperands (PATTERN (insn
)) >= 0
1371 && ! check_asm_operands (PATTERN (insn
)))
1372 instantiate_virtual_regs_lossage (insn
);
1375 /* Now instantiate the remaining register equivalences for debugging info.
1376 These will not be valid addresses. */
1377 instantiate_decls (current_function_decl
, 0);
1379 /* Indicate that, from now on, assign_stack_local should use
1380 frame_pointer_rtx. */
1381 virtuals_instantiated
= 1;
1384 /* Scan all decls in FNDECL (both variables and parameters) and instantiate
1385 all virtual registers in their DECL_RTL's.
1387 If VALID_ONLY, do this only if the resulting address is still valid.
1388 Otherwise, always do it. */
1391 instantiate_decls (tree fndecl
, int valid_only
)
1395 /* Process all parameters of the function. */
1396 for (decl
= DECL_ARGUMENTS (fndecl
); decl
; decl
= TREE_CHAIN (decl
))
1398 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (decl
));
1399 HOST_WIDE_INT size_rtl
;
1401 instantiate_decl (DECL_RTL (decl
), size
, valid_only
);
1403 /* If the parameter was promoted, then the incoming RTL mode may be
1404 larger than the declared type size. We must use the larger of
1406 size_rtl
= GET_MODE_SIZE (GET_MODE (DECL_INCOMING_RTL (decl
)));
1407 size
= MAX (size_rtl
, size
);
1408 instantiate_decl (DECL_INCOMING_RTL (decl
), size
, valid_only
);
1411 /* Now process all variables defined in the function or its subblocks. */
1412 instantiate_decls_1 (DECL_INITIAL (fndecl
), valid_only
);
1415 /* Subroutine of instantiate_decls: Process all decls in the given
1416 BLOCK node and all its subblocks. */
1419 instantiate_decls_1 (tree let
, int valid_only
)
1423 for (t
= BLOCK_VARS (let
); t
; t
= TREE_CHAIN (t
))
1424 if (DECL_RTL_SET_P (t
))
1425 instantiate_decl (DECL_RTL (t
),
1426 int_size_in_bytes (TREE_TYPE (t
)),
1429 /* Process all subblocks. */
1430 for (t
= BLOCK_SUBBLOCKS (let
); t
; t
= TREE_CHAIN (t
))
1431 instantiate_decls_1 (t
, valid_only
);
1434 /* Subroutine of the preceding procedures: Given RTL representing a
1435 decl and the size of the object, do any instantiation required.
1437 If VALID_ONLY is nonzero, it means that the RTL should only be
1438 changed if the new address is valid. */
1441 instantiate_decl (rtx x
, HOST_WIDE_INT size
, int valid_only
)
1443 enum machine_mode mode
;
1446 /* If this is not a MEM, no need to do anything. Similarly if the
1447 address is a constant or a register that is not a virtual register. */
1449 if (x
== 0 || !MEM_P (x
))
1453 if (CONSTANT_P (addr
)
1455 && (REGNO (addr
) < FIRST_VIRTUAL_REGISTER
1456 || REGNO (addr
) > LAST_VIRTUAL_REGISTER
)))
1459 /* If we should only do this if the address is valid, copy the address.
1460 We need to do this so we can undo any changes that might make the
1461 address invalid. This copy is unfortunate, but probably can't be
1465 addr
= copy_rtx (addr
);
1467 instantiate_virtual_regs_1 (&addr
, NULL_RTX
, 0);
1469 if (valid_only
&& size
>= 0)
1471 unsigned HOST_WIDE_INT decl_size
= size
;
1473 /* Now verify that the resulting address is valid for every integer or
1474 floating-point mode up to and including SIZE bytes long. We do this
1475 since the object might be accessed in any mode and frame addresses
1478 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
1479 mode
!= VOIDmode
&& GET_MODE_SIZE (mode
) <= decl_size
;
1480 mode
= GET_MODE_WIDER_MODE (mode
))
1481 if (! memory_address_p (mode
, addr
))
1484 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_FLOAT
);
1485 mode
!= VOIDmode
&& GET_MODE_SIZE (mode
) <= decl_size
;
1486 mode
= GET_MODE_WIDER_MODE (mode
))
1487 if (! memory_address_p (mode
, addr
))
1491 /* Put back the address now that we have updated it and we either know
1492 it is valid or we don't care whether it is valid. */
1497 /* Given a piece of RTX and a pointer to a HOST_WIDE_INT, if the RTX
1498 is a virtual register, return the equivalent hard register and set the
1499 offset indirectly through the pointer. Otherwise, return 0. */
1502 instantiate_new_reg (rtx x
, HOST_WIDE_INT
*poffset
)
1505 HOST_WIDE_INT offset
;
1507 if (x
== virtual_incoming_args_rtx
)
1508 new = arg_pointer_rtx
, offset
= in_arg_offset
;
1509 else if (x
== virtual_stack_vars_rtx
)
1510 new = frame_pointer_rtx
, offset
= var_offset
;
1511 else if (x
== virtual_stack_dynamic_rtx
)
1512 new = stack_pointer_rtx
, offset
= dynamic_offset
;
1513 else if (x
== virtual_outgoing_args_rtx
)
1514 new = stack_pointer_rtx
, offset
= out_arg_offset
;
1515 else if (x
== virtual_cfa_rtx
)
1516 new = arg_pointer_rtx
, offset
= cfa_offset
;
1525 /* Called when instantiate_virtual_regs has failed to update the instruction.
1526 Usually this means that non-matching instruction has been emit, however for
1527 asm statements it may be the problem in the constraints. */
1529 instantiate_virtual_regs_lossage (rtx insn
)
1531 if (asm_noperands (PATTERN (insn
)) >= 0)
1533 error_for_asm (insn
, "impossible constraint in `asm'");
1539 /* Given a pointer to a piece of rtx and an optional pointer to the
1540 containing object, instantiate any virtual registers present in it.
1542 If EXTRA_INSNS, we always do the replacement and generate
1543 any extra insns before OBJECT. If it zero, we do nothing if replacement
1546 Return 1 if we either had nothing to do or if we were able to do the
1547 needed replacement. Return 0 otherwise; we only return zero if
1548 EXTRA_INSNS is zero.
1550 We first try some simple transformations to avoid the creation of extra
1554 instantiate_virtual_regs_1 (rtx
*loc
, rtx object
, int extra_insns
)
1559 HOST_WIDE_INT offset
= 0;
1565 /* Re-start here to avoid recursion in common cases. */
1572 /* We may have detected and deleted invalid asm statements. */
1573 if (object
&& INSN_P (object
) && INSN_DELETED_P (object
))
1576 code
= GET_CODE (x
);
1578 /* Check for some special cases. */
1596 /* We are allowed to set the virtual registers. This means that
1597 the actual register should receive the source minus the
1598 appropriate offset. This is used, for example, in the handling
1599 of non-local gotos. */
1600 if ((new = instantiate_new_reg (SET_DEST (x
), &offset
)) != 0)
1602 rtx src
= SET_SRC (x
);
1604 /* We are setting the register, not using it, so the relevant
1605 offset is the negative of the offset to use were we using
1608 instantiate_virtual_regs_1 (&src
, NULL_RTX
, 0);
1610 /* The only valid sources here are PLUS or REG. Just do
1611 the simplest possible thing to handle them. */
1612 if (!REG_P (src
) && GET_CODE (src
) != PLUS
)
1614 instantiate_virtual_regs_lossage (object
);
1620 temp
= force_operand (src
, NULL_RTX
);
1623 temp
= force_operand (plus_constant (temp
, offset
), NULL_RTX
);
1627 emit_insn_before (seq
, object
);
1630 if (! validate_change (object
, &SET_SRC (x
), temp
, 0)
1632 instantiate_virtual_regs_lossage (object
);
1637 instantiate_virtual_regs_1 (&SET_DEST (x
), object
, extra_insns
);
1642 /* Handle special case of virtual register plus constant. */
1643 if (CONSTANT_P (XEXP (x
, 1)))
1645 rtx old
, new_offset
;
1647 /* Check for (plus (plus VIRT foo) (const_int)) first. */
1648 if (GET_CODE (XEXP (x
, 0)) == PLUS
)
1650 if ((new = instantiate_new_reg (XEXP (XEXP (x
, 0), 0), &offset
)))
1652 instantiate_virtual_regs_1 (&XEXP (XEXP (x
, 0), 1), object
,
1654 new = gen_rtx_PLUS (Pmode
, new, XEXP (XEXP (x
, 0), 1));
1663 #ifdef POINTERS_EXTEND_UNSIGNED
1664 /* If we have (plus (subreg (virtual-reg)) (const_int)), we know
1665 we can commute the PLUS and SUBREG because pointers into the
1666 frame are well-behaved. */
1667 else if (GET_CODE (XEXP (x
, 0)) == SUBREG
&& GET_MODE (x
) == ptr_mode
1668 && GET_CODE (XEXP (x
, 1)) == CONST_INT
1670 = instantiate_new_reg (SUBREG_REG (XEXP (x
, 0)),
1672 && validate_change (object
, loc
,
1673 plus_constant (gen_lowpart (ptr_mode
,
1676 + INTVAL (XEXP (x
, 1))),
1680 else if ((new = instantiate_new_reg (XEXP (x
, 0), &offset
)) == 0)
1682 /* We know the second operand is a constant. Unless the
1683 first operand is a REG (which has been already checked),
1684 it needs to be checked. */
1685 if (!REG_P (XEXP (x
, 0)))
1693 new_offset
= plus_constant (XEXP (x
, 1), offset
);
1695 /* If the new constant is zero, try to replace the sum with just
1697 if (new_offset
== const0_rtx
1698 && validate_change (object
, loc
, new, 0))
1701 /* Next try to replace the register and new offset.
1702 There are two changes to validate here and we can't assume that
1703 in the case of old offset equals new just changing the register
1704 will yield a valid insn. In the interests of a little efficiency,
1705 however, we only call validate change once (we don't queue up the
1706 changes and then call apply_change_group). */
1710 ? ! validate_change (object
, &XEXP (x
, 0), new, 0)
1711 : (XEXP (x
, 0) = new,
1712 ! validate_change (object
, &XEXP (x
, 1), new_offset
, 0)))
1720 /* Otherwise copy the new constant into a register and replace
1721 constant with that register. */
1722 temp
= gen_reg_rtx (Pmode
);
1724 if (validate_change (object
, &XEXP (x
, 1), temp
, 0))
1725 emit_insn_before (gen_move_insn (temp
, new_offset
), object
);
1728 /* If that didn't work, replace this expression with a
1729 register containing the sum. */
1732 new = gen_rtx_PLUS (Pmode
, new, new_offset
);
1735 temp
= force_operand (new, NULL_RTX
);
1739 emit_insn_before (seq
, object
);
1740 if (! validate_change (object
, loc
, temp
, 0)
1741 && ! validate_replace_rtx (x
, temp
, object
))
1743 instantiate_virtual_regs_lossage (object
);
1752 /* Fall through to generic two-operand expression case. */
1758 case DIV
: case UDIV
:
1759 case MOD
: case UMOD
:
1760 case AND
: case IOR
: case XOR
:
1761 case ROTATERT
: case ROTATE
:
1762 case ASHIFTRT
: case LSHIFTRT
: case ASHIFT
:
1764 case GE
: case GT
: case GEU
: case GTU
:
1765 case LE
: case LT
: case LEU
: case LTU
:
1766 if (XEXP (x
, 1) && ! CONSTANT_P (XEXP (x
, 1)))
1767 instantiate_virtual_regs_1 (&XEXP (x
, 1), object
, extra_insns
);
1772 /* Most cases of MEM that convert to valid addresses have already been
1773 handled by our scan of decls. The only special handling we
1774 need here is to make a copy of the rtx to ensure it isn't being
1775 shared if we have to change it to a pseudo.
1777 If the rtx is a simple reference to an address via a virtual register,
1778 it can potentially be shared. In such cases, first try to make it
1779 a valid address, which can also be shared. Otherwise, copy it and
1782 First check for common cases that need no processing. These are
1783 usually due to instantiation already being done on a previous instance
1787 if (CONSTANT_ADDRESS_P (temp
)
1788 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1789 || temp
== arg_pointer_rtx
1791 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
1792 || temp
== hard_frame_pointer_rtx
1794 || temp
== frame_pointer_rtx
)
1797 if (GET_CODE (temp
) == PLUS
1798 && CONSTANT_ADDRESS_P (XEXP (temp
, 1))
1799 && (XEXP (temp
, 0) == frame_pointer_rtx
1800 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
1801 || XEXP (temp
, 0) == hard_frame_pointer_rtx
1803 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1804 || XEXP (temp
, 0) == arg_pointer_rtx
1809 if (temp
== virtual_stack_vars_rtx
1810 || temp
== virtual_incoming_args_rtx
1811 || (GET_CODE (temp
) == PLUS
1812 && CONSTANT_ADDRESS_P (XEXP (temp
, 1))
1813 && (XEXP (temp
, 0) == virtual_stack_vars_rtx
1814 || XEXP (temp
, 0) == virtual_incoming_args_rtx
)))
1816 /* This MEM may be shared. If the substitution can be done without
1817 the need to generate new pseudos, we want to do it in place
1818 so all copies of the shared rtx benefit. The call below will
1819 only make substitutions if the resulting address is still
1822 Note that we cannot pass X as the object in the recursive call
1823 since the insn being processed may not allow all valid
1824 addresses. However, if we were not passed on object, we can
1825 only modify X without copying it if X will have a valid
1828 ??? Also note that this can still lose if OBJECT is an insn that
1829 has less restrictions on an address that some other insn.
1830 In that case, we will modify the shared address. This case
1831 doesn't seem very likely, though. One case where this could
1832 happen is in the case of a USE or CLOBBER reference, but we
1833 take care of that below. */
1835 if (instantiate_virtual_regs_1 (&XEXP (x
, 0),
1836 object
? object
: x
, 0))
1839 /* Otherwise make a copy and process that copy. We copy the entire
1840 RTL expression since it might be a PLUS which could also be
1842 *loc
= x
= copy_rtx (x
);
1845 /* Fall through to generic unary operation case. */
1848 case STRICT_LOW_PART
:
1850 case PRE_DEC
: case PRE_INC
: case POST_DEC
: case POST_INC
:
1851 case SIGN_EXTEND
: case ZERO_EXTEND
:
1852 case TRUNCATE
: case FLOAT_EXTEND
: case FLOAT_TRUNCATE
:
1853 case FLOAT
: case FIX
:
1854 case UNSIGNED_FIX
: case UNSIGNED_FLOAT
:
1859 case POPCOUNT
: case PARITY
:
1860 /* These case either have just one operand or we know that we need not
1861 check the rest of the operands. */
1867 /* If the operand is a MEM, see if the change is a valid MEM. If not,
1868 go ahead and make the invalid one, but do it to a copy. For a REG,
1869 just make the recursive call, since there's no chance of a problem. */
1871 if ((MEM_P (XEXP (x
, 0))
1872 && instantiate_virtual_regs_1 (&XEXP (XEXP (x
, 0), 0), XEXP (x
, 0),
1874 || (REG_P (XEXP (x
, 0))
1875 && instantiate_virtual_regs_1 (&XEXP (x
, 0), object
, 0)))
1878 XEXP (x
, 0) = copy_rtx (XEXP (x
, 0));
1883 /* Try to replace with a PLUS. If that doesn't work, compute the sum
1884 in front of this insn and substitute the temporary. */
1885 if ((new = instantiate_new_reg (x
, &offset
)) != 0)
1887 temp
= plus_constant (new, offset
);
1888 if (!validate_change (object
, loc
, temp
, 0))
1894 temp
= force_operand (temp
, NULL_RTX
);
1898 emit_insn_before (seq
, object
);
1899 if (! validate_change (object
, loc
, temp
, 0)
1900 && ! validate_replace_rtx (x
, temp
, object
))
1901 instantiate_virtual_regs_lossage (object
);
1911 /* Scan all subexpressions. */
1912 fmt
= GET_RTX_FORMAT (code
);
1913 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++, fmt
++)
1916 if (!instantiate_virtual_regs_1 (&XEXP (x
, i
), object
, extra_insns
))
1919 else if (*fmt
== 'E')
1920 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1921 if (! instantiate_virtual_regs_1 (&XVECEXP (x
, i
, j
), object
,
1928 /* Return 1 if EXP is an aggregate type (or a value with aggregate type).
1929 This means a type for which function calls must pass an address to the
1930 function or get an address back from the function.
1931 EXP may be a type node or an expression (whose type is tested). */
1934 aggregate_value_p (tree exp
, tree fntype
)
1936 int i
, regno
, nregs
;
1939 tree type
= (TYPE_P (exp
)) ? exp
: TREE_TYPE (exp
);
1942 switch (TREE_CODE (fntype
))
1945 fntype
= get_callee_fndecl (fntype
);
1946 fntype
= fntype
? TREE_TYPE (fntype
) : 0;
1949 fntype
= TREE_TYPE (fntype
);
1954 case IDENTIFIER_NODE
:
1958 /* We don't expect other rtl types here. */
1962 if (TREE_CODE (type
) == VOID_TYPE
)
1964 if (targetm
.calls
.return_in_memory (type
, fntype
))
1966 /* Types that are TREE_ADDRESSABLE must be constructed in memory,
1967 and thus can't be returned in registers. */
1968 if (TREE_ADDRESSABLE (type
))
1970 if (flag_pcc_struct_return
&& AGGREGATE_TYPE_P (type
))
1972 /* Make sure we have suitable call-clobbered regs to return
1973 the value in; if not, we must return it in memory. */
1974 reg
= hard_function_value (type
, 0, 0);
1976 /* If we have something other than a REG (e.g. a PARALLEL), then assume
1981 regno
= REGNO (reg
);
1982 nregs
= hard_regno_nregs
[regno
][TYPE_MODE (type
)];
1983 for (i
= 0; i
< nregs
; i
++)
1984 if (! call_used_regs
[regno
+ i
])
1989 /* Return true if we should assign DECL a pseudo register; false if it
1990 should live on the local stack. */
1993 use_register_for_decl (tree decl
)
1995 /* Honor volatile. */
1996 if (TREE_SIDE_EFFECTS (decl
))
1999 /* Honor addressability. */
2000 if (TREE_ADDRESSABLE (decl
))
2003 /* Only register-like things go in registers. */
2004 if (DECL_MODE (decl
) == BLKmode
)
2007 /* If -ffloat-store specified, don't put explicit float variables
2009 /* ??? This should be checked after DECL_ARTIFICIAL, but tree-ssa
2010 propagates values across these stores, and it probably shouldn't. */
2011 if (flag_float_store
&& FLOAT_TYPE_P (TREE_TYPE (decl
)))
2014 /* Compiler-generated temporaries can always go in registers. */
2015 if (DECL_ARTIFICIAL (decl
))
2018 #ifdef NON_SAVING_SETJMP
2019 /* Protect variables not declared "register" from setjmp. */
2020 if (NON_SAVING_SETJMP
2021 && current_function_calls_setjmp
2022 && !DECL_REGISTER (decl
))
2026 return (optimize
|| DECL_REGISTER (decl
));
2029 /* Return true if TYPE should be passed by invisible reference. */
2032 pass_by_reference (CUMULATIVE_ARGS
*ca
, enum machine_mode mode
,
2033 tree type
, bool named_arg
)
2037 /* If this type contains non-trivial constructors, then it is
2038 forbidden for the middle-end to create any new copies. */
2039 if (TREE_ADDRESSABLE (type
))
2042 /* If an object's size is dependent on itself, there's no way
2043 to *not* pass by reference. */
2044 if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type
)))
2048 return targetm
.calls
.pass_by_reference (ca
, mode
, type
, named_arg
);
2051 /* Structures to communicate between the subroutines of assign_parms.
2052 The first holds data persistent across all parameters, the second
2053 is cleared out for each parameter. */
2055 struct assign_parm_data_all
2057 CUMULATIVE_ARGS args_so_far
;
2058 struct args_size stack_args_size
;
2059 tree function_result_decl
;
2061 rtx conversion_insns
;
2062 HOST_WIDE_INT pretend_args_size
;
2063 HOST_WIDE_INT extra_pretend_bytes
;
2064 int reg_parm_stack_space
;
2067 struct assign_parm_data_one
2073 enum machine_mode nominal_mode
;
2074 enum machine_mode passed_mode
;
2075 enum machine_mode promoted_mode
;
2076 struct locate_and_pad_arg_data locate
;
2078 BOOL_BITFIELD named_arg
: 1;
2079 BOOL_BITFIELD last_named
: 1;
2080 BOOL_BITFIELD passed_pointer
: 1;
2081 BOOL_BITFIELD on_stack
: 1;
2082 BOOL_BITFIELD loaded_in_reg
: 1;
2085 /* A subroutine of assign_parms. Initialize ALL. */
2088 assign_parms_initialize_all (struct assign_parm_data_all
*all
)
2092 memset (all
, 0, sizeof (*all
));
2094 fntype
= TREE_TYPE (current_function_decl
);
2096 #ifdef INIT_CUMULATIVE_INCOMING_ARGS
2097 INIT_CUMULATIVE_INCOMING_ARGS (all
->args_so_far
, fntype
, NULL_RTX
);
2099 INIT_CUMULATIVE_ARGS (all
->args_so_far
, fntype
, NULL_RTX
,
2100 current_function_decl
, -1);
2103 #ifdef REG_PARM_STACK_SPACE
2104 all
->reg_parm_stack_space
= REG_PARM_STACK_SPACE (current_function_decl
);
2108 /* If ARGS contains entries with complex types, split the entry into two
2109 entries of the component type. Return a new list of substitutions are
2110 needed, else the old list. */
2113 split_complex_args (tree args
)
2117 /* Before allocating memory, check for the common case of no complex. */
2118 for (p
= args
; p
; p
= TREE_CHAIN (p
))
2120 tree type
= TREE_TYPE (p
);
2121 if (TREE_CODE (type
) == COMPLEX_TYPE
2122 && targetm
.calls
.split_complex_arg (type
))
2128 args
= copy_list (args
);
2130 for (p
= args
; p
; p
= TREE_CHAIN (p
))
2132 tree type
= TREE_TYPE (p
);
2133 if (TREE_CODE (type
) == COMPLEX_TYPE
2134 && targetm
.calls
.split_complex_arg (type
))
2137 tree subtype
= TREE_TYPE (type
);
2139 /* Rewrite the PARM_DECL's type with its component. */
2140 TREE_TYPE (p
) = subtype
;
2141 DECL_ARG_TYPE (p
) = TREE_TYPE (DECL_ARG_TYPE (p
));
2142 DECL_MODE (p
) = VOIDmode
;
2143 DECL_SIZE (p
) = NULL
;
2144 DECL_SIZE_UNIT (p
) = NULL
;
2147 /* Build a second synthetic decl. */
2148 decl
= build_decl (PARM_DECL
, NULL_TREE
, subtype
);
2149 DECL_ARG_TYPE (decl
) = DECL_ARG_TYPE (p
);
2150 layout_decl (decl
, 0);
2152 /* Splice it in; skip the new decl. */
2153 TREE_CHAIN (decl
) = TREE_CHAIN (p
);
2154 TREE_CHAIN (p
) = decl
;
2162 /* A subroutine of assign_parms. Adjust the parameter list to incorporate
2163 the hidden struct return argument, and (abi willing) complex args.
2164 Return the new parameter list. */
2167 assign_parms_augmented_arg_list (struct assign_parm_data_all
*all
)
2169 tree fndecl
= current_function_decl
;
2170 tree fntype
= TREE_TYPE (fndecl
);
2171 tree fnargs
= DECL_ARGUMENTS (fndecl
);
2173 /* If struct value address is treated as the first argument, make it so. */
2174 if (aggregate_value_p (DECL_RESULT (fndecl
), fndecl
)
2175 && ! current_function_returns_pcc_struct
2176 && targetm
.calls
.struct_value_rtx (TREE_TYPE (fndecl
), 1) == 0)
2178 tree type
= build_pointer_type (TREE_TYPE (fntype
));
2181 decl
= build_decl (PARM_DECL
, NULL_TREE
, type
);
2182 DECL_ARG_TYPE (decl
) = type
;
2183 DECL_ARTIFICIAL (decl
) = 1;
2185 TREE_CHAIN (decl
) = fnargs
;
2187 all
->function_result_decl
= decl
;
2190 all
->orig_fnargs
= fnargs
;
2192 /* If the target wants to split complex arguments into scalars, do so. */
2193 if (targetm
.calls
.split_complex_arg
)
2194 fnargs
= split_complex_args (fnargs
);
2199 /* A subroutine of assign_parms. Examine PARM and pull out type and mode
2200 data for the parameter. Incorporate ABI specifics such as pass-by-
2201 reference and type promotion. */
2204 assign_parm_find_data_types (struct assign_parm_data_all
*all
, tree parm
,
2205 struct assign_parm_data_one
*data
)
2207 tree nominal_type
, passed_type
;
2208 enum machine_mode nominal_mode
, passed_mode
, promoted_mode
;
2210 memset (data
, 0, sizeof (*data
));
2212 /* Set LAST_NAMED if this is last named arg before last anonymous args. */
2213 if (current_function_stdarg
)
2216 for (tem
= TREE_CHAIN (parm
); tem
; tem
= TREE_CHAIN (tem
))
2217 if (DECL_NAME (tem
))
2220 data
->last_named
= true;
2223 /* Set NAMED_ARG if this arg should be treated as a named arg. For
2224 most machines, if this is a varargs/stdarg function, then we treat
2225 the last named arg as if it were anonymous too. */
2226 if (targetm
.calls
.strict_argument_naming (&all
->args_so_far
))
2227 data
->named_arg
= 1;
2229 data
->named_arg
= !data
->last_named
;
2231 nominal_type
= TREE_TYPE (parm
);
2232 passed_type
= DECL_ARG_TYPE (parm
);
2234 /* Look out for errors propagating this far. Also, if the parameter's
2235 type is void then its value doesn't matter. */
2236 if (TREE_TYPE (parm
) == error_mark_node
2237 /* This can happen after weird syntax errors
2238 or if an enum type is defined among the parms. */
2239 || TREE_CODE (parm
) != PARM_DECL
2240 || passed_type
== NULL
2241 || VOID_TYPE_P (nominal_type
))
2243 nominal_type
= passed_type
= void_type_node
;
2244 nominal_mode
= passed_mode
= promoted_mode
= VOIDmode
;
2248 /* Find mode of arg as it is passed, and mode of arg as it should be
2249 during execution of this function. */
2250 passed_mode
= TYPE_MODE (passed_type
);
2251 nominal_mode
= TYPE_MODE (nominal_type
);
2253 /* If the parm is to be passed as a transparent union, use the type of
2254 the first field for the tests below. We have already verified that
2255 the modes are the same. */
2256 if (DECL_TRANSPARENT_UNION (parm
)
2257 || (TREE_CODE (passed_type
) == UNION_TYPE
2258 && TYPE_TRANSPARENT_UNION (passed_type
)))
2259 passed_type
= TREE_TYPE (TYPE_FIELDS (passed_type
));
2261 /* See if this arg was passed by invisible reference. */
2262 if (pass_by_reference (&all
->args_so_far
, passed_mode
,
2263 passed_type
, data
->named_arg
))
2265 passed_type
= nominal_type
= build_pointer_type (passed_type
);
2266 data
->passed_pointer
= true;
2267 passed_mode
= nominal_mode
= Pmode
;
2269 /* See if the frontend wants to pass this by invisible reference. */
2270 else if (passed_type
!= nominal_type
2271 && POINTER_TYPE_P (passed_type
)
2272 && TREE_TYPE (passed_type
) == nominal_type
)
2274 nominal_type
= passed_type
;
2275 data
->passed_pointer
= 1;
2276 passed_mode
= nominal_mode
= Pmode
;
2279 /* Find mode as it is passed by the ABI. */
2280 promoted_mode
= passed_mode
;
2281 if (targetm
.calls
.promote_function_args (TREE_TYPE (current_function_decl
)))
2283 int unsignedp
= TYPE_UNSIGNED (passed_type
);
2284 promoted_mode
= promote_mode (passed_type
, promoted_mode
,
2289 data
->nominal_type
= nominal_type
;
2290 data
->passed_type
= passed_type
;
2291 data
->nominal_mode
= nominal_mode
;
2292 data
->passed_mode
= passed_mode
;
2293 data
->promoted_mode
= promoted_mode
;
2296 /* A subroutine of assign_parms. Invoke setup_incoming_varargs. */
2299 assign_parms_setup_varargs (struct assign_parm_data_all
*all
,
2300 struct assign_parm_data_one
*data
, bool no_rtl
)
2302 int varargs_pretend_bytes
= 0;
2304 targetm
.calls
.setup_incoming_varargs (&all
->args_so_far
,
2305 data
->promoted_mode
,
2307 &varargs_pretend_bytes
, no_rtl
);
2309 /* If the back-end has requested extra stack space, record how much is
2310 needed. Do not change pretend_args_size otherwise since it may be
2311 nonzero from an earlier partial argument. */
2312 if (varargs_pretend_bytes
> 0)
2313 all
->pretend_args_size
= varargs_pretend_bytes
;
2316 /* A subroutine of assign_parms. Set DATA->ENTRY_PARM corresponding to
2317 the incoming location of the current parameter. */
2320 assign_parm_find_entry_rtl (struct assign_parm_data_all
*all
,
2321 struct assign_parm_data_one
*data
)
2323 HOST_WIDE_INT pretend_bytes
= 0;
2327 if (data
->promoted_mode
== VOIDmode
)
2329 data
->entry_parm
= data
->stack_parm
= const0_rtx
;
2333 #ifdef FUNCTION_INCOMING_ARG
2334 entry_parm
= FUNCTION_INCOMING_ARG (all
->args_so_far
, data
->promoted_mode
,
2335 data
->passed_type
, data
->named_arg
);
2337 entry_parm
= FUNCTION_ARG (all
->args_so_far
, data
->promoted_mode
,
2338 data
->passed_type
, data
->named_arg
);
2341 if (entry_parm
== 0)
2342 data
->promoted_mode
= data
->passed_mode
;
2344 /* Determine parm's home in the stack, in case it arrives in the stack
2345 or we should pretend it did. Compute the stack position and rtx where
2346 the argument arrives and its size.
2348 There is one complexity here: If this was a parameter that would
2349 have been passed in registers, but wasn't only because it is
2350 __builtin_va_alist, we want locate_and_pad_parm to treat it as if
2351 it came in a register so that REG_PARM_STACK_SPACE isn't skipped.
2352 In this case, we call FUNCTION_ARG with NAMED set to 1 instead of 0
2353 as it was the previous time. */
2354 in_regs
= entry_parm
!= 0;
2355 #ifdef STACK_PARMS_IN_REG_PARM_AREA
2358 if (!in_regs
&& !data
->named_arg
)
2360 if (targetm
.calls
.pretend_outgoing_varargs_named (&all
->args_so_far
))
2363 #ifdef FUNCTION_INCOMING_ARG
2364 tem
= FUNCTION_INCOMING_ARG (all
->args_so_far
, data
->promoted_mode
,
2365 data
->passed_type
, true);
2367 tem
= FUNCTION_ARG (all
->args_so_far
, data
->promoted_mode
,
2368 data
->passed_type
, true);
2370 in_regs
= tem
!= NULL
;
2374 /* If this parameter was passed both in registers and in the stack, use
2375 the copy on the stack. */
2376 if (targetm
.calls
.must_pass_in_stack (data
->promoted_mode
,
2384 partial
= FUNCTION_ARG_PARTIAL_NREGS (all
->args_so_far
,
2385 data
->promoted_mode
,
2388 data
->partial
= partial
;
2390 /* The caller might already have allocated stack space for the
2391 register parameters. */
2392 if (partial
!= 0 && all
->reg_parm_stack_space
== 0)
2394 /* Part of this argument is passed in registers and part
2395 is passed on the stack. Ask the prologue code to extend
2396 the stack part so that we can recreate the full value.
2398 PRETEND_BYTES is the size of the registers we need to store.
2399 CURRENT_FUNCTION_PRETEND_ARGS_SIZE is the amount of extra
2400 stack space that the prologue should allocate.
2402 Internally, gcc assumes that the argument pointer is aligned
2403 to STACK_BOUNDARY bits. This is used both for alignment
2404 optimizations (see init_emit) and to locate arguments that are
2405 aligned to more than PARM_BOUNDARY bits. We must preserve this
2406 invariant by rounding CURRENT_FUNCTION_PRETEND_ARGS_SIZE up to
2407 a stack boundary. */
2409 /* We assume at most one partial arg, and it must be the first
2410 argument on the stack. */
2411 if (all
->extra_pretend_bytes
|| all
->pretend_args_size
)
2414 pretend_bytes
= partial
* UNITS_PER_WORD
;
2415 all
->pretend_args_size
= CEIL_ROUND (pretend_bytes
, STACK_BYTES
);
2417 /* We want to align relative to the actual stack pointer, so
2418 don't include this in the stack size until later. */
2419 all
->extra_pretend_bytes
= all
->pretend_args_size
;
2423 locate_and_pad_parm (data
->promoted_mode
, data
->passed_type
, in_regs
,
2424 entry_parm
? data
->partial
: 0, current_function_decl
,
2425 &all
->stack_args_size
, &data
->locate
);
2427 /* Adjust offsets to include the pretend args. */
2428 pretend_bytes
= all
->extra_pretend_bytes
- pretend_bytes
;
2429 data
->locate
.slot_offset
.constant
+= pretend_bytes
;
2430 data
->locate
.offset
.constant
+= pretend_bytes
;
2432 data
->entry_parm
= entry_parm
;
2435 /* A subroutine of assign_parms. If there is actually space on the stack
2436 for this parm, count it in stack_args_size and return true. */
2439 assign_parm_is_stack_parm (struct assign_parm_data_all
*all
,
2440 struct assign_parm_data_one
*data
)
2442 /* Trivially true if we've no incomming register. */
2443 if (data
->entry_parm
== NULL
)
2445 /* Also true if we're partially in registers and partially not,
2446 since we've arranged to drop the entire argument on the stack. */
2447 else if (data
->partial
!= 0)
2449 /* Also true if the target says that it's passed in both registers
2450 and on the stack. */
2451 else if (GET_CODE (data
->entry_parm
) == PARALLEL
2452 && XEXP (XVECEXP (data
->entry_parm
, 0, 0), 0) == NULL_RTX
)
2454 /* Also true if the target says that there's stack allocated for
2455 all register parameters. */
2456 else if (all
->reg_parm_stack_space
> 0)
2458 /* Otherwise, no, this parameter has no ABI defined stack slot. */
2462 all
->stack_args_size
.constant
+= data
->locate
.size
.constant
;
2463 if (data
->locate
.size
.var
)
2464 ADD_PARM_SIZE (all
->stack_args_size
, data
->locate
.size
.var
);
2469 /* A subroutine of assign_parms. Given that this parameter is allocated
2470 stack space by the ABI, find it. */
2473 assign_parm_find_stack_rtl (tree parm
, struct assign_parm_data_one
*data
)
2475 rtx offset_rtx
, stack_parm
;
2476 unsigned int align
, boundary
;
2478 /* If we're passing this arg using a reg, make its stack home the
2479 aligned stack slot. */
2480 if (data
->entry_parm
)
2481 offset_rtx
= ARGS_SIZE_RTX (data
->locate
.slot_offset
);
2483 offset_rtx
= ARGS_SIZE_RTX (data
->locate
.offset
);
2485 stack_parm
= current_function_internal_arg_pointer
;
2486 if (offset_rtx
!= const0_rtx
)
2487 stack_parm
= gen_rtx_PLUS (Pmode
, stack_parm
, offset_rtx
);
2488 stack_parm
= gen_rtx_MEM (data
->promoted_mode
, stack_parm
);
2490 set_mem_attributes (stack_parm
, parm
, 1);
2492 boundary
= FUNCTION_ARG_BOUNDARY (data
->promoted_mode
, data
->passed_type
);
2495 /* If we're padding upward, we know that the alignment of the slot
2496 is FUNCTION_ARG_BOUNDARY. If we're using slot_offset, we're
2497 intentionally forcing upward padding. Otherwise we have to come
2498 up with a guess at the alignment based on OFFSET_RTX. */
2499 if (data
->locate
.where_pad
== upward
|| data
->entry_parm
)
2501 else if (GET_CODE (offset_rtx
) == CONST_INT
)
2503 align
= INTVAL (offset_rtx
) * BITS_PER_UNIT
| boundary
;
2504 align
= align
& -align
;
2507 set_mem_align (stack_parm
, align
);
2509 if (data
->entry_parm
)
2510 set_reg_attrs_for_parm (data
->entry_parm
, stack_parm
);
2512 data
->stack_parm
= stack_parm
;
2515 /* A subroutine of assign_parms. Adjust DATA->ENTRY_RTL such that it's
2516 always valid and contiguous. */
2519 assign_parm_adjust_entry_rtl (struct assign_parm_data_one
*data
)
2521 rtx entry_parm
= data
->entry_parm
;
2522 rtx stack_parm
= data
->stack_parm
;
2524 /* If this parm was passed part in regs and part in memory, pretend it
2525 arrived entirely in memory by pushing the register-part onto the stack.
2526 In the special case of a DImode or DFmode that is split, we could put
2527 it together in a pseudoreg directly, but for now that's not worth
2529 if (data
->partial
!= 0)
2531 /* Handle calls that pass values in multiple non-contiguous
2532 locations. The Irix 6 ABI has examples of this. */
2533 if (GET_CODE (entry_parm
) == PARALLEL
)
2534 emit_group_store (validize_mem (stack_parm
), entry_parm
,
2536 int_size_in_bytes (data
->passed_type
));
2538 move_block_from_reg (REGNO (entry_parm
), validize_mem (stack_parm
),
2541 entry_parm
= stack_parm
;
2544 /* If we didn't decide this parm came in a register, by default it came
2546 else if (entry_parm
== NULL
)
2547 entry_parm
= stack_parm
;
2549 /* When an argument is passed in multiple locations, we can't make use
2550 of this information, but we can save some copying if the whole argument
2551 is passed in a single register. */
2552 else if (GET_CODE (entry_parm
) == PARALLEL
2553 && data
->nominal_mode
!= BLKmode
2554 && data
->passed_mode
!= BLKmode
)
2556 size_t i
, len
= XVECLEN (entry_parm
, 0);
2558 for (i
= 0; i
< len
; i
++)
2559 if (XEXP (XVECEXP (entry_parm
, 0, i
), 0) != NULL_RTX
2560 && REG_P (XEXP (XVECEXP (entry_parm
, 0, i
), 0))
2561 && (GET_MODE (XEXP (XVECEXP (entry_parm
, 0, i
), 0))
2562 == data
->passed_mode
)
2563 && INTVAL (XEXP (XVECEXP (entry_parm
, 0, i
), 1)) == 0)
2565 entry_parm
= XEXP (XVECEXP (entry_parm
, 0, i
), 0);
2570 data
->entry_parm
= entry_parm
;
2573 /* A subroutine of assign_parms. Adjust DATA->STACK_RTL such that it's
2574 always valid and properly aligned. */
2578 assign_parm_adjust_stack_rtl (struct assign_parm_data_one
*data
)
2580 rtx stack_parm
= data
->stack_parm
;
2582 /* If we can't trust the parm stack slot to be aligned enough for its
2583 ultimate type, don't use that slot after entry. We'll make another
2584 stack slot, if we need one. */
2585 if (STRICT_ALIGNMENT
&& stack_parm
2586 && GET_MODE_ALIGNMENT (data
->nominal_mode
) > MEM_ALIGN (stack_parm
))
2589 /* If parm was passed in memory, and we need to convert it on entry,
2590 don't store it back in that same slot. */
2591 else if (data
->entry_parm
== stack_parm
2592 && data
->nominal_mode
!= BLKmode
2593 && data
->nominal_mode
!= data
->passed_mode
)
2596 data
->stack_parm
= stack_parm
;
2599 /* A subroutine of assign_parms. Return true if the current parameter
2600 should be stored as a BLKmode in the current frame. */
2603 assign_parm_setup_block_p (struct assign_parm_data_one
*data
)
2605 if (data
->nominal_mode
== BLKmode
)
2607 if (GET_CODE (data
->entry_parm
) == PARALLEL
)
2610 #ifdef BLOCK_REG_PADDING
2611 if (data
->locate
.where_pad
== (BYTES_BIG_ENDIAN
? upward
: downward
)
2612 && GET_MODE_SIZE (data
->promoted_mode
) < UNITS_PER_WORD
)
2619 /* A subroutine of assign_parms. Arrange for the parameter to be
2620 present and valid in DATA->STACK_RTL. */
2623 assign_parm_setup_block (tree parm
, struct assign_parm_data_one
*data
)
2625 rtx entry_parm
= data
->entry_parm
;
2626 rtx stack_parm
= data
->stack_parm
;
2628 /* If we've a non-block object that's nevertheless passed in parts,
2629 reconstitute it in register operations rather than on the stack. */
2630 if (GET_CODE (entry_parm
) == PARALLEL
2631 && data
->nominal_mode
!= BLKmode
2632 && XVECLEN (entry_parm
, 0) > 1
2635 rtx parmreg
= gen_reg_rtx (data
->nominal_mode
);
2637 emit_group_store (parmreg
, entry_parm
, data
->nominal_type
,
2638 int_size_in_bytes (data
->nominal_type
));
2639 SET_DECL_RTL (parm
, parmreg
);
2643 /* If a BLKmode arrives in registers, copy it to a stack slot. Handle
2644 calls that pass values in multiple non-contiguous locations. */
2645 if (REG_P (entry_parm
) || GET_CODE (entry_parm
) == PARALLEL
)
2647 HOST_WIDE_INT size
= int_size_in_bytes (data
->passed_type
);
2648 HOST_WIDE_INT size_stored
= CEIL_ROUND (size
, UNITS_PER_WORD
);
2651 /* Note that we will be storing an integral number of words.
2652 So we have to be careful to ensure that we allocate an
2653 integral number of words. We do this below in the
2654 assign_stack_local if space was not allocated in the argument
2655 list. If it was, this will not work if PARM_BOUNDARY is not
2656 a multiple of BITS_PER_WORD. It isn't clear how to fix this
2657 if it becomes a problem. Exception is when BLKmode arrives
2658 with arguments not conforming to word_mode. */
2660 if (stack_parm
== 0)
2662 stack_parm
= assign_stack_local (BLKmode
, size_stored
, 0);
2663 data
->stack_parm
= stack_parm
;
2664 PUT_MODE (stack_parm
, GET_MODE (entry_parm
));
2665 set_mem_attributes (stack_parm
, parm
, 1);
2667 else if (GET_CODE (entry_parm
) == PARALLEL
)
2669 else if (size
!= 0 && PARM_BOUNDARY
% BITS_PER_WORD
!= 0)
2672 mem
= validize_mem (stack_parm
);
2674 /* Handle values in multiple non-contiguous locations. */
2675 if (GET_CODE (entry_parm
) == PARALLEL
)
2676 emit_group_store (mem
, entry_parm
, data
->passed_type
, size
);
2681 /* If SIZE is that of a mode no bigger than a word, just use
2682 that mode's store operation. */
2683 else if (size
<= UNITS_PER_WORD
)
2685 enum machine_mode mode
2686 = mode_for_size (size
* BITS_PER_UNIT
, MODE_INT
, 0);
2689 #ifdef BLOCK_REG_PADDING
2690 && (size
== UNITS_PER_WORD
2691 || (BLOCK_REG_PADDING (mode
, data
->passed_type
, 1)
2692 != (BYTES_BIG_ENDIAN
? upward
: downward
)))
2696 rtx reg
= gen_rtx_REG (mode
, REGNO (entry_parm
));
2697 emit_move_insn (change_address (mem
, mode
, 0), reg
);
2700 /* Blocks smaller than a word on a BYTES_BIG_ENDIAN
2701 machine must be aligned to the left before storing
2702 to memory. Note that the previous test doesn't
2703 handle all cases (e.g. SIZE == 3). */
2704 else if (size
!= UNITS_PER_WORD
2705 #ifdef BLOCK_REG_PADDING
2706 && (BLOCK_REG_PADDING (mode
, data
->passed_type
, 1)
2714 int by
= (UNITS_PER_WORD
- size
) * BITS_PER_UNIT
;
2715 rtx reg
= gen_rtx_REG (word_mode
, REGNO (data
->entry_parm
));
2717 x
= expand_shift (LSHIFT_EXPR
, word_mode
, reg
,
2718 build_int_2 (by
, 0), NULL_RTX
, 1);
2719 tem
= change_address (mem
, word_mode
, 0);
2720 emit_move_insn (tem
, x
);
2723 move_block_from_reg (REGNO (data
->entry_parm
), mem
,
2724 size_stored
/ UNITS_PER_WORD
);
2727 move_block_from_reg (REGNO (data
->entry_parm
), mem
,
2728 size_stored
/ UNITS_PER_WORD
);
2731 SET_DECL_RTL (parm
, stack_parm
);
2734 /* A subroutine of assign_parms. Allocate a pseudo to hold the current
2735 parameter. Get it there. Perform all ABI specified conversions. */
2738 assign_parm_setup_reg (struct assign_parm_data_all
*all
, tree parm
,
2739 struct assign_parm_data_one
*data
)
2742 enum machine_mode promoted_nominal_mode
;
2743 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (parm
));
2744 bool did_conversion
= false;
2746 /* Store the parm in a pseudoregister during the function, but we may
2747 need to do it in a wider mode. */
2749 promoted_nominal_mode
2750 = promote_mode (data
->nominal_type
, data
->nominal_mode
, &unsignedp
, 0);
2752 parmreg
= gen_reg_rtx (promoted_nominal_mode
);
2754 if (!DECL_ARTIFICIAL (parm
))
2755 mark_user_reg (parmreg
);
2757 /* If this was an item that we received a pointer to,
2758 set DECL_RTL appropriately. */
2759 if (data
->passed_pointer
)
2761 rtx x
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data
->passed_type
)), parmreg
);
2762 set_mem_attributes (x
, parm
, 1);
2763 SET_DECL_RTL (parm
, x
);
2767 SET_DECL_RTL (parm
, parmreg
);
2768 maybe_set_unchanging (DECL_RTL (parm
), parm
);
2771 /* Copy the value into the register. */
2772 if (data
->nominal_mode
!= data
->passed_mode
2773 || promoted_nominal_mode
!= data
->promoted_mode
)
2777 /* ENTRY_PARM has been converted to PROMOTED_MODE, its
2778 mode, by the caller. We now have to convert it to
2779 NOMINAL_MODE, if different. However, PARMREG may be in
2780 a different mode than NOMINAL_MODE if it is being stored
2783 If ENTRY_PARM is a hard register, it might be in a register
2784 not valid for operating in its mode (e.g., an odd-numbered
2785 register for a DFmode). In that case, moves are the only
2786 thing valid, so we can't do a convert from there. This
2787 occurs when the calling sequence allow such misaligned
2790 In addition, the conversion may involve a call, which could
2791 clobber parameters which haven't been copied to pseudo
2792 registers yet. Therefore, we must first copy the parm to
2793 a pseudo reg here, and save the conversion until after all
2794 parameters have been moved. */
2796 rtx tempreg
= gen_reg_rtx (GET_MODE (data
->entry_parm
));
2798 emit_move_insn (tempreg
, validize_mem (data
->entry_parm
));
2800 push_to_sequence (all
->conversion_insns
);
2801 tempreg
= convert_to_mode (data
->nominal_mode
, tempreg
, unsignedp
);
2803 if (GET_CODE (tempreg
) == SUBREG
2804 && GET_MODE (tempreg
) == data
->nominal_mode
2805 && REG_P (SUBREG_REG (tempreg
))
2806 && data
->nominal_mode
== data
->passed_mode
2807 && GET_MODE (SUBREG_REG (tempreg
)) == GET_MODE (data
->entry_parm
)
2808 && GET_MODE_SIZE (GET_MODE (tempreg
))
2809 < GET_MODE_SIZE (GET_MODE (data
->entry_parm
)))
2811 /* The argument is already sign/zero extended, so note it
2813 SUBREG_PROMOTED_VAR_P (tempreg
) = 1;
2814 SUBREG_PROMOTED_UNSIGNED_SET (tempreg
, unsignedp
);
2817 /* TREE_USED gets set erroneously during expand_assignment. */
2818 save_tree_used
= TREE_USED (parm
);
2819 expand_assignment (parm
, make_tree (data
->nominal_type
, tempreg
), 0);
2820 TREE_USED (parm
) = save_tree_used
;
2821 all
->conversion_insns
= get_insns ();
2824 did_conversion
= true;
2827 emit_move_insn (parmreg
, validize_mem (data
->entry_parm
));
2829 /* If we were passed a pointer but the actual value can safely live
2830 in a register, put it in one. */
2831 if (data
->passed_pointer
2832 && TYPE_MODE (TREE_TYPE (parm
)) != BLKmode
2833 /* If by-reference argument was promoted, demote it. */
2834 && (TYPE_MODE (TREE_TYPE (parm
)) != GET_MODE (DECL_RTL (parm
))
2835 || use_register_for_decl (parm
)))
2837 /* We can't use nominal_mode, because it will have been set to
2838 Pmode above. We must use the actual mode of the parm. */
2839 parmreg
= gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm
)));
2840 mark_user_reg (parmreg
);
2842 if (GET_MODE (parmreg
) != GET_MODE (DECL_RTL (parm
)))
2844 rtx tempreg
= gen_reg_rtx (GET_MODE (DECL_RTL (parm
)));
2845 int unsigned_p
= TYPE_UNSIGNED (TREE_TYPE (parm
));
2847 push_to_sequence (all
->conversion_insns
);
2848 emit_move_insn (tempreg
, DECL_RTL (parm
));
2849 tempreg
= convert_to_mode (GET_MODE (parmreg
), tempreg
, unsigned_p
);
2850 emit_move_insn (parmreg
, tempreg
);
2851 all
->conversion_insns
= get_insns();
2854 did_conversion
= true;
2857 emit_move_insn (parmreg
, DECL_RTL (parm
));
2859 SET_DECL_RTL (parm
, parmreg
);
2861 /* STACK_PARM is the pointer, not the parm, and PARMREG is
2863 data
->stack_parm
= NULL
;
2866 /* If we are passed an arg by reference and it is our responsibility
2867 to make a copy, do it now.
2868 PASSED_TYPE and PASSED mode now refer to the pointer, not the
2869 original argument, so we must recreate them in the call to
2870 FUNCTION_ARG_CALLEE_COPIES. */
2871 /* ??? Later add code to handle the case that if the argument isn't
2872 modified, don't do the copy. */
2874 else if (data
->passed_pointer
)
2876 tree type
= TREE_TYPE (data
->passed_type
);
2878 if (FUNCTION_ARG_CALLEE_COPIES (all
->args_so_far
, TYPE_MODE (type
),
2879 type
, data
->named_arg
)
2880 && !TREE_ADDRESSABLE (type
))
2884 /* This sequence may involve a library call perhaps clobbering
2885 registers that haven't been copied to pseudos yet. */
2887 push_to_sequence (all
->conversion_insns
);
2889 if (!COMPLETE_TYPE_P (type
)
2890 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
2892 /* This is a variable sized object. */
2893 copy
= allocate_dynamic_stack_space (expr_size (parm
), NULL_RTX
,
2895 copy
= gen_rtx_MEM (BLKmode
, copy
);
2898 copy
= assign_stack_temp (TYPE_MODE (type
),
2899 int_size_in_bytes (type
), 1);
2900 set_mem_attributes (copy
, parm
, 1);
2902 store_expr (parm
, copy
, 0);
2903 emit_move_insn (parmreg
, XEXP (copy
, 0));
2904 all
->conversion_insns
= get_insns ();
2907 did_conversion
= true;
2911 /* Mark the register as eliminable if we did no conversion and it was
2912 copied from memory at a fixed offset, and the arg pointer was not
2913 copied to a pseudo-reg. If the arg pointer is a pseudo reg or the
2914 offset formed an invalid address, such memory-equivalences as we
2915 make here would screw up life analysis for it. */
2916 if (data
->nominal_mode
== data
->passed_mode
2918 && data
->stack_parm
!= 0
2919 && MEM_P (data
->stack_parm
)
2920 && data
->locate
.offset
.var
== 0
2921 && reg_mentioned_p (virtual_incoming_args_rtx
,
2922 XEXP (data
->stack_parm
, 0)))
2924 rtx linsn
= get_last_insn ();
2927 /* Mark complex types separately. */
2928 if (GET_CODE (parmreg
) == CONCAT
)
2930 enum machine_mode submode
2931 = GET_MODE_INNER (GET_MODE (parmreg
));
2932 int regnor
= REGNO (gen_realpart (submode
, parmreg
));
2933 int regnoi
= REGNO (gen_imagpart (submode
, parmreg
));
2934 rtx stackr
= gen_realpart (submode
, data
->stack_parm
);
2935 rtx stacki
= gen_imagpart (submode
, data
->stack_parm
);
2937 /* Scan backwards for the set of the real and
2939 for (sinsn
= linsn
; sinsn
!= 0;
2940 sinsn
= prev_nonnote_insn (sinsn
))
2942 set
= single_set (sinsn
);
2946 if (SET_DEST (set
) == regno_reg_rtx
[regnoi
])
2948 = gen_rtx_EXPR_LIST (REG_EQUIV
, stacki
,
2950 else if (SET_DEST (set
) == regno_reg_rtx
[regnor
])
2952 = gen_rtx_EXPR_LIST (REG_EQUIV
, stackr
,
2956 else if ((set
= single_set (linsn
)) != 0
2957 && SET_DEST (set
) == parmreg
)
2959 = gen_rtx_EXPR_LIST (REG_EQUIV
,
2960 data
->stack_parm
, REG_NOTES (linsn
));
2963 /* For pointer data type, suggest pointer register. */
2964 if (POINTER_TYPE_P (TREE_TYPE (parm
)))
2965 mark_reg_pointer (parmreg
,
2966 TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm
))));
2969 /* A subroutine of assign_parms. Allocate stack space to hold the current
2970 parameter. Get it there. Perform all ABI specified conversions. */
2973 assign_parm_setup_stack (struct assign_parm_data_all
*all
, tree parm
,
2974 struct assign_parm_data_one
*data
)
2976 /* Value must be stored in the stack slot STACK_PARM during function
2979 if (data
->promoted_mode
!= data
->nominal_mode
)
2981 /* Conversion is required. */
2982 rtx tempreg
= gen_reg_rtx (GET_MODE (data
->entry_parm
));
2984 emit_move_insn (tempreg
, validize_mem (data
->entry_parm
));
2986 push_to_sequence (all
->conversion_insns
);
2987 data
->entry_parm
= convert_to_mode (data
->nominal_mode
, tempreg
,
2988 TYPE_UNSIGNED (TREE_TYPE (parm
)));
2990 if (data
->stack_parm
)
2991 /* ??? This may need a big-endian conversion on sparc64. */
2993 = adjust_address (data
->stack_parm
, data
->nominal_mode
, 0);
2995 all
->conversion_insns
= get_insns ();
2999 if (data
->entry_parm
!= data
->stack_parm
)
3001 if (data
->stack_parm
== 0)
3004 = assign_stack_local (GET_MODE (data
->entry_parm
),
3005 GET_MODE_SIZE (GET_MODE (data
->entry_parm
)),
3007 set_mem_attributes (data
->stack_parm
, parm
, 1);
3010 if (data
->promoted_mode
!= data
->nominal_mode
)
3012 push_to_sequence (all
->conversion_insns
);
3013 emit_move_insn (validize_mem (data
->stack_parm
),
3014 validize_mem (data
->entry_parm
));
3015 all
->conversion_insns
= get_insns ();
3019 emit_move_insn (validize_mem (data
->stack_parm
),
3020 validize_mem (data
->entry_parm
));
3023 SET_DECL_RTL (parm
, data
->stack_parm
);
3026 /* A subroutine of assign_parms. If the ABI splits complex arguments, then
3027 undo the frobbing that we did in assign_parms_augmented_arg_list. */
3030 assign_parms_unsplit_complex (tree orig_fnargs
, tree fnargs
)
3034 for (parm
= orig_fnargs
; parm
; parm
= TREE_CHAIN (parm
))
3036 if (TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
3037 && targetm
.calls
.split_complex_arg (TREE_TYPE (parm
)))
3039 rtx tmp
, real
, imag
;
3040 enum machine_mode inner
= GET_MODE_INNER (DECL_MODE (parm
));
3042 real
= DECL_RTL (fnargs
);
3043 imag
= DECL_RTL (TREE_CHAIN (fnargs
));
3044 if (inner
!= GET_MODE (real
))
3046 real
= gen_lowpart_SUBREG (inner
, real
);
3047 imag
= gen_lowpart_SUBREG (inner
, imag
);
3049 tmp
= gen_rtx_CONCAT (DECL_MODE (parm
), real
, imag
);
3050 SET_DECL_RTL (parm
, tmp
);
3052 real
= DECL_INCOMING_RTL (fnargs
);
3053 imag
= DECL_INCOMING_RTL (TREE_CHAIN (fnargs
));
3054 if (inner
!= GET_MODE (real
))
3056 real
= gen_lowpart_SUBREG (inner
, real
);
3057 imag
= gen_lowpart_SUBREG (inner
, imag
);
3059 tmp
= gen_rtx_CONCAT (DECL_MODE (parm
), real
, imag
);
3060 set_decl_incoming_rtl (parm
, tmp
);
3061 fnargs
= TREE_CHAIN (fnargs
);
3065 SET_DECL_RTL (parm
, DECL_RTL (fnargs
));
3066 set_decl_incoming_rtl (parm
, DECL_INCOMING_RTL (fnargs
));
3068 /* Set MEM_EXPR to the original decl, i.e. to PARM,
3069 instead of the copy of decl, i.e. FNARGS. */
3070 if (DECL_INCOMING_RTL (parm
) && MEM_P (DECL_INCOMING_RTL (parm
)))
3071 set_mem_expr (DECL_INCOMING_RTL (parm
), parm
);
3074 fnargs
= TREE_CHAIN (fnargs
);
3078 /* Assign RTL expressions to the function's parameters. This may involve
3079 copying them into registers and using those registers as the DECL_RTL. */
3082 assign_parms (tree fndecl
)
3084 struct assign_parm_data_all all
;
3086 rtx internal_arg_pointer
;
3087 int varargs_setup
= 0;
3089 /* If the reg that the virtual arg pointer will be translated into is
3090 not a fixed reg or is the stack pointer, make a copy of the virtual
3091 arg pointer, and address parms via the copy. The frame pointer is
3092 considered fixed even though it is not marked as such.
3094 The second time through, simply use ap to avoid generating rtx. */
3096 if ((ARG_POINTER_REGNUM
== STACK_POINTER_REGNUM
3097 || ! (fixed_regs
[ARG_POINTER_REGNUM
]
3098 || ARG_POINTER_REGNUM
== FRAME_POINTER_REGNUM
)))
3099 internal_arg_pointer
= copy_to_reg (virtual_incoming_args_rtx
);
3101 internal_arg_pointer
= virtual_incoming_args_rtx
;
3102 current_function_internal_arg_pointer
= internal_arg_pointer
;
3104 assign_parms_initialize_all (&all
);
3105 fnargs
= assign_parms_augmented_arg_list (&all
);
3107 for (parm
= fnargs
; parm
; parm
= TREE_CHAIN (parm
))
3109 struct assign_parm_data_one data
;
3111 /* Extract the type of PARM; adjust it according to ABI. */
3112 assign_parm_find_data_types (&all
, parm
, &data
);
3114 /* Early out for errors and void parameters. */
3115 if (data
.passed_mode
== VOIDmode
)
3117 SET_DECL_RTL (parm
, const0_rtx
);
3118 DECL_INCOMING_RTL (parm
) = DECL_RTL (parm
);
3122 /* Handle stdargs. LAST_NAMED is a slight mis-nomer; it's also true
3123 for the unnamed dummy argument following the last named argument.
3124 See ABI silliness wrt strict_argument_naming and NAMED_ARG. So
3125 we only want to do this when we get to the actual last named
3126 argument, which will be the first time LAST_NAMED gets set. */
3127 if (data
.last_named
&& !varargs_setup
)
3129 varargs_setup
= true;
3130 assign_parms_setup_varargs (&all
, &data
, false);
3133 /* Find out where the parameter arrives in this function. */
3134 assign_parm_find_entry_rtl (&all
, &data
);
3136 /* Find out where stack space for this parameter might be. */
3137 if (assign_parm_is_stack_parm (&all
, &data
))
3139 assign_parm_find_stack_rtl (parm
, &data
);
3140 assign_parm_adjust_entry_rtl (&data
);
3143 /* Record permanently how this parm was passed. */
3144 set_decl_incoming_rtl (parm
, data
.entry_parm
);
3146 /* Update info on where next arg arrives in registers. */
3147 FUNCTION_ARG_ADVANCE (all
.args_so_far
, data
.promoted_mode
,
3148 data
.passed_type
, data
.named_arg
);
3150 assign_parm_adjust_stack_rtl (&data
);
3152 if (assign_parm_setup_block_p (&data
))
3153 assign_parm_setup_block (parm
, &data
);
3154 else if (data
.passed_pointer
|| use_register_for_decl (parm
))
3155 assign_parm_setup_reg (&all
, parm
, &data
);
3157 assign_parm_setup_stack (&all
, parm
, &data
);
3160 if (targetm
.calls
.split_complex_arg
&& fnargs
!= all
.orig_fnargs
)
3161 assign_parms_unsplit_complex (all
.orig_fnargs
, fnargs
);
3163 /* Output all parameter conversion instructions (possibly including calls)
3164 now that all parameters have been copied out of hard registers. */
3165 emit_insn (all
.conversion_insns
);
3167 /* If we are receiving a struct value address as the first argument, set up
3168 the RTL for the function result. As this might require code to convert
3169 the transmitted address to Pmode, we do this here to ensure that possible
3170 preliminary conversions of the address have been emitted already. */
3171 if (all
.function_result_decl
)
3173 tree result
= DECL_RESULT (current_function_decl
);
3174 rtx addr
= DECL_RTL (all
.function_result_decl
);
3177 addr
= convert_memory_address (Pmode
, addr
);
3178 x
= gen_rtx_MEM (DECL_MODE (result
), addr
);
3179 set_mem_attributes (x
, result
, 1);
3180 SET_DECL_RTL (result
, x
);
3183 /* We have aligned all the args, so add space for the pretend args. */
3184 current_function_pretend_args_size
= all
.pretend_args_size
;
3185 all
.stack_args_size
.constant
+= all
.extra_pretend_bytes
;
3186 current_function_args_size
= all
.stack_args_size
.constant
;
3188 /* Adjust function incoming argument size for alignment and
3191 #ifdef REG_PARM_STACK_SPACE
3192 current_function_args_size
= MAX (current_function_args_size
,
3193 REG_PARM_STACK_SPACE (fndecl
));
3196 current_function_args_size
3197 = ((current_function_args_size
+ STACK_BYTES
- 1)
3198 / STACK_BYTES
) * STACK_BYTES
;
3200 #ifdef ARGS_GROW_DOWNWARD
3201 current_function_arg_offset_rtx
3202 = (all
.stack_args_size
.var
== 0 ? GEN_INT (-all
.stack_args_size
.constant
)
3203 : expand_expr (size_diffop (all
.stack_args_size
.var
,
3204 size_int (-all
.stack_args_size
.constant
)),
3205 NULL_RTX
, VOIDmode
, 0));
3207 current_function_arg_offset_rtx
= ARGS_SIZE_RTX (all
.stack_args_size
);
3210 /* See how many bytes, if any, of its args a function should try to pop
3213 current_function_pops_args
= RETURN_POPS_ARGS (fndecl
, TREE_TYPE (fndecl
),
3214 current_function_args_size
);
3216 /* For stdarg.h function, save info about
3217 regs and stack space used by the named args. */
3219 current_function_args_info
= all
.args_so_far
;
3221 /* Set the rtx used for the function return value. Put this in its
3222 own variable so any optimizers that need this information don't have
3223 to include tree.h. Do this here so it gets done when an inlined
3224 function gets output. */
3226 current_function_return_rtx
3227 = (DECL_RTL_SET_P (DECL_RESULT (fndecl
))
3228 ? DECL_RTL (DECL_RESULT (fndecl
)) : NULL_RTX
);
3230 /* If scalar return value was computed in a pseudo-reg, or was a named
3231 return value that got dumped to the stack, copy that to the hard
3233 if (DECL_RTL_SET_P (DECL_RESULT (fndecl
)))
3235 tree decl_result
= DECL_RESULT (fndecl
);
3236 rtx decl_rtl
= DECL_RTL (decl_result
);
3238 if (REG_P (decl_rtl
)
3239 ? REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
3240 : DECL_REGISTER (decl_result
))
3244 #ifdef FUNCTION_OUTGOING_VALUE
3245 real_decl_rtl
= FUNCTION_OUTGOING_VALUE (TREE_TYPE (decl_result
),
3248 real_decl_rtl
= FUNCTION_VALUE (TREE_TYPE (decl_result
),
3251 REG_FUNCTION_VALUE_P (real_decl_rtl
) = 1;
3252 /* The delay slot scheduler assumes that current_function_return_rtx
3253 holds the hard register containing the return value, not a
3254 temporary pseudo. */
3255 current_function_return_rtx
= real_decl_rtl
;
3260 /* Indicate whether REGNO is an incoming argument to the current function
3261 that was promoted to a wider mode. If so, return the RTX for the
3262 register (to get its mode). PMODE and PUNSIGNEDP are set to the mode
3263 that REGNO is promoted from and whether the promotion was signed or
3267 promoted_input_arg (unsigned int regno
, enum machine_mode
*pmode
, int *punsignedp
)
3271 for (arg
= DECL_ARGUMENTS (current_function_decl
); arg
;
3272 arg
= TREE_CHAIN (arg
))
3273 if (REG_P (DECL_INCOMING_RTL (arg
))
3274 && REGNO (DECL_INCOMING_RTL (arg
)) == regno
3275 && TYPE_MODE (DECL_ARG_TYPE (arg
)) == TYPE_MODE (TREE_TYPE (arg
)))
3277 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (arg
));
3278 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (arg
));
3280 mode
= promote_mode (TREE_TYPE (arg
), mode
, &unsignedp
, 1);
3281 if (mode
== GET_MODE (DECL_INCOMING_RTL (arg
))
3282 && mode
!= DECL_MODE (arg
))
3284 *pmode
= DECL_MODE (arg
);
3285 *punsignedp
= unsignedp
;
3286 return DECL_INCOMING_RTL (arg
);
3294 /* Compute the size and offset from the start of the stacked arguments for a
3295 parm passed in mode PASSED_MODE and with type TYPE.
3297 INITIAL_OFFSET_PTR points to the current offset into the stacked
3300 The starting offset and size for this parm are returned in
3301 LOCATE->OFFSET and LOCATE->SIZE, respectively. When IN_REGS is
3302 nonzero, the offset is that of stack slot, which is returned in
3303 LOCATE->SLOT_OFFSET. LOCATE->ALIGNMENT_PAD is the amount of
3304 padding required from the initial offset ptr to the stack slot.
3306 IN_REGS is nonzero if the argument will be passed in registers. It will
3307 never be set if REG_PARM_STACK_SPACE is not defined.
3309 FNDECL is the function in which the argument was defined.
3311 There are two types of rounding that are done. The first, controlled by
3312 FUNCTION_ARG_BOUNDARY, forces the offset from the start of the argument
3313 list to be aligned to the specific boundary (in bits). This rounding
3314 affects the initial and starting offsets, but not the argument size.
3316 The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY,
3317 optionally rounds the size of the parm to PARM_BOUNDARY. The
3318 initial offset is not affected by this rounding, while the size always
3319 is and the starting offset may be. */
3321 /* LOCATE->OFFSET will be negative for ARGS_GROW_DOWNWARD case;
3322 INITIAL_OFFSET_PTR is positive because locate_and_pad_parm's
3323 callers pass in the total size of args so far as
3324 INITIAL_OFFSET_PTR. LOCATE->SIZE is always positive. */
3327 locate_and_pad_parm (enum machine_mode passed_mode
, tree type
, int in_regs
,
3328 int partial
, tree fndecl ATTRIBUTE_UNUSED
,
3329 struct args_size
*initial_offset_ptr
,
3330 struct locate_and_pad_arg_data
*locate
)
3333 enum direction where_pad
;
3335 int reg_parm_stack_space
= 0;
3336 int part_size_in_regs
;
3338 #ifdef REG_PARM_STACK_SPACE
3339 reg_parm_stack_space
= REG_PARM_STACK_SPACE (fndecl
);
3341 /* If we have found a stack parm before we reach the end of the
3342 area reserved for registers, skip that area. */
3345 if (reg_parm_stack_space
> 0)
3347 if (initial_offset_ptr
->var
)
3349 initial_offset_ptr
->var
3350 = size_binop (MAX_EXPR
, ARGS_SIZE_TREE (*initial_offset_ptr
),
3351 ssize_int (reg_parm_stack_space
));
3352 initial_offset_ptr
->constant
= 0;
3354 else if (initial_offset_ptr
->constant
< reg_parm_stack_space
)
3355 initial_offset_ptr
->constant
= reg_parm_stack_space
;
3358 #endif /* REG_PARM_STACK_SPACE */
3360 part_size_in_regs
= 0;
3361 if (reg_parm_stack_space
== 0)
3362 part_size_in_regs
= ((partial
* UNITS_PER_WORD
)
3363 / (PARM_BOUNDARY
/ BITS_PER_UNIT
)
3364 * (PARM_BOUNDARY
/ BITS_PER_UNIT
));
3367 = type
? size_in_bytes (type
) : size_int (GET_MODE_SIZE (passed_mode
));
3368 where_pad
= FUNCTION_ARG_PADDING (passed_mode
, type
);
3369 boundary
= FUNCTION_ARG_BOUNDARY (passed_mode
, type
);
3370 locate
->where_pad
= where_pad
;
3372 #ifdef ARGS_GROW_DOWNWARD
3373 locate
->slot_offset
.constant
= -initial_offset_ptr
->constant
;
3374 if (initial_offset_ptr
->var
)
3375 locate
->slot_offset
.var
= size_binop (MINUS_EXPR
, ssize_int (0),
3376 initial_offset_ptr
->var
);
3380 if (where_pad
!= none
3381 && (!host_integerp (sizetree
, 1)
3382 || (tree_low_cst (sizetree
, 1) * BITS_PER_UNIT
) % PARM_BOUNDARY
))
3383 s2
= round_up (s2
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
3384 SUB_PARM_SIZE (locate
->slot_offset
, s2
);
3387 locate
->slot_offset
.constant
+= part_size_in_regs
;
3390 #ifdef REG_PARM_STACK_SPACE
3391 || REG_PARM_STACK_SPACE (fndecl
) > 0
3394 pad_to_arg_alignment (&locate
->slot_offset
, boundary
,
3395 &locate
->alignment_pad
);
3397 locate
->size
.constant
= (-initial_offset_ptr
->constant
3398 - locate
->slot_offset
.constant
);
3399 if (initial_offset_ptr
->var
)
3400 locate
->size
.var
= size_binop (MINUS_EXPR
,
3401 size_binop (MINUS_EXPR
,
3403 initial_offset_ptr
->var
),
3404 locate
->slot_offset
.var
);
3406 /* Pad_below needs the pre-rounded size to know how much to pad
3408 locate
->offset
= locate
->slot_offset
;
3409 if (where_pad
== downward
)
3410 pad_below (&locate
->offset
, passed_mode
, sizetree
);
3412 #else /* !ARGS_GROW_DOWNWARD */
3414 #ifdef REG_PARM_STACK_SPACE
3415 || REG_PARM_STACK_SPACE (fndecl
) > 0
3418 pad_to_arg_alignment (initial_offset_ptr
, boundary
,
3419 &locate
->alignment_pad
);
3420 locate
->slot_offset
= *initial_offset_ptr
;
3422 #ifdef PUSH_ROUNDING
3423 if (passed_mode
!= BLKmode
)
3424 sizetree
= size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree
)));
3427 /* Pad_below needs the pre-rounded size to know how much to pad below
3428 so this must be done before rounding up. */
3429 locate
->offset
= locate
->slot_offset
;
3430 if (where_pad
== downward
)
3431 pad_below (&locate
->offset
, passed_mode
, sizetree
);
3433 if (where_pad
!= none
3434 && (!host_integerp (sizetree
, 1)
3435 || (tree_low_cst (sizetree
, 1) * BITS_PER_UNIT
) % PARM_BOUNDARY
))
3436 sizetree
= round_up (sizetree
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
3438 ADD_PARM_SIZE (locate
->size
, sizetree
);
3440 locate
->size
.constant
-= part_size_in_regs
;
3441 #endif /* ARGS_GROW_DOWNWARD */
3444 /* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY.
3445 BOUNDARY is measured in bits, but must be a multiple of a storage unit. */
3448 pad_to_arg_alignment (struct args_size
*offset_ptr
, int boundary
,
3449 struct args_size
*alignment_pad
)
3451 tree save_var
= NULL_TREE
;
3452 HOST_WIDE_INT save_constant
= 0;
3453 int boundary_in_bytes
= boundary
/ BITS_PER_UNIT
;
3454 HOST_WIDE_INT sp_offset
= STACK_POINTER_OFFSET
;
3456 #ifdef SPARC_STACK_BOUNDARY_HACK
3457 /* The sparc port has a bug. It sometimes claims a STACK_BOUNDARY
3458 higher than the real alignment of %sp. However, when it does this,
3459 the alignment of %sp+STACK_POINTER_OFFSET will be STACK_BOUNDARY.
3460 This is a temporary hack while the sparc port is fixed. */
3461 if (SPARC_STACK_BOUNDARY_HACK
)
3465 if (boundary
> PARM_BOUNDARY
&& boundary
> STACK_BOUNDARY
)
3467 save_var
= offset_ptr
->var
;
3468 save_constant
= offset_ptr
->constant
;
3471 alignment_pad
->var
= NULL_TREE
;
3472 alignment_pad
->constant
= 0;
3474 if (boundary
> BITS_PER_UNIT
)
3476 if (offset_ptr
->var
)
3478 tree sp_offset_tree
= ssize_int (sp_offset
);
3479 tree offset
= size_binop (PLUS_EXPR
,
3480 ARGS_SIZE_TREE (*offset_ptr
),
3482 #ifdef ARGS_GROW_DOWNWARD
3483 tree rounded
= round_down (offset
, boundary
/ BITS_PER_UNIT
);
3485 tree rounded
= round_up (offset
, boundary
/ BITS_PER_UNIT
);
3488 offset_ptr
->var
= size_binop (MINUS_EXPR
, rounded
, sp_offset_tree
);
3489 /* ARGS_SIZE_TREE includes constant term. */
3490 offset_ptr
->constant
= 0;
3491 if (boundary
> PARM_BOUNDARY
&& boundary
> STACK_BOUNDARY
)
3492 alignment_pad
->var
= size_binop (MINUS_EXPR
, offset_ptr
->var
,
3497 offset_ptr
->constant
= -sp_offset
+
3498 #ifdef ARGS_GROW_DOWNWARD
3499 FLOOR_ROUND (offset_ptr
->constant
+ sp_offset
, boundary_in_bytes
);
3501 CEIL_ROUND (offset_ptr
->constant
+ sp_offset
, boundary_in_bytes
);
3503 if (boundary
> PARM_BOUNDARY
&& boundary
> STACK_BOUNDARY
)
3504 alignment_pad
->constant
= offset_ptr
->constant
- save_constant
;
3510 pad_below (struct args_size
*offset_ptr
, enum machine_mode passed_mode
, tree sizetree
)
3512 if (passed_mode
!= BLKmode
)
3514 if (GET_MODE_BITSIZE (passed_mode
) % PARM_BOUNDARY
)
3515 offset_ptr
->constant
3516 += (((GET_MODE_BITSIZE (passed_mode
) + PARM_BOUNDARY
- 1)
3517 / PARM_BOUNDARY
* PARM_BOUNDARY
/ BITS_PER_UNIT
)
3518 - GET_MODE_SIZE (passed_mode
));
3522 if (TREE_CODE (sizetree
) != INTEGER_CST
3523 || (TREE_INT_CST_LOW (sizetree
) * BITS_PER_UNIT
) % PARM_BOUNDARY
)
3525 /* Round the size up to multiple of PARM_BOUNDARY bits. */
3526 tree s2
= round_up (sizetree
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
3528 ADD_PARM_SIZE (*offset_ptr
, s2
);
3529 SUB_PARM_SIZE (*offset_ptr
, sizetree
);
3534 /* Walk the tree of blocks describing the binding levels within a function
3535 and warn about variables the might be killed by setjmp or vfork.
3536 This is done after calling flow_analysis and before global_alloc
3537 clobbers the pseudo-regs to hard regs. */
3540 setjmp_vars_warning (tree block
)
3544 for (decl
= BLOCK_VARS (block
); decl
; decl
= TREE_CHAIN (decl
))
3546 if (TREE_CODE (decl
) == VAR_DECL
3547 && DECL_RTL_SET_P (decl
)
3548 && REG_P (DECL_RTL (decl
))
3549 && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl
))))
3550 warning ("%Jvariable '%D' might be clobbered by `longjmp' or `vfork'",
3554 for (sub
= BLOCK_SUBBLOCKS (block
); sub
; sub
= TREE_CHAIN (sub
))
3555 setjmp_vars_warning (sub
);
3558 /* Do the appropriate part of setjmp_vars_warning
3559 but for arguments instead of local variables. */
3562 setjmp_args_warning (void)
3565 for (decl
= DECL_ARGUMENTS (current_function_decl
);
3566 decl
; decl
= TREE_CHAIN (decl
))
3567 if (DECL_RTL (decl
) != 0
3568 && REG_P (DECL_RTL (decl
))
3569 && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl
))))
3570 warning ("%Jargument '%D' might be clobbered by `longjmp' or `vfork'",
3575 /* Convert a stack slot address ADDR for variable VAR
3576 (from a containing function)
3577 into an address valid in this function (using a static chain). */
3580 fix_lexical_addr (rtx addr
, tree var
)
3583 HOST_WIDE_INT displacement
;
3584 tree context
= decl_function_context (var
);
3585 struct function
*fp
;
3588 /* If this is the present function, we need not do anything. */
3589 if (context
== current_function_decl
)
3592 fp
= find_function_data (context
);
3594 /* Decode given address as base reg plus displacement. */
3596 basereg
= addr
, displacement
= 0;
3597 else if (GET_CODE (addr
) == PLUS
&& GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
3598 basereg
= XEXP (addr
, 0), displacement
= INTVAL (XEXP (addr
, 1));
3605 /* Use same offset, relative to appropriate static chain or argument
3607 return plus_constant (base
, displacement
);
3610 /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
3611 and create duplicate blocks. */
3612 /* ??? Need an option to either create block fragments or to create
3613 abstract origin duplicates of a source block. It really depends
3614 on what optimization has been performed. */
3617 reorder_blocks (void)
3619 tree block
= DECL_INITIAL (current_function_decl
);
3620 varray_type block_stack
;
3622 if (block
== NULL_TREE
)
3625 VARRAY_TREE_INIT (block_stack
, 10, "block_stack");
3627 /* Reset the TREE_ASM_WRITTEN bit for all blocks. */
3628 clear_block_marks (block
);
3630 /* Prune the old trees away, so that they don't get in the way. */
3631 BLOCK_SUBBLOCKS (block
) = NULL_TREE
;
3632 BLOCK_CHAIN (block
) = NULL_TREE
;
3634 /* Recreate the block tree from the note nesting. */
3635 reorder_blocks_1 (get_insns (), block
, &block_stack
);
3636 BLOCK_SUBBLOCKS (block
) = blocks_nreverse (BLOCK_SUBBLOCKS (block
));
3638 /* Remove deleted blocks from the block fragment chains. */
3639 reorder_fix_fragments (block
);
3642 /* Helper function for reorder_blocks. Reset TREE_ASM_WRITTEN. */
3645 clear_block_marks (tree block
)
3649 TREE_ASM_WRITTEN (block
) = 0;
3650 clear_block_marks (BLOCK_SUBBLOCKS (block
));
3651 block
= BLOCK_CHAIN (block
);
3656 reorder_blocks_1 (rtx insns
, tree current_block
, varray_type
*p_block_stack
)
3660 for (insn
= insns
; insn
; insn
= NEXT_INSN (insn
))
3664 if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_BEG
)
3666 tree block
= NOTE_BLOCK (insn
);
3668 /* If we have seen this block before, that means it now
3669 spans multiple address regions. Create a new fragment. */
3670 if (TREE_ASM_WRITTEN (block
))
3672 tree new_block
= copy_node (block
);
3675 origin
= (BLOCK_FRAGMENT_ORIGIN (block
)
3676 ? BLOCK_FRAGMENT_ORIGIN (block
)
3678 BLOCK_FRAGMENT_ORIGIN (new_block
) = origin
;
3679 BLOCK_FRAGMENT_CHAIN (new_block
)
3680 = BLOCK_FRAGMENT_CHAIN (origin
);
3681 BLOCK_FRAGMENT_CHAIN (origin
) = new_block
;
3683 NOTE_BLOCK (insn
) = new_block
;
3687 BLOCK_SUBBLOCKS (block
) = 0;
3688 TREE_ASM_WRITTEN (block
) = 1;
3689 /* When there's only one block for the entire function,
3690 current_block == block and we mustn't do this, it
3691 will cause infinite recursion. */
3692 if (block
!= current_block
)
3694 BLOCK_SUPERCONTEXT (block
) = current_block
;
3695 BLOCK_CHAIN (block
) = BLOCK_SUBBLOCKS (current_block
);
3696 BLOCK_SUBBLOCKS (current_block
) = block
;
3697 current_block
= block
;
3699 VARRAY_PUSH_TREE (*p_block_stack
, block
);
3701 else if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_END
)
3703 NOTE_BLOCK (insn
) = VARRAY_TOP_TREE (*p_block_stack
);
3704 VARRAY_POP (*p_block_stack
);
3705 BLOCK_SUBBLOCKS (current_block
)
3706 = blocks_nreverse (BLOCK_SUBBLOCKS (current_block
));
3707 current_block
= BLOCK_SUPERCONTEXT (current_block
);
3713 /* Rationalize BLOCK_FRAGMENT_ORIGIN. If an origin block no longer
3714 appears in the block tree, select one of the fragments to become
3715 the new origin block. */
3718 reorder_fix_fragments (tree block
)
3722 tree dup_origin
= BLOCK_FRAGMENT_ORIGIN (block
);
3723 tree new_origin
= NULL_TREE
;
3727 if (! TREE_ASM_WRITTEN (dup_origin
))
3729 new_origin
= BLOCK_FRAGMENT_CHAIN (dup_origin
);
3731 /* Find the first of the remaining fragments. There must
3732 be at least one -- the current block. */
3733 while (! TREE_ASM_WRITTEN (new_origin
))
3734 new_origin
= BLOCK_FRAGMENT_CHAIN (new_origin
);
3735 BLOCK_FRAGMENT_ORIGIN (new_origin
) = NULL_TREE
;
3738 else if (! dup_origin
)
3741 /* Re-root the rest of the fragments to the new origin. In the
3742 case that DUP_ORIGIN was null, that means BLOCK was the origin
3743 of a chain of fragments and we want to remove those fragments
3744 that didn't make it to the output. */
3747 tree
*pp
= &BLOCK_FRAGMENT_CHAIN (new_origin
);
3752 if (TREE_ASM_WRITTEN (chain
))
3754 BLOCK_FRAGMENT_ORIGIN (chain
) = new_origin
;
3756 pp
= &BLOCK_FRAGMENT_CHAIN (chain
);
3758 chain
= BLOCK_FRAGMENT_CHAIN (chain
);
3763 reorder_fix_fragments (BLOCK_SUBBLOCKS (block
));
3764 block
= BLOCK_CHAIN (block
);
3768 /* Reverse the order of elements in the chain T of blocks,
3769 and return the new head of the chain (old last element). */
3772 blocks_nreverse (tree t
)
3774 tree prev
= 0, decl
, next
;
3775 for (decl
= t
; decl
; decl
= next
)
3777 next
= BLOCK_CHAIN (decl
);
3778 BLOCK_CHAIN (decl
) = prev
;
3784 /* Count the subblocks of the list starting with BLOCK. If VECTOR is
3785 non-NULL, list them all into VECTOR, in a depth-first preorder
3786 traversal of the block tree. Also clear TREE_ASM_WRITTEN in all
3790 all_blocks (tree block
, tree
*vector
)
3796 TREE_ASM_WRITTEN (block
) = 0;
3798 /* Record this block. */
3800 vector
[n_blocks
] = block
;
3804 /* Record the subblocks, and their subblocks... */
3805 n_blocks
+= all_blocks (BLOCK_SUBBLOCKS (block
),
3806 vector
? vector
+ n_blocks
: 0);
3807 block
= BLOCK_CHAIN (block
);
3813 /* Return a vector containing all the blocks rooted at BLOCK. The
3814 number of elements in the vector is stored in N_BLOCKS_P. The
3815 vector is dynamically allocated; it is the caller's responsibility
3816 to call `free' on the pointer returned. */
3819 get_block_vector (tree block
, int *n_blocks_p
)
3823 *n_blocks_p
= all_blocks (block
, NULL
);
3824 block_vector
= xmalloc (*n_blocks_p
* sizeof (tree
));
3825 all_blocks (block
, block_vector
);
3827 return block_vector
;
3830 static GTY(()) int next_block_index
= 2;
3832 /* Set BLOCK_NUMBER for all the blocks in FN. */
3835 number_blocks (tree fn
)
3841 /* For SDB and XCOFF debugging output, we start numbering the blocks
3842 from 1 within each function, rather than keeping a running
3844 #if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
3845 if (write_symbols
== SDB_DEBUG
|| write_symbols
== XCOFF_DEBUG
)
3846 next_block_index
= 1;
3849 block_vector
= get_block_vector (DECL_INITIAL (fn
), &n_blocks
);
3851 /* The top-level BLOCK isn't numbered at all. */
3852 for (i
= 1; i
< n_blocks
; ++i
)
3853 /* We number the blocks from two. */
3854 BLOCK_NUMBER (block_vector
[i
]) = next_block_index
++;
3856 free (block_vector
);
3861 /* If VAR is present in a subblock of BLOCK, return the subblock. */
3864 debug_find_var_in_block_tree (tree var
, tree block
)
3868 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
3872 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= TREE_CHAIN (t
))
3874 tree ret
= debug_find_var_in_block_tree (var
, t
);
3882 /* Allocate a function structure for FNDECL and set its contents
3886 allocate_struct_function (tree fndecl
)
3889 tree fntype
= fndecl
? TREE_TYPE (fndecl
) : NULL_TREE
;
3891 cfun
= ggc_alloc_cleared (sizeof (struct function
));
3893 cfun
->stack_alignment_needed
= STACK_BOUNDARY
;
3894 cfun
->preferred_stack_boundary
= STACK_BOUNDARY
;
3896 current_function_funcdef_no
= funcdef_no
++;
3898 cfun
->function_frequency
= FUNCTION_FREQUENCY_NORMAL
;
3900 init_stmt_for_function ();
3901 init_eh_for_function ();
3903 lang_hooks
.function
.init (cfun
);
3904 if (init_machine_status
)
3905 cfun
->machine
= (*init_machine_status
) ();
3910 DECL_STRUCT_FUNCTION (fndecl
) = cfun
;
3911 cfun
->decl
= fndecl
;
3913 result
= DECL_RESULT (fndecl
);
3914 if (aggregate_value_p (result
, fndecl
))
3916 #ifdef PCC_STATIC_STRUCT_RETURN
3917 current_function_returns_pcc_struct
= 1;
3919 current_function_returns_struct
= 1;
3922 current_function_returns_pointer
= POINTER_TYPE_P (TREE_TYPE (result
));
3924 current_function_stdarg
3926 && TYPE_ARG_TYPES (fntype
) != 0
3927 && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype
)))
3928 != void_type_node
));
3931 /* Reset cfun, and other non-struct-function variables to defaults as
3932 appropriate for emitting rtl at the start of a function. */
3935 prepare_function_start (tree fndecl
)
3937 if (fndecl
&& DECL_STRUCT_FUNCTION (fndecl
))
3938 cfun
= DECL_STRUCT_FUNCTION (fndecl
);
3940 allocate_struct_function (fndecl
);
3942 init_varasm_status (cfun
);
3945 cse_not_expected
= ! optimize
;
3947 /* Caller save not needed yet. */
3948 caller_save_needed
= 0;
3950 /* We haven't done register allocation yet. */
3953 /* Indicate that we need to distinguish between the return value of the
3954 present function and the return value of a function being called. */
3955 rtx_equal_function_value_matters
= 1;
3957 /* Indicate that we have not instantiated virtual registers yet. */
3958 virtuals_instantiated
= 0;
3960 /* Indicate that we want CONCATs now. */
3961 generating_concat_p
= 1;
3963 /* Indicate we have no need of a frame pointer yet. */
3964 frame_pointer_needed
= 0;
3967 /* Initialize the rtl expansion mechanism so that we can do simple things
3968 like generate sequences. This is used to provide a context during global
3969 initialization of some passes. */
3971 init_dummy_function_start (void)
3973 prepare_function_start (NULL
);
3976 /* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node)
3977 and initialize static variables for generating RTL for the statements
3981 init_function_start (tree subr
)
3983 prepare_function_start (subr
);
3985 /* Prevent ever trying to delete the first instruction of a
3986 function. Also tell final how to output a linenum before the
3987 function prologue. Note linenums could be missing, e.g. when
3988 compiling a Java .class file. */
3989 if (! DECL_IS_BUILTIN (subr
))
3990 emit_line_note (DECL_SOURCE_LOCATION (subr
));
3992 /* Make sure first insn is a note even if we don't want linenums.
3993 This makes sure the first insn will never be deleted.
3994 Also, final expects a note to appear there. */
3995 emit_note (NOTE_INSN_DELETED
);
3997 /* Warn if this value is an aggregate type,
3998 regardless of which calling convention we are using for it. */
3999 if (warn_aggregate_return
4000 && AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr
))))
4001 warning ("function returns an aggregate");
4004 /* Make sure all values used by the optimization passes have sane
4007 init_function_for_compilation (void)
4011 /* No prologue/epilogue insns yet. */
4012 VARRAY_GROW (prologue
, 0);
4013 VARRAY_GROW (epilogue
, 0);
4014 VARRAY_GROW (sibcall_epilogue
, 0);
4017 /* Expand a call to __main at the beginning of a possible main function. */
4019 #if defined(INIT_SECTION_ASM_OP) && !defined(INVOKE__main)
4020 #undef HAS_INIT_SECTION
4021 #define HAS_INIT_SECTION
4025 expand_main_function (void)
4027 #ifdef FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN
4028 if (FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN
)
4030 int align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
4034 /* Forcibly align the stack. */
4035 #ifdef STACK_GROWS_DOWNWARD
4036 tmp
= expand_simple_binop (Pmode
, AND
, stack_pointer_rtx
, GEN_INT(-align
),
4037 stack_pointer_rtx
, 1, OPTAB_WIDEN
);
4039 tmp
= expand_simple_binop (Pmode
, PLUS
, stack_pointer_rtx
,
4040 GEN_INT (align
- 1), NULL_RTX
, 1, OPTAB_WIDEN
);
4041 tmp
= expand_simple_binop (Pmode
, AND
, tmp
, GEN_INT (-align
),
4042 stack_pointer_rtx
, 1, OPTAB_WIDEN
);
4044 if (tmp
!= stack_pointer_rtx
)
4045 emit_move_insn (stack_pointer_rtx
, tmp
);
4047 /* Enlist allocate_dynamic_stack_space to pick up the pieces. */
4048 tmp
= force_reg (Pmode
, const0_rtx
);
4049 allocate_dynamic_stack_space (tmp
, NULL_RTX
, BIGGEST_ALIGNMENT
);
4053 for (tmp
= get_last_insn (); tmp
; tmp
= PREV_INSN (tmp
))
4054 if (NOTE_P (tmp
) && NOTE_LINE_NUMBER (tmp
) == NOTE_INSN_FUNCTION_BEG
)
4057 emit_insn_before (seq
, tmp
);
4063 #ifndef HAS_INIT_SECTION
4064 emit_library_call (init_one_libfunc (NAME__MAIN
), LCT_NORMAL
, VOIDmode
, 0);
4068 /* The PENDING_SIZES represent the sizes of variable-sized types.
4069 Create RTL for the various sizes now (using temporary variables),
4070 so that we can refer to the sizes from the RTL we are generating
4071 for the current function. The PENDING_SIZES are a TREE_LIST. The
4072 TREE_VALUE of each node is a SAVE_EXPR. */
4075 expand_pending_sizes (tree pending_sizes
)
4079 /* Evaluate now the sizes of any types declared among the arguments. */
4080 for (tem
= pending_sizes
; tem
; tem
= TREE_CHAIN (tem
))
4081 expand_expr (TREE_VALUE (tem
), const0_rtx
, VOIDmode
, 0);
4084 /* Start the RTL for a new function, and set variables used for
4086 SUBR is the FUNCTION_DECL node.
4087 PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with
4088 the function's parameters, which must be run at any return statement. */
4091 expand_function_start (tree subr
)
4093 /* Make sure volatile mem refs aren't considered
4094 valid operands of arithmetic insns. */
4095 init_recog_no_volatile ();
4097 current_function_profile
4099 && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr
));
4101 current_function_limit_stack
4102 = (stack_limit_rtx
!= NULL_RTX
&& ! DECL_NO_LIMIT_STACK (subr
));
4104 /* Make the label for return statements to jump to. Do not special
4105 case machines with special return instructions -- they will be
4106 handled later during jump, ifcvt, or epilogue creation. */
4107 return_label
= gen_label_rtx ();
4109 /* Initialize rtx used to return the value. */
4110 /* Do this before assign_parms so that we copy the struct value address
4111 before any library calls that assign parms might generate. */
4113 /* Decide whether to return the value in memory or in a register. */
4114 if (aggregate_value_p (DECL_RESULT (subr
), subr
))
4116 /* Returning something that won't go in a register. */
4117 rtx value_address
= 0;
4119 #ifdef PCC_STATIC_STRUCT_RETURN
4120 if (current_function_returns_pcc_struct
)
4122 int size
= int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr
)));
4123 value_address
= assemble_static_space (size
);
4128 rtx sv
= targetm
.calls
.struct_value_rtx (TREE_TYPE (subr
), 1);
4129 /* Expect to be passed the address of a place to store the value.
4130 If it is passed as an argument, assign_parms will take care of
4134 value_address
= gen_reg_rtx (Pmode
);
4135 emit_move_insn (value_address
, sv
);
4140 rtx x
= gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr
)), value_address
);
4141 set_mem_attributes (x
, DECL_RESULT (subr
), 1);
4142 SET_DECL_RTL (DECL_RESULT (subr
), x
);
4145 else if (DECL_MODE (DECL_RESULT (subr
)) == VOIDmode
)
4146 /* If return mode is void, this decl rtl should not be used. */
4147 SET_DECL_RTL (DECL_RESULT (subr
), NULL_RTX
);
4150 /* Compute the return values into a pseudo reg, which we will copy
4151 into the true return register after the cleanups are done. */
4153 /* In order to figure out what mode to use for the pseudo, we
4154 figure out what the mode of the eventual return register will
4155 actually be, and use that. */
4157 = hard_function_value (TREE_TYPE (DECL_RESULT (subr
)),
4160 /* Structures that are returned in registers are not aggregate_value_p,
4161 so we may see a PARALLEL or a REG. */
4162 if (REG_P (hard_reg
))
4163 SET_DECL_RTL (DECL_RESULT (subr
), gen_reg_rtx (GET_MODE (hard_reg
)));
4164 else if (GET_CODE (hard_reg
) == PARALLEL
)
4165 SET_DECL_RTL (DECL_RESULT (subr
), gen_group_rtx (hard_reg
));
4169 /* Set DECL_REGISTER flag so that expand_function_end will copy the
4170 result to the real return register(s). */
4171 DECL_REGISTER (DECL_RESULT (subr
)) = 1;
4174 /* Initialize rtx for parameters and local variables.
4175 In some cases this requires emitting insns. */
4176 assign_parms (subr
);
4178 /* If function gets a static chain arg, store it. */
4179 if (cfun
->static_chain_decl
)
4181 tree parm
= cfun
->static_chain_decl
;
4182 rtx local
= gen_reg_rtx (Pmode
);
4184 set_decl_incoming_rtl (parm
, static_chain_incoming_rtx
);
4185 SET_DECL_RTL (parm
, local
);
4186 maybe_set_unchanging (local
, parm
);
4187 mark_reg_pointer (local
, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm
))));
4189 emit_move_insn (local
, static_chain_incoming_rtx
);
4192 /* If the function receives a non-local goto, then store the
4193 bits we need to restore the frame pointer. */
4194 if (cfun
->nonlocal_goto_save_area
)
4199 /* ??? We need to do this save early. Unfortunately here is
4200 before the frame variable gets declared. Help out... */
4201 expand_var (TREE_OPERAND (cfun
->nonlocal_goto_save_area
, 0));
4203 t_save
= build (ARRAY_REF
, ptr_type_node
, cfun
->nonlocal_goto_save_area
,
4204 integer_zero_node
, NULL_TREE
, NULL_TREE
);
4205 r_save
= expand_expr (t_save
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
4206 r_save
= convert_memory_address (Pmode
, r_save
);
4208 emit_move_insn (r_save
, virtual_stack_vars_rtx
);
4209 update_nonlocal_goto_save_area ();
4212 /* The following was moved from init_function_start.
4213 The move is supposed to make sdb output more accurate. */
4214 /* Indicate the beginning of the function body,
4215 as opposed to parm setup. */
4216 emit_note (NOTE_INSN_FUNCTION_BEG
);
4218 if (!NOTE_P (get_last_insn ()))
4219 emit_note (NOTE_INSN_DELETED
);
4220 parm_birth_insn
= get_last_insn ();
4222 if (current_function_profile
)
4225 PROFILE_HOOK (current_function_funcdef_no
);
4229 /* After the display initializations is where the tail-recursion label
4230 should go, if we end up needing one. Ensure we have a NOTE here
4231 since some things (like trampolines) get placed before this. */
4232 tail_recursion_reentry
= emit_note (NOTE_INSN_DELETED
);
4234 /* Evaluate now the sizes of any types declared among the arguments. */
4235 expand_pending_sizes (nreverse (get_pending_sizes ()));
4237 /* Make sure there is a line number after the function entry setup code. */
4238 force_next_line_note ();
4241 /* Undo the effects of init_dummy_function_start. */
4243 expand_dummy_function_end (void)
4245 /* End any sequences that failed to be closed due to syntax errors. */
4246 while (in_sequence_p ())
4249 /* Outside function body, can't compute type's actual size
4250 until next function's body starts. */
4252 free_after_parsing (cfun
);
4253 free_after_compilation (cfun
);
4257 /* Call DOIT for each hard register used as a return value from
4258 the current function. */
4261 diddle_return_value (void (*doit
) (rtx
, void *), void *arg
)
4263 rtx outgoing
= current_function_return_rtx
;
4268 if (REG_P (outgoing
))
4269 (*doit
) (outgoing
, arg
);
4270 else if (GET_CODE (outgoing
) == PARALLEL
)
4274 for (i
= 0; i
< XVECLEN (outgoing
, 0); i
++)
4276 rtx x
= XEXP (XVECEXP (outgoing
, 0, i
), 0);
4278 if (REG_P (x
) && REGNO (x
) < FIRST_PSEUDO_REGISTER
)
4285 do_clobber_return_reg (rtx reg
, void *arg ATTRIBUTE_UNUSED
)
4287 emit_insn (gen_rtx_CLOBBER (VOIDmode
, reg
));
4291 clobber_return_register (void)
4293 diddle_return_value (do_clobber_return_reg
, NULL
);
4295 /* In case we do use pseudo to return value, clobber it too. */
4296 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl
)))
4298 tree decl_result
= DECL_RESULT (current_function_decl
);
4299 rtx decl_rtl
= DECL_RTL (decl_result
);
4300 if (REG_P (decl_rtl
) && REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
)
4302 do_clobber_return_reg (decl_rtl
, NULL
);
4308 do_use_return_reg (rtx reg
, void *arg ATTRIBUTE_UNUSED
)
4310 emit_insn (gen_rtx_USE (VOIDmode
, reg
));
4314 use_return_register (void)
4316 diddle_return_value (do_use_return_reg
, NULL
);
4319 /* Possibly warn about unused parameters. */
4321 do_warn_unused_parameter (tree fn
)
4325 for (decl
= DECL_ARGUMENTS (fn
);
4326 decl
; decl
= TREE_CHAIN (decl
))
4327 if (!TREE_USED (decl
) && TREE_CODE (decl
) == PARM_DECL
4328 && DECL_NAME (decl
) && !DECL_ARTIFICIAL (decl
))
4329 warning ("%Junused parameter '%D'", decl
, decl
);
4332 static GTY(()) rtx initial_trampoline
;
4334 /* Generate RTL for the end of the current function. */
4337 expand_function_end (void)
4341 /* If arg_pointer_save_area was referenced only from a nested
4342 function, we will not have initialized it yet. Do that now. */
4343 if (arg_pointer_save_area
&& ! cfun
->arg_pointer_save_area_init
)
4344 get_arg_pointer_save_area (cfun
);
4346 /* If we are doing stack checking and this function makes calls,
4347 do a stack probe at the start of the function to ensure we have enough
4348 space for another stack frame. */
4349 if (flag_stack_check
&& ! STACK_CHECK_BUILTIN
)
4353 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
4357 probe_stack_range (STACK_CHECK_PROTECT
,
4358 GEN_INT (STACK_CHECK_MAX_FRAME_SIZE
));
4361 emit_insn_before (seq
, tail_recursion_reentry
);
4366 /* Possibly warn about unused parameters.
4367 When frontend does unit-at-a-time, the warning is already
4368 issued at finalization time. */
4369 if (warn_unused_parameter
4370 && !lang_hooks
.callgraph
.expand_function
)
4371 do_warn_unused_parameter (current_function_decl
);
4373 /* End any sequences that failed to be closed due to syntax errors. */
4374 while (in_sequence_p ())
4377 clear_pending_stack_adjust ();
4378 do_pending_stack_adjust ();
4380 /* @@@ This is a kludge. We want to ensure that instructions that
4381 may trap are not moved into the epilogue by scheduling, because
4382 we don't always emit unwind information for the epilogue.
4383 However, not all machine descriptions define a blockage insn, so
4384 emit an ASM_INPUT to act as one. */
4385 if (flag_non_call_exceptions
)
4386 emit_insn (gen_rtx_ASM_INPUT (VOIDmode
, ""));
4388 /* Mark the end of the function body.
4389 If control reaches this insn, the function can drop through
4390 without returning a value. */
4391 emit_note (NOTE_INSN_FUNCTION_END
);
4393 /* Must mark the last line number note in the function, so that the test
4394 coverage code can avoid counting the last line twice. This just tells
4395 the code to ignore the immediately following line note, since there
4396 already exists a copy of this note somewhere above. This line number
4397 note is still needed for debugging though, so we can't delete it. */
4398 if (flag_test_coverage
)
4399 emit_note (NOTE_INSN_REPEATED_LINE_NUMBER
);
4401 /* Output a linenumber for the end of the function.
4402 SDB depends on this. */
4403 force_next_line_note ();
4404 emit_line_note (input_location
);
4406 /* Before the return label (if any), clobber the return
4407 registers so that they are not propagated live to the rest of
4408 the function. This can only happen with functions that drop
4409 through; if there had been a return statement, there would
4410 have either been a return rtx, or a jump to the return label.
4412 We delay actual code generation after the current_function_value_rtx
4414 clobber_after
= get_last_insn ();
4416 /* Output the label for the actual return from the function,
4417 if one is expected. This happens either because a function epilogue
4418 is used instead of a return instruction, or because a return was done
4419 with a goto in order to run local cleanups, or because of pcc-style
4420 structure returning. */
4422 emit_label (return_label
);
4424 /* Let except.c know where it should emit the call to unregister
4425 the function context for sjlj exceptions. */
4426 if (flag_exceptions
&& USING_SJLJ_EXCEPTIONS
)
4427 sjlj_emit_function_exit_after (get_last_insn ());
4429 /* If we had calls to alloca, and this machine needs
4430 an accurate stack pointer to exit the function,
4431 insert some code to save and restore the stack pointer. */
4432 if (! EXIT_IGNORE_STACK
4433 && current_function_calls_alloca
)
4437 emit_stack_save (SAVE_FUNCTION
, &tem
, parm_birth_insn
);
4438 emit_stack_restore (SAVE_FUNCTION
, tem
, NULL_RTX
);
4441 /* If scalar return value was computed in a pseudo-reg, or was a named
4442 return value that got dumped to the stack, copy that to the hard
4444 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl
)))
4446 tree decl_result
= DECL_RESULT (current_function_decl
);
4447 rtx decl_rtl
= DECL_RTL (decl_result
);
4449 if (REG_P (decl_rtl
)
4450 ? REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
4451 : DECL_REGISTER (decl_result
))
4453 rtx real_decl_rtl
= current_function_return_rtx
;
4455 /* This should be set in assign_parms. */
4456 if (! REG_FUNCTION_VALUE_P (real_decl_rtl
))
4459 /* If this is a BLKmode structure being returned in registers,
4460 then use the mode computed in expand_return. Note that if
4461 decl_rtl is memory, then its mode may have been changed,
4462 but that current_function_return_rtx has not. */
4463 if (GET_MODE (real_decl_rtl
) == BLKmode
)
4464 PUT_MODE (real_decl_rtl
, GET_MODE (decl_rtl
));
4466 /* If a named return value dumped decl_return to memory, then
4467 we may need to re-do the PROMOTE_MODE signed/unsigned
4469 if (GET_MODE (real_decl_rtl
) != GET_MODE (decl_rtl
))
4471 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (decl_result
));
4473 if (targetm
.calls
.promote_function_return (TREE_TYPE (current_function_decl
)))
4474 promote_mode (TREE_TYPE (decl_result
), GET_MODE (decl_rtl
),
4477 convert_move (real_decl_rtl
, decl_rtl
, unsignedp
);
4479 else if (GET_CODE (real_decl_rtl
) == PARALLEL
)
4481 /* If expand_function_start has created a PARALLEL for decl_rtl,
4482 move the result to the real return registers. Otherwise, do
4483 a group load from decl_rtl for a named return. */
4484 if (GET_CODE (decl_rtl
) == PARALLEL
)
4485 emit_group_move (real_decl_rtl
, decl_rtl
);
4487 emit_group_load (real_decl_rtl
, decl_rtl
,
4488 TREE_TYPE (decl_result
),
4489 int_size_in_bytes (TREE_TYPE (decl_result
)));
4492 emit_move_insn (real_decl_rtl
, decl_rtl
);
4496 /* If returning a structure, arrange to return the address of the value
4497 in a place where debuggers expect to find it.
4499 If returning a structure PCC style,
4500 the caller also depends on this value.
4501 And current_function_returns_pcc_struct is not necessarily set. */
4502 if (current_function_returns_struct
4503 || current_function_returns_pcc_struct
)
4506 = XEXP (DECL_RTL (DECL_RESULT (current_function_decl
)), 0);
4507 tree type
= TREE_TYPE (DECL_RESULT (current_function_decl
));
4508 #ifdef FUNCTION_OUTGOING_VALUE
4510 = FUNCTION_OUTGOING_VALUE (build_pointer_type (type
),
4511 current_function_decl
);
4514 = FUNCTION_VALUE (build_pointer_type (type
), current_function_decl
);
4517 /* Mark this as a function return value so integrate will delete the
4518 assignment and USE below when inlining this function. */
4519 REG_FUNCTION_VALUE_P (outgoing
) = 1;
4521 /* The address may be ptr_mode and OUTGOING may be Pmode. */
4522 value_address
= convert_memory_address (GET_MODE (outgoing
),
4525 emit_move_insn (outgoing
, value_address
);
4527 /* Show return register used to hold result (in this case the address
4529 current_function_return_rtx
= outgoing
;
4532 /* If this is an implementation of throw, do what's necessary to
4533 communicate between __builtin_eh_return and the epilogue. */
4534 expand_eh_return ();
4536 /* Emit the actual code to clobber return register. */
4541 clobber_return_register ();
4545 after
= emit_insn_after (seq
, clobber_after
);
4548 /* Output the label for the naked return from the function, if one is
4549 expected. This is currently used only by __builtin_return. */
4550 if (naked_return_label
)
4551 emit_label (naked_return_label
);
4553 /* ??? This should no longer be necessary since stupid is no longer with
4554 us, but there are some parts of the compiler (eg reload_combine, and
4555 sh mach_dep_reorg) that still try and compute their own lifetime info
4556 instead of using the general framework. */
4557 use_return_register ();
4561 get_arg_pointer_save_area (struct function
*f
)
4563 rtx ret
= f
->x_arg_pointer_save_area
;
4567 ret
= assign_stack_local_1 (Pmode
, GET_MODE_SIZE (Pmode
), 0, f
);
4568 f
->x_arg_pointer_save_area
= ret
;
4571 if (f
== cfun
&& ! f
->arg_pointer_save_area_init
)
4575 /* Save the arg pointer at the beginning of the function. The
4576 generated stack slot may not be a valid memory address, so we
4577 have to check it and fix it if necessary. */
4579 emit_move_insn (validize_mem (ret
), virtual_incoming_args_rtx
);
4583 push_topmost_sequence ();
4584 emit_insn_after (seq
, get_insns ());
4585 pop_topmost_sequence ();
4591 /* Extend a vector that records the INSN_UIDs of INSNS
4592 (a list of one or more insns). */
4595 record_insns (rtx insns
, varray_type
*vecp
)
4602 while (tmp
!= NULL_RTX
)
4605 tmp
= NEXT_INSN (tmp
);
4608 i
= VARRAY_SIZE (*vecp
);
4609 VARRAY_GROW (*vecp
, i
+ len
);
4611 while (tmp
!= NULL_RTX
)
4613 VARRAY_INT (*vecp
, i
) = INSN_UID (tmp
);
4615 tmp
= NEXT_INSN (tmp
);
4619 /* Set the locator of the insn chain starting at INSN to LOC. */
4621 set_insn_locators (rtx insn
, int loc
)
4623 while (insn
!= NULL_RTX
)
4626 INSN_LOCATOR (insn
) = loc
;
4627 insn
= NEXT_INSN (insn
);
4631 /* Determine how many INSN_UIDs in VEC are part of INSN. Because we can
4632 be running after reorg, SEQUENCE rtl is possible. */
4635 contains (rtx insn
, varray_type vec
)
4639 if (NONJUMP_INSN_P (insn
)
4640 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
4643 for (i
= XVECLEN (PATTERN (insn
), 0) - 1; i
>= 0; i
--)
4644 for (j
= VARRAY_SIZE (vec
) - 1; j
>= 0; --j
)
4645 if (INSN_UID (XVECEXP (PATTERN (insn
), 0, i
)) == VARRAY_INT (vec
, j
))
4651 for (j
= VARRAY_SIZE (vec
) - 1; j
>= 0; --j
)
4652 if (INSN_UID (insn
) == VARRAY_INT (vec
, j
))
4659 prologue_epilogue_contains (rtx insn
)
4661 if (contains (insn
, prologue
))
4663 if (contains (insn
, epilogue
))
4669 sibcall_epilogue_contains (rtx insn
)
4671 if (sibcall_epilogue
)
4672 return contains (insn
, sibcall_epilogue
);
4677 /* Insert gen_return at the end of block BB. This also means updating
4678 block_for_insn appropriately. */
4681 emit_return_into_block (basic_block bb
, rtx line_note
)
4683 emit_jump_insn_after (gen_return (), BB_END (bb
));
4685 emit_note_copy_after (line_note
, PREV_INSN (BB_END (bb
)));
4687 #endif /* HAVE_return */
4689 #if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX)
4691 /* These functions convert the epilogue into a variant that does not modify the
4692 stack pointer. This is used in cases where a function returns an object
4693 whose size is not known until it is computed. The called function leaves the
4694 object on the stack, leaves the stack depressed, and returns a pointer to
4697 What we need to do is track all modifications and references to the stack
4698 pointer, deleting the modifications and changing the references to point to
4699 the location the stack pointer would have pointed to had the modifications
4702 These functions need to be portable so we need to make as few assumptions
4703 about the epilogue as we can. However, the epilogue basically contains
4704 three things: instructions to reset the stack pointer, instructions to
4705 reload registers, possibly including the frame pointer, and an
4706 instruction to return to the caller.
4708 If we can't be sure of what a relevant epilogue insn is doing, we abort.
4709 We also make no attempt to validate the insns we make since if they are
4710 invalid, we probably can't do anything valid. The intent is that these
4711 routines get "smarter" as more and more machines start to use them and
4712 they try operating on different epilogues.
4714 We use the following structure to track what the part of the epilogue that
4715 we've already processed has done. We keep two copies of the SP equivalence,
4716 one for use during the insn we are processing and one for use in the next
4717 insn. The difference is because one part of a PARALLEL may adjust SP
4718 and the other may use it. */
4722 rtx sp_equiv_reg
; /* REG that SP is set from, perhaps SP. */
4723 HOST_WIDE_INT sp_offset
; /* Offset from SP_EQUIV_REG of present SP. */
4724 rtx new_sp_equiv_reg
; /* REG to be used at end of insn. */
4725 HOST_WIDE_INT new_sp_offset
; /* Offset to be used at end of insn. */
4726 rtx equiv_reg_src
; /* If nonzero, the value that SP_EQUIV_REG
4727 should be set to once we no longer need
4729 rtx const_equiv
[FIRST_PSEUDO_REGISTER
]; /* Any known constant equivalences
4733 static void handle_epilogue_set (rtx
, struct epi_info
*);
4734 static void update_epilogue_consts (rtx
, rtx
, void *);
4735 static void emit_equiv_load (struct epi_info
*);
4737 /* Modify INSN, a list of one or more insns that is part of the epilogue, to
4738 no modifications to the stack pointer. Return the new list of insns. */
4741 keep_stack_depressed (rtx insns
)
4744 struct epi_info info
;
4747 /* If the epilogue is just a single instruction, it must be OK as is. */
4748 if (NEXT_INSN (insns
) == NULL_RTX
)
4751 /* Otherwise, start a sequence, initialize the information we have, and
4752 process all the insns we were given. */
4755 info
.sp_equiv_reg
= stack_pointer_rtx
;
4757 info
.equiv_reg_src
= 0;
4759 for (j
= 0; j
< FIRST_PSEUDO_REGISTER
; j
++)
4760 info
.const_equiv
[j
] = 0;
4764 while (insn
!= NULL_RTX
)
4766 next
= NEXT_INSN (insn
);
4775 /* If this insn references the register that SP is equivalent to and
4776 we have a pending load to that register, we must force out the load
4777 first and then indicate we no longer know what SP's equivalent is. */
4778 if (info
.equiv_reg_src
!= 0
4779 && reg_referenced_p (info
.sp_equiv_reg
, PATTERN (insn
)))
4781 emit_equiv_load (&info
);
4782 info
.sp_equiv_reg
= 0;
4785 info
.new_sp_equiv_reg
= info
.sp_equiv_reg
;
4786 info
.new_sp_offset
= info
.sp_offset
;
4788 /* If this is a (RETURN) and the return address is on the stack,
4789 update the address and change to an indirect jump. */
4790 if (GET_CODE (PATTERN (insn
)) == RETURN
4791 || (GET_CODE (PATTERN (insn
)) == PARALLEL
4792 && GET_CODE (XVECEXP (PATTERN (insn
), 0, 0)) == RETURN
))
4794 rtx retaddr
= INCOMING_RETURN_ADDR_RTX
;
4796 HOST_WIDE_INT offset
= 0;
4797 rtx jump_insn
, jump_set
;
4799 /* If the return address is in a register, we can emit the insn
4800 unchanged. Otherwise, it must be a MEM and we see what the
4801 base register and offset are. In any case, we have to emit any
4802 pending load to the equivalent reg of SP, if any. */
4803 if (REG_P (retaddr
))
4805 emit_equiv_load (&info
);
4810 else if (MEM_P (retaddr
)
4811 && REG_P (XEXP (retaddr
, 0)))
4812 base
= gen_rtx_REG (Pmode
, REGNO (XEXP (retaddr
, 0))), offset
= 0;
4813 else if (MEM_P (retaddr
)
4814 && GET_CODE (XEXP (retaddr
, 0)) == PLUS
4815 && REG_P (XEXP (XEXP (retaddr
, 0), 0))
4816 && GET_CODE (XEXP (XEXP (retaddr
, 0), 1)) == CONST_INT
)
4818 base
= gen_rtx_REG (Pmode
, REGNO (XEXP (XEXP (retaddr
, 0), 0)));
4819 offset
= INTVAL (XEXP (XEXP (retaddr
, 0), 1));
4824 /* If the base of the location containing the return pointer
4825 is SP, we must update it with the replacement address. Otherwise,
4826 just build the necessary MEM. */
4827 retaddr
= plus_constant (base
, offset
);
4828 if (base
== stack_pointer_rtx
)
4829 retaddr
= simplify_replace_rtx (retaddr
, stack_pointer_rtx
,
4830 plus_constant (info
.sp_equiv_reg
,
4833 retaddr
= gen_rtx_MEM (Pmode
, retaddr
);
4835 /* If there is a pending load to the equivalent register for SP
4836 and we reference that register, we must load our address into
4837 a scratch register and then do that load. */
4838 if (info
.equiv_reg_src
4839 && reg_overlap_mentioned_p (info
.equiv_reg_src
, retaddr
))
4844 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
4845 if (HARD_REGNO_MODE_OK (regno
, Pmode
)
4846 && !fixed_regs
[regno
]
4847 && TEST_HARD_REG_BIT (regs_invalidated_by_call
, regno
)
4848 && !REGNO_REG_SET_P (EXIT_BLOCK_PTR
->global_live_at_start
,
4850 && !refers_to_regno_p (regno
,
4851 regno
+ hard_regno_nregs
[regno
]
4853 info
.equiv_reg_src
, NULL
)
4854 && info
.const_equiv
[regno
] == 0)
4857 if (regno
== FIRST_PSEUDO_REGISTER
)
4860 reg
= gen_rtx_REG (Pmode
, regno
);
4861 emit_move_insn (reg
, retaddr
);
4865 emit_equiv_load (&info
);
4866 jump_insn
= emit_jump_insn (gen_indirect_jump (retaddr
));
4868 /* Show the SET in the above insn is a RETURN. */
4869 jump_set
= single_set (jump_insn
);
4873 SET_IS_RETURN_P (jump_set
) = 1;
4876 /* If SP is not mentioned in the pattern and its equivalent register, if
4877 any, is not modified, just emit it. Otherwise, if neither is set,
4878 replace the reference to SP and emit the insn. If none of those are
4879 true, handle each SET individually. */
4880 else if (!reg_mentioned_p (stack_pointer_rtx
, PATTERN (insn
))
4881 && (info
.sp_equiv_reg
== stack_pointer_rtx
4882 || !reg_set_p (info
.sp_equiv_reg
, insn
)))
4884 else if (! reg_set_p (stack_pointer_rtx
, insn
)
4885 && (info
.sp_equiv_reg
== stack_pointer_rtx
4886 || !reg_set_p (info
.sp_equiv_reg
, insn
)))
4888 if (! validate_replace_rtx (stack_pointer_rtx
,
4889 plus_constant (info
.sp_equiv_reg
,
4896 else if (GET_CODE (PATTERN (insn
)) == SET
)
4897 handle_epilogue_set (PATTERN (insn
), &info
);
4898 else if (GET_CODE (PATTERN (insn
)) == PARALLEL
)
4900 for (j
= 0; j
< XVECLEN (PATTERN (insn
), 0); j
++)
4901 if (GET_CODE (XVECEXP (PATTERN (insn
), 0, j
)) == SET
)
4902 handle_epilogue_set (XVECEXP (PATTERN (insn
), 0, j
), &info
);
4907 info
.sp_equiv_reg
= info
.new_sp_equiv_reg
;
4908 info
.sp_offset
= info
.new_sp_offset
;
4910 /* Now update any constants this insn sets. */
4911 note_stores (PATTERN (insn
), update_epilogue_consts
, &info
);
4915 insns
= get_insns ();
4920 /* SET is a SET from an insn in the epilogue. P is a pointer to the epi_info
4921 structure that contains information about what we've seen so far. We
4922 process this SET by either updating that data or by emitting one or
4926 handle_epilogue_set (rtx set
, struct epi_info
*p
)
4928 /* First handle the case where we are setting SP. Record what it is being
4929 set from. If unknown, abort. */
4930 if (reg_set_p (stack_pointer_rtx
, set
))
4932 if (SET_DEST (set
) != stack_pointer_rtx
)
4935 if (GET_CODE (SET_SRC (set
)) == PLUS
)
4937 p
->new_sp_equiv_reg
= XEXP (SET_SRC (set
), 0);
4938 if (GET_CODE (XEXP (SET_SRC (set
), 1)) == CONST_INT
)
4939 p
->new_sp_offset
= INTVAL (XEXP (SET_SRC (set
), 1));
4940 else if (REG_P (XEXP (SET_SRC (set
), 1))
4941 && REGNO (XEXP (SET_SRC (set
), 1)) < FIRST_PSEUDO_REGISTER
4942 && p
->const_equiv
[REGNO (XEXP (SET_SRC (set
), 1))] != 0)
4944 = INTVAL (p
->const_equiv
[REGNO (XEXP (SET_SRC (set
), 1))]);
4949 p
->new_sp_equiv_reg
= SET_SRC (set
), p
->new_sp_offset
= 0;
4951 /* If we are adjusting SP, we adjust from the old data. */
4952 if (p
->new_sp_equiv_reg
== stack_pointer_rtx
)
4954 p
->new_sp_equiv_reg
= p
->sp_equiv_reg
;
4955 p
->new_sp_offset
+= p
->sp_offset
;
4958 if (p
->new_sp_equiv_reg
== 0 || !REG_P (p
->new_sp_equiv_reg
))
4964 /* Next handle the case where we are setting SP's equivalent register.
4965 If we already have a value to set it to, abort. We could update, but
4966 there seems little point in handling that case. Note that we have
4967 to allow for the case where we are setting the register set in
4968 the previous part of a PARALLEL inside a single insn. But use the
4969 old offset for any updates within this insn. We must allow for the case
4970 where the register is being set in a different (usually wider) mode than
4972 else if (p
->new_sp_equiv_reg
!= 0 && reg_set_p (p
->new_sp_equiv_reg
, set
))
4974 if (p
->equiv_reg_src
!= 0
4975 || !REG_P (p
->new_sp_equiv_reg
)
4976 || !REG_P (SET_DEST (set
))
4977 || GET_MODE_BITSIZE (GET_MODE (SET_DEST (set
))) > BITS_PER_WORD
4978 || REGNO (p
->new_sp_equiv_reg
) != REGNO (SET_DEST (set
)))
4982 = simplify_replace_rtx (SET_SRC (set
), stack_pointer_rtx
,
4983 plus_constant (p
->sp_equiv_reg
,
4987 /* Otherwise, replace any references to SP in the insn to its new value
4988 and emit the insn. */
4991 SET_SRC (set
) = simplify_replace_rtx (SET_SRC (set
), stack_pointer_rtx
,
4992 plus_constant (p
->sp_equiv_reg
,
4994 SET_DEST (set
) = simplify_replace_rtx (SET_DEST (set
), stack_pointer_rtx
,
4995 plus_constant (p
->sp_equiv_reg
,
5001 /* Update the tracking information for registers set to constants. */
5004 update_epilogue_consts (rtx dest
, rtx x
, void *data
)
5006 struct epi_info
*p
= (struct epi_info
*) data
;
5009 if (!REG_P (dest
) || REGNO (dest
) >= FIRST_PSEUDO_REGISTER
)
5012 /* If we are either clobbering a register or doing a partial set,
5013 show we don't know the value. */
5014 else if (GET_CODE (x
) == CLOBBER
|| ! rtx_equal_p (dest
, SET_DEST (x
)))
5015 p
->const_equiv
[REGNO (dest
)] = 0;
5017 /* If we are setting it to a constant, record that constant. */
5018 else if (GET_CODE (SET_SRC (x
)) == CONST_INT
)
5019 p
->const_equiv
[REGNO (dest
)] = SET_SRC (x
);
5021 /* If this is a binary operation between a register we have been tracking
5022 and a constant, see if we can compute a new constant value. */
5023 else if (ARITHMETIC_P (SET_SRC (x
))
5024 && REG_P (XEXP (SET_SRC (x
), 0))
5025 && REGNO (XEXP (SET_SRC (x
), 0)) < FIRST_PSEUDO_REGISTER
5026 && p
->const_equiv
[REGNO (XEXP (SET_SRC (x
), 0))] != 0
5027 && GET_CODE (XEXP (SET_SRC (x
), 1)) == CONST_INT
5028 && 0 != (new = simplify_binary_operation
5029 (GET_CODE (SET_SRC (x
)), GET_MODE (dest
),
5030 p
->const_equiv
[REGNO (XEXP (SET_SRC (x
), 0))],
5031 XEXP (SET_SRC (x
), 1)))
5032 && GET_CODE (new) == CONST_INT
)
5033 p
->const_equiv
[REGNO (dest
)] = new;
5035 /* Otherwise, we can't do anything with this value. */
5037 p
->const_equiv
[REGNO (dest
)] = 0;
5040 /* Emit an insn to do the load shown in p->equiv_reg_src, if needed. */
5043 emit_equiv_load (struct epi_info
*p
)
5045 if (p
->equiv_reg_src
!= 0)
5047 rtx dest
= p
->sp_equiv_reg
;
5049 if (GET_MODE (p
->equiv_reg_src
) != GET_MODE (dest
))
5050 dest
= gen_rtx_REG (GET_MODE (p
->equiv_reg_src
),
5051 REGNO (p
->sp_equiv_reg
));
5053 emit_move_insn (dest
, p
->equiv_reg_src
);
5054 p
->equiv_reg_src
= 0;
5059 /* Generate the prologue and epilogue RTL if the machine supports it. Thread
5060 this into place with notes indicating where the prologue ends and where
5061 the epilogue begins. Update the basic block information when possible. */
5064 thread_prologue_and_epilogue_insns (rtx f ATTRIBUTE_UNUSED
)
5068 #if defined (HAVE_sibcall_epilogue) || defined (HAVE_epilogue) || defined (HAVE_return) || defined (HAVE_prologue)
5071 #ifdef HAVE_prologue
5072 rtx prologue_end
= NULL_RTX
;
5074 #if defined (HAVE_epilogue) || defined(HAVE_return)
5075 rtx epilogue_end
= NULL_RTX
;
5078 #ifdef HAVE_prologue
5082 seq
= gen_prologue ();
5085 /* Retain a map of the prologue insns. */
5086 record_insns (seq
, &prologue
);
5087 prologue_end
= emit_note (NOTE_INSN_PROLOGUE_END
);
5091 set_insn_locators (seq
, prologue_locator
);
5093 /* Can't deal with multiple successors of the entry block
5094 at the moment. Function should always have at least one
5096 if (!ENTRY_BLOCK_PTR
->succ
|| ENTRY_BLOCK_PTR
->succ
->succ_next
)
5099 insert_insn_on_edge (seq
, ENTRY_BLOCK_PTR
->succ
);
5104 /* If the exit block has no non-fake predecessors, we don't need
5106 for (e
= EXIT_BLOCK_PTR
->pred
; e
; e
= e
->pred_next
)
5107 if ((e
->flags
& EDGE_FAKE
) == 0)
5113 if (optimize
&& HAVE_return
)
5115 /* If we're allowed to generate a simple return instruction,
5116 then by definition we don't need a full epilogue. Examine
5117 the block that falls through to EXIT. If it does not
5118 contain any code, examine its predecessors and try to
5119 emit (conditional) return instructions. */
5125 for (e
= EXIT_BLOCK_PTR
->pred
; e
; e
= e
->pred_next
)
5126 if (e
->flags
& EDGE_FALLTHRU
)
5132 /* Verify that there are no active instructions in the last block. */
5133 label
= BB_END (last
);
5134 while (label
&& !LABEL_P (label
))
5136 if (active_insn_p (label
))
5138 label
= PREV_INSN (label
);
5141 if (BB_HEAD (last
) == label
&& LABEL_P (label
))
5143 rtx epilogue_line_note
= NULL_RTX
;
5145 /* Locate the line number associated with the closing brace,
5146 if we can find one. */
5147 for (seq
= get_last_insn ();
5148 seq
&& ! active_insn_p (seq
);
5149 seq
= PREV_INSN (seq
))
5150 if (NOTE_P (seq
) && NOTE_LINE_NUMBER (seq
) > 0)
5152 epilogue_line_note
= seq
;
5156 for (e
= last
->pred
; e
; e
= e_next
)
5158 basic_block bb
= e
->src
;
5161 e_next
= e
->pred_next
;
5162 if (bb
== ENTRY_BLOCK_PTR
)
5166 if (!JUMP_P (jump
) || JUMP_LABEL (jump
) != label
)
5169 /* If we have an unconditional jump, we can replace that
5170 with a simple return instruction. */
5171 if (simplejump_p (jump
))
5173 emit_return_into_block (bb
, epilogue_line_note
);
5177 /* If we have a conditional jump, we can try to replace
5178 that with a conditional return instruction. */
5179 else if (condjump_p (jump
))
5181 if (! redirect_jump (jump
, 0, 0))
5184 /* If this block has only one successor, it both jumps
5185 and falls through to the fallthru block, so we can't
5187 if (bb
->succ
->succ_next
== NULL
)
5193 /* Fix up the CFG for the successful change we just made. */
5194 redirect_edge_succ (e
, EXIT_BLOCK_PTR
);
5197 /* Emit a return insn for the exit fallthru block. Whether
5198 this is still reachable will be determined later. */
5200 emit_barrier_after (BB_END (last
));
5201 emit_return_into_block (last
, epilogue_line_note
);
5202 epilogue_end
= BB_END (last
);
5203 last
->succ
->flags
&= ~EDGE_FALLTHRU
;
5208 /* Find the edge that falls through to EXIT. Other edges may exist
5209 due to RETURN instructions, but those don't need epilogues.
5210 There really shouldn't be a mixture -- either all should have
5211 been converted or none, however... */
5213 for (e
= EXIT_BLOCK_PTR
->pred
; e
; e
= e
->pred_next
)
5214 if (e
->flags
& EDGE_FALLTHRU
)
5219 #ifdef HAVE_epilogue
5223 epilogue_end
= emit_note (NOTE_INSN_EPILOGUE_BEG
);
5225 seq
= gen_epilogue ();
5227 #ifdef INCOMING_RETURN_ADDR_RTX
5228 /* If this function returns with the stack depressed and we can support
5229 it, massage the epilogue to actually do that. */
5230 if (TREE_CODE (TREE_TYPE (current_function_decl
)) == FUNCTION_TYPE
5231 && TYPE_RETURNS_STACK_DEPRESSED (TREE_TYPE (current_function_decl
)))
5232 seq
= keep_stack_depressed (seq
);
5235 emit_jump_insn (seq
);
5237 /* Retain a map of the epilogue insns. */
5238 record_insns (seq
, &epilogue
);
5239 set_insn_locators (seq
, epilogue_locator
);
5244 insert_insn_on_edge (seq
, e
);
5252 if (! next_active_insn (BB_END (e
->src
)))
5254 /* We have a fall-through edge to the exit block, the source is not
5255 at the end of the function, and there will be an assembler epilogue
5256 at the end of the function.
5257 We can't use force_nonfallthru here, because that would try to
5258 use return. Inserting a jump 'by hand' is extremely messy, so
5259 we take advantage of cfg_layout_finalize using
5260 fixup_fallthru_exit_predecessor. */
5261 cfg_layout_initialize ();
5262 FOR_EACH_BB (cur_bb
)
5263 if (cur_bb
->index
>= 0 && cur_bb
->next_bb
->index
>= 0)
5264 cur_bb
->rbi
->next
= cur_bb
->next_bb
;
5265 cfg_layout_finalize ();
5270 commit_edge_insertions ();
5272 #ifdef HAVE_sibcall_epilogue
5273 /* Emit sibling epilogues before any sibling call sites. */
5274 for (e
= EXIT_BLOCK_PTR
->pred
; e
; e
= e
->pred_next
)
5276 basic_block bb
= e
->src
;
5277 rtx insn
= BB_END (bb
);
5282 || ! SIBLING_CALL_P (insn
))
5286 emit_insn (gen_sibcall_epilogue ());
5290 /* Retain a map of the epilogue insns. Used in life analysis to
5291 avoid getting rid of sibcall epilogue insns. Do this before we
5292 actually emit the sequence. */
5293 record_insns (seq
, &sibcall_epilogue
);
5294 set_insn_locators (seq
, epilogue_locator
);
5296 i
= PREV_INSN (insn
);
5297 newinsn
= emit_insn_before (seq
, insn
);
5301 #ifdef HAVE_prologue
5302 /* This is probably all useless now that we use locators. */
5307 /* GDB handles `break f' by setting a breakpoint on the first
5308 line note after the prologue. Which means (1) that if
5309 there are line number notes before where we inserted the
5310 prologue we should move them, and (2) we should generate a
5311 note before the end of the first basic block, if there isn't
5314 ??? This behavior is completely broken when dealing with
5315 multiple entry functions. We simply place the note always
5316 into first basic block and let alternate entry points
5320 for (insn
= prologue_end
; insn
; insn
= prev
)
5322 prev
= PREV_INSN (insn
);
5323 if (NOTE_P (insn
) && NOTE_LINE_NUMBER (insn
) > 0)
5325 /* Note that we cannot reorder the first insn in the
5326 chain, since rest_of_compilation relies on that
5327 remaining constant. */
5330 reorder_insns (insn
, insn
, prologue_end
);
5334 /* Find the last line number note in the first block. */
5335 for (insn
= BB_END (ENTRY_BLOCK_PTR
->next_bb
);
5336 insn
!= prologue_end
&& insn
;
5337 insn
= PREV_INSN (insn
))
5338 if (NOTE_P (insn
) && NOTE_LINE_NUMBER (insn
) > 0)
5341 /* If we didn't find one, make a copy of the first line number
5345 for (insn
= next_active_insn (prologue_end
);
5347 insn
= PREV_INSN (insn
))
5348 if (NOTE_P (insn
) && NOTE_LINE_NUMBER (insn
) > 0)
5350 emit_note_copy_after (insn
, prologue_end
);
5356 #ifdef HAVE_epilogue
5361 /* Similarly, move any line notes that appear after the epilogue.
5362 There is no need, however, to be quite so anal about the existence
5363 of such a note. Also move the NOTE_INSN_FUNCTION_END and (possibly)
5364 NOTE_INSN_FUNCTION_BEG notes, as those can be relevant for debug
5366 for (insn
= epilogue_end
; insn
; insn
= next
)
5368 next
= NEXT_INSN (insn
);
5370 && (NOTE_LINE_NUMBER (insn
) > 0
5371 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_FUNCTION_BEG
5372 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_FUNCTION_END
))
5373 reorder_insns (insn
, insn
, PREV_INSN (epilogue_end
));
5379 /* Reposition the prologue-end and epilogue-begin notes after instruction
5380 scheduling and delayed branch scheduling. */
5383 reposition_prologue_and_epilogue_notes (rtx f ATTRIBUTE_UNUSED
)
5385 #if defined (HAVE_prologue) || defined (HAVE_epilogue)
5386 rtx insn
, last
, note
;
5389 if ((len
= VARRAY_SIZE (prologue
)) > 0)
5393 /* Scan from the beginning until we reach the last prologue insn.
5394 We apparently can't depend on basic_block_{head,end} after
5396 for (insn
= f
; insn
; insn
= NEXT_INSN (insn
))
5400 if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_PROLOGUE_END
)
5403 else if (contains (insn
, prologue
))
5413 /* Find the prologue-end note if we haven't already, and
5414 move it to just after the last prologue insn. */
5417 for (note
= last
; (note
= NEXT_INSN (note
));)
5419 && NOTE_LINE_NUMBER (note
) == NOTE_INSN_PROLOGUE_END
)
5423 /* Avoid placing note between CODE_LABEL and BASIC_BLOCK note. */
5425 last
= NEXT_INSN (last
);
5426 reorder_insns (note
, note
, last
);
5430 if ((len
= VARRAY_SIZE (epilogue
)) > 0)
5434 /* Scan from the end until we reach the first epilogue insn.
5435 We apparently can't depend on basic_block_{head,end} after
5437 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
5441 if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_EPILOGUE_BEG
)
5444 else if (contains (insn
, epilogue
))
5454 /* Find the epilogue-begin note if we haven't already, and
5455 move it to just before the first epilogue insn. */
5458 for (note
= insn
; (note
= PREV_INSN (note
));)
5460 && NOTE_LINE_NUMBER (note
) == NOTE_INSN_EPILOGUE_BEG
)
5464 if (PREV_INSN (last
) != note
)
5465 reorder_insns (note
, note
, PREV_INSN (last
));
5468 #endif /* HAVE_prologue or HAVE_epilogue */
5471 /* Called once, at initialization, to initialize function.c. */
5474 init_function_once (void)
5476 VARRAY_INT_INIT (prologue
, 0, "prologue");
5477 VARRAY_INT_INIT (epilogue
, 0, "epilogue");
5478 VARRAY_INT_INIT (sibcall_epilogue
, 0, "sibcall_epilogue");
5481 /* Resets insn_block_boundaries array. */
5484 reset_block_changes (void)
5486 VARRAY_TREE_INIT (cfun
->ib_boundaries_block
, 100, "ib_boundaries_block");
5487 VARRAY_PUSH_TREE (cfun
->ib_boundaries_block
, NULL_TREE
);
5490 /* Record the boundary for BLOCK. */
5492 record_block_change (tree block
)
5500 last_block
= VARRAY_TOP_TREE (cfun
->ib_boundaries_block
);
5501 VARRAY_POP (cfun
->ib_boundaries_block
);
5503 for (i
= VARRAY_ACTIVE_SIZE (cfun
->ib_boundaries_block
); i
< n
; i
++)
5504 VARRAY_PUSH_TREE (cfun
->ib_boundaries_block
, last_block
);
5506 VARRAY_PUSH_TREE (cfun
->ib_boundaries_block
, block
);
5509 /* Finishes record of boundaries. */
5510 void finalize_block_changes (void)
5512 record_block_change (DECL_INITIAL (current_function_decl
));
5515 /* For INSN return the BLOCK it belongs to. */
5517 check_block_change (rtx insn
, tree
*block
)
5519 unsigned uid
= INSN_UID (insn
);
5521 if (uid
>= VARRAY_ACTIVE_SIZE (cfun
->ib_boundaries_block
))
5524 *block
= VARRAY_TREE (cfun
->ib_boundaries_block
, uid
);
5527 /* Releases the ib_boundaries_block records. */
5529 free_block_changes (void)
5531 cfun
->ib_boundaries_block
= NULL
;
5534 /* Returns the name of the current function. */
5536 current_function_name (void)
5538 return lang_hooks
.decl_printable_name (cfun
->decl
, 2);
5541 #include "gt-function.h"