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 /* Nonzero if function being compiled doesn't contain any calls
91 (ignoring the prologue and epilogue). This is set prior to
92 local register allocation and is valid for the remaining
94 int current_function_is_leaf
;
96 /* Nonzero if function being compiled doesn't modify the stack pointer
97 (ignoring the prologue and epilogue). This is only valid after
98 life_analysis has run. */
99 int current_function_sp_is_unchanging
;
101 /* Nonzero if the function being compiled is a leaf function which only
102 uses leaf registers. This is valid after reload (specifically after
103 sched2) and is useful only if the port defines LEAF_REGISTERS. */
104 int current_function_uses_only_leaf_regs
;
106 /* Nonzero once virtual register instantiation has been done.
107 assign_stack_local uses frame_pointer_rtx when this is nonzero.
108 calls.c:emit_library_call_value_1 uses it to set up
109 post-instantiation libcalls. */
110 int virtuals_instantiated
;
112 /* Assign unique numbers to labels generated for profiling, debugging, etc. */
113 static GTY(()) int funcdef_no
;
115 /* These variables hold pointers to functions to create and destroy
116 target specific, per-function data structures. */
117 struct machine_function
* (*init_machine_status
) (void);
119 /* The currently compiled function. */
120 struct function
*cfun
= 0;
122 /* These arrays record the INSN_UIDs of the prologue and epilogue insns. */
123 static GTY(()) varray_type prologue
;
124 static GTY(()) varray_type epilogue
;
126 /* Array of INSN_UIDs to hold the INSN_UIDs for each sibcall epilogue
128 static GTY(()) varray_type sibcall_epilogue
;
130 /* In order to evaluate some expressions, such as function calls returning
131 structures in memory, we need to temporarily allocate stack locations.
132 We record each allocated temporary in the following structure.
134 Associated with each temporary slot is a nesting level. When we pop up
135 one level, all temporaries associated with the previous level are freed.
136 Normally, all temporaries are freed after the execution of the statement
137 in which they were created. However, if we are inside a ({...}) grouping,
138 the result may be in a temporary and hence must be preserved. If the
139 result could be in a temporary, we preserve it if we can determine which
140 one it is in. If we cannot determine which temporary may contain the
141 result, all temporaries are preserved. A temporary is preserved by
142 pretending it was allocated at the previous nesting level.
144 Automatic variables are also assigned temporary slots, at the nesting
145 level where they are defined. They are marked a "kept" so that
146 free_temp_slots will not free them. */
148 struct temp_slot
GTY(())
150 /* Points to next temporary slot. */
151 struct temp_slot
*next
;
152 /* Points to previous temporary slot. */
153 struct temp_slot
*prev
;
155 /* The rtx to used to reference the slot. */
157 /* The rtx used to represent the address if not the address of the
158 slot above. May be an EXPR_LIST if multiple addresses exist. */
160 /* The alignment (in bits) of the slot. */
162 /* The size, in units, of the slot. */
164 /* The type of the object in the slot, or zero if it doesn't correspond
165 to a type. We use this to determine whether a slot can be reused.
166 It can be reused if objects of the type of the new slot will always
167 conflict with objects of the type of the old slot. */
169 /* Nonzero if this temporary is currently in use. */
171 /* Nonzero if this temporary has its address taken. */
173 /* Nesting level at which this slot is being used. */
175 /* Nonzero if this should survive a call to free_temp_slots. */
177 /* The offset of the slot from the frame_pointer, including extra space
178 for alignment. This info is for combine_temp_slots. */
179 HOST_WIDE_INT base_offset
;
180 /* The size of the slot, including extra space for alignment. This
181 info is for combine_temp_slots. */
182 HOST_WIDE_INT full_size
;
185 /* Forward declarations. */
187 static rtx
assign_stack_local_1 (enum machine_mode
, HOST_WIDE_INT
, int,
189 static struct temp_slot
*find_temp_slot_from_address (rtx
);
190 static void instantiate_decls (tree
, int);
191 static void instantiate_decls_1 (tree
, int);
192 static void instantiate_decl (rtx
, HOST_WIDE_INT
, int);
193 static rtx
instantiate_new_reg (rtx
, HOST_WIDE_INT
*);
194 static int instantiate_virtual_regs_1 (rtx
*, rtx
, int);
195 static void pad_to_arg_alignment (struct args_size
*, int, struct args_size
*);
196 static void pad_below (struct args_size
*, enum machine_mode
, tree
);
197 static void reorder_blocks_1 (rtx
, tree
, varray_type
*);
198 static void reorder_fix_fragments (tree
);
199 static int all_blocks (tree
, tree
*);
200 static tree
*get_block_vector (tree
, int *);
201 extern tree
debug_find_var_in_block_tree (tree
, tree
);
202 /* We always define `record_insns' even if it's not used so that we
203 can always export `prologue_epilogue_contains'. */
204 static void record_insns (rtx
, varray_type
*) ATTRIBUTE_UNUSED
;
205 static int contains (rtx
, varray_type
);
207 static void emit_return_into_block (basic_block
, rtx
);
209 #if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX)
210 static rtx
keep_stack_depressed (rtx
);
212 static void prepare_function_start (tree
);
213 static void do_clobber_return_reg (rtx
, void *);
214 static void do_use_return_reg (rtx
, void *);
215 static void instantiate_virtual_regs_lossage (rtx
);
216 static void set_insn_locators (rtx
, int) ATTRIBUTE_UNUSED
;
218 /* Pointer to chain of `struct function' for containing functions. */
219 struct function
*outer_function_chain
;
221 /* Given a function decl for a containing function,
222 return the `struct function' for it. */
225 find_function_data (tree decl
)
229 for (p
= outer_function_chain
; p
; p
= p
->outer
)
236 /* Save the current context for compilation of a nested function.
237 This is called from language-specific code. The caller should use
238 the enter_nested langhook to save any language-specific state,
239 since this function knows only about language-independent
243 push_function_context_to (tree context
)
249 if (context
== current_function_decl
)
250 cfun
->contains_functions
= 1;
253 struct function
*containing
= find_function_data (context
);
254 containing
->contains_functions
= 1;
259 init_dummy_function_start ();
262 p
->outer
= outer_function_chain
;
263 outer_function_chain
= p
;
265 lang_hooks
.function
.enter_nested (p
);
271 push_function_context (void)
273 push_function_context_to (current_function_decl
);
276 /* Restore the last saved context, at the end of a nested function.
277 This function is called from language-specific code. */
280 pop_function_context_from (tree context ATTRIBUTE_UNUSED
)
282 struct function
*p
= outer_function_chain
;
285 outer_function_chain
= p
->outer
;
287 current_function_decl
= p
->decl
;
290 lang_hooks
.function
.leave_nested (p
);
292 /* Reset variables that have known state during rtx generation. */
293 virtuals_instantiated
= 0;
294 generating_concat_p
= 1;
298 pop_function_context (void)
300 pop_function_context_from (current_function_decl
);
303 /* Clear out all parts of the state in F that can safely be discarded
304 after the function has been parsed, but not compiled, to let
305 garbage collection reclaim the memory. */
308 free_after_parsing (struct function
*f
)
310 /* f->expr->forced_labels is used by code generation. */
311 /* f->emit->regno_reg_rtx is used by code generation. */
312 /* f->varasm is used by code generation. */
313 /* f->eh->eh_return_stub_label is used by code generation. */
315 lang_hooks
.function
.final (f
);
318 /* Clear out all parts of the state in F that can safely be discarded
319 after the function has been compiled, to let garbage collection
320 reclaim the memory. */
323 free_after_compilation (struct function
*f
)
331 f
->x_avail_temp_slots
= NULL
;
332 f
->x_used_temp_slots
= NULL
;
333 f
->arg_offset_rtx
= NULL
;
334 f
->return_rtx
= NULL
;
335 f
->internal_arg_pointer
= NULL
;
336 f
->x_nonlocal_goto_handler_labels
= NULL
;
337 f
->x_return_label
= NULL
;
338 f
->x_naked_return_label
= NULL
;
339 f
->x_stack_slot_list
= NULL
;
340 f
->x_tail_recursion_reentry
= NULL
;
341 f
->x_arg_pointer_save_area
= NULL
;
342 f
->x_parm_birth_insn
= NULL
;
343 f
->original_arg_vector
= NULL
;
344 f
->original_decl_initial
= NULL
;
345 f
->epilogue_delay_list
= NULL
;
348 /* Allocate fixed slots in the stack frame of the current function. */
350 /* Return size needed for stack frame based on slots so far allocated in
352 This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY;
353 the caller may have to do that. */
356 get_func_frame_size (struct function
*f
)
358 #ifdef FRAME_GROWS_DOWNWARD
359 return -f
->x_frame_offset
;
361 return f
->x_frame_offset
;
365 /* Return size needed for stack frame based on slots so far allocated.
366 This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY;
367 the caller may have to do that. */
369 get_frame_size (void)
371 return get_func_frame_size (cfun
);
374 /* Allocate a stack slot of SIZE bytes and return a MEM rtx for it
375 with machine mode MODE.
377 ALIGN controls the amount of alignment for the address of the slot:
378 0 means according to MODE,
379 -1 means use BIGGEST_ALIGNMENT and round size to multiple of that,
380 -2 means use BITS_PER_UNIT,
381 positive specifies alignment boundary in bits.
383 We do not round to stack_boundary here.
385 FUNCTION specifies the function to allocate in. */
388 assign_stack_local_1 (enum machine_mode mode
, HOST_WIDE_INT size
, int align
,
389 struct function
*function
)
392 int bigend_correction
= 0;
393 unsigned int alignment
;
394 int frame_off
, frame_alignment
, frame_phase
;
401 alignment
= BIGGEST_ALIGNMENT
;
403 alignment
= GET_MODE_ALIGNMENT (mode
);
405 /* Allow the target to (possibly) increase the alignment of this
407 type
= lang_hooks
.types
.type_for_mode (mode
, 0);
409 alignment
= LOCAL_ALIGNMENT (type
, alignment
);
411 alignment
/= BITS_PER_UNIT
;
413 else if (align
== -1)
415 alignment
= BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
;
416 size
= CEIL_ROUND (size
, alignment
);
418 else if (align
== -2)
419 alignment
= 1; /* BITS_PER_UNIT / BITS_PER_UNIT */
421 alignment
= align
/ BITS_PER_UNIT
;
423 #ifdef FRAME_GROWS_DOWNWARD
424 function
->x_frame_offset
-= size
;
427 /* Ignore alignment we can't do with expected alignment of the boundary. */
428 if (alignment
* BITS_PER_UNIT
> PREFERRED_STACK_BOUNDARY
)
429 alignment
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
431 if (function
->stack_alignment_needed
< alignment
* BITS_PER_UNIT
)
432 function
->stack_alignment_needed
= alignment
* BITS_PER_UNIT
;
434 /* Calculate how many bytes the start of local variables is off from
436 frame_alignment
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
437 frame_off
= STARTING_FRAME_OFFSET
% frame_alignment
;
438 frame_phase
= frame_off
? frame_alignment
- frame_off
: 0;
440 /* Round the frame offset to the specified alignment. The default is
441 to always honor requests to align the stack but a port may choose to
442 do its own stack alignment by defining STACK_ALIGNMENT_NEEDED. */
443 if (STACK_ALIGNMENT_NEEDED
447 /* We must be careful here, since FRAME_OFFSET might be negative and
448 division with a negative dividend isn't as well defined as we might
449 like. So we instead assume that ALIGNMENT is a power of two and
450 use logical operations which are unambiguous. */
451 #ifdef FRAME_GROWS_DOWNWARD
452 function
->x_frame_offset
453 = (FLOOR_ROUND (function
->x_frame_offset
- frame_phase
,
454 (unsigned HOST_WIDE_INT
) alignment
)
457 function
->x_frame_offset
458 = (CEIL_ROUND (function
->x_frame_offset
- frame_phase
,
459 (unsigned HOST_WIDE_INT
) alignment
)
464 /* On a big-endian machine, if we are allocating more space than we will use,
465 use the least significant bytes of those that are allocated. */
466 if (BYTES_BIG_ENDIAN
&& mode
!= BLKmode
)
467 bigend_correction
= size
- GET_MODE_SIZE (mode
);
469 /* If we have already instantiated virtual registers, return the actual
470 address relative to the frame pointer. */
471 if (function
== cfun
&& virtuals_instantiated
)
472 addr
= plus_constant (frame_pointer_rtx
,
474 (frame_offset
+ bigend_correction
475 + STARTING_FRAME_OFFSET
, Pmode
));
477 addr
= plus_constant (virtual_stack_vars_rtx
,
479 (function
->x_frame_offset
+ bigend_correction
,
482 #ifndef FRAME_GROWS_DOWNWARD
483 function
->x_frame_offset
+= size
;
486 x
= gen_rtx_MEM (mode
, addr
);
488 function
->x_stack_slot_list
489 = gen_rtx_EXPR_LIST (VOIDmode
, x
, function
->x_stack_slot_list
);
494 /* Wrapper around assign_stack_local_1; assign a local stack slot for the
498 assign_stack_local (enum machine_mode mode
, HOST_WIDE_INT size
, int align
)
500 return assign_stack_local_1 (mode
, size
, align
, cfun
);
504 /* Removes temporary slot TEMP from LIST. */
507 cut_slot_from_list (struct temp_slot
*temp
, struct temp_slot
**list
)
510 temp
->next
->prev
= temp
->prev
;
512 temp
->prev
->next
= temp
->next
;
516 temp
->prev
= temp
->next
= NULL
;
519 /* Inserts temporary slot TEMP to LIST. */
522 insert_slot_to_list (struct temp_slot
*temp
, struct temp_slot
**list
)
526 (*list
)->prev
= temp
;
531 /* Returns the list of used temp slots at LEVEL. */
533 static struct temp_slot
**
534 temp_slots_at_level (int level
)
537 if (!used_temp_slots
)
538 VARRAY_GENERIC_PTR_INIT (used_temp_slots
, 3, "used_temp_slots");
540 while (level
>= (int) VARRAY_ACTIVE_SIZE (used_temp_slots
))
541 VARRAY_PUSH_GENERIC_PTR (used_temp_slots
, NULL
);
543 return (struct temp_slot
**) &VARRAY_GENERIC_PTR (used_temp_slots
, level
);
546 /* Returns the maximal temporary slot level. */
549 max_slot_level (void)
551 if (!used_temp_slots
)
554 return VARRAY_ACTIVE_SIZE (used_temp_slots
) - 1;
557 /* Moves temporary slot TEMP to LEVEL. */
560 move_slot_to_level (struct temp_slot
*temp
, int level
)
562 cut_slot_from_list (temp
, temp_slots_at_level (temp
->level
));
563 insert_slot_to_list (temp
, temp_slots_at_level (level
));
567 /* Make temporary slot TEMP available. */
570 make_slot_available (struct temp_slot
*temp
)
572 cut_slot_from_list (temp
, temp_slots_at_level (temp
->level
));
573 insert_slot_to_list (temp
, &avail_temp_slots
);
578 /* Allocate a temporary stack slot and record it for possible later
581 MODE is the machine mode to be given to the returned rtx.
583 SIZE is the size in units of the space required. We do no rounding here
584 since assign_stack_local will do any required rounding.
586 KEEP is 1 if this slot is to be retained after a call to
587 free_temp_slots. Automatic variables for a block are allocated
588 with this flag. KEEP values of 2 or 3 were needed respectively
589 for variables whose lifetime is controlled by CLEANUP_POINT_EXPRs
590 or for SAVE_EXPRs, but they are now unused and will abort.
592 TYPE is the type that will be used for the stack slot. */
595 assign_stack_temp_for_type (enum machine_mode mode
, HOST_WIDE_INT size
, int keep
,
599 struct temp_slot
*p
, *best_p
= 0, *selected
= NULL
, **pp
;
602 /* If SIZE is -1 it means that somebody tried to allocate a temporary
603 of a variable size. */
604 gcc_assert (size
!= -1);
606 /* These are now unused. */
607 gcc_assert (keep
<= 1);
610 align
= BIGGEST_ALIGNMENT
;
612 align
= GET_MODE_ALIGNMENT (mode
);
615 type
= lang_hooks
.types
.type_for_mode (mode
, 0);
618 align
= LOCAL_ALIGNMENT (type
, align
);
620 /* Try to find an available, already-allocated temporary of the proper
621 mode which meets the size and alignment requirements. Choose the
622 smallest one with the closest alignment. */
623 for (p
= avail_temp_slots
; p
; p
= p
->next
)
625 if (p
->align
>= align
&& p
->size
>= size
&& GET_MODE (p
->slot
) == mode
626 && objects_must_conflict_p (p
->type
, type
)
627 && (best_p
== 0 || best_p
->size
> p
->size
628 || (best_p
->size
== p
->size
&& best_p
->align
> p
->align
)))
630 if (p
->align
== align
&& p
->size
== size
)
633 cut_slot_from_list (selected
, &avail_temp_slots
);
641 /* Make our best, if any, the one to use. */
645 cut_slot_from_list (selected
, &avail_temp_slots
);
647 /* If there are enough aligned bytes left over, make them into a new
648 temp_slot so that the extra bytes don't get wasted. Do this only
649 for BLKmode slots, so that we can be sure of the alignment. */
650 if (GET_MODE (best_p
->slot
) == BLKmode
)
652 int alignment
= best_p
->align
/ BITS_PER_UNIT
;
653 HOST_WIDE_INT rounded_size
= CEIL_ROUND (size
, alignment
);
655 if (best_p
->size
- rounded_size
>= alignment
)
657 p
= ggc_alloc (sizeof (struct temp_slot
));
658 p
->in_use
= p
->addr_taken
= 0;
659 p
->size
= best_p
->size
- rounded_size
;
660 p
->base_offset
= best_p
->base_offset
+ rounded_size
;
661 p
->full_size
= best_p
->full_size
- rounded_size
;
662 p
->slot
= gen_rtx_MEM (BLKmode
,
663 plus_constant (XEXP (best_p
->slot
, 0),
665 p
->align
= best_p
->align
;
667 p
->type
= best_p
->type
;
668 insert_slot_to_list (p
, &avail_temp_slots
);
670 stack_slot_list
= gen_rtx_EXPR_LIST (VOIDmode
, p
->slot
,
673 best_p
->size
= rounded_size
;
674 best_p
->full_size
= rounded_size
;
679 /* If we still didn't find one, make a new temporary. */
682 HOST_WIDE_INT frame_offset_old
= frame_offset
;
684 p
= ggc_alloc (sizeof (struct temp_slot
));
686 /* We are passing an explicit alignment request to assign_stack_local.
687 One side effect of that is assign_stack_local will not round SIZE
688 to ensure the frame offset remains suitably aligned.
690 So for requests which depended on the rounding of SIZE, we go ahead
691 and round it now. We also make sure ALIGNMENT is at least
692 BIGGEST_ALIGNMENT. */
693 gcc_assert (mode
!= BLKmode
|| align
== BIGGEST_ALIGNMENT
);
694 p
->slot
= assign_stack_local (mode
,
696 ? CEIL_ROUND (size
, (int) align
/ BITS_PER_UNIT
)
702 /* The following slot size computation is necessary because we don't
703 know the actual size of the temporary slot until assign_stack_local
704 has performed all the frame alignment and size rounding for the
705 requested temporary. Note that extra space added for alignment
706 can be either above or below this stack slot depending on which
707 way the frame grows. We include the extra space if and only if it
708 is above this slot. */
709 #ifdef FRAME_GROWS_DOWNWARD
710 p
->size
= frame_offset_old
- frame_offset
;
715 /* Now define the fields used by combine_temp_slots. */
716 #ifdef FRAME_GROWS_DOWNWARD
717 p
->base_offset
= frame_offset
;
718 p
->full_size
= frame_offset_old
- frame_offset
;
720 p
->base_offset
= frame_offset_old
;
721 p
->full_size
= frame_offset
- frame_offset_old
;
732 p
->level
= temp_slot_level
;
735 pp
= temp_slots_at_level (p
->level
);
736 insert_slot_to_list (p
, pp
);
738 /* Create a new MEM rtx to avoid clobbering MEM flags of old slots. */
739 slot
= gen_rtx_MEM (mode
, XEXP (p
->slot
, 0));
740 stack_slot_list
= gen_rtx_EXPR_LIST (VOIDmode
, slot
, stack_slot_list
);
742 /* If we know the alias set for the memory that will be used, use
743 it. If there's no TYPE, then we don't know anything about the
744 alias set for the memory. */
745 set_mem_alias_set (slot
, type
? get_alias_set (type
) : 0);
746 set_mem_align (slot
, align
);
748 /* If a type is specified, set the relevant flags. */
751 MEM_VOLATILE_P (slot
) = TYPE_VOLATILE (type
);
752 MEM_SET_IN_STRUCT_P (slot
, AGGREGATE_TYPE_P (type
));
758 /* Allocate a temporary stack slot and record it for possible later
759 reuse. First three arguments are same as in preceding function. */
762 assign_stack_temp (enum machine_mode mode
, HOST_WIDE_INT size
, int keep
)
764 return assign_stack_temp_for_type (mode
, size
, keep
, NULL_TREE
);
767 /* Assign a temporary.
768 If TYPE_OR_DECL is a decl, then we are doing it on behalf of the decl
769 and so that should be used in error messages. In either case, we
770 allocate of the given type.
771 KEEP is as for assign_stack_temp.
772 MEMORY_REQUIRED is 1 if the result must be addressable stack memory;
773 it is 0 if a register is OK.
774 DONT_PROMOTE is 1 if we should not promote values in register
778 assign_temp (tree type_or_decl
, int keep
, int memory_required
,
779 int dont_promote ATTRIBUTE_UNUSED
)
782 enum machine_mode mode
;
787 if (DECL_P (type_or_decl
))
788 decl
= type_or_decl
, type
= TREE_TYPE (decl
);
790 decl
= NULL
, type
= type_or_decl
;
792 mode
= TYPE_MODE (type
);
794 unsignedp
= TYPE_UNSIGNED (type
);
797 if (mode
== BLKmode
|| memory_required
)
799 HOST_WIDE_INT size
= int_size_in_bytes (type
);
803 /* Zero sized arrays are GNU C extension. Set size to 1 to avoid
804 problems with allocating the stack space. */
808 /* Unfortunately, we don't yet know how to allocate variable-sized
809 temporaries. However, sometimes we have a fixed upper limit on
810 the size (which is stored in TYPE_ARRAY_MAX_SIZE) and can use that
811 instead. This is the case for Chill variable-sized strings. */
812 if (size
== -1 && TREE_CODE (type
) == ARRAY_TYPE
813 && TYPE_ARRAY_MAX_SIZE (type
) != NULL_TREE
814 && host_integerp (TYPE_ARRAY_MAX_SIZE (type
), 1))
815 size
= tree_low_cst (TYPE_ARRAY_MAX_SIZE (type
), 1);
817 /* If we still haven't been able to get a size, see if the language
818 can compute a maximum size. */
820 && (size_tree
= lang_hooks
.types
.max_size (type
)) != 0
821 && host_integerp (size_tree
, 1))
822 size
= tree_low_cst (size_tree
, 1);
824 /* The size of the temporary may be too large to fit into an integer. */
825 /* ??? Not sure this should happen except for user silliness, so limit
826 this to things that aren't compiler-generated temporaries. The
827 rest of the time we'll abort in assign_stack_temp_for_type. */
828 if (decl
&& size
== -1
829 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
)
831 error ("%Jsize of variable %qD is too large", decl
, decl
);
835 tmp
= assign_stack_temp_for_type (mode
, size
, keep
, type
);
841 mode
= promote_mode (type
, mode
, &unsignedp
, 0);
844 return gen_reg_rtx (mode
);
847 /* Combine temporary stack slots which are adjacent on the stack.
849 This allows for better use of already allocated stack space. This is only
850 done for BLKmode slots because we can be sure that we won't have alignment
851 problems in this case. */
854 combine_temp_slots (void)
856 struct temp_slot
*p
, *q
, *next
, *next_q
;
859 /* We can't combine slots, because the information about which slot
860 is in which alias set will be lost. */
861 if (flag_strict_aliasing
)
864 /* If there are a lot of temp slots, don't do anything unless
865 high levels of optimization. */
866 if (! flag_expensive_optimizations
)
867 for (p
= avail_temp_slots
, num_slots
= 0; p
; p
= p
->next
, num_slots
++)
868 if (num_slots
> 100 || (num_slots
> 10 && optimize
== 0))
871 for (p
= avail_temp_slots
; p
; p
= next
)
877 if (GET_MODE (p
->slot
) != BLKmode
)
880 for (q
= p
->next
; q
; q
= next_q
)
886 if (GET_MODE (q
->slot
) != BLKmode
)
889 if (p
->base_offset
+ p
->full_size
== q
->base_offset
)
891 /* Q comes after P; combine Q into P. */
893 p
->full_size
+= q
->full_size
;
896 else if (q
->base_offset
+ q
->full_size
== p
->base_offset
)
898 /* P comes after Q; combine P into Q. */
900 q
->full_size
+= p
->full_size
;
905 cut_slot_from_list (q
, &avail_temp_slots
);
908 /* Either delete P or advance past it. */
910 cut_slot_from_list (p
, &avail_temp_slots
);
914 /* Find the temp slot corresponding to the object at address X. */
916 static struct temp_slot
*
917 find_temp_slot_from_address (rtx x
)
923 for (i
= max_slot_level (); i
>= 0; i
--)
924 for (p
= *temp_slots_at_level (i
); p
; p
= p
->next
)
926 if (XEXP (p
->slot
, 0) == x
928 || (GET_CODE (x
) == PLUS
929 && XEXP (x
, 0) == virtual_stack_vars_rtx
930 && GET_CODE (XEXP (x
, 1)) == CONST_INT
931 && INTVAL (XEXP (x
, 1)) >= p
->base_offset
932 && INTVAL (XEXP (x
, 1)) < p
->base_offset
+ p
->full_size
))
935 else if (p
->address
!= 0 && GET_CODE (p
->address
) == EXPR_LIST
)
936 for (next
= p
->address
; next
; next
= XEXP (next
, 1))
937 if (XEXP (next
, 0) == x
)
941 /* If we have a sum involving a register, see if it points to a temp
943 if (GET_CODE (x
) == PLUS
&& REG_P (XEXP (x
, 0))
944 && (p
= find_temp_slot_from_address (XEXP (x
, 0))) != 0)
946 else if (GET_CODE (x
) == PLUS
&& REG_P (XEXP (x
, 1))
947 && (p
= find_temp_slot_from_address (XEXP (x
, 1))) != 0)
953 /* Indicate that NEW is an alternate way of referring to the temp slot
954 that previously was known by OLD. */
957 update_temp_slot_address (rtx old
, rtx
new)
961 if (rtx_equal_p (old
, new))
964 p
= find_temp_slot_from_address (old
);
966 /* If we didn't find one, see if both OLD is a PLUS. If so, and NEW
967 is a register, see if one operand of the PLUS is a temporary
968 location. If so, NEW points into it. Otherwise, if both OLD and
969 NEW are a PLUS and if there is a register in common between them.
970 If so, try a recursive call on those values. */
973 if (GET_CODE (old
) != PLUS
)
978 update_temp_slot_address (XEXP (old
, 0), new);
979 update_temp_slot_address (XEXP (old
, 1), new);
982 else if (GET_CODE (new) != PLUS
)
985 if (rtx_equal_p (XEXP (old
, 0), XEXP (new, 0)))
986 update_temp_slot_address (XEXP (old
, 1), XEXP (new, 1));
987 else if (rtx_equal_p (XEXP (old
, 1), XEXP (new, 0)))
988 update_temp_slot_address (XEXP (old
, 0), XEXP (new, 1));
989 else if (rtx_equal_p (XEXP (old
, 0), XEXP (new, 1)))
990 update_temp_slot_address (XEXP (old
, 1), XEXP (new, 0));
991 else if (rtx_equal_p (XEXP (old
, 1), XEXP (new, 1)))
992 update_temp_slot_address (XEXP (old
, 0), XEXP (new, 0));
997 /* Otherwise add an alias for the temp's address. */
998 else if (p
->address
== 0)
1002 if (GET_CODE (p
->address
) != EXPR_LIST
)
1003 p
->address
= gen_rtx_EXPR_LIST (VOIDmode
, p
->address
, NULL_RTX
);
1005 p
->address
= gen_rtx_EXPR_LIST (VOIDmode
, new, p
->address
);
1009 /* If X could be a reference to a temporary slot, mark the fact that its
1010 address was taken. */
1013 mark_temp_addr_taken (rtx x
)
1015 struct temp_slot
*p
;
1020 /* If X is not in memory or is at a constant address, it cannot be in
1021 a temporary slot. */
1022 if (!MEM_P (x
) || CONSTANT_P (XEXP (x
, 0)))
1025 p
= find_temp_slot_from_address (XEXP (x
, 0));
1030 /* If X could be a reference to a temporary slot, mark that slot as
1031 belonging to the to one level higher than the current level. If X
1032 matched one of our slots, just mark that one. Otherwise, we can't
1033 easily predict which it is, so upgrade all of them. Kept slots
1034 need not be touched.
1036 This is called when an ({...}) construct occurs and a statement
1037 returns a value in memory. */
1040 preserve_temp_slots (rtx x
)
1042 struct temp_slot
*p
= 0, *next
;
1044 /* If there is no result, we still might have some objects whose address
1045 were taken, so we need to make sure they stay around. */
1048 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1053 move_slot_to_level (p
, temp_slot_level
- 1);
1059 /* If X is a register that is being used as a pointer, see if we have
1060 a temporary slot we know it points to. To be consistent with
1061 the code below, we really should preserve all non-kept slots
1062 if we can't find a match, but that seems to be much too costly. */
1063 if (REG_P (x
) && REG_POINTER (x
))
1064 p
= find_temp_slot_from_address (x
);
1066 /* If X is not in memory or is at a constant address, it cannot be in
1067 a temporary slot, but it can contain something whose address was
1069 if (p
== 0 && (!MEM_P (x
) || CONSTANT_P (XEXP (x
, 0))))
1071 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1076 move_slot_to_level (p
, temp_slot_level
- 1);
1082 /* First see if we can find a match. */
1084 p
= find_temp_slot_from_address (XEXP (x
, 0));
1088 /* Move everything at our level whose address was taken to our new
1089 level in case we used its address. */
1090 struct temp_slot
*q
;
1092 if (p
->level
== temp_slot_level
)
1094 for (q
= *temp_slots_at_level (temp_slot_level
); q
; q
= next
)
1098 if (p
!= q
&& q
->addr_taken
)
1099 move_slot_to_level (q
, temp_slot_level
- 1);
1102 move_slot_to_level (p
, temp_slot_level
- 1);
1108 /* Otherwise, preserve all non-kept slots at this level. */
1109 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1114 move_slot_to_level (p
, temp_slot_level
- 1);
1118 /* Free all temporaries used so far. This is normally called at the
1119 end of generating code for a statement. */
1122 free_temp_slots (void)
1124 struct temp_slot
*p
, *next
;
1126 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1131 make_slot_available (p
);
1134 combine_temp_slots ();
1137 /* Push deeper into the nesting level for stack temporaries. */
1140 push_temp_slots (void)
1145 /* Pop a temporary nesting level. All slots in use in the current level
1149 pop_temp_slots (void)
1151 struct temp_slot
*p
, *next
;
1153 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1156 make_slot_available (p
);
1159 combine_temp_slots ();
1164 /* Initialize temporary slots. */
1167 init_temp_slots (void)
1169 /* We have not allocated any temporaries yet. */
1170 avail_temp_slots
= 0;
1171 used_temp_slots
= 0;
1172 temp_slot_level
= 0;
1175 /* These routines are responsible for converting virtual register references
1176 to the actual hard register references once RTL generation is complete.
1178 The following four variables are used for communication between the
1179 routines. They contain the offsets of the virtual registers from their
1180 respective hard registers. */
1182 static int in_arg_offset
;
1183 static int var_offset
;
1184 static int dynamic_offset
;
1185 static int out_arg_offset
;
1186 static int cfa_offset
;
1188 /* In most machines, the stack pointer register is equivalent to the bottom
1191 #ifndef STACK_POINTER_OFFSET
1192 #define STACK_POINTER_OFFSET 0
1195 /* If not defined, pick an appropriate default for the offset of dynamically
1196 allocated memory depending on the value of ACCUMULATE_OUTGOING_ARGS,
1197 REG_PARM_STACK_SPACE, and OUTGOING_REG_PARM_STACK_SPACE. */
1199 #ifndef STACK_DYNAMIC_OFFSET
1201 /* The bottom of the stack points to the actual arguments. If
1202 REG_PARM_STACK_SPACE is defined, this includes the space for the register
1203 parameters. However, if OUTGOING_REG_PARM_STACK space is not defined,
1204 stack space for register parameters is not pushed by the caller, but
1205 rather part of the fixed stack areas and hence not included in
1206 `current_function_outgoing_args_size'. Nevertheless, we must allow
1207 for it when allocating stack dynamic objects. */
1209 #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE)
1210 #define STACK_DYNAMIC_OFFSET(FNDECL) \
1211 ((ACCUMULATE_OUTGOING_ARGS \
1212 ? (current_function_outgoing_args_size + REG_PARM_STACK_SPACE (FNDECL)) : 0)\
1213 + (STACK_POINTER_OFFSET)) \
1216 #define STACK_DYNAMIC_OFFSET(FNDECL) \
1217 ((ACCUMULATE_OUTGOING_ARGS ? current_function_outgoing_args_size : 0) \
1218 + (STACK_POINTER_OFFSET))
1222 /* On most machines, the CFA coincides with the first incoming parm. */
1224 #ifndef ARG_POINTER_CFA_OFFSET
1225 #define ARG_POINTER_CFA_OFFSET(FNDECL) FIRST_PARM_OFFSET (FNDECL)
1229 /* Pass through the INSNS of function FNDECL and convert virtual register
1230 references to hard register references. */
1233 instantiate_virtual_regs (void)
1237 /* Compute the offsets to use for this function. */
1238 in_arg_offset
= FIRST_PARM_OFFSET (current_function_decl
);
1239 var_offset
= STARTING_FRAME_OFFSET
;
1240 dynamic_offset
= STACK_DYNAMIC_OFFSET (current_function_decl
);
1241 out_arg_offset
= STACK_POINTER_OFFSET
;
1242 cfa_offset
= ARG_POINTER_CFA_OFFSET (current_function_decl
);
1244 /* Scan all variables and parameters of this function. For each that is
1245 in memory, instantiate all virtual registers if the result is a valid
1246 address. If not, we do it later. That will handle most uses of virtual
1247 regs on many machines. */
1248 instantiate_decls (current_function_decl
, 1);
1250 /* Initialize recognition, indicating that volatile is OK. */
1253 /* Scan through all the insns, instantiating every virtual register still
1255 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1256 if (GET_CODE (insn
) == INSN
|| GET_CODE (insn
) == JUMP_INSN
1257 || GET_CODE (insn
) == CALL_INSN
)
1259 instantiate_virtual_regs_1 (&PATTERN (insn
), insn
, 1);
1260 if (INSN_DELETED_P (insn
))
1262 instantiate_virtual_regs_1 (®_NOTES (insn
), NULL_RTX
, 0);
1263 /* Instantiate any virtual registers in CALL_INSN_FUNCTION_USAGE. */
1264 if (GET_CODE (insn
) == CALL_INSN
)
1265 instantiate_virtual_regs_1 (&CALL_INSN_FUNCTION_USAGE (insn
),
1268 /* Past this point all ASM statements should match. Verify that
1269 to avoid failures later in the compilation process. */
1270 if (asm_noperands (PATTERN (insn
)) >= 0
1271 && ! check_asm_operands (PATTERN (insn
)))
1272 instantiate_virtual_regs_lossage (insn
);
1275 /* Now instantiate the remaining register equivalences for debugging info.
1276 These will not be valid addresses. */
1277 instantiate_decls (current_function_decl
, 0);
1279 /* Indicate that, from now on, assign_stack_local should use
1280 frame_pointer_rtx. */
1281 virtuals_instantiated
= 1;
1284 /* Scan all decls in FNDECL (both variables and parameters) and instantiate
1285 all virtual registers in their DECL_RTL's.
1287 If VALID_ONLY, do this only if the resulting address is still valid.
1288 Otherwise, always do it. */
1291 instantiate_decls (tree fndecl
, int valid_only
)
1295 /* Process all parameters of the function. */
1296 for (decl
= DECL_ARGUMENTS (fndecl
); decl
; decl
= TREE_CHAIN (decl
))
1298 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (decl
));
1299 HOST_WIDE_INT size_rtl
;
1301 instantiate_decl (DECL_RTL (decl
), size
, valid_only
);
1303 /* If the parameter was promoted, then the incoming RTL mode may be
1304 larger than the declared type size. We must use the larger of
1306 size_rtl
= GET_MODE_SIZE (GET_MODE (DECL_INCOMING_RTL (decl
)));
1307 size
= MAX (size_rtl
, size
);
1308 instantiate_decl (DECL_INCOMING_RTL (decl
), size
, valid_only
);
1311 /* Now process all variables defined in the function or its subblocks. */
1312 instantiate_decls_1 (DECL_INITIAL (fndecl
), valid_only
);
1315 /* Subroutine of instantiate_decls: Process all decls in the given
1316 BLOCK node and all its subblocks. */
1319 instantiate_decls_1 (tree let
, int valid_only
)
1323 for (t
= BLOCK_VARS (let
); t
; t
= TREE_CHAIN (t
))
1324 if (DECL_RTL_SET_P (t
))
1325 instantiate_decl (DECL_RTL (t
),
1326 int_size_in_bytes (TREE_TYPE (t
)),
1329 /* Process all subblocks. */
1330 for (t
= BLOCK_SUBBLOCKS (let
); t
; t
= TREE_CHAIN (t
))
1331 instantiate_decls_1 (t
, valid_only
);
1334 /* Subroutine of the preceding procedures: Given RTL representing a
1335 decl and the size of the object, do any instantiation required.
1337 If VALID_ONLY is nonzero, it means that the RTL should only be
1338 changed if the new address is valid. */
1341 instantiate_decl (rtx x
, HOST_WIDE_INT size
, int valid_only
)
1343 enum machine_mode mode
;
1349 /* If this is a CONCAT, recurse for the pieces. */
1350 if (GET_CODE (x
) == CONCAT
)
1352 instantiate_decl (XEXP (x
, 0), size
/ 2, valid_only
);
1353 instantiate_decl (XEXP (x
, 1), size
/ 2, valid_only
);
1357 /* If this is not a MEM, no need to do anything. Similarly if the
1358 address is a constant or a register that is not a virtual register. */
1363 if (CONSTANT_P (addr
)
1365 && (REGNO (addr
) < FIRST_VIRTUAL_REGISTER
1366 || REGNO (addr
) > LAST_VIRTUAL_REGISTER
)))
1369 /* If we should only do this if the address is valid, copy the address.
1370 We need to do this so we can undo any changes that might make the
1371 address invalid. This copy is unfortunate, but probably can't be
1375 addr
= copy_rtx (addr
);
1377 instantiate_virtual_regs_1 (&addr
, NULL_RTX
, 0);
1379 if (valid_only
&& size
>= 0)
1381 unsigned HOST_WIDE_INT decl_size
= size
;
1383 /* Now verify that the resulting address is valid for every integer or
1384 floating-point mode up to and including SIZE bytes long. We do this
1385 since the object might be accessed in any mode and frame addresses
1388 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
1389 mode
!= VOIDmode
&& GET_MODE_SIZE (mode
) <= decl_size
;
1390 mode
= GET_MODE_WIDER_MODE (mode
))
1391 if (! memory_address_p (mode
, addr
))
1394 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_FLOAT
);
1395 mode
!= VOIDmode
&& GET_MODE_SIZE (mode
) <= decl_size
;
1396 mode
= GET_MODE_WIDER_MODE (mode
))
1397 if (! memory_address_p (mode
, addr
))
1401 /* Put back the address now that we have updated it and we either know
1402 it is valid or we don't care whether it is valid. */
1407 /* Given a piece of RTX and a pointer to a HOST_WIDE_INT, if the RTX
1408 is a virtual register, return the equivalent hard register and set the
1409 offset indirectly through the pointer. Otherwise, return 0. */
1412 instantiate_new_reg (rtx x
, HOST_WIDE_INT
*poffset
)
1415 HOST_WIDE_INT offset
;
1417 if (x
== virtual_incoming_args_rtx
)
1418 new = arg_pointer_rtx
, offset
= in_arg_offset
;
1419 else if (x
== virtual_stack_vars_rtx
)
1420 new = frame_pointer_rtx
, offset
= var_offset
;
1421 else if (x
== virtual_stack_dynamic_rtx
)
1422 new = stack_pointer_rtx
, offset
= dynamic_offset
;
1423 else if (x
== virtual_outgoing_args_rtx
)
1424 new = stack_pointer_rtx
, offset
= out_arg_offset
;
1425 else if (x
== virtual_cfa_rtx
)
1426 new = arg_pointer_rtx
, offset
= cfa_offset
;
1435 /* Called when instantiate_virtual_regs has failed to update the instruction.
1436 Usually this means that non-matching instruction has been emit, however for
1437 asm statements it may be the problem in the constraints. */
1439 instantiate_virtual_regs_lossage (rtx insn
)
1441 gcc_assert (asm_noperands (PATTERN (insn
)) >= 0);
1442 error_for_asm (insn
, "impossible constraint in %<asm%>");
1445 /* Given a pointer to a piece of rtx and an optional pointer to the
1446 containing object, instantiate any virtual registers present in it.
1448 If EXTRA_INSNS, we always do the replacement and generate
1449 any extra insns before OBJECT. If it zero, we do nothing if replacement
1452 Return 1 if we either had nothing to do or if we were able to do the
1453 needed replacement. Return 0 otherwise; we only return zero if
1454 EXTRA_INSNS is zero.
1456 We first try some simple transformations to avoid the creation of extra
1460 instantiate_virtual_regs_1 (rtx
*loc
, rtx object
, int extra_insns
)
1465 HOST_WIDE_INT offset
= 0;
1471 /* Re-start here to avoid recursion in common cases. */
1478 /* We may have detected and deleted invalid asm statements. */
1479 if (object
&& INSN_P (object
) && INSN_DELETED_P (object
))
1482 code
= GET_CODE (x
);
1484 /* Check for some special cases. */
1502 /* We are allowed to set the virtual registers. This means that
1503 the actual register should receive the source minus the
1504 appropriate offset. This is used, for example, in the handling
1505 of non-local gotos. */
1506 if ((new = instantiate_new_reg (SET_DEST (x
), &offset
)) != 0)
1508 rtx src
= SET_SRC (x
);
1510 /* We are setting the register, not using it, so the relevant
1511 offset is the negative of the offset to use were we using
1514 instantiate_virtual_regs_1 (&src
, NULL_RTX
, 0);
1516 /* The only valid sources here are PLUS or REG. Just do
1517 the simplest possible thing to handle them. */
1518 if (!REG_P (src
) && GET_CODE (src
) != PLUS
)
1520 instantiate_virtual_regs_lossage (object
);
1526 temp
= force_operand (src
, NULL_RTX
);
1529 temp
= force_operand (plus_constant (temp
, offset
), NULL_RTX
);
1533 emit_insn_before (seq
, object
);
1536 if (! validate_change (object
, &SET_SRC (x
), temp
, 0)
1538 instantiate_virtual_regs_lossage (object
);
1543 instantiate_virtual_regs_1 (&SET_DEST (x
), object
, extra_insns
);
1548 /* Handle special case of virtual register plus constant. */
1549 if (CONSTANT_P (XEXP (x
, 1)))
1551 rtx old
, new_offset
;
1553 /* Check for (plus (plus VIRT foo) (const_int)) first. */
1554 if (GET_CODE (XEXP (x
, 0)) == PLUS
)
1556 if ((new = instantiate_new_reg (XEXP (XEXP (x
, 0), 0), &offset
)))
1558 instantiate_virtual_regs_1 (&XEXP (XEXP (x
, 0), 1), object
,
1560 new = gen_rtx_PLUS (Pmode
, new, XEXP (XEXP (x
, 0), 1));
1569 #ifdef POINTERS_EXTEND_UNSIGNED
1570 /* If we have (plus (subreg (virtual-reg)) (const_int)), we know
1571 we can commute the PLUS and SUBREG because pointers into the
1572 frame are well-behaved. */
1573 else if (GET_CODE (XEXP (x
, 0)) == SUBREG
&& GET_MODE (x
) == ptr_mode
1574 && GET_CODE (XEXP (x
, 1)) == CONST_INT
1576 = instantiate_new_reg (SUBREG_REG (XEXP (x
, 0)),
1578 && validate_change (object
, loc
,
1579 plus_constant (gen_lowpart (ptr_mode
,
1582 + INTVAL (XEXP (x
, 1))),
1586 else if ((new = instantiate_new_reg (XEXP (x
, 0), &offset
)) == 0)
1588 /* We know the second operand is a constant. Unless the
1589 first operand is a REG (which has been already checked),
1590 it needs to be checked. */
1591 if (!REG_P (XEXP (x
, 0)))
1599 new_offset
= plus_constant (XEXP (x
, 1), offset
);
1601 /* If the new constant is zero, try to replace the sum with just
1603 if (new_offset
== const0_rtx
1604 && validate_change (object
, loc
, new, 0))
1607 /* Next try to replace the register and new offset.
1608 There are two changes to validate here and we can't assume that
1609 in the case of old offset equals new just changing the register
1610 will yield a valid insn. In the interests of a little efficiency,
1611 however, we only call validate change once (we don't queue up the
1612 changes and then call apply_change_group). */
1616 ? ! validate_change (object
, &XEXP (x
, 0), new, 0)
1617 : (XEXP (x
, 0) = new,
1618 ! validate_change (object
, &XEXP (x
, 1), new_offset
, 0)))
1626 /* Otherwise copy the new constant into a register and replace
1627 constant with that register. */
1628 temp
= gen_reg_rtx (Pmode
);
1630 if (validate_change (object
, &XEXP (x
, 1), temp
, 0))
1631 emit_insn_before (gen_move_insn (temp
, new_offset
), object
);
1634 /* If that didn't work, replace this expression with a
1635 register containing the sum. */
1638 new = gen_rtx_PLUS (Pmode
, new, new_offset
);
1641 temp
= force_operand (new, NULL_RTX
);
1645 emit_insn_before (seq
, object
);
1646 if (! validate_change (object
, loc
, temp
, 0)
1647 && ! validate_replace_rtx (x
, temp
, object
))
1649 instantiate_virtual_regs_lossage (object
);
1658 /* Fall through to generic two-operand expression case. */
1664 case DIV
: case UDIV
:
1665 case MOD
: case UMOD
:
1666 case AND
: case IOR
: case XOR
:
1667 case ROTATERT
: case ROTATE
:
1668 case ASHIFTRT
: case LSHIFTRT
: case ASHIFT
:
1670 case GE
: case GT
: case GEU
: case GTU
:
1671 case LE
: case LT
: case LEU
: case LTU
:
1672 if (XEXP (x
, 1) && ! CONSTANT_P (XEXP (x
, 1)))
1673 instantiate_virtual_regs_1 (&XEXP (x
, 1), object
, extra_insns
);
1678 /* Most cases of MEM that convert to valid addresses have already been
1679 handled by our scan of decls. The only special handling we
1680 need here is to make a copy of the rtx to ensure it isn't being
1681 shared if we have to change it to a pseudo.
1683 If the rtx is a simple reference to an address via a virtual register,
1684 it can potentially be shared. In such cases, first try to make it
1685 a valid address, which can also be shared. Otherwise, copy it and
1688 First check for common cases that need no processing. These are
1689 usually due to instantiation already being done on a previous instance
1693 if (CONSTANT_ADDRESS_P (temp
)
1694 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1695 || temp
== arg_pointer_rtx
1697 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
1698 || temp
== hard_frame_pointer_rtx
1700 || temp
== frame_pointer_rtx
)
1703 if (GET_CODE (temp
) == PLUS
1704 && CONSTANT_ADDRESS_P (XEXP (temp
, 1))
1705 && (XEXP (temp
, 0) == frame_pointer_rtx
1706 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
1707 || XEXP (temp
, 0) == hard_frame_pointer_rtx
1709 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1710 || XEXP (temp
, 0) == arg_pointer_rtx
1715 if (temp
== virtual_stack_vars_rtx
1716 || temp
== virtual_incoming_args_rtx
1717 || (GET_CODE (temp
) == PLUS
1718 && CONSTANT_ADDRESS_P (XEXP (temp
, 1))
1719 && (XEXP (temp
, 0) == virtual_stack_vars_rtx
1720 || XEXP (temp
, 0) == virtual_incoming_args_rtx
)))
1722 /* This MEM may be shared. If the substitution can be done without
1723 the need to generate new pseudos, we want to do it in place
1724 so all copies of the shared rtx benefit. The call below will
1725 only make substitutions if the resulting address is still
1728 Note that we cannot pass X as the object in the recursive call
1729 since the insn being processed may not allow all valid
1730 addresses. However, if we were not passed on object, we can
1731 only modify X without copying it if X will have a valid
1734 ??? Also note that this can still lose if OBJECT is an insn that
1735 has less restrictions on an address that some other insn.
1736 In that case, we will modify the shared address. This case
1737 doesn't seem very likely, though. One case where this could
1738 happen is in the case of a USE or CLOBBER reference, but we
1739 take care of that below. */
1741 if (instantiate_virtual_regs_1 (&XEXP (x
, 0),
1742 object
? object
: x
, 0))
1745 /* Otherwise make a copy and process that copy. We copy the entire
1746 RTL expression since it might be a PLUS which could also be
1748 *loc
= x
= copy_rtx (x
);
1751 /* Fall through to generic unary operation case. */
1754 case STRICT_LOW_PART
:
1756 case PRE_DEC
: case PRE_INC
: case POST_DEC
: case POST_INC
:
1757 case SIGN_EXTEND
: case ZERO_EXTEND
:
1758 case TRUNCATE
: case FLOAT_EXTEND
: case FLOAT_TRUNCATE
:
1759 case FLOAT
: case FIX
:
1760 case UNSIGNED_FIX
: case UNSIGNED_FLOAT
:
1765 case POPCOUNT
: case PARITY
:
1766 /* These case either have just one operand or we know that we need not
1767 check the rest of the operands. */
1773 /* If the operand is a MEM, see if the change is a valid MEM. If not,
1774 go ahead and make the invalid one, but do it to a copy. For a REG,
1775 just make the recursive call, since there's no chance of a problem. */
1777 if ((MEM_P (XEXP (x
, 0))
1778 && instantiate_virtual_regs_1 (&XEXP (XEXP (x
, 0), 0), XEXP (x
, 0),
1780 || (REG_P (XEXP (x
, 0))
1781 && instantiate_virtual_regs_1 (&XEXP (x
, 0), object
, 0)))
1784 XEXP (x
, 0) = copy_rtx (XEXP (x
, 0));
1789 /* Try to replace with a PLUS. If that doesn't work, compute the sum
1790 in front of this insn and substitute the temporary. */
1791 if ((new = instantiate_new_reg (x
, &offset
)) != 0)
1793 temp
= plus_constant (new, offset
);
1794 if (!validate_change (object
, loc
, temp
, 0))
1800 temp
= force_operand (temp
, NULL_RTX
);
1804 emit_insn_before (seq
, object
);
1805 if (! validate_change (object
, loc
, temp
, 0)
1806 && ! validate_replace_rtx (x
, temp
, object
))
1807 instantiate_virtual_regs_lossage (object
);
1817 /* Scan all subexpressions. */
1818 fmt
= GET_RTX_FORMAT (code
);
1819 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++, fmt
++)
1822 if (!instantiate_virtual_regs_1 (&XEXP (x
, i
), object
, extra_insns
))
1825 else if (*fmt
== 'E')
1826 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1827 if (! instantiate_virtual_regs_1 (&XVECEXP (x
, i
, j
), object
,
1834 /* Return 1 if EXP is an aggregate type (or a value with aggregate type).
1835 This means a type for which function calls must pass an address to the
1836 function or get an address back from the function.
1837 EXP may be a type node or an expression (whose type is tested). */
1840 aggregate_value_p (tree exp
, tree fntype
)
1842 int i
, regno
, nregs
;
1845 tree type
= (TYPE_P (exp
)) ? exp
: TREE_TYPE (exp
);
1848 switch (TREE_CODE (fntype
))
1851 fntype
= get_callee_fndecl (fntype
);
1852 fntype
= fntype
? TREE_TYPE (fntype
) : 0;
1855 fntype
= TREE_TYPE (fntype
);
1860 case IDENTIFIER_NODE
:
1864 /* We don't expect other rtl types here. */
1868 if (TREE_CODE (type
) == VOID_TYPE
)
1870 /* If the front end has decided that this needs to be passed by
1871 reference, do so. */
1872 if ((TREE_CODE (exp
) == PARM_DECL
|| TREE_CODE (exp
) == RESULT_DECL
)
1873 && DECL_BY_REFERENCE (exp
))
1875 if (targetm
.calls
.return_in_memory (type
, fntype
))
1877 /* Types that are TREE_ADDRESSABLE must be constructed in memory,
1878 and thus can't be returned in registers. */
1879 if (TREE_ADDRESSABLE (type
))
1881 if (flag_pcc_struct_return
&& AGGREGATE_TYPE_P (type
))
1883 /* Make sure we have suitable call-clobbered regs to return
1884 the value in; if not, we must return it in memory. */
1885 reg
= hard_function_value (type
, 0, 0);
1887 /* If we have something other than a REG (e.g. a PARALLEL), then assume
1892 regno
= REGNO (reg
);
1893 nregs
= hard_regno_nregs
[regno
][TYPE_MODE (type
)];
1894 for (i
= 0; i
< nregs
; i
++)
1895 if (! call_used_regs
[regno
+ i
])
1900 /* Return true if we should assign DECL a pseudo register; false if it
1901 should live on the local stack. */
1904 use_register_for_decl (tree decl
)
1906 /* Honor volatile. */
1907 if (TREE_SIDE_EFFECTS (decl
))
1910 /* Honor addressability. */
1911 if (TREE_ADDRESSABLE (decl
))
1914 /* Only register-like things go in registers. */
1915 if (DECL_MODE (decl
) == BLKmode
)
1918 /* If -ffloat-store specified, don't put explicit float variables
1920 /* ??? This should be checked after DECL_ARTIFICIAL, but tree-ssa
1921 propagates values across these stores, and it probably shouldn't. */
1922 if (flag_float_store
&& FLOAT_TYPE_P (TREE_TYPE (decl
)))
1925 /* Compiler-generated temporaries can always go in registers. */
1926 if (DECL_ARTIFICIAL (decl
))
1929 return (optimize
|| DECL_REGISTER (decl
));
1932 /* Return true if TYPE should be passed by invisible reference. */
1935 pass_by_reference (CUMULATIVE_ARGS
*ca
, enum machine_mode mode
,
1936 tree type
, bool named_arg
)
1940 /* If this type contains non-trivial constructors, then it is
1941 forbidden for the middle-end to create any new copies. */
1942 if (TREE_ADDRESSABLE (type
))
1945 /* GCC post 3.4 passes *all* variable sized types by reference. */
1946 if (!TYPE_SIZE (type
) || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1950 return targetm
.calls
.pass_by_reference (ca
, mode
, type
, named_arg
);
1953 /* Return true if TYPE, which is passed by reference, should be callee
1954 copied instead of caller copied. */
1957 reference_callee_copied (CUMULATIVE_ARGS
*ca
, enum machine_mode mode
,
1958 tree type
, bool named_arg
)
1960 if (type
&& TREE_ADDRESSABLE (type
))
1962 return targetm
.calls
.callee_copies (ca
, mode
, type
, named_arg
);
1965 /* Structures to communicate between the subroutines of assign_parms.
1966 The first holds data persistent across all parameters, the second
1967 is cleared out for each parameter. */
1969 struct assign_parm_data_all
1971 CUMULATIVE_ARGS args_so_far
;
1972 struct args_size stack_args_size
;
1973 tree function_result_decl
;
1975 rtx conversion_insns
;
1976 HOST_WIDE_INT pretend_args_size
;
1977 HOST_WIDE_INT extra_pretend_bytes
;
1978 int reg_parm_stack_space
;
1981 struct assign_parm_data_one
1987 enum machine_mode nominal_mode
;
1988 enum machine_mode passed_mode
;
1989 enum machine_mode promoted_mode
;
1990 struct locate_and_pad_arg_data locate
;
1992 BOOL_BITFIELD named_arg
: 1;
1993 BOOL_BITFIELD last_named
: 1;
1994 BOOL_BITFIELD passed_pointer
: 1;
1995 BOOL_BITFIELD on_stack
: 1;
1996 BOOL_BITFIELD loaded_in_reg
: 1;
1999 /* A subroutine of assign_parms. Initialize ALL. */
2002 assign_parms_initialize_all (struct assign_parm_data_all
*all
)
2006 memset (all
, 0, sizeof (*all
));
2008 fntype
= TREE_TYPE (current_function_decl
);
2010 #ifdef INIT_CUMULATIVE_INCOMING_ARGS
2011 INIT_CUMULATIVE_INCOMING_ARGS (all
->args_so_far
, fntype
, NULL_RTX
);
2013 INIT_CUMULATIVE_ARGS (all
->args_so_far
, fntype
, NULL_RTX
,
2014 current_function_decl
, -1);
2017 #ifdef REG_PARM_STACK_SPACE
2018 all
->reg_parm_stack_space
= REG_PARM_STACK_SPACE (current_function_decl
);
2022 /* If ARGS contains entries with complex types, split the entry into two
2023 entries of the component type. Return a new list of substitutions are
2024 needed, else the old list. */
2027 split_complex_args (tree args
)
2031 /* Before allocating memory, check for the common case of no complex. */
2032 for (p
= args
; p
; p
= TREE_CHAIN (p
))
2034 tree type
= TREE_TYPE (p
);
2035 if (TREE_CODE (type
) == COMPLEX_TYPE
2036 && targetm
.calls
.split_complex_arg (type
))
2042 args
= copy_list (args
);
2044 for (p
= args
; p
; p
= TREE_CHAIN (p
))
2046 tree type
= TREE_TYPE (p
);
2047 if (TREE_CODE (type
) == COMPLEX_TYPE
2048 && targetm
.calls
.split_complex_arg (type
))
2051 tree subtype
= TREE_TYPE (type
);
2053 /* Rewrite the PARM_DECL's type with its component. */
2054 TREE_TYPE (p
) = subtype
;
2055 DECL_ARG_TYPE (p
) = TREE_TYPE (DECL_ARG_TYPE (p
));
2056 DECL_MODE (p
) = VOIDmode
;
2057 DECL_SIZE (p
) = NULL
;
2058 DECL_SIZE_UNIT (p
) = NULL
;
2061 /* Build a second synthetic decl. */
2062 decl
= build_decl (PARM_DECL
, NULL_TREE
, subtype
);
2063 DECL_ARG_TYPE (decl
) = DECL_ARG_TYPE (p
);
2064 layout_decl (decl
, 0);
2066 /* Splice it in; skip the new decl. */
2067 TREE_CHAIN (decl
) = TREE_CHAIN (p
);
2068 TREE_CHAIN (p
) = decl
;
2076 /* A subroutine of assign_parms. Adjust the parameter list to incorporate
2077 the hidden struct return argument, and (abi willing) complex args.
2078 Return the new parameter list. */
2081 assign_parms_augmented_arg_list (struct assign_parm_data_all
*all
)
2083 tree fndecl
= current_function_decl
;
2084 tree fntype
= TREE_TYPE (fndecl
);
2085 tree fnargs
= DECL_ARGUMENTS (fndecl
);
2087 /* If struct value address is treated as the first argument, make it so. */
2088 if (aggregate_value_p (DECL_RESULT (fndecl
), fndecl
)
2089 && ! current_function_returns_pcc_struct
2090 && targetm
.calls
.struct_value_rtx (TREE_TYPE (fndecl
), 1) == 0)
2092 tree type
= build_pointer_type (TREE_TYPE (fntype
));
2095 decl
= build_decl (PARM_DECL
, NULL_TREE
, type
);
2096 DECL_ARG_TYPE (decl
) = type
;
2097 DECL_ARTIFICIAL (decl
) = 1;
2099 TREE_CHAIN (decl
) = fnargs
;
2101 all
->function_result_decl
= decl
;
2104 all
->orig_fnargs
= fnargs
;
2106 /* If the target wants to split complex arguments into scalars, do so. */
2107 if (targetm
.calls
.split_complex_arg
)
2108 fnargs
= split_complex_args (fnargs
);
2113 /* A subroutine of assign_parms. Examine PARM and pull out type and mode
2114 data for the parameter. Incorporate ABI specifics such as pass-by-
2115 reference and type promotion. */
2118 assign_parm_find_data_types (struct assign_parm_data_all
*all
, tree parm
,
2119 struct assign_parm_data_one
*data
)
2121 tree nominal_type
, passed_type
;
2122 enum machine_mode nominal_mode
, passed_mode
, promoted_mode
;
2124 memset (data
, 0, sizeof (*data
));
2126 /* Set LAST_NAMED if this is last named arg before last anonymous args. */
2127 if (current_function_stdarg
)
2130 for (tem
= TREE_CHAIN (parm
); tem
; tem
= TREE_CHAIN (tem
))
2131 if (DECL_NAME (tem
))
2134 data
->last_named
= true;
2137 /* Set NAMED_ARG if this arg should be treated as a named arg. For
2138 most machines, if this is a varargs/stdarg function, then we treat
2139 the last named arg as if it were anonymous too. */
2140 if (targetm
.calls
.strict_argument_naming (&all
->args_so_far
))
2141 data
->named_arg
= 1;
2143 data
->named_arg
= !data
->last_named
;
2145 nominal_type
= TREE_TYPE (parm
);
2146 passed_type
= DECL_ARG_TYPE (parm
);
2148 /* Look out for errors propagating this far. Also, if the parameter's
2149 type is void then its value doesn't matter. */
2150 if (TREE_TYPE (parm
) == error_mark_node
2151 /* This can happen after weird syntax errors
2152 or if an enum type is defined among the parms. */
2153 || TREE_CODE (parm
) != PARM_DECL
2154 || passed_type
== NULL
2155 || VOID_TYPE_P (nominal_type
))
2157 nominal_type
= passed_type
= void_type_node
;
2158 nominal_mode
= passed_mode
= promoted_mode
= VOIDmode
;
2162 /* Find mode of arg as it is passed, and mode of arg as it should be
2163 during execution of this function. */
2164 passed_mode
= TYPE_MODE (passed_type
);
2165 nominal_mode
= TYPE_MODE (nominal_type
);
2167 /* If the parm is to be passed as a transparent union, use the type of
2168 the first field for the tests below. We have already verified that
2169 the modes are the same. */
2170 if (DECL_TRANSPARENT_UNION (parm
)
2171 || (TREE_CODE (passed_type
) == UNION_TYPE
2172 && TYPE_TRANSPARENT_UNION (passed_type
)))
2173 passed_type
= TREE_TYPE (TYPE_FIELDS (passed_type
));
2175 /* See if this arg was passed by invisible reference. */
2176 if (pass_by_reference (&all
->args_so_far
, passed_mode
,
2177 passed_type
, data
->named_arg
))
2179 passed_type
= nominal_type
= build_pointer_type (passed_type
);
2180 data
->passed_pointer
= true;
2181 passed_mode
= nominal_mode
= Pmode
;
2184 /* Find mode as it is passed by the ABI. */
2185 promoted_mode
= passed_mode
;
2186 if (targetm
.calls
.promote_function_args (TREE_TYPE (current_function_decl
)))
2188 int unsignedp
= TYPE_UNSIGNED (passed_type
);
2189 promoted_mode
= promote_mode (passed_type
, promoted_mode
,
2194 data
->nominal_type
= nominal_type
;
2195 data
->passed_type
= passed_type
;
2196 data
->nominal_mode
= nominal_mode
;
2197 data
->passed_mode
= passed_mode
;
2198 data
->promoted_mode
= promoted_mode
;
2201 /* A subroutine of assign_parms. Invoke setup_incoming_varargs. */
2204 assign_parms_setup_varargs (struct assign_parm_data_all
*all
,
2205 struct assign_parm_data_one
*data
, bool no_rtl
)
2207 int varargs_pretend_bytes
= 0;
2209 targetm
.calls
.setup_incoming_varargs (&all
->args_so_far
,
2210 data
->promoted_mode
,
2212 &varargs_pretend_bytes
, no_rtl
);
2214 /* If the back-end has requested extra stack space, record how much is
2215 needed. Do not change pretend_args_size otherwise since it may be
2216 nonzero from an earlier partial argument. */
2217 if (varargs_pretend_bytes
> 0)
2218 all
->pretend_args_size
= varargs_pretend_bytes
;
2221 /* A subroutine of assign_parms. Set DATA->ENTRY_PARM corresponding to
2222 the incoming location of the current parameter. */
2225 assign_parm_find_entry_rtl (struct assign_parm_data_all
*all
,
2226 struct assign_parm_data_one
*data
)
2228 HOST_WIDE_INT pretend_bytes
= 0;
2232 if (data
->promoted_mode
== VOIDmode
)
2234 data
->entry_parm
= data
->stack_parm
= const0_rtx
;
2238 #ifdef FUNCTION_INCOMING_ARG
2239 entry_parm
= FUNCTION_INCOMING_ARG (all
->args_so_far
, data
->promoted_mode
,
2240 data
->passed_type
, data
->named_arg
);
2242 entry_parm
= FUNCTION_ARG (all
->args_so_far
, data
->promoted_mode
,
2243 data
->passed_type
, data
->named_arg
);
2246 if (entry_parm
== 0)
2247 data
->promoted_mode
= data
->passed_mode
;
2249 /* Determine parm's home in the stack, in case it arrives in the stack
2250 or we should pretend it did. Compute the stack position and rtx where
2251 the argument arrives and its size.
2253 There is one complexity here: If this was a parameter that would
2254 have been passed in registers, but wasn't only because it is
2255 __builtin_va_alist, we want locate_and_pad_parm to treat it as if
2256 it came in a register so that REG_PARM_STACK_SPACE isn't skipped.
2257 In this case, we call FUNCTION_ARG with NAMED set to 1 instead of 0
2258 as it was the previous time. */
2259 in_regs
= entry_parm
!= 0;
2260 #ifdef STACK_PARMS_IN_REG_PARM_AREA
2263 if (!in_regs
&& !data
->named_arg
)
2265 if (targetm
.calls
.pretend_outgoing_varargs_named (&all
->args_so_far
))
2268 #ifdef FUNCTION_INCOMING_ARG
2269 tem
= FUNCTION_INCOMING_ARG (all
->args_so_far
, data
->promoted_mode
,
2270 data
->passed_type
, true);
2272 tem
= FUNCTION_ARG (all
->args_so_far
, data
->promoted_mode
,
2273 data
->passed_type
, true);
2275 in_regs
= tem
!= NULL
;
2279 /* If this parameter was passed both in registers and in the stack, use
2280 the copy on the stack. */
2281 if (targetm
.calls
.must_pass_in_stack (data
->promoted_mode
,
2289 partial
= FUNCTION_ARG_PARTIAL_NREGS (all
->args_so_far
,
2290 data
->promoted_mode
,
2293 data
->partial
= partial
;
2295 /* The caller might already have allocated stack space for the
2296 register parameters. */
2297 if (partial
!= 0 && all
->reg_parm_stack_space
== 0)
2299 /* Part of this argument is passed in registers and part
2300 is passed on the stack. Ask the prologue code to extend
2301 the stack part so that we can recreate the full value.
2303 PRETEND_BYTES is the size of the registers we need to store.
2304 CURRENT_FUNCTION_PRETEND_ARGS_SIZE is the amount of extra
2305 stack space that the prologue should allocate.
2307 Internally, gcc assumes that the argument pointer is aligned
2308 to STACK_BOUNDARY bits. This is used both for alignment
2309 optimizations (see init_emit) and to locate arguments that are
2310 aligned to more than PARM_BOUNDARY bits. We must preserve this
2311 invariant by rounding CURRENT_FUNCTION_PRETEND_ARGS_SIZE up to
2312 a stack boundary. */
2314 /* We assume at most one partial arg, and it must be the first
2315 argument on the stack. */
2316 gcc_assert (!all
->extra_pretend_bytes
&& !all
->pretend_args_size
);
2318 pretend_bytes
= partial
* UNITS_PER_WORD
;
2319 all
->pretend_args_size
= CEIL_ROUND (pretend_bytes
, STACK_BYTES
);
2321 /* We want to align relative to the actual stack pointer, so
2322 don't include this in the stack size until later. */
2323 all
->extra_pretend_bytes
= all
->pretend_args_size
;
2327 locate_and_pad_parm (data
->promoted_mode
, data
->passed_type
, in_regs
,
2328 entry_parm
? data
->partial
: 0, current_function_decl
,
2329 &all
->stack_args_size
, &data
->locate
);
2331 /* Adjust offsets to include the pretend args. */
2332 pretend_bytes
= all
->extra_pretend_bytes
- pretend_bytes
;
2333 data
->locate
.slot_offset
.constant
+= pretend_bytes
;
2334 data
->locate
.offset
.constant
+= pretend_bytes
;
2336 data
->entry_parm
= entry_parm
;
2339 /* A subroutine of assign_parms. If there is actually space on the stack
2340 for this parm, count it in stack_args_size and return true. */
2343 assign_parm_is_stack_parm (struct assign_parm_data_all
*all
,
2344 struct assign_parm_data_one
*data
)
2346 /* Trivially true if we've no incoming register. */
2347 if (data
->entry_parm
== NULL
)
2349 /* Also true if we're partially in registers and partially not,
2350 since we've arranged to drop the entire argument on the stack. */
2351 else if (data
->partial
!= 0)
2353 /* Also true if the target says that it's passed in both registers
2354 and on the stack. */
2355 else if (GET_CODE (data
->entry_parm
) == PARALLEL
2356 && XEXP (XVECEXP (data
->entry_parm
, 0, 0), 0) == NULL_RTX
)
2358 /* Also true if the target says that there's stack allocated for
2359 all register parameters. */
2360 else if (all
->reg_parm_stack_space
> 0)
2362 /* Otherwise, no, this parameter has no ABI defined stack slot. */
2366 all
->stack_args_size
.constant
+= data
->locate
.size
.constant
;
2367 if (data
->locate
.size
.var
)
2368 ADD_PARM_SIZE (all
->stack_args_size
, data
->locate
.size
.var
);
2373 /* A subroutine of assign_parms. Given that this parameter is allocated
2374 stack space by the ABI, find it. */
2377 assign_parm_find_stack_rtl (tree parm
, struct assign_parm_data_one
*data
)
2379 rtx offset_rtx
, stack_parm
;
2380 unsigned int align
, boundary
;
2382 /* If we're passing this arg using a reg, make its stack home the
2383 aligned stack slot. */
2384 if (data
->entry_parm
)
2385 offset_rtx
= ARGS_SIZE_RTX (data
->locate
.slot_offset
);
2387 offset_rtx
= ARGS_SIZE_RTX (data
->locate
.offset
);
2389 stack_parm
= current_function_internal_arg_pointer
;
2390 if (offset_rtx
!= const0_rtx
)
2391 stack_parm
= gen_rtx_PLUS (Pmode
, stack_parm
, offset_rtx
);
2392 stack_parm
= gen_rtx_MEM (data
->promoted_mode
, stack_parm
);
2394 set_mem_attributes (stack_parm
, parm
, 1);
2396 boundary
= FUNCTION_ARG_BOUNDARY (data
->promoted_mode
, data
->passed_type
);
2399 /* If we're padding upward, we know that the alignment of the slot
2400 is FUNCTION_ARG_BOUNDARY. If we're using slot_offset, we're
2401 intentionally forcing upward padding. Otherwise we have to come
2402 up with a guess at the alignment based on OFFSET_RTX. */
2403 if (data
->locate
.where_pad
== upward
|| data
->entry_parm
)
2405 else if (GET_CODE (offset_rtx
) == CONST_INT
)
2407 align
= INTVAL (offset_rtx
) * BITS_PER_UNIT
| boundary
;
2408 align
= align
& -align
;
2411 set_mem_align (stack_parm
, align
);
2413 if (data
->entry_parm
)
2414 set_reg_attrs_for_parm (data
->entry_parm
, stack_parm
);
2416 data
->stack_parm
= stack_parm
;
2419 /* A subroutine of assign_parms. Adjust DATA->ENTRY_RTL such that it's
2420 always valid and contiguous. */
2423 assign_parm_adjust_entry_rtl (struct assign_parm_data_one
*data
)
2425 rtx entry_parm
= data
->entry_parm
;
2426 rtx stack_parm
= data
->stack_parm
;
2428 /* If this parm was passed part in regs and part in memory, pretend it
2429 arrived entirely in memory by pushing the register-part onto the stack.
2430 In the special case of a DImode or DFmode that is split, we could put
2431 it together in a pseudoreg directly, but for now that's not worth
2433 if (data
->partial
!= 0)
2435 /* Handle calls that pass values in multiple non-contiguous
2436 locations. The Irix 6 ABI has examples of this. */
2437 if (GET_CODE (entry_parm
) == PARALLEL
)
2438 emit_group_store (validize_mem (stack_parm
), entry_parm
,
2440 int_size_in_bytes (data
->passed_type
));
2442 move_block_from_reg (REGNO (entry_parm
), validize_mem (stack_parm
),
2445 entry_parm
= stack_parm
;
2448 /* If we didn't decide this parm came in a register, by default it came
2450 else if (entry_parm
== NULL
)
2451 entry_parm
= stack_parm
;
2453 /* When an argument is passed in multiple locations, we can't make use
2454 of this information, but we can save some copying if the whole argument
2455 is passed in a single register. */
2456 else if (GET_CODE (entry_parm
) == PARALLEL
2457 && data
->nominal_mode
!= BLKmode
2458 && data
->passed_mode
!= BLKmode
)
2460 size_t i
, len
= XVECLEN (entry_parm
, 0);
2462 for (i
= 0; i
< len
; i
++)
2463 if (XEXP (XVECEXP (entry_parm
, 0, i
), 0) != NULL_RTX
2464 && REG_P (XEXP (XVECEXP (entry_parm
, 0, i
), 0))
2465 && (GET_MODE (XEXP (XVECEXP (entry_parm
, 0, i
), 0))
2466 == data
->passed_mode
)
2467 && INTVAL (XEXP (XVECEXP (entry_parm
, 0, i
), 1)) == 0)
2469 entry_parm
= XEXP (XVECEXP (entry_parm
, 0, i
), 0);
2474 data
->entry_parm
= entry_parm
;
2477 /* A subroutine of assign_parms. Adjust DATA->STACK_RTL such that it's
2478 always valid and properly aligned. */
2482 assign_parm_adjust_stack_rtl (struct assign_parm_data_one
*data
)
2484 rtx stack_parm
= data
->stack_parm
;
2486 /* If we can't trust the parm stack slot to be aligned enough for its
2487 ultimate type, don't use that slot after entry. We'll make another
2488 stack slot, if we need one. */
2489 if (STRICT_ALIGNMENT
&& stack_parm
2490 && GET_MODE_ALIGNMENT (data
->nominal_mode
) > MEM_ALIGN (stack_parm
))
2493 /* If parm was passed in memory, and we need to convert it on entry,
2494 don't store it back in that same slot. */
2495 else if (data
->entry_parm
== stack_parm
2496 && data
->nominal_mode
!= BLKmode
2497 && data
->nominal_mode
!= data
->passed_mode
)
2500 data
->stack_parm
= stack_parm
;
2503 /* A subroutine of assign_parms. Return true if the current parameter
2504 should be stored as a BLKmode in the current frame. */
2507 assign_parm_setup_block_p (struct assign_parm_data_one
*data
)
2509 if (data
->nominal_mode
== BLKmode
)
2511 if (GET_CODE (data
->entry_parm
) == PARALLEL
)
2514 #ifdef BLOCK_REG_PADDING
2515 /* Only assign_parm_setup_block knows how to deal with register arguments
2516 that are padded at the least significant end. */
2517 if (REG_P (data
->entry_parm
)
2518 && GET_MODE_SIZE (data
->promoted_mode
) < UNITS_PER_WORD
2519 && (BLOCK_REG_PADDING (data
->passed_mode
, data
->passed_type
, 1)
2520 == (BYTES_BIG_ENDIAN
? upward
: downward
)))
2527 /* A subroutine of assign_parms. Arrange for the parameter to be
2528 present and valid in DATA->STACK_RTL. */
2531 assign_parm_setup_block (struct assign_parm_data_all
*all
,
2532 tree parm
, struct assign_parm_data_one
*data
)
2534 rtx entry_parm
= data
->entry_parm
;
2535 rtx stack_parm
= data
->stack_parm
;
2537 if (GET_CODE (entry_parm
) == PARALLEL
)
2538 entry_parm
= emit_group_move_into_temps (entry_parm
);
2540 /* If we've a non-block object that's nevertheless passed in parts,
2541 reconstitute it in register operations rather than on the stack. */
2542 if (GET_CODE (entry_parm
) == PARALLEL
2543 && data
->nominal_mode
!= BLKmode
2544 && XVECLEN (entry_parm
, 0) > 1
2545 && use_register_for_decl (parm
))
2547 rtx parmreg
= gen_reg_rtx (data
->nominal_mode
);
2549 push_to_sequence (all
->conversion_insns
);
2551 /* For values returned in multiple registers, handle possible
2552 incompatible calls to emit_group_store.
2554 For example, the following would be invalid, and would have to
2555 be fixed by the conditional below:
2557 emit_group_store ((reg:SF), (parallel:DF))
2558 emit_group_store ((reg:SI), (parallel:DI))
2560 An example of this are doubles in e500 v2:
2561 (parallel:DF (expr_list (reg:SI) (const_int 0))
2562 (expr_list (reg:SI) (const_int 4))). */
2563 if (data
->nominal_mode
!= data
->passed_mode
)
2565 rtx t
= gen_reg_rtx (GET_MODE (entry_parm
));
2566 emit_group_store (t
, entry_parm
, NULL_TREE
,
2567 GET_MODE_SIZE (GET_MODE (entry_parm
)));
2568 convert_move (parmreg
, t
, 0);
2571 emit_group_store (parmreg
, entry_parm
, data
->nominal_type
,
2572 int_size_in_bytes (data
->nominal_type
));
2574 all
->conversion_insns
= get_insns ();
2577 SET_DECL_RTL (parm
, parmreg
);
2581 /* If a BLKmode arrives in registers, copy it to a stack slot. Handle
2582 calls that pass values in multiple non-contiguous locations. */
2583 if (REG_P (entry_parm
) || GET_CODE (entry_parm
) == PARALLEL
)
2585 HOST_WIDE_INT size
= int_size_in_bytes (data
->passed_type
);
2586 HOST_WIDE_INT size_stored
= CEIL_ROUND (size
, UNITS_PER_WORD
);
2589 /* Note that we will be storing an integral number of words.
2590 So we have to be careful to ensure that we allocate an
2591 integral number of words. We do this below in the
2592 assign_stack_local if space was not allocated in the argument
2593 list. If it was, this will not work if PARM_BOUNDARY is not
2594 a multiple of BITS_PER_WORD. It isn't clear how to fix this
2595 if it becomes a problem. Exception is when BLKmode arrives
2596 with arguments not conforming to word_mode. */
2598 if (stack_parm
== 0)
2600 stack_parm
= assign_stack_local (BLKmode
, size_stored
, 0);
2601 data
->stack_parm
= stack_parm
;
2602 PUT_MODE (stack_parm
, GET_MODE (entry_parm
));
2603 set_mem_attributes (stack_parm
, parm
, 1);
2605 else if (GET_CODE (entry_parm
) == PARALLEL
)
2608 gcc_assert (!size
|| !(PARM_BOUNDARY
% BITS_PER_WORD
));
2610 mem
= validize_mem (stack_parm
);
2612 /* Handle values in multiple non-contiguous locations. */
2613 if (GET_CODE (entry_parm
) == PARALLEL
)
2615 push_to_sequence (all
->conversion_insns
);
2616 emit_group_store (mem
, entry_parm
, data
->passed_type
, size
);
2617 all
->conversion_insns
= get_insns ();
2624 /* If SIZE is that of a mode no bigger than a word, just use
2625 that mode's store operation. */
2626 else if (size
<= UNITS_PER_WORD
)
2628 enum machine_mode mode
2629 = mode_for_size (size
* BITS_PER_UNIT
, MODE_INT
, 0);
2632 #ifdef BLOCK_REG_PADDING
2633 && (size
== UNITS_PER_WORD
2634 || (BLOCK_REG_PADDING (mode
, data
->passed_type
, 1)
2635 != (BYTES_BIG_ENDIAN
? upward
: downward
)))
2639 rtx reg
= gen_rtx_REG (mode
, REGNO (entry_parm
));
2640 emit_move_insn (change_address (mem
, mode
, 0), reg
);
2643 /* Blocks smaller than a word on a BYTES_BIG_ENDIAN
2644 machine must be aligned to the left before storing
2645 to memory. Note that the previous test doesn't
2646 handle all cases (e.g. SIZE == 3). */
2647 else if (size
!= UNITS_PER_WORD
2648 #ifdef BLOCK_REG_PADDING
2649 && (BLOCK_REG_PADDING (mode
, data
->passed_type
, 1)
2657 int by
= (UNITS_PER_WORD
- size
) * BITS_PER_UNIT
;
2658 rtx reg
= gen_rtx_REG (word_mode
, REGNO (entry_parm
));
2660 x
= expand_shift (LSHIFT_EXPR
, word_mode
, reg
,
2661 build_int_cst (NULL_TREE
, by
),
2663 tem
= change_address (mem
, word_mode
, 0);
2664 emit_move_insn (tem
, x
);
2667 move_block_from_reg (REGNO (entry_parm
), mem
,
2668 size_stored
/ UNITS_PER_WORD
);
2671 move_block_from_reg (REGNO (entry_parm
), mem
,
2672 size_stored
/ UNITS_PER_WORD
);
2675 SET_DECL_RTL (parm
, stack_parm
);
2678 /* A subroutine of assign_parms. Allocate a pseudo to hold the current
2679 parameter. Get it there. Perform all ABI specified conversions. */
2682 assign_parm_setup_reg (struct assign_parm_data_all
*all
, tree parm
,
2683 struct assign_parm_data_one
*data
)
2686 enum machine_mode promoted_nominal_mode
;
2687 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (parm
));
2688 bool did_conversion
= false;
2690 /* Store the parm in a pseudoregister during the function, but we may
2691 need to do it in a wider mode. */
2693 promoted_nominal_mode
2694 = promote_mode (data
->nominal_type
, data
->nominal_mode
, &unsignedp
, 0);
2696 parmreg
= gen_reg_rtx (promoted_nominal_mode
);
2698 if (!DECL_ARTIFICIAL (parm
))
2699 mark_user_reg (parmreg
);
2701 /* If this was an item that we received a pointer to,
2702 set DECL_RTL appropriately. */
2703 if (data
->passed_pointer
)
2705 rtx x
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data
->passed_type
)), parmreg
);
2706 set_mem_attributes (x
, parm
, 1);
2707 SET_DECL_RTL (parm
, x
);
2710 SET_DECL_RTL (parm
, parmreg
);
2712 /* Copy the value into the register. */
2713 if (data
->nominal_mode
!= data
->passed_mode
2714 || promoted_nominal_mode
!= data
->promoted_mode
)
2718 /* ENTRY_PARM has been converted to PROMOTED_MODE, its
2719 mode, by the caller. We now have to convert it to
2720 NOMINAL_MODE, if different. However, PARMREG may be in
2721 a different mode than NOMINAL_MODE if it is being stored
2724 If ENTRY_PARM is a hard register, it might be in a register
2725 not valid for operating in its mode (e.g., an odd-numbered
2726 register for a DFmode). In that case, moves are the only
2727 thing valid, so we can't do a convert from there. This
2728 occurs when the calling sequence allow such misaligned
2731 In addition, the conversion may involve a call, which could
2732 clobber parameters which haven't been copied to pseudo
2733 registers yet. Therefore, we must first copy the parm to
2734 a pseudo reg here, and save the conversion until after all
2735 parameters have been moved. */
2737 rtx tempreg
= gen_reg_rtx (GET_MODE (data
->entry_parm
));
2739 emit_move_insn (tempreg
, validize_mem (data
->entry_parm
));
2741 push_to_sequence (all
->conversion_insns
);
2742 tempreg
= convert_to_mode (data
->nominal_mode
, tempreg
, unsignedp
);
2744 if (GET_CODE (tempreg
) == SUBREG
2745 && GET_MODE (tempreg
) == data
->nominal_mode
2746 && REG_P (SUBREG_REG (tempreg
))
2747 && data
->nominal_mode
== data
->passed_mode
2748 && GET_MODE (SUBREG_REG (tempreg
)) == GET_MODE (data
->entry_parm
)
2749 && GET_MODE_SIZE (GET_MODE (tempreg
))
2750 < GET_MODE_SIZE (GET_MODE (data
->entry_parm
)))
2752 /* The argument is already sign/zero extended, so note it
2754 SUBREG_PROMOTED_VAR_P (tempreg
) = 1;
2755 SUBREG_PROMOTED_UNSIGNED_SET (tempreg
, unsignedp
);
2758 /* TREE_USED gets set erroneously during expand_assignment. */
2759 save_tree_used
= TREE_USED (parm
);
2760 expand_assignment (parm
, make_tree (data
->nominal_type
, tempreg
));
2761 TREE_USED (parm
) = save_tree_used
;
2762 all
->conversion_insns
= get_insns ();
2765 did_conversion
= true;
2768 emit_move_insn (parmreg
, validize_mem (data
->entry_parm
));
2770 /* If we were passed a pointer but the actual value can safely live
2771 in a register, put it in one. */
2772 if (data
->passed_pointer
2773 && TYPE_MODE (TREE_TYPE (parm
)) != BLKmode
2774 /* If by-reference argument was promoted, demote it. */
2775 && (TYPE_MODE (TREE_TYPE (parm
)) != GET_MODE (DECL_RTL (parm
))
2776 || use_register_for_decl (parm
)))
2778 /* We can't use nominal_mode, because it will have been set to
2779 Pmode above. We must use the actual mode of the parm. */
2780 parmreg
= gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm
)));
2781 mark_user_reg (parmreg
);
2783 if (GET_MODE (parmreg
) != GET_MODE (DECL_RTL (parm
)))
2785 rtx tempreg
= gen_reg_rtx (GET_MODE (DECL_RTL (parm
)));
2786 int unsigned_p
= TYPE_UNSIGNED (TREE_TYPE (parm
));
2788 push_to_sequence (all
->conversion_insns
);
2789 emit_move_insn (tempreg
, DECL_RTL (parm
));
2790 tempreg
= convert_to_mode (GET_MODE (parmreg
), tempreg
, unsigned_p
);
2791 emit_move_insn (parmreg
, tempreg
);
2792 all
->conversion_insns
= get_insns ();
2795 did_conversion
= true;
2798 emit_move_insn (parmreg
, DECL_RTL (parm
));
2800 SET_DECL_RTL (parm
, parmreg
);
2802 /* STACK_PARM is the pointer, not the parm, and PARMREG is
2804 data
->stack_parm
= NULL
;
2807 /* If we are passed an arg by reference and it is our responsibility
2808 to make a copy, do it now.
2809 PASSED_TYPE and PASSED mode now refer to the pointer, not the
2810 original argument, so we must recreate them in the call to
2811 FUNCTION_ARG_CALLEE_COPIES. */
2812 /* ??? Later add code to handle the case that if the argument isn't
2813 modified, don't do the copy. */
2815 else if (data
->passed_pointer
)
2817 tree type
= TREE_TYPE (data
->passed_type
);
2819 if (reference_callee_copied (&all
->args_so_far
, TYPE_MODE (type
),
2820 type
, data
->named_arg
))
2824 /* This sequence may involve a library call perhaps clobbering
2825 registers that haven't been copied to pseudos yet. */
2827 push_to_sequence (all
->conversion_insns
);
2829 if (!COMPLETE_TYPE_P (type
)
2830 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
2832 /* This is a variable sized object. */
2833 copy
= allocate_dynamic_stack_space (expr_size (parm
), NULL_RTX
,
2835 copy
= gen_rtx_MEM (BLKmode
, copy
);
2838 copy
= assign_stack_temp (TYPE_MODE (type
),
2839 int_size_in_bytes (type
), 1);
2840 set_mem_attributes (copy
, parm
, 1);
2842 store_expr (parm
, copy
, 0);
2843 emit_move_insn (parmreg
, XEXP (copy
, 0));
2844 all
->conversion_insns
= get_insns ();
2847 did_conversion
= true;
2851 /* Mark the register as eliminable if we did no conversion and it was
2852 copied from memory at a fixed offset, and the arg pointer was not
2853 copied to a pseudo-reg. If the arg pointer is a pseudo reg or the
2854 offset formed an invalid address, such memory-equivalences as we
2855 make here would screw up life analysis for it. */
2856 if (data
->nominal_mode
== data
->passed_mode
2858 && data
->stack_parm
!= 0
2859 && MEM_P (data
->stack_parm
)
2860 && data
->locate
.offset
.var
== 0
2861 && reg_mentioned_p (virtual_incoming_args_rtx
,
2862 XEXP (data
->stack_parm
, 0)))
2864 rtx linsn
= get_last_insn ();
2867 /* Mark complex types separately. */
2868 if (GET_CODE (parmreg
) == CONCAT
)
2870 enum machine_mode submode
2871 = GET_MODE_INNER (GET_MODE (parmreg
));
2872 int regnor
= REGNO (XEXP (parmreg
, 0));
2873 int regnoi
= REGNO (XEXP (parmreg
, 1));
2874 rtx stackr
= adjust_address_nv (data
->stack_parm
, submode
, 0);
2875 rtx stacki
= adjust_address_nv (data
->stack_parm
, submode
,
2876 GET_MODE_SIZE (submode
));
2878 /* Scan backwards for the set of the real and
2880 for (sinsn
= linsn
; sinsn
!= 0;
2881 sinsn
= prev_nonnote_insn (sinsn
))
2883 set
= single_set (sinsn
);
2887 if (SET_DEST (set
) == regno_reg_rtx
[regnoi
])
2889 = gen_rtx_EXPR_LIST (REG_EQUIV
, stacki
,
2891 else if (SET_DEST (set
) == regno_reg_rtx
[regnor
])
2893 = gen_rtx_EXPR_LIST (REG_EQUIV
, stackr
,
2897 else if ((set
= single_set (linsn
)) != 0
2898 && SET_DEST (set
) == parmreg
)
2900 = gen_rtx_EXPR_LIST (REG_EQUIV
,
2901 data
->stack_parm
, REG_NOTES (linsn
));
2904 /* For pointer data type, suggest pointer register. */
2905 if (POINTER_TYPE_P (TREE_TYPE (parm
)))
2906 mark_reg_pointer (parmreg
,
2907 TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm
))));
2910 /* A subroutine of assign_parms. Allocate stack space to hold the current
2911 parameter. Get it there. Perform all ABI specified conversions. */
2914 assign_parm_setup_stack (struct assign_parm_data_all
*all
, tree parm
,
2915 struct assign_parm_data_one
*data
)
2917 /* Value must be stored in the stack slot STACK_PARM during function
2920 if (data
->promoted_mode
!= data
->nominal_mode
)
2922 /* Conversion is required. */
2923 rtx tempreg
= gen_reg_rtx (GET_MODE (data
->entry_parm
));
2925 emit_move_insn (tempreg
, validize_mem (data
->entry_parm
));
2927 push_to_sequence (all
->conversion_insns
);
2928 data
->entry_parm
= convert_to_mode (data
->nominal_mode
, tempreg
,
2929 TYPE_UNSIGNED (TREE_TYPE (parm
)));
2931 if (data
->stack_parm
)
2932 /* ??? This may need a big-endian conversion on sparc64. */
2934 = adjust_address (data
->stack_parm
, data
->nominal_mode
, 0);
2936 all
->conversion_insns
= get_insns ();
2940 if (data
->entry_parm
!= data
->stack_parm
)
2942 if (data
->stack_parm
== 0)
2945 = assign_stack_local (GET_MODE (data
->entry_parm
),
2946 GET_MODE_SIZE (GET_MODE (data
->entry_parm
)),
2948 set_mem_attributes (data
->stack_parm
, parm
, 1);
2951 if (data
->promoted_mode
!= data
->nominal_mode
)
2953 push_to_sequence (all
->conversion_insns
);
2954 emit_move_insn (validize_mem (data
->stack_parm
),
2955 validize_mem (data
->entry_parm
));
2956 all
->conversion_insns
= get_insns ();
2960 emit_move_insn (validize_mem (data
->stack_parm
),
2961 validize_mem (data
->entry_parm
));
2964 SET_DECL_RTL (parm
, data
->stack_parm
);
2967 /* A subroutine of assign_parms. If the ABI splits complex arguments, then
2968 undo the frobbing that we did in assign_parms_augmented_arg_list. */
2971 assign_parms_unsplit_complex (tree orig_fnargs
, tree fnargs
)
2975 for (parm
= orig_fnargs
; parm
; parm
= TREE_CHAIN (parm
))
2977 if (TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
2978 && targetm
.calls
.split_complex_arg (TREE_TYPE (parm
)))
2980 rtx tmp
, real
, imag
;
2981 enum machine_mode inner
= GET_MODE_INNER (DECL_MODE (parm
));
2983 real
= DECL_RTL (fnargs
);
2984 imag
= DECL_RTL (TREE_CHAIN (fnargs
));
2985 if (inner
!= GET_MODE (real
))
2987 real
= gen_lowpart_SUBREG (inner
, real
);
2988 imag
= gen_lowpart_SUBREG (inner
, imag
);
2990 tmp
= gen_rtx_CONCAT (DECL_MODE (parm
), real
, imag
);
2991 SET_DECL_RTL (parm
, tmp
);
2993 real
= DECL_INCOMING_RTL (fnargs
);
2994 imag
= DECL_INCOMING_RTL (TREE_CHAIN (fnargs
));
2995 if (inner
!= GET_MODE (real
))
2997 real
= gen_lowpart_SUBREG (inner
, real
);
2998 imag
= gen_lowpart_SUBREG (inner
, imag
);
3000 tmp
= gen_rtx_CONCAT (DECL_MODE (parm
), real
, imag
);
3001 set_decl_incoming_rtl (parm
, tmp
);
3002 fnargs
= TREE_CHAIN (fnargs
);
3006 SET_DECL_RTL (parm
, DECL_RTL (fnargs
));
3007 set_decl_incoming_rtl (parm
, DECL_INCOMING_RTL (fnargs
));
3009 /* Set MEM_EXPR to the original decl, i.e. to PARM,
3010 instead of the copy of decl, i.e. FNARGS. */
3011 if (DECL_INCOMING_RTL (parm
) && MEM_P (DECL_INCOMING_RTL (parm
)))
3012 set_mem_expr (DECL_INCOMING_RTL (parm
), parm
);
3015 fnargs
= TREE_CHAIN (fnargs
);
3019 /* Assign RTL expressions to the function's parameters. This may involve
3020 copying them into registers and using those registers as the DECL_RTL. */
3023 assign_parms (tree fndecl
)
3025 struct assign_parm_data_all all
;
3027 rtx internal_arg_pointer
;
3028 int varargs_setup
= 0;
3030 /* If the reg that the virtual arg pointer will be translated into is
3031 not a fixed reg or is the stack pointer, make a copy of the virtual
3032 arg pointer, and address parms via the copy. The frame pointer is
3033 considered fixed even though it is not marked as such.
3035 The second time through, simply use ap to avoid generating rtx. */
3037 if ((ARG_POINTER_REGNUM
== STACK_POINTER_REGNUM
3038 || ! (fixed_regs
[ARG_POINTER_REGNUM
]
3039 || ARG_POINTER_REGNUM
== FRAME_POINTER_REGNUM
)))
3040 internal_arg_pointer
= copy_to_reg (virtual_incoming_args_rtx
);
3042 internal_arg_pointer
= virtual_incoming_args_rtx
;
3043 current_function_internal_arg_pointer
= internal_arg_pointer
;
3045 assign_parms_initialize_all (&all
);
3046 fnargs
= assign_parms_augmented_arg_list (&all
);
3048 for (parm
= fnargs
; parm
; parm
= TREE_CHAIN (parm
))
3050 struct assign_parm_data_one data
;
3052 /* Extract the type of PARM; adjust it according to ABI. */
3053 assign_parm_find_data_types (&all
, parm
, &data
);
3055 /* Early out for errors and void parameters. */
3056 if (data
.passed_mode
== VOIDmode
)
3058 SET_DECL_RTL (parm
, const0_rtx
);
3059 DECL_INCOMING_RTL (parm
) = DECL_RTL (parm
);
3063 /* Handle stdargs. LAST_NAMED is a slight mis-nomer; it's also true
3064 for the unnamed dummy argument following the last named argument.
3065 See ABI silliness wrt strict_argument_naming and NAMED_ARG. So
3066 we only want to do this when we get to the actual last named
3067 argument, which will be the first time LAST_NAMED gets set. */
3068 if (data
.last_named
&& !varargs_setup
)
3070 varargs_setup
= true;
3071 assign_parms_setup_varargs (&all
, &data
, false);
3074 /* Find out where the parameter arrives in this function. */
3075 assign_parm_find_entry_rtl (&all
, &data
);
3077 /* Find out where stack space for this parameter might be. */
3078 if (assign_parm_is_stack_parm (&all
, &data
))
3080 assign_parm_find_stack_rtl (parm
, &data
);
3081 assign_parm_adjust_entry_rtl (&data
);
3084 /* Record permanently how this parm was passed. */
3085 set_decl_incoming_rtl (parm
, data
.entry_parm
);
3087 /* Update info on where next arg arrives in registers. */
3088 FUNCTION_ARG_ADVANCE (all
.args_so_far
, data
.promoted_mode
,
3089 data
.passed_type
, data
.named_arg
);
3091 assign_parm_adjust_stack_rtl (&data
);
3093 if (assign_parm_setup_block_p (&data
))
3094 assign_parm_setup_block (&all
, parm
, &data
);
3095 else if (data
.passed_pointer
|| use_register_for_decl (parm
))
3096 assign_parm_setup_reg (&all
, parm
, &data
);
3098 assign_parm_setup_stack (&all
, parm
, &data
);
3101 if (targetm
.calls
.split_complex_arg
&& fnargs
!= all
.orig_fnargs
)
3102 assign_parms_unsplit_complex (all
.orig_fnargs
, fnargs
);
3104 /* Output all parameter conversion instructions (possibly including calls)
3105 now that all parameters have been copied out of hard registers. */
3106 emit_insn (all
.conversion_insns
);
3108 /* If we are receiving a struct value address as the first argument, set up
3109 the RTL for the function result. As this might require code to convert
3110 the transmitted address to Pmode, we do this here to ensure that possible
3111 preliminary conversions of the address have been emitted already. */
3112 if (all
.function_result_decl
)
3114 tree result
= DECL_RESULT (current_function_decl
);
3115 rtx addr
= DECL_RTL (all
.function_result_decl
);
3118 if (DECL_BY_REFERENCE (result
))
3122 addr
= convert_memory_address (Pmode
, addr
);
3123 x
= gen_rtx_MEM (DECL_MODE (result
), addr
);
3124 set_mem_attributes (x
, result
, 1);
3126 SET_DECL_RTL (result
, x
);
3129 /* We have aligned all the args, so add space for the pretend args. */
3130 current_function_pretend_args_size
= all
.pretend_args_size
;
3131 all
.stack_args_size
.constant
+= all
.extra_pretend_bytes
;
3132 current_function_args_size
= all
.stack_args_size
.constant
;
3134 /* Adjust function incoming argument size for alignment and
3137 #ifdef REG_PARM_STACK_SPACE
3138 current_function_args_size
= MAX (current_function_args_size
,
3139 REG_PARM_STACK_SPACE (fndecl
));
3142 current_function_args_size
3143 = ((current_function_args_size
+ STACK_BYTES
- 1)
3144 / STACK_BYTES
) * STACK_BYTES
;
3146 #ifdef ARGS_GROW_DOWNWARD
3147 current_function_arg_offset_rtx
3148 = (all
.stack_args_size
.var
== 0 ? GEN_INT (-all
.stack_args_size
.constant
)
3149 : expand_expr (size_diffop (all
.stack_args_size
.var
,
3150 size_int (-all
.stack_args_size
.constant
)),
3151 NULL_RTX
, VOIDmode
, 0));
3153 current_function_arg_offset_rtx
= ARGS_SIZE_RTX (all
.stack_args_size
);
3156 /* See how many bytes, if any, of its args a function should try to pop
3159 current_function_pops_args
= RETURN_POPS_ARGS (fndecl
, TREE_TYPE (fndecl
),
3160 current_function_args_size
);
3162 /* For stdarg.h function, save info about
3163 regs and stack space used by the named args. */
3165 current_function_args_info
= all
.args_so_far
;
3167 /* Set the rtx used for the function return value. Put this in its
3168 own variable so any optimizers that need this information don't have
3169 to include tree.h. Do this here so it gets done when an inlined
3170 function gets output. */
3172 current_function_return_rtx
3173 = (DECL_RTL_SET_P (DECL_RESULT (fndecl
))
3174 ? DECL_RTL (DECL_RESULT (fndecl
)) : NULL_RTX
);
3176 /* If scalar return value was computed in a pseudo-reg, or was a named
3177 return value that got dumped to the stack, copy that to the hard
3179 if (DECL_RTL_SET_P (DECL_RESULT (fndecl
)))
3181 tree decl_result
= DECL_RESULT (fndecl
);
3182 rtx decl_rtl
= DECL_RTL (decl_result
);
3184 if (REG_P (decl_rtl
)
3185 ? REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
3186 : DECL_REGISTER (decl_result
))
3190 #ifdef FUNCTION_OUTGOING_VALUE
3191 real_decl_rtl
= FUNCTION_OUTGOING_VALUE (TREE_TYPE (decl_result
),
3194 real_decl_rtl
= FUNCTION_VALUE (TREE_TYPE (decl_result
),
3197 REG_FUNCTION_VALUE_P (real_decl_rtl
) = 1;
3198 /* The delay slot scheduler assumes that current_function_return_rtx
3199 holds the hard register containing the return value, not a
3200 temporary pseudo. */
3201 current_function_return_rtx
= real_decl_rtl
;
3206 /* Indicate whether REGNO is an incoming argument to the current function
3207 that was promoted to a wider mode. If so, return the RTX for the
3208 register (to get its mode). PMODE and PUNSIGNEDP are set to the mode
3209 that REGNO is promoted from and whether the promotion was signed or
3213 promoted_input_arg (unsigned int regno
, enum machine_mode
*pmode
, int *punsignedp
)
3217 for (arg
= DECL_ARGUMENTS (current_function_decl
); arg
;
3218 arg
= TREE_CHAIN (arg
))
3219 if (REG_P (DECL_INCOMING_RTL (arg
))
3220 && REGNO (DECL_INCOMING_RTL (arg
)) == regno
3221 && TYPE_MODE (DECL_ARG_TYPE (arg
)) == TYPE_MODE (TREE_TYPE (arg
)))
3223 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (arg
));
3224 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (arg
));
3226 mode
= promote_mode (TREE_TYPE (arg
), mode
, &unsignedp
, 1);
3227 if (mode
== GET_MODE (DECL_INCOMING_RTL (arg
))
3228 && mode
!= DECL_MODE (arg
))
3230 *pmode
= DECL_MODE (arg
);
3231 *punsignedp
= unsignedp
;
3232 return DECL_INCOMING_RTL (arg
);
3240 /* Compute the size and offset from the start of the stacked arguments for a
3241 parm passed in mode PASSED_MODE and with type TYPE.
3243 INITIAL_OFFSET_PTR points to the current offset into the stacked
3246 The starting offset and size for this parm are returned in
3247 LOCATE->OFFSET and LOCATE->SIZE, respectively. When IN_REGS is
3248 nonzero, the offset is that of stack slot, which is returned in
3249 LOCATE->SLOT_OFFSET. LOCATE->ALIGNMENT_PAD is the amount of
3250 padding required from the initial offset ptr to the stack slot.
3252 IN_REGS is nonzero if the argument will be passed in registers. It will
3253 never be set if REG_PARM_STACK_SPACE is not defined.
3255 FNDECL is the function in which the argument was defined.
3257 There are two types of rounding that are done. The first, controlled by
3258 FUNCTION_ARG_BOUNDARY, forces the offset from the start of the argument
3259 list to be aligned to the specific boundary (in bits). This rounding
3260 affects the initial and starting offsets, but not the argument size.
3262 The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY,
3263 optionally rounds the size of the parm to PARM_BOUNDARY. The
3264 initial offset is not affected by this rounding, while the size always
3265 is and the starting offset may be. */
3267 /* LOCATE->OFFSET will be negative for ARGS_GROW_DOWNWARD case;
3268 INITIAL_OFFSET_PTR is positive because locate_and_pad_parm's
3269 callers pass in the total size of args so far as
3270 INITIAL_OFFSET_PTR. LOCATE->SIZE is always positive. */
3273 locate_and_pad_parm (enum machine_mode passed_mode
, tree type
, int in_regs
,
3274 int partial
, tree fndecl ATTRIBUTE_UNUSED
,
3275 struct args_size
*initial_offset_ptr
,
3276 struct locate_and_pad_arg_data
*locate
)
3279 enum direction where_pad
;
3281 int reg_parm_stack_space
= 0;
3282 int part_size_in_regs
;
3284 #ifdef REG_PARM_STACK_SPACE
3285 reg_parm_stack_space
= REG_PARM_STACK_SPACE (fndecl
);
3287 /* If we have found a stack parm before we reach the end of the
3288 area reserved for registers, skip that area. */
3291 if (reg_parm_stack_space
> 0)
3293 if (initial_offset_ptr
->var
)
3295 initial_offset_ptr
->var
3296 = size_binop (MAX_EXPR
, ARGS_SIZE_TREE (*initial_offset_ptr
),
3297 ssize_int (reg_parm_stack_space
));
3298 initial_offset_ptr
->constant
= 0;
3300 else if (initial_offset_ptr
->constant
< reg_parm_stack_space
)
3301 initial_offset_ptr
->constant
= reg_parm_stack_space
;
3304 #endif /* REG_PARM_STACK_SPACE */
3306 part_size_in_regs
= 0;
3307 if (reg_parm_stack_space
== 0)
3308 part_size_in_regs
= ((partial
* UNITS_PER_WORD
)
3309 / (PARM_BOUNDARY
/ BITS_PER_UNIT
)
3310 * (PARM_BOUNDARY
/ BITS_PER_UNIT
));
3313 = type
? size_in_bytes (type
) : size_int (GET_MODE_SIZE (passed_mode
));
3314 where_pad
= FUNCTION_ARG_PADDING (passed_mode
, type
);
3315 boundary
= FUNCTION_ARG_BOUNDARY (passed_mode
, type
);
3316 locate
->where_pad
= where_pad
;
3318 #ifdef ARGS_GROW_DOWNWARD
3319 locate
->slot_offset
.constant
= -initial_offset_ptr
->constant
;
3320 if (initial_offset_ptr
->var
)
3321 locate
->slot_offset
.var
= size_binop (MINUS_EXPR
, ssize_int (0),
3322 initial_offset_ptr
->var
);
3326 if (where_pad
!= none
3327 && (!host_integerp (sizetree
, 1)
3328 || (tree_low_cst (sizetree
, 1) * BITS_PER_UNIT
) % PARM_BOUNDARY
))
3329 s2
= round_up (s2
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
3330 SUB_PARM_SIZE (locate
->slot_offset
, s2
);
3333 locate
->slot_offset
.constant
+= part_size_in_regs
;
3336 #ifdef REG_PARM_STACK_SPACE
3337 || REG_PARM_STACK_SPACE (fndecl
) > 0
3340 pad_to_arg_alignment (&locate
->slot_offset
, boundary
,
3341 &locate
->alignment_pad
);
3343 locate
->size
.constant
= (-initial_offset_ptr
->constant
3344 - locate
->slot_offset
.constant
);
3345 if (initial_offset_ptr
->var
)
3346 locate
->size
.var
= size_binop (MINUS_EXPR
,
3347 size_binop (MINUS_EXPR
,
3349 initial_offset_ptr
->var
),
3350 locate
->slot_offset
.var
);
3352 /* Pad_below needs the pre-rounded size to know how much to pad
3354 locate
->offset
= locate
->slot_offset
;
3355 if (where_pad
== downward
)
3356 pad_below (&locate
->offset
, passed_mode
, sizetree
);
3358 #else /* !ARGS_GROW_DOWNWARD */
3360 #ifdef REG_PARM_STACK_SPACE
3361 || REG_PARM_STACK_SPACE (fndecl
) > 0
3364 pad_to_arg_alignment (initial_offset_ptr
, boundary
,
3365 &locate
->alignment_pad
);
3366 locate
->slot_offset
= *initial_offset_ptr
;
3368 #ifdef PUSH_ROUNDING
3369 if (passed_mode
!= BLKmode
)
3370 sizetree
= size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree
)));
3373 /* Pad_below needs the pre-rounded size to know how much to pad below
3374 so this must be done before rounding up. */
3375 locate
->offset
= locate
->slot_offset
;
3376 if (where_pad
== downward
)
3377 pad_below (&locate
->offset
, passed_mode
, sizetree
);
3379 if (where_pad
!= none
3380 && (!host_integerp (sizetree
, 1)
3381 || (tree_low_cst (sizetree
, 1) * BITS_PER_UNIT
) % PARM_BOUNDARY
))
3382 sizetree
= round_up (sizetree
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
3384 ADD_PARM_SIZE (locate
->size
, sizetree
);
3386 locate
->size
.constant
-= part_size_in_regs
;
3387 #endif /* ARGS_GROW_DOWNWARD */
3390 /* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY.
3391 BOUNDARY is measured in bits, but must be a multiple of a storage unit. */
3394 pad_to_arg_alignment (struct args_size
*offset_ptr
, int boundary
,
3395 struct args_size
*alignment_pad
)
3397 tree save_var
= NULL_TREE
;
3398 HOST_WIDE_INT save_constant
= 0;
3399 int boundary_in_bytes
= boundary
/ BITS_PER_UNIT
;
3400 HOST_WIDE_INT sp_offset
= STACK_POINTER_OFFSET
;
3402 #ifdef SPARC_STACK_BOUNDARY_HACK
3403 /* The sparc port has a bug. It sometimes claims a STACK_BOUNDARY
3404 higher than the real alignment of %sp. However, when it does this,
3405 the alignment of %sp+STACK_POINTER_OFFSET will be STACK_BOUNDARY.
3406 This is a temporary hack while the sparc port is fixed. */
3407 if (SPARC_STACK_BOUNDARY_HACK
)
3411 if (boundary
> PARM_BOUNDARY
&& boundary
> STACK_BOUNDARY
)
3413 save_var
= offset_ptr
->var
;
3414 save_constant
= offset_ptr
->constant
;
3417 alignment_pad
->var
= NULL_TREE
;
3418 alignment_pad
->constant
= 0;
3420 if (boundary
> BITS_PER_UNIT
)
3422 if (offset_ptr
->var
)
3424 tree sp_offset_tree
= ssize_int (sp_offset
);
3425 tree offset
= size_binop (PLUS_EXPR
,
3426 ARGS_SIZE_TREE (*offset_ptr
),
3428 #ifdef ARGS_GROW_DOWNWARD
3429 tree rounded
= round_down (offset
, boundary
/ BITS_PER_UNIT
);
3431 tree rounded
= round_up (offset
, boundary
/ BITS_PER_UNIT
);
3434 offset_ptr
->var
= size_binop (MINUS_EXPR
, rounded
, sp_offset_tree
);
3435 /* ARGS_SIZE_TREE includes constant term. */
3436 offset_ptr
->constant
= 0;
3437 if (boundary
> PARM_BOUNDARY
&& boundary
> STACK_BOUNDARY
)
3438 alignment_pad
->var
= size_binop (MINUS_EXPR
, offset_ptr
->var
,
3443 offset_ptr
->constant
= -sp_offset
+
3444 #ifdef ARGS_GROW_DOWNWARD
3445 FLOOR_ROUND (offset_ptr
->constant
+ sp_offset
, boundary_in_bytes
);
3447 CEIL_ROUND (offset_ptr
->constant
+ sp_offset
, boundary_in_bytes
);
3449 if (boundary
> PARM_BOUNDARY
&& boundary
> STACK_BOUNDARY
)
3450 alignment_pad
->constant
= offset_ptr
->constant
- save_constant
;
3456 pad_below (struct args_size
*offset_ptr
, enum machine_mode passed_mode
, tree sizetree
)
3458 if (passed_mode
!= BLKmode
)
3460 if (GET_MODE_BITSIZE (passed_mode
) % PARM_BOUNDARY
)
3461 offset_ptr
->constant
3462 += (((GET_MODE_BITSIZE (passed_mode
) + PARM_BOUNDARY
- 1)
3463 / PARM_BOUNDARY
* PARM_BOUNDARY
/ BITS_PER_UNIT
)
3464 - GET_MODE_SIZE (passed_mode
));
3468 if (TREE_CODE (sizetree
) != INTEGER_CST
3469 || (TREE_INT_CST_LOW (sizetree
) * BITS_PER_UNIT
) % PARM_BOUNDARY
)
3471 /* Round the size up to multiple of PARM_BOUNDARY bits. */
3472 tree s2
= round_up (sizetree
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
3474 ADD_PARM_SIZE (*offset_ptr
, s2
);
3475 SUB_PARM_SIZE (*offset_ptr
, sizetree
);
3480 /* Walk the tree of blocks describing the binding levels within a function
3481 and warn about variables the might be killed by setjmp or vfork.
3482 This is done after calling flow_analysis and before global_alloc
3483 clobbers the pseudo-regs to hard regs. */
3486 setjmp_vars_warning (tree block
)
3490 for (decl
= BLOCK_VARS (block
); decl
; decl
= TREE_CHAIN (decl
))
3492 if (TREE_CODE (decl
) == VAR_DECL
3493 && DECL_RTL_SET_P (decl
)
3494 && REG_P (DECL_RTL (decl
))
3495 && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl
))))
3496 warning ("%Jvariable %qD might be clobbered by %<longjmp%>"
3501 for (sub
= BLOCK_SUBBLOCKS (block
); sub
; sub
= TREE_CHAIN (sub
))
3502 setjmp_vars_warning (sub
);
3505 /* Do the appropriate part of setjmp_vars_warning
3506 but for arguments instead of local variables. */
3509 setjmp_args_warning (void)
3512 for (decl
= DECL_ARGUMENTS (current_function_decl
);
3513 decl
; decl
= TREE_CHAIN (decl
))
3514 if (DECL_RTL (decl
) != 0
3515 && REG_P (DECL_RTL (decl
))
3516 && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl
))))
3517 warning ("%Jargument %qD might be clobbered by %<longjmp%> or %<vfork%>",
3522 /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
3523 and create duplicate blocks. */
3524 /* ??? Need an option to either create block fragments or to create
3525 abstract origin duplicates of a source block. It really depends
3526 on what optimization has been performed. */
3529 reorder_blocks (void)
3531 tree block
= DECL_INITIAL (current_function_decl
);
3532 varray_type block_stack
;
3534 if (block
== NULL_TREE
)
3537 VARRAY_TREE_INIT (block_stack
, 10, "block_stack");
3539 /* Reset the TREE_ASM_WRITTEN bit for all blocks. */
3540 clear_block_marks (block
);
3542 /* Prune the old trees away, so that they don't get in the way. */
3543 BLOCK_SUBBLOCKS (block
) = NULL_TREE
;
3544 BLOCK_CHAIN (block
) = NULL_TREE
;
3546 /* Recreate the block tree from the note nesting. */
3547 reorder_blocks_1 (get_insns (), block
, &block_stack
);
3548 BLOCK_SUBBLOCKS (block
) = blocks_nreverse (BLOCK_SUBBLOCKS (block
));
3550 /* Remove deleted blocks from the block fragment chains. */
3551 reorder_fix_fragments (block
);
3554 /* Helper function for reorder_blocks. Reset TREE_ASM_WRITTEN. */
3557 clear_block_marks (tree block
)
3561 TREE_ASM_WRITTEN (block
) = 0;
3562 clear_block_marks (BLOCK_SUBBLOCKS (block
));
3563 block
= BLOCK_CHAIN (block
);
3568 reorder_blocks_1 (rtx insns
, tree current_block
, varray_type
*p_block_stack
)
3572 for (insn
= insns
; insn
; insn
= NEXT_INSN (insn
))
3576 if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_BEG
)
3578 tree block
= NOTE_BLOCK (insn
);
3580 /* If we have seen this block before, that means it now
3581 spans multiple address regions. Create a new fragment. */
3582 if (TREE_ASM_WRITTEN (block
))
3584 tree new_block
= copy_node (block
);
3587 origin
= (BLOCK_FRAGMENT_ORIGIN (block
)
3588 ? BLOCK_FRAGMENT_ORIGIN (block
)
3590 BLOCK_FRAGMENT_ORIGIN (new_block
) = origin
;
3591 BLOCK_FRAGMENT_CHAIN (new_block
)
3592 = BLOCK_FRAGMENT_CHAIN (origin
);
3593 BLOCK_FRAGMENT_CHAIN (origin
) = new_block
;
3595 NOTE_BLOCK (insn
) = new_block
;
3599 BLOCK_SUBBLOCKS (block
) = 0;
3600 TREE_ASM_WRITTEN (block
) = 1;
3601 /* When there's only one block for the entire function,
3602 current_block == block and we mustn't do this, it
3603 will cause infinite recursion. */
3604 if (block
!= current_block
)
3606 BLOCK_SUPERCONTEXT (block
) = current_block
;
3607 BLOCK_CHAIN (block
) = BLOCK_SUBBLOCKS (current_block
);
3608 BLOCK_SUBBLOCKS (current_block
) = block
;
3609 current_block
= block
;
3611 VARRAY_PUSH_TREE (*p_block_stack
, block
);
3613 else if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_END
)
3615 NOTE_BLOCK (insn
) = VARRAY_TOP_TREE (*p_block_stack
);
3616 VARRAY_POP (*p_block_stack
);
3617 BLOCK_SUBBLOCKS (current_block
)
3618 = blocks_nreverse (BLOCK_SUBBLOCKS (current_block
));
3619 current_block
= BLOCK_SUPERCONTEXT (current_block
);
3625 /* Rationalize BLOCK_FRAGMENT_ORIGIN. If an origin block no longer
3626 appears in the block tree, select one of the fragments to become
3627 the new origin block. */
3630 reorder_fix_fragments (tree block
)
3634 tree dup_origin
= BLOCK_FRAGMENT_ORIGIN (block
);
3635 tree new_origin
= NULL_TREE
;
3639 if (! TREE_ASM_WRITTEN (dup_origin
))
3641 new_origin
= BLOCK_FRAGMENT_CHAIN (dup_origin
);
3643 /* Find the first of the remaining fragments. There must
3644 be at least one -- the current block. */
3645 while (! TREE_ASM_WRITTEN (new_origin
))
3646 new_origin
= BLOCK_FRAGMENT_CHAIN (new_origin
);
3647 BLOCK_FRAGMENT_ORIGIN (new_origin
) = NULL_TREE
;
3650 else if (! dup_origin
)
3653 /* Re-root the rest of the fragments to the new origin. In the
3654 case that DUP_ORIGIN was null, that means BLOCK was the origin
3655 of a chain of fragments and we want to remove those fragments
3656 that didn't make it to the output. */
3659 tree
*pp
= &BLOCK_FRAGMENT_CHAIN (new_origin
);
3664 if (TREE_ASM_WRITTEN (chain
))
3666 BLOCK_FRAGMENT_ORIGIN (chain
) = new_origin
;
3668 pp
= &BLOCK_FRAGMENT_CHAIN (chain
);
3670 chain
= BLOCK_FRAGMENT_CHAIN (chain
);
3675 reorder_fix_fragments (BLOCK_SUBBLOCKS (block
));
3676 block
= BLOCK_CHAIN (block
);
3680 /* Reverse the order of elements in the chain T of blocks,
3681 and return the new head of the chain (old last element). */
3684 blocks_nreverse (tree t
)
3686 tree prev
= 0, decl
, next
;
3687 for (decl
= t
; decl
; decl
= next
)
3689 next
= BLOCK_CHAIN (decl
);
3690 BLOCK_CHAIN (decl
) = prev
;
3696 /* Count the subblocks of the list starting with BLOCK. If VECTOR is
3697 non-NULL, list them all into VECTOR, in a depth-first preorder
3698 traversal of the block tree. Also clear TREE_ASM_WRITTEN in all
3702 all_blocks (tree block
, tree
*vector
)
3708 TREE_ASM_WRITTEN (block
) = 0;
3710 /* Record this block. */
3712 vector
[n_blocks
] = block
;
3716 /* Record the subblocks, and their subblocks... */
3717 n_blocks
+= all_blocks (BLOCK_SUBBLOCKS (block
),
3718 vector
? vector
+ n_blocks
: 0);
3719 block
= BLOCK_CHAIN (block
);
3725 /* Return a vector containing all the blocks rooted at BLOCK. The
3726 number of elements in the vector is stored in N_BLOCKS_P. The
3727 vector is dynamically allocated; it is the caller's responsibility
3728 to call `free' on the pointer returned. */
3731 get_block_vector (tree block
, int *n_blocks_p
)
3735 *n_blocks_p
= all_blocks (block
, NULL
);
3736 block_vector
= xmalloc (*n_blocks_p
* sizeof (tree
));
3737 all_blocks (block
, block_vector
);
3739 return block_vector
;
3742 static GTY(()) int next_block_index
= 2;
3744 /* Set BLOCK_NUMBER for all the blocks in FN. */
3747 number_blocks (tree fn
)
3753 /* For SDB and XCOFF debugging output, we start numbering the blocks
3754 from 1 within each function, rather than keeping a running
3756 #if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
3757 if (write_symbols
== SDB_DEBUG
|| write_symbols
== XCOFF_DEBUG
)
3758 next_block_index
= 1;
3761 block_vector
= get_block_vector (DECL_INITIAL (fn
), &n_blocks
);
3763 /* The top-level BLOCK isn't numbered at all. */
3764 for (i
= 1; i
< n_blocks
; ++i
)
3765 /* We number the blocks from two. */
3766 BLOCK_NUMBER (block_vector
[i
]) = next_block_index
++;
3768 free (block_vector
);
3773 /* If VAR is present in a subblock of BLOCK, return the subblock. */
3776 debug_find_var_in_block_tree (tree var
, tree block
)
3780 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
3784 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= TREE_CHAIN (t
))
3786 tree ret
= debug_find_var_in_block_tree (var
, t
);
3794 /* Allocate a function structure for FNDECL and set its contents
3798 allocate_struct_function (tree fndecl
)
3801 tree fntype
= fndecl
? TREE_TYPE (fndecl
) : NULL_TREE
;
3803 cfun
= ggc_alloc_cleared (sizeof (struct function
));
3805 cfun
->stack_alignment_needed
= STACK_BOUNDARY
;
3806 cfun
->preferred_stack_boundary
= STACK_BOUNDARY
;
3808 current_function_funcdef_no
= funcdef_no
++;
3810 cfun
->function_frequency
= FUNCTION_FREQUENCY_NORMAL
;
3812 init_eh_for_function ();
3814 lang_hooks
.function
.init (cfun
);
3815 if (init_machine_status
)
3816 cfun
->machine
= (*init_machine_status
) ();
3821 DECL_STRUCT_FUNCTION (fndecl
) = cfun
;
3822 cfun
->decl
= fndecl
;
3824 result
= DECL_RESULT (fndecl
);
3825 if (aggregate_value_p (result
, fndecl
))
3827 #ifdef PCC_STATIC_STRUCT_RETURN
3828 current_function_returns_pcc_struct
= 1;
3830 current_function_returns_struct
= 1;
3833 current_function_returns_pointer
= POINTER_TYPE_P (TREE_TYPE (result
));
3835 current_function_stdarg
3837 && TYPE_ARG_TYPES (fntype
) != 0
3838 && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype
)))
3839 != void_type_node
));
3842 /* Reset cfun, and other non-struct-function variables to defaults as
3843 appropriate for emitting rtl at the start of a function. */
3846 prepare_function_start (tree fndecl
)
3848 if (fndecl
&& DECL_STRUCT_FUNCTION (fndecl
))
3849 cfun
= DECL_STRUCT_FUNCTION (fndecl
);
3851 allocate_struct_function (fndecl
);
3853 init_varasm_status (cfun
);
3856 cse_not_expected
= ! optimize
;
3858 /* Caller save not needed yet. */
3859 caller_save_needed
= 0;
3861 /* We haven't done register allocation yet. */
3864 /* Indicate that we have not instantiated virtual registers yet. */
3865 virtuals_instantiated
= 0;
3867 /* Indicate that we want CONCATs now. */
3868 generating_concat_p
= 1;
3870 /* Indicate we have no need of a frame pointer yet. */
3871 frame_pointer_needed
= 0;
3874 /* Initialize the rtl expansion mechanism so that we can do simple things
3875 like generate sequences. This is used to provide a context during global
3876 initialization of some passes. */
3878 init_dummy_function_start (void)
3880 prepare_function_start (NULL
);
3883 /* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node)
3884 and initialize static variables for generating RTL for the statements
3888 init_function_start (tree subr
)
3890 prepare_function_start (subr
);
3892 /* Prevent ever trying to delete the first instruction of a
3893 function. Also tell final how to output a linenum before the
3894 function prologue. Note linenums could be missing, e.g. when
3895 compiling a Java .class file. */
3896 if (! DECL_IS_BUILTIN (subr
))
3897 emit_line_note (DECL_SOURCE_LOCATION (subr
));
3899 /* Make sure first insn is a note even if we don't want linenums.
3900 This makes sure the first insn will never be deleted.
3901 Also, final expects a note to appear there. */
3902 emit_note (NOTE_INSN_DELETED
);
3904 /* Warn if this value is an aggregate type,
3905 regardless of which calling convention we are using for it. */
3906 if (warn_aggregate_return
3907 && AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr
))))
3908 warning ("function returns an aggregate");
3911 /* Make sure all values used by the optimization passes have sane
3914 init_function_for_compilation (void)
3918 /* No prologue/epilogue insns yet. */
3919 VARRAY_GROW (prologue
, 0);
3920 VARRAY_GROW (epilogue
, 0);
3921 VARRAY_GROW (sibcall_epilogue
, 0);
3924 /* Expand a call to __main at the beginning of a possible main function. */
3926 #if defined(INIT_SECTION_ASM_OP) && !defined(INVOKE__main)
3927 #undef HAS_INIT_SECTION
3928 #define HAS_INIT_SECTION
3932 expand_main_function (void)
3934 #ifdef FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN
3935 if (FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN
)
3937 int align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
3941 /* Forcibly align the stack. */
3942 #ifdef STACK_GROWS_DOWNWARD
3943 tmp
= expand_simple_binop (Pmode
, AND
, stack_pointer_rtx
, GEN_INT(-align
),
3944 stack_pointer_rtx
, 1, OPTAB_WIDEN
);
3946 tmp
= expand_simple_binop (Pmode
, PLUS
, stack_pointer_rtx
,
3947 GEN_INT (align
- 1), NULL_RTX
, 1, OPTAB_WIDEN
);
3948 tmp
= expand_simple_binop (Pmode
, AND
, tmp
, GEN_INT (-align
),
3949 stack_pointer_rtx
, 1, OPTAB_WIDEN
);
3951 if (tmp
!= stack_pointer_rtx
)
3952 emit_move_insn (stack_pointer_rtx
, tmp
);
3954 /* Enlist allocate_dynamic_stack_space to pick up the pieces. */
3955 tmp
= force_reg (Pmode
, const0_rtx
);
3956 allocate_dynamic_stack_space (tmp
, NULL_RTX
, BIGGEST_ALIGNMENT
);
3960 for (tmp
= get_last_insn (); tmp
; tmp
= PREV_INSN (tmp
))
3961 if (NOTE_P (tmp
) && NOTE_LINE_NUMBER (tmp
) == NOTE_INSN_FUNCTION_BEG
)
3964 emit_insn_before (seq
, tmp
);
3970 #ifndef HAS_INIT_SECTION
3971 emit_library_call (init_one_libfunc (NAME__MAIN
), LCT_NORMAL
, VOIDmode
, 0);
3975 /* The PENDING_SIZES represent the sizes of variable-sized types.
3976 Create RTL for the various sizes now (using temporary variables),
3977 so that we can refer to the sizes from the RTL we are generating
3978 for the current function. The PENDING_SIZES are a TREE_LIST. The
3979 TREE_VALUE of each node is a SAVE_EXPR. */
3982 expand_pending_sizes (tree pending_sizes
)
3986 /* Evaluate now the sizes of any types declared among the arguments. */
3987 for (tem
= pending_sizes
; tem
; tem
= TREE_CHAIN (tem
))
3988 expand_expr (TREE_VALUE (tem
), const0_rtx
, VOIDmode
, 0);
3991 /* Start the RTL for a new function, and set variables used for
3993 SUBR is the FUNCTION_DECL node.
3994 PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with
3995 the function's parameters, which must be run at any return statement. */
3998 expand_function_start (tree subr
)
4000 /* Make sure volatile mem refs aren't considered
4001 valid operands of arithmetic insns. */
4002 init_recog_no_volatile ();
4004 current_function_profile
4006 && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr
));
4008 current_function_limit_stack
4009 = (stack_limit_rtx
!= NULL_RTX
&& ! DECL_NO_LIMIT_STACK (subr
));
4011 /* Make the label for return statements to jump to. Do not special
4012 case machines with special return instructions -- they will be
4013 handled later during jump, ifcvt, or epilogue creation. */
4014 return_label
= gen_label_rtx ();
4016 /* Initialize rtx used to return the value. */
4017 /* Do this before assign_parms so that we copy the struct value address
4018 before any library calls that assign parms might generate. */
4020 /* Decide whether to return the value in memory or in a register. */
4021 if (aggregate_value_p (DECL_RESULT (subr
), subr
))
4023 /* Returning something that won't go in a register. */
4024 rtx value_address
= 0;
4026 #ifdef PCC_STATIC_STRUCT_RETURN
4027 if (current_function_returns_pcc_struct
)
4029 int size
= int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr
)));
4030 value_address
= assemble_static_space (size
);
4035 rtx sv
= targetm
.calls
.struct_value_rtx (TREE_TYPE (subr
), 1);
4036 /* Expect to be passed the address of a place to store the value.
4037 If it is passed as an argument, assign_parms will take care of
4041 value_address
= gen_reg_rtx (Pmode
);
4042 emit_move_insn (value_address
, sv
);
4047 rtx x
= value_address
;
4048 if (!DECL_BY_REFERENCE (DECL_RESULT (subr
)))
4050 x
= gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr
)), x
);
4051 set_mem_attributes (x
, DECL_RESULT (subr
), 1);
4053 SET_DECL_RTL (DECL_RESULT (subr
), x
);
4056 else if (DECL_MODE (DECL_RESULT (subr
)) == VOIDmode
)
4057 /* If return mode is void, this decl rtl should not be used. */
4058 SET_DECL_RTL (DECL_RESULT (subr
), NULL_RTX
);
4061 /* Compute the return values into a pseudo reg, which we will copy
4062 into the true return register after the cleanups are done. */
4063 tree return_type
= TREE_TYPE (DECL_RESULT (subr
));
4064 if (TYPE_MODE (return_type
) != BLKmode
4065 && targetm
.calls
.return_in_msb (return_type
))
4066 /* expand_function_end will insert the appropriate padding in
4067 this case. Use the return value's natural (unpadded) mode
4068 within the function proper. */
4069 SET_DECL_RTL (DECL_RESULT (subr
),
4070 gen_reg_rtx (TYPE_MODE (return_type
)));
4073 /* In order to figure out what mode to use for the pseudo, we
4074 figure out what the mode of the eventual return register will
4075 actually be, and use that. */
4076 rtx hard_reg
= hard_function_value (return_type
, subr
, 1);
4078 /* Structures that are returned in registers are not
4079 aggregate_value_p, so we may see a PARALLEL or a REG. */
4080 if (REG_P (hard_reg
))
4081 SET_DECL_RTL (DECL_RESULT (subr
),
4082 gen_reg_rtx (GET_MODE (hard_reg
)));
4085 gcc_assert (GET_CODE (hard_reg
) == PARALLEL
);
4086 SET_DECL_RTL (DECL_RESULT (subr
), gen_group_rtx (hard_reg
));
4090 /* Set DECL_REGISTER flag so that expand_function_end will copy the
4091 result to the real return register(s). */
4092 DECL_REGISTER (DECL_RESULT (subr
)) = 1;
4095 /* Initialize rtx for parameters and local variables.
4096 In some cases this requires emitting insns. */
4097 assign_parms (subr
);
4099 /* If function gets a static chain arg, store it. */
4100 if (cfun
->static_chain_decl
)
4102 tree parm
= cfun
->static_chain_decl
;
4103 rtx local
= gen_reg_rtx (Pmode
);
4105 set_decl_incoming_rtl (parm
, static_chain_incoming_rtx
);
4106 SET_DECL_RTL (parm
, local
);
4107 mark_reg_pointer (local
, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm
))));
4109 emit_move_insn (local
, static_chain_incoming_rtx
);
4112 /* If the function receives a non-local goto, then store the
4113 bits we need to restore the frame pointer. */
4114 if (cfun
->nonlocal_goto_save_area
)
4119 /* ??? We need to do this save early. Unfortunately here is
4120 before the frame variable gets declared. Help out... */
4121 expand_var (TREE_OPERAND (cfun
->nonlocal_goto_save_area
, 0));
4123 t_save
= build4 (ARRAY_REF
, ptr_type_node
,
4124 cfun
->nonlocal_goto_save_area
,
4125 integer_zero_node
, NULL_TREE
, NULL_TREE
);
4126 r_save
= expand_expr (t_save
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
4127 r_save
= convert_memory_address (Pmode
, r_save
);
4129 emit_move_insn (r_save
, virtual_stack_vars_rtx
);
4130 update_nonlocal_goto_save_area ();
4133 /* The following was moved from init_function_start.
4134 The move is supposed to make sdb output more accurate. */
4135 /* Indicate the beginning of the function body,
4136 as opposed to parm setup. */
4137 emit_note (NOTE_INSN_FUNCTION_BEG
);
4139 if (!NOTE_P (get_last_insn ()))
4140 emit_note (NOTE_INSN_DELETED
);
4141 parm_birth_insn
= get_last_insn ();
4143 if (current_function_profile
)
4146 PROFILE_HOOK (current_function_funcdef_no
);
4150 /* After the display initializations is where the tail-recursion label
4151 should go, if we end up needing one. Ensure we have a NOTE here
4152 since some things (like trampolines) get placed before this. */
4153 tail_recursion_reentry
= emit_note (NOTE_INSN_DELETED
);
4155 /* Evaluate now the sizes of any types declared among the arguments. */
4156 expand_pending_sizes (nreverse (get_pending_sizes ()));
4158 /* Make sure there is a line number after the function entry setup code. */
4159 force_next_line_note ();
4162 /* Undo the effects of init_dummy_function_start. */
4164 expand_dummy_function_end (void)
4166 /* End any sequences that failed to be closed due to syntax errors. */
4167 while (in_sequence_p ())
4170 /* Outside function body, can't compute type's actual size
4171 until next function's body starts. */
4173 free_after_parsing (cfun
);
4174 free_after_compilation (cfun
);
4178 /* Call DOIT for each hard register used as a return value from
4179 the current function. */
4182 diddle_return_value (void (*doit
) (rtx
, void *), void *arg
)
4184 rtx outgoing
= current_function_return_rtx
;
4189 if (REG_P (outgoing
))
4190 (*doit
) (outgoing
, arg
);
4191 else if (GET_CODE (outgoing
) == PARALLEL
)
4195 for (i
= 0; i
< XVECLEN (outgoing
, 0); i
++)
4197 rtx x
= XEXP (XVECEXP (outgoing
, 0, i
), 0);
4199 if (REG_P (x
) && REGNO (x
) < FIRST_PSEUDO_REGISTER
)
4206 do_clobber_return_reg (rtx reg
, void *arg ATTRIBUTE_UNUSED
)
4208 emit_insn (gen_rtx_CLOBBER (VOIDmode
, reg
));
4212 clobber_return_register (void)
4214 diddle_return_value (do_clobber_return_reg
, NULL
);
4216 /* In case we do use pseudo to return value, clobber it too. */
4217 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl
)))
4219 tree decl_result
= DECL_RESULT (current_function_decl
);
4220 rtx decl_rtl
= DECL_RTL (decl_result
);
4221 if (REG_P (decl_rtl
) && REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
)
4223 do_clobber_return_reg (decl_rtl
, NULL
);
4229 do_use_return_reg (rtx reg
, void *arg ATTRIBUTE_UNUSED
)
4231 emit_insn (gen_rtx_USE (VOIDmode
, reg
));
4235 use_return_register (void)
4237 diddle_return_value (do_use_return_reg
, NULL
);
4240 /* Possibly warn about unused parameters. */
4242 do_warn_unused_parameter (tree fn
)
4246 for (decl
= DECL_ARGUMENTS (fn
);
4247 decl
; decl
= TREE_CHAIN (decl
))
4248 if (!TREE_USED (decl
) && TREE_CODE (decl
) == PARM_DECL
4249 && DECL_NAME (decl
) && !DECL_ARTIFICIAL (decl
))
4250 warning ("%Junused parameter %qD", decl
, decl
);
4253 static GTY(()) rtx initial_trampoline
;
4255 /* Generate RTL for the end of the current function. */
4258 expand_function_end (void)
4262 /* If arg_pointer_save_area was referenced only from a nested
4263 function, we will not have initialized it yet. Do that now. */
4264 if (arg_pointer_save_area
&& ! cfun
->arg_pointer_save_area_init
)
4265 get_arg_pointer_save_area (cfun
);
4267 /* If we are doing stack checking and this function makes calls,
4268 do a stack probe at the start of the function to ensure we have enough
4269 space for another stack frame. */
4270 if (flag_stack_check
&& ! STACK_CHECK_BUILTIN
)
4274 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
4278 probe_stack_range (STACK_CHECK_PROTECT
,
4279 GEN_INT (STACK_CHECK_MAX_FRAME_SIZE
));
4282 emit_insn_before (seq
, tail_recursion_reentry
);
4287 /* Possibly warn about unused parameters.
4288 When frontend does unit-at-a-time, the warning is already
4289 issued at finalization time. */
4290 if (warn_unused_parameter
4291 && !lang_hooks
.callgraph
.expand_function
)
4292 do_warn_unused_parameter (current_function_decl
);
4294 /* End any sequences that failed to be closed due to syntax errors. */
4295 while (in_sequence_p ())
4298 clear_pending_stack_adjust ();
4299 do_pending_stack_adjust ();
4301 /* @@@ This is a kludge. We want to ensure that instructions that
4302 may trap are not moved into the epilogue by scheduling, because
4303 we don't always emit unwind information for the epilogue.
4304 However, not all machine descriptions define a blockage insn, so
4305 emit an ASM_INPUT to act as one. */
4306 if (flag_non_call_exceptions
)
4307 emit_insn (gen_rtx_ASM_INPUT (VOIDmode
, ""));
4309 /* Mark the end of the function body.
4310 If control reaches this insn, the function can drop through
4311 without returning a value. */
4312 emit_note (NOTE_INSN_FUNCTION_END
);
4314 /* Must mark the last line number note in the function, so that the test
4315 coverage code can avoid counting the last line twice. This just tells
4316 the code to ignore the immediately following line note, since there
4317 already exists a copy of this note somewhere above. This line number
4318 note is still needed for debugging though, so we can't delete it. */
4319 if (flag_test_coverage
)
4320 emit_note (NOTE_INSN_REPEATED_LINE_NUMBER
);
4322 /* Output a linenumber for the end of the function.
4323 SDB depends on this. */
4324 force_next_line_note ();
4325 emit_line_note (input_location
);
4327 /* Before the return label (if any), clobber the return
4328 registers so that they are not propagated live to the rest of
4329 the function. This can only happen with functions that drop
4330 through; if there had been a return statement, there would
4331 have either been a return rtx, or a jump to the return label.
4333 We delay actual code generation after the current_function_value_rtx
4335 clobber_after
= get_last_insn ();
4337 /* Output the label for the actual return from the function. */
4338 emit_label (return_label
);
4340 /* Let except.c know where it should emit the call to unregister
4341 the function context for sjlj exceptions. */
4342 if (flag_exceptions
&& USING_SJLJ_EXCEPTIONS
)
4343 sjlj_emit_function_exit_after (get_last_insn ());
4345 /* If we had calls to alloca, and this machine needs
4346 an accurate stack pointer to exit the function,
4347 insert some code to save and restore the stack pointer. */
4348 if (! EXIT_IGNORE_STACK
4349 && current_function_calls_alloca
)
4353 emit_stack_save (SAVE_FUNCTION
, &tem
, parm_birth_insn
);
4354 emit_stack_restore (SAVE_FUNCTION
, tem
, NULL_RTX
);
4357 /* If scalar return value was computed in a pseudo-reg, or was a named
4358 return value that got dumped to the stack, copy that to the hard
4360 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl
)))
4362 tree decl_result
= DECL_RESULT (current_function_decl
);
4363 rtx decl_rtl
= DECL_RTL (decl_result
);
4365 if (REG_P (decl_rtl
)
4366 ? REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
4367 : DECL_REGISTER (decl_result
))
4369 rtx real_decl_rtl
= current_function_return_rtx
;
4371 /* This should be set in assign_parms. */
4372 gcc_assert (REG_FUNCTION_VALUE_P (real_decl_rtl
));
4374 /* If this is a BLKmode structure being returned in registers,
4375 then use the mode computed in expand_return. Note that if
4376 decl_rtl is memory, then its mode may have been changed,
4377 but that current_function_return_rtx has not. */
4378 if (GET_MODE (real_decl_rtl
) == BLKmode
)
4379 PUT_MODE (real_decl_rtl
, GET_MODE (decl_rtl
));
4381 /* If a non-BLKmode return value should be padded at the least
4382 significant end of the register, shift it left by the appropriate
4383 amount. BLKmode results are handled using the group load/store
4385 if (TYPE_MODE (TREE_TYPE (decl_result
)) != BLKmode
4386 && targetm
.calls
.return_in_msb (TREE_TYPE (decl_result
)))
4388 emit_move_insn (gen_rtx_REG (GET_MODE (decl_rtl
),
4389 REGNO (real_decl_rtl
)),
4391 shift_return_value (GET_MODE (decl_rtl
), true, real_decl_rtl
);
4393 /* If a named return value dumped decl_return to memory, then
4394 we may need to re-do the PROMOTE_MODE signed/unsigned
4396 else if (GET_MODE (real_decl_rtl
) != GET_MODE (decl_rtl
))
4398 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (decl_result
));
4400 if (targetm
.calls
.promote_function_return (TREE_TYPE (current_function_decl
)))
4401 promote_mode (TREE_TYPE (decl_result
), GET_MODE (decl_rtl
),
4404 convert_move (real_decl_rtl
, decl_rtl
, unsignedp
);
4406 else if (GET_CODE (real_decl_rtl
) == PARALLEL
)
4408 /* If expand_function_start has created a PARALLEL for decl_rtl,
4409 move the result to the real return registers. Otherwise, do
4410 a group load from decl_rtl for a named return. */
4411 if (GET_CODE (decl_rtl
) == PARALLEL
)
4412 emit_group_move (real_decl_rtl
, decl_rtl
);
4414 emit_group_load (real_decl_rtl
, decl_rtl
,
4415 TREE_TYPE (decl_result
),
4416 int_size_in_bytes (TREE_TYPE (decl_result
)));
4419 emit_move_insn (real_decl_rtl
, decl_rtl
);
4423 /* If returning a structure, arrange to return the address of the value
4424 in a place where debuggers expect to find it.
4426 If returning a structure PCC style,
4427 the caller also depends on this value.
4428 And current_function_returns_pcc_struct is not necessarily set. */
4429 if (current_function_returns_struct
4430 || current_function_returns_pcc_struct
)
4432 rtx value_address
= DECL_RTL (DECL_RESULT (current_function_decl
));
4433 tree type
= TREE_TYPE (DECL_RESULT (current_function_decl
));
4436 if (DECL_BY_REFERENCE (DECL_RESULT (current_function_decl
)))
4437 type
= TREE_TYPE (type
);
4439 value_address
= XEXP (value_address
, 0);
4441 #ifdef FUNCTION_OUTGOING_VALUE
4442 outgoing
= FUNCTION_OUTGOING_VALUE (build_pointer_type (type
),
4443 current_function_decl
);
4445 outgoing
= FUNCTION_VALUE (build_pointer_type (type
),
4446 current_function_decl
);
4449 /* Mark this as a function return value so integrate will delete the
4450 assignment and USE below when inlining this function. */
4451 REG_FUNCTION_VALUE_P (outgoing
) = 1;
4453 /* The address may be ptr_mode and OUTGOING may be Pmode. */
4454 value_address
= convert_memory_address (GET_MODE (outgoing
),
4457 emit_move_insn (outgoing
, value_address
);
4459 /* Show return register used to hold result (in this case the address
4461 current_function_return_rtx
= outgoing
;
4464 /* If this is an implementation of throw, do what's necessary to
4465 communicate between __builtin_eh_return and the epilogue. */
4466 expand_eh_return ();
4468 /* Emit the actual code to clobber return register. */
4473 clobber_return_register ();
4474 expand_naked_return ();
4478 emit_insn_after (seq
, clobber_after
);
4481 /* Output the label for the naked return from the function. */
4482 emit_label (naked_return_label
);
4484 /* ??? This should no longer be necessary since stupid is no longer with
4485 us, but there are some parts of the compiler (eg reload_combine, and
4486 sh mach_dep_reorg) that still try and compute their own lifetime info
4487 instead of using the general framework. */
4488 use_return_register ();
4492 get_arg_pointer_save_area (struct function
*f
)
4494 rtx ret
= f
->x_arg_pointer_save_area
;
4498 ret
= assign_stack_local_1 (Pmode
, GET_MODE_SIZE (Pmode
), 0, f
);
4499 f
->x_arg_pointer_save_area
= ret
;
4502 if (f
== cfun
&& ! f
->arg_pointer_save_area_init
)
4506 /* Save the arg pointer at the beginning of the function. The
4507 generated stack slot may not be a valid memory address, so we
4508 have to check it and fix it if necessary. */
4510 emit_move_insn (validize_mem (ret
), virtual_incoming_args_rtx
);
4514 push_topmost_sequence ();
4515 emit_insn_after (seq
, get_insns ());
4516 pop_topmost_sequence ();
4522 /* Extend a vector that records the INSN_UIDs of INSNS
4523 (a list of one or more insns). */
4526 record_insns (rtx insns
, varray_type
*vecp
)
4533 while (tmp
!= NULL_RTX
)
4536 tmp
= NEXT_INSN (tmp
);
4539 i
= VARRAY_SIZE (*vecp
);
4540 VARRAY_GROW (*vecp
, i
+ len
);
4542 while (tmp
!= NULL_RTX
)
4544 VARRAY_INT (*vecp
, i
) = INSN_UID (tmp
);
4546 tmp
= NEXT_INSN (tmp
);
4550 /* Set the locator of the insn chain starting at INSN to LOC. */
4552 set_insn_locators (rtx insn
, int loc
)
4554 while (insn
!= NULL_RTX
)
4557 INSN_LOCATOR (insn
) = loc
;
4558 insn
= NEXT_INSN (insn
);
4562 /* Determine how many INSN_UIDs in VEC are part of INSN. Because we can
4563 be running after reorg, SEQUENCE rtl is possible. */
4566 contains (rtx insn
, varray_type vec
)
4570 if (NONJUMP_INSN_P (insn
)
4571 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
4574 for (i
= XVECLEN (PATTERN (insn
), 0) - 1; i
>= 0; i
--)
4575 for (j
= VARRAY_SIZE (vec
) - 1; j
>= 0; --j
)
4576 if (INSN_UID (XVECEXP (PATTERN (insn
), 0, i
)) == VARRAY_INT (vec
, j
))
4582 for (j
= VARRAY_SIZE (vec
) - 1; j
>= 0; --j
)
4583 if (INSN_UID (insn
) == VARRAY_INT (vec
, j
))
4590 prologue_epilogue_contains (rtx insn
)
4592 if (contains (insn
, prologue
))
4594 if (contains (insn
, epilogue
))
4600 sibcall_epilogue_contains (rtx insn
)
4602 if (sibcall_epilogue
)
4603 return contains (insn
, sibcall_epilogue
);
4608 /* Insert gen_return at the end of block BB. This also means updating
4609 block_for_insn appropriately. */
4612 emit_return_into_block (basic_block bb
, rtx line_note
)
4614 emit_jump_insn_after (gen_return (), BB_END (bb
));
4616 emit_note_copy_after (line_note
, PREV_INSN (BB_END (bb
)));
4618 #endif /* HAVE_return */
4620 #if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX)
4622 /* These functions convert the epilogue into a variant that does not modify the
4623 stack pointer. This is used in cases where a function returns an object
4624 whose size is not known until it is computed. The called function leaves the
4625 object on the stack, leaves the stack depressed, and returns a pointer to
4628 What we need to do is track all modifications and references to the stack
4629 pointer, deleting the modifications and changing the references to point to
4630 the location the stack pointer would have pointed to had the modifications
4633 These functions need to be portable so we need to make as few assumptions
4634 about the epilogue as we can. However, the epilogue basically contains
4635 three things: instructions to reset the stack pointer, instructions to
4636 reload registers, possibly including the frame pointer, and an
4637 instruction to return to the caller.
4639 If we can't be sure of what a relevant epilogue insn is doing, we abort.
4640 We also make no attempt to validate the insns we make since if they are
4641 invalid, we probably can't do anything valid. The intent is that these
4642 routines get "smarter" as more and more machines start to use them and
4643 they try operating on different epilogues.
4645 We use the following structure to track what the part of the epilogue that
4646 we've already processed has done. We keep two copies of the SP equivalence,
4647 one for use during the insn we are processing and one for use in the next
4648 insn. The difference is because one part of a PARALLEL may adjust SP
4649 and the other may use it. */
4653 rtx sp_equiv_reg
; /* REG that SP is set from, perhaps SP. */
4654 HOST_WIDE_INT sp_offset
; /* Offset from SP_EQUIV_REG of present SP. */
4655 rtx new_sp_equiv_reg
; /* REG to be used at end of insn. */
4656 HOST_WIDE_INT new_sp_offset
; /* Offset to be used at end of insn. */
4657 rtx equiv_reg_src
; /* If nonzero, the value that SP_EQUIV_REG
4658 should be set to once we no longer need
4660 rtx const_equiv
[FIRST_PSEUDO_REGISTER
]; /* Any known constant equivalences
4664 static void handle_epilogue_set (rtx
, struct epi_info
*);
4665 static void update_epilogue_consts (rtx
, rtx
, void *);
4666 static void emit_equiv_load (struct epi_info
*);
4668 /* Modify INSN, a list of one or more insns that is part of the epilogue, to
4669 no modifications to the stack pointer. Return the new list of insns. */
4672 keep_stack_depressed (rtx insns
)
4675 struct epi_info info
;
4678 /* If the epilogue is just a single instruction, it must be OK as is. */
4679 if (NEXT_INSN (insns
) == NULL_RTX
)
4682 /* Otherwise, start a sequence, initialize the information we have, and
4683 process all the insns we were given. */
4686 info
.sp_equiv_reg
= stack_pointer_rtx
;
4688 info
.equiv_reg_src
= 0;
4690 for (j
= 0; j
< FIRST_PSEUDO_REGISTER
; j
++)
4691 info
.const_equiv
[j
] = 0;
4695 while (insn
!= NULL_RTX
)
4697 next
= NEXT_INSN (insn
);
4706 /* If this insn references the register that SP is equivalent to and
4707 we have a pending load to that register, we must force out the load
4708 first and then indicate we no longer know what SP's equivalent is. */
4709 if (info
.equiv_reg_src
!= 0
4710 && reg_referenced_p (info
.sp_equiv_reg
, PATTERN (insn
)))
4712 emit_equiv_load (&info
);
4713 info
.sp_equiv_reg
= 0;
4716 info
.new_sp_equiv_reg
= info
.sp_equiv_reg
;
4717 info
.new_sp_offset
= info
.sp_offset
;
4719 /* If this is a (RETURN) and the return address is on the stack,
4720 update the address and change to an indirect jump. */
4721 if (GET_CODE (PATTERN (insn
)) == RETURN
4722 || (GET_CODE (PATTERN (insn
)) == PARALLEL
4723 && GET_CODE (XVECEXP (PATTERN (insn
), 0, 0)) == RETURN
))
4725 rtx retaddr
= INCOMING_RETURN_ADDR_RTX
;
4727 HOST_WIDE_INT offset
= 0;
4728 rtx jump_insn
, jump_set
;
4730 /* If the return address is in a register, we can emit the insn
4731 unchanged. Otherwise, it must be a MEM and we see what the
4732 base register and offset are. In any case, we have to emit any
4733 pending load to the equivalent reg of SP, if any. */
4734 if (REG_P (retaddr
))
4736 emit_equiv_load (&info
);
4744 gcc_assert (MEM_P (retaddr
));
4746 ret_ptr
= XEXP (retaddr
, 0);
4748 if (REG_P (ret_ptr
))
4750 base
= gen_rtx_REG (Pmode
, REGNO (ret_ptr
));
4755 gcc_assert (GET_CODE (ret_ptr
) == PLUS
4756 && REG_P (XEXP (ret_ptr
, 0))
4757 && GET_CODE (XEXP (ret_ptr
, 1)) == CONST_INT
);
4758 base
= gen_rtx_REG (Pmode
, REGNO (XEXP (ret_ptr
, 0)));
4759 offset
= INTVAL (XEXP (ret_ptr
, 1));
4763 /* If the base of the location containing the return pointer
4764 is SP, we must update it with the replacement address. Otherwise,
4765 just build the necessary MEM. */
4766 retaddr
= plus_constant (base
, offset
);
4767 if (base
== stack_pointer_rtx
)
4768 retaddr
= simplify_replace_rtx (retaddr
, stack_pointer_rtx
,
4769 plus_constant (info
.sp_equiv_reg
,
4772 retaddr
= gen_rtx_MEM (Pmode
, retaddr
);
4774 /* If there is a pending load to the equivalent register for SP
4775 and we reference that register, we must load our address into
4776 a scratch register and then do that load. */
4777 if (info
.equiv_reg_src
4778 && reg_overlap_mentioned_p (info
.equiv_reg_src
, retaddr
))
4783 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
4784 if (HARD_REGNO_MODE_OK (regno
, Pmode
)
4785 && !fixed_regs
[regno
]
4786 && TEST_HARD_REG_BIT (regs_invalidated_by_call
, regno
)
4787 && !REGNO_REG_SET_P (EXIT_BLOCK_PTR
->global_live_at_start
,
4789 && !refers_to_regno_p (regno
,
4790 regno
+ hard_regno_nregs
[regno
]
4792 info
.equiv_reg_src
, NULL
)
4793 && info
.const_equiv
[regno
] == 0)
4796 gcc_assert (regno
< FIRST_PSEUDO_REGISTER
);
4798 reg
= gen_rtx_REG (Pmode
, regno
);
4799 emit_move_insn (reg
, retaddr
);
4803 emit_equiv_load (&info
);
4804 jump_insn
= emit_jump_insn (gen_indirect_jump (retaddr
));
4806 /* Show the SET in the above insn is a RETURN. */
4807 jump_set
= single_set (jump_insn
);
4808 gcc_assert (jump_set
);
4809 SET_IS_RETURN_P (jump_set
) = 1;
4812 /* If SP is not mentioned in the pattern and its equivalent register, if
4813 any, is not modified, just emit it. Otherwise, if neither is set,
4814 replace the reference to SP and emit the insn. If none of those are
4815 true, handle each SET individually. */
4816 else if (!reg_mentioned_p (stack_pointer_rtx
, PATTERN (insn
))
4817 && (info
.sp_equiv_reg
== stack_pointer_rtx
4818 || !reg_set_p (info
.sp_equiv_reg
, insn
)))
4820 else if (! reg_set_p (stack_pointer_rtx
, insn
)
4821 && (info
.sp_equiv_reg
== stack_pointer_rtx
4822 || !reg_set_p (info
.sp_equiv_reg
, insn
)))
4826 changed
= validate_replace_rtx (stack_pointer_rtx
,
4827 plus_constant (info
.sp_equiv_reg
,
4830 gcc_assert (changed
);
4834 else if (GET_CODE (PATTERN (insn
)) == SET
)
4835 handle_epilogue_set (PATTERN (insn
), &info
);
4836 else if (GET_CODE (PATTERN (insn
)) == PARALLEL
)
4838 for (j
= 0; j
< XVECLEN (PATTERN (insn
), 0); j
++)
4839 if (GET_CODE (XVECEXP (PATTERN (insn
), 0, j
)) == SET
)
4840 handle_epilogue_set (XVECEXP (PATTERN (insn
), 0, j
), &info
);
4845 info
.sp_equiv_reg
= info
.new_sp_equiv_reg
;
4846 info
.sp_offset
= info
.new_sp_offset
;
4848 /* Now update any constants this insn sets. */
4849 note_stores (PATTERN (insn
), update_epilogue_consts
, &info
);
4853 insns
= get_insns ();
4858 /* SET is a SET from an insn in the epilogue. P is a pointer to the epi_info
4859 structure that contains information about what we've seen so far. We
4860 process this SET by either updating that data or by emitting one or
4864 handle_epilogue_set (rtx set
, struct epi_info
*p
)
4866 /* First handle the case where we are setting SP. Record what it is being
4867 set from. If unknown, abort. */
4868 if (reg_set_p (stack_pointer_rtx
, set
))
4870 gcc_assert (SET_DEST (set
) == stack_pointer_rtx
);
4872 if (GET_CODE (SET_SRC (set
)) == PLUS
)
4874 p
->new_sp_equiv_reg
= XEXP (SET_SRC (set
), 0);
4875 if (GET_CODE (XEXP (SET_SRC (set
), 1)) == CONST_INT
)
4876 p
->new_sp_offset
= INTVAL (XEXP (SET_SRC (set
), 1));
4879 gcc_assert (REG_P (XEXP (SET_SRC (set
), 1))
4880 && (REGNO (XEXP (SET_SRC (set
), 1))
4881 < FIRST_PSEUDO_REGISTER
)
4882 && p
->const_equiv
[REGNO (XEXP (SET_SRC (set
), 1))]);
4884 = INTVAL (p
->const_equiv
[REGNO (XEXP (SET_SRC (set
), 1))]);
4888 p
->new_sp_equiv_reg
= SET_SRC (set
), p
->new_sp_offset
= 0;
4890 /* If we are adjusting SP, we adjust from the old data. */
4891 if (p
->new_sp_equiv_reg
== stack_pointer_rtx
)
4893 p
->new_sp_equiv_reg
= p
->sp_equiv_reg
;
4894 p
->new_sp_offset
+= p
->sp_offset
;
4897 gcc_assert (p
->new_sp_equiv_reg
&& REG_P (p
->new_sp_equiv_reg
));
4902 /* Next handle the case where we are setting SP's equivalent register.
4903 If we already have a value to set it to, abort. We could update, but
4904 there seems little point in handling that case. Note that we have
4905 to allow for the case where we are setting the register set in
4906 the previous part of a PARALLEL inside a single insn. But use the
4907 old offset for any updates within this insn. We must allow for the case
4908 where the register is being set in a different (usually wider) mode than
4910 else if (p
->new_sp_equiv_reg
!= 0 && reg_set_p (p
->new_sp_equiv_reg
, set
))
4912 gcc_assert (!p
->equiv_reg_src
4913 && REG_P (p
->new_sp_equiv_reg
)
4914 && REG_P (SET_DEST (set
))
4915 && (GET_MODE_BITSIZE (GET_MODE (SET_DEST (set
)))
4917 && REGNO (p
->new_sp_equiv_reg
) == REGNO (SET_DEST (set
)));
4919 = simplify_replace_rtx (SET_SRC (set
), stack_pointer_rtx
,
4920 plus_constant (p
->sp_equiv_reg
,
4924 /* Otherwise, replace any references to SP in the insn to its new value
4925 and emit the insn. */
4928 SET_SRC (set
) = simplify_replace_rtx (SET_SRC (set
), stack_pointer_rtx
,
4929 plus_constant (p
->sp_equiv_reg
,
4931 SET_DEST (set
) = simplify_replace_rtx (SET_DEST (set
), stack_pointer_rtx
,
4932 plus_constant (p
->sp_equiv_reg
,
4938 /* Update the tracking information for registers set to constants. */
4941 update_epilogue_consts (rtx dest
, rtx x
, void *data
)
4943 struct epi_info
*p
= (struct epi_info
*) data
;
4946 if (!REG_P (dest
) || REGNO (dest
) >= FIRST_PSEUDO_REGISTER
)
4949 /* If we are either clobbering a register or doing a partial set,
4950 show we don't know the value. */
4951 else if (GET_CODE (x
) == CLOBBER
|| ! rtx_equal_p (dest
, SET_DEST (x
)))
4952 p
->const_equiv
[REGNO (dest
)] = 0;
4954 /* If we are setting it to a constant, record that constant. */
4955 else if (GET_CODE (SET_SRC (x
)) == CONST_INT
)
4956 p
->const_equiv
[REGNO (dest
)] = SET_SRC (x
);
4958 /* If this is a binary operation between a register we have been tracking
4959 and a constant, see if we can compute a new constant value. */
4960 else if (ARITHMETIC_P (SET_SRC (x
))
4961 && REG_P (XEXP (SET_SRC (x
), 0))
4962 && REGNO (XEXP (SET_SRC (x
), 0)) < FIRST_PSEUDO_REGISTER
4963 && p
->const_equiv
[REGNO (XEXP (SET_SRC (x
), 0))] != 0
4964 && GET_CODE (XEXP (SET_SRC (x
), 1)) == CONST_INT
4965 && 0 != (new = simplify_binary_operation
4966 (GET_CODE (SET_SRC (x
)), GET_MODE (dest
),
4967 p
->const_equiv
[REGNO (XEXP (SET_SRC (x
), 0))],
4968 XEXP (SET_SRC (x
), 1)))
4969 && GET_CODE (new) == CONST_INT
)
4970 p
->const_equiv
[REGNO (dest
)] = new;
4972 /* Otherwise, we can't do anything with this value. */
4974 p
->const_equiv
[REGNO (dest
)] = 0;
4977 /* Emit an insn to do the load shown in p->equiv_reg_src, if needed. */
4980 emit_equiv_load (struct epi_info
*p
)
4982 if (p
->equiv_reg_src
!= 0)
4984 rtx dest
= p
->sp_equiv_reg
;
4986 if (GET_MODE (p
->equiv_reg_src
) != GET_MODE (dest
))
4987 dest
= gen_rtx_REG (GET_MODE (p
->equiv_reg_src
),
4988 REGNO (p
->sp_equiv_reg
));
4990 emit_move_insn (dest
, p
->equiv_reg_src
);
4991 p
->equiv_reg_src
= 0;
4996 /* Generate the prologue and epilogue RTL if the machine supports it. Thread
4997 this into place with notes indicating where the prologue ends and where
4998 the epilogue begins. Update the basic block information when possible. */
5001 thread_prologue_and_epilogue_insns (rtx f ATTRIBUTE_UNUSED
)
5005 #if defined (HAVE_sibcall_epilogue) || defined (HAVE_epilogue) || defined (HAVE_return) || defined (HAVE_prologue)
5008 #ifdef HAVE_prologue
5009 rtx prologue_end
= NULL_RTX
;
5011 #if defined (HAVE_epilogue) || defined(HAVE_return)
5012 rtx epilogue_end
= NULL_RTX
;
5016 #ifdef HAVE_prologue
5020 seq
= gen_prologue ();
5023 /* Retain a map of the prologue insns. */
5024 record_insns (seq
, &prologue
);
5025 prologue_end
= emit_note (NOTE_INSN_PROLOGUE_END
);
5029 set_insn_locators (seq
, prologue_locator
);
5031 /* Can't deal with multiple successors of the entry block
5032 at the moment. Function should always have at least one
5034 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR
->succs
) == 1);
5036 insert_insn_on_edge (seq
, EDGE_SUCC (ENTRY_BLOCK_PTR
, 0));
5041 /* If the exit block has no non-fake predecessors, we don't need
5043 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
5044 if ((e
->flags
& EDGE_FAKE
) == 0)
5050 if (optimize
&& HAVE_return
)
5052 /* If we're allowed to generate a simple return instruction,
5053 then by definition we don't need a full epilogue. Examine
5054 the block that falls through to EXIT. If it does not
5055 contain any code, examine its predecessors and try to
5056 emit (conditional) return instructions. */
5061 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
5062 if (e
->flags
& EDGE_FALLTHRU
)
5068 /* Verify that there are no active instructions in the last block. */
5069 label
= BB_END (last
);
5070 while (label
&& !LABEL_P (label
))
5072 if (active_insn_p (label
))
5074 label
= PREV_INSN (label
);
5077 if (BB_HEAD (last
) == label
&& LABEL_P (label
))
5080 rtx epilogue_line_note
= NULL_RTX
;
5082 /* Locate the line number associated with the closing brace,
5083 if we can find one. */
5084 for (seq
= get_last_insn ();
5085 seq
&& ! active_insn_p (seq
);
5086 seq
= PREV_INSN (seq
))
5087 if (NOTE_P (seq
) && NOTE_LINE_NUMBER (seq
) > 0)
5089 epilogue_line_note
= seq
;
5093 for (ei2
= ei_start (last
->preds
); (e
= ei_safe_edge (ei2
)); )
5095 basic_block bb
= e
->src
;
5098 if (bb
== ENTRY_BLOCK_PTR
)
5105 if (!JUMP_P (jump
) || JUMP_LABEL (jump
) != label
)
5111 /* If we have an unconditional jump, we can replace that
5112 with a simple return instruction. */
5113 if (simplejump_p (jump
))
5115 emit_return_into_block (bb
, epilogue_line_note
);
5119 /* If we have a conditional jump, we can try to replace
5120 that with a conditional return instruction. */
5121 else if (condjump_p (jump
))
5123 if (! redirect_jump (jump
, 0, 0))
5129 /* If this block has only one successor, it both jumps
5130 and falls through to the fallthru block, so we can't
5132 if (EDGE_COUNT (bb
->succs
) == 1)
5144 /* Fix up the CFG for the successful change we just made. */
5145 redirect_edge_succ (e
, EXIT_BLOCK_PTR
);
5148 /* Emit a return insn for the exit fallthru block. Whether
5149 this is still reachable will be determined later. */
5151 emit_barrier_after (BB_END (last
));
5152 emit_return_into_block (last
, epilogue_line_note
);
5153 epilogue_end
= BB_END (last
);
5154 EDGE_SUCC (last
, 0)->flags
&= ~EDGE_FALLTHRU
;
5159 /* Find the edge that falls through to EXIT. Other edges may exist
5160 due to RETURN instructions, but those don't need epilogues.
5161 There really shouldn't be a mixture -- either all should have
5162 been converted or none, however... */
5164 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
5165 if (e
->flags
& EDGE_FALLTHRU
)
5170 #ifdef HAVE_epilogue
5174 epilogue_end
= emit_note (NOTE_INSN_EPILOGUE_BEG
);
5176 seq
= gen_epilogue ();
5178 #ifdef INCOMING_RETURN_ADDR_RTX
5179 /* If this function returns with the stack depressed and we can support
5180 it, massage the epilogue to actually do that. */
5181 if (TREE_CODE (TREE_TYPE (current_function_decl
)) == FUNCTION_TYPE
5182 && TYPE_RETURNS_STACK_DEPRESSED (TREE_TYPE (current_function_decl
)))
5183 seq
= keep_stack_depressed (seq
);
5186 emit_jump_insn (seq
);
5188 /* Retain a map of the epilogue insns. */
5189 record_insns (seq
, &epilogue
);
5190 set_insn_locators (seq
, epilogue_locator
);
5195 insert_insn_on_edge (seq
, e
);
5203 if (! next_active_insn (BB_END (e
->src
)))
5205 /* We have a fall-through edge to the exit block, the source is not
5206 at the end of the function, and there will be an assembler epilogue
5207 at the end of the function.
5208 We can't use force_nonfallthru here, because that would try to
5209 use return. Inserting a jump 'by hand' is extremely messy, so
5210 we take advantage of cfg_layout_finalize using
5211 fixup_fallthru_exit_predecessor. */
5212 cfg_layout_initialize (0);
5213 FOR_EACH_BB (cur_bb
)
5214 if (cur_bb
->index
>= 0 && cur_bb
->next_bb
->index
>= 0)
5215 cur_bb
->rbi
->next
= cur_bb
->next_bb
;
5216 cfg_layout_finalize ();
5221 commit_edge_insertions ();
5223 #ifdef HAVE_sibcall_epilogue
5224 /* Emit sibling epilogues before any sibling call sites. */
5225 for (ei
= ei_start (EXIT_BLOCK_PTR
->preds
); (e
= ei_safe_edge (ei
)); )
5227 basic_block bb
= e
->src
;
5228 rtx insn
= BB_END (bb
);
5233 || ! SIBLING_CALL_P (insn
))
5240 emit_insn (gen_sibcall_epilogue ());
5244 /* Retain a map of the epilogue insns. Used in life analysis to
5245 avoid getting rid of sibcall epilogue insns. Do this before we
5246 actually emit the sequence. */
5247 record_insns (seq
, &sibcall_epilogue
);
5248 set_insn_locators (seq
, epilogue_locator
);
5250 i
= PREV_INSN (insn
);
5251 newinsn
= emit_insn_before (seq
, insn
);
5256 #ifdef HAVE_prologue
5257 /* This is probably all useless now that we use locators. */
5262 /* GDB handles `break f' by setting a breakpoint on the first
5263 line note after the prologue. Which means (1) that if
5264 there are line number notes before where we inserted the
5265 prologue we should move them, and (2) we should generate a
5266 note before the end of the first basic block, if there isn't
5269 ??? This behavior is completely broken when dealing with
5270 multiple entry functions. We simply place the note always
5271 into first basic block and let alternate entry points
5275 for (insn
= prologue_end
; insn
; insn
= prev
)
5277 prev
= PREV_INSN (insn
);
5278 if (NOTE_P (insn
) && NOTE_LINE_NUMBER (insn
) > 0)
5280 /* Note that we cannot reorder the first insn in the
5281 chain, since rest_of_compilation relies on that
5282 remaining constant. */
5285 reorder_insns (insn
, insn
, prologue_end
);
5289 /* Find the last line number note in the first block. */
5290 for (insn
= BB_END (ENTRY_BLOCK_PTR
->next_bb
);
5291 insn
!= prologue_end
&& insn
;
5292 insn
= PREV_INSN (insn
))
5293 if (NOTE_P (insn
) && NOTE_LINE_NUMBER (insn
) > 0)
5296 /* If we didn't find one, make a copy of the first line number
5300 for (insn
= next_active_insn (prologue_end
);
5302 insn
= PREV_INSN (insn
))
5303 if (NOTE_P (insn
) && NOTE_LINE_NUMBER (insn
) > 0)
5305 emit_note_copy_after (insn
, prologue_end
);
5311 #ifdef HAVE_epilogue
5316 /* Similarly, move any line notes that appear after the epilogue.
5317 There is no need, however, to be quite so anal about the existence
5318 of such a note. Also move the NOTE_INSN_FUNCTION_END and (possibly)
5319 NOTE_INSN_FUNCTION_BEG notes, as those can be relevant for debug
5321 for (insn
= epilogue_end
; insn
; insn
= next
)
5323 next
= NEXT_INSN (insn
);
5325 && (NOTE_LINE_NUMBER (insn
) > 0
5326 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_FUNCTION_BEG
5327 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_FUNCTION_END
))
5328 reorder_insns (insn
, insn
, PREV_INSN (epilogue_end
));
5334 /* Reposition the prologue-end and epilogue-begin notes after instruction
5335 scheduling and delayed branch scheduling. */
5338 reposition_prologue_and_epilogue_notes (rtx f ATTRIBUTE_UNUSED
)
5340 #if defined (HAVE_prologue) || defined (HAVE_epilogue)
5341 rtx insn
, last
, note
;
5344 if ((len
= VARRAY_SIZE (prologue
)) > 0)
5348 /* Scan from the beginning until we reach the last prologue insn.
5349 We apparently can't depend on basic_block_{head,end} after
5351 for (insn
= f
; insn
; insn
= NEXT_INSN (insn
))
5355 if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_PROLOGUE_END
)
5358 else if (contains (insn
, prologue
))
5368 /* Find the prologue-end note if we haven't already, and
5369 move it to just after the last prologue insn. */
5372 for (note
= last
; (note
= NEXT_INSN (note
));)
5374 && NOTE_LINE_NUMBER (note
) == NOTE_INSN_PROLOGUE_END
)
5378 /* Avoid placing note between CODE_LABEL and BASIC_BLOCK note. */
5380 last
= NEXT_INSN (last
);
5381 reorder_insns (note
, note
, last
);
5385 if ((len
= VARRAY_SIZE (epilogue
)) > 0)
5389 /* Scan from the end until we reach the first epilogue insn.
5390 We apparently can't depend on basic_block_{head,end} after
5392 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
5396 if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_EPILOGUE_BEG
)
5399 else if (contains (insn
, epilogue
))
5409 /* Find the epilogue-begin note if we haven't already, and
5410 move it to just before the first epilogue insn. */
5413 for (note
= insn
; (note
= PREV_INSN (note
));)
5415 && NOTE_LINE_NUMBER (note
) == NOTE_INSN_EPILOGUE_BEG
)
5419 if (PREV_INSN (last
) != note
)
5420 reorder_insns (note
, note
, PREV_INSN (last
));
5423 #endif /* HAVE_prologue or HAVE_epilogue */
5426 /* Called once, at initialization, to initialize function.c. */
5429 init_function_once (void)
5431 VARRAY_INT_INIT (prologue
, 0, "prologue");
5432 VARRAY_INT_INIT (epilogue
, 0, "epilogue");
5433 VARRAY_INT_INIT (sibcall_epilogue
, 0, "sibcall_epilogue");
5436 /* Resets insn_block_boundaries array. */
5439 reset_block_changes (void)
5441 VARRAY_TREE_INIT (cfun
->ib_boundaries_block
, 100, "ib_boundaries_block");
5442 VARRAY_PUSH_TREE (cfun
->ib_boundaries_block
, NULL_TREE
);
5445 /* Record the boundary for BLOCK. */
5447 record_block_change (tree block
)
5455 last_block
= VARRAY_TOP_TREE (cfun
->ib_boundaries_block
);
5456 VARRAY_POP (cfun
->ib_boundaries_block
);
5458 for (i
= VARRAY_ACTIVE_SIZE (cfun
->ib_boundaries_block
); i
< n
; i
++)
5459 VARRAY_PUSH_TREE (cfun
->ib_boundaries_block
, last_block
);
5461 VARRAY_PUSH_TREE (cfun
->ib_boundaries_block
, block
);
5464 /* Finishes record of boundaries. */
5465 void finalize_block_changes (void)
5467 record_block_change (DECL_INITIAL (current_function_decl
));
5470 /* For INSN return the BLOCK it belongs to. */
5472 check_block_change (rtx insn
, tree
*block
)
5474 unsigned uid
= INSN_UID (insn
);
5476 if (uid
>= VARRAY_ACTIVE_SIZE (cfun
->ib_boundaries_block
))
5479 *block
= VARRAY_TREE (cfun
->ib_boundaries_block
, uid
);
5482 /* Releases the ib_boundaries_block records. */
5484 free_block_changes (void)
5486 cfun
->ib_boundaries_block
= NULL
;
5489 /* Returns the name of the current function. */
5491 current_function_name (void)
5493 return lang_hooks
.decl_printable_name (cfun
->decl
, 2);
5496 #include "gt-function.h"