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 restore_emit_status (p
);
292 lang_hooks
.function
.leave_nested (p
);
294 /* Reset variables that have known state during rtx generation. */
295 virtuals_instantiated
= 0;
296 generating_concat_p
= 1;
300 pop_function_context (void)
302 pop_function_context_from (current_function_decl
);
305 /* Clear out all parts of the state in F that can safely be discarded
306 after the function has been parsed, but not compiled, to let
307 garbage collection reclaim the memory. */
310 free_after_parsing (struct function
*f
)
312 /* f->expr->forced_labels is used by code generation. */
313 /* f->emit->regno_reg_rtx is used by code generation. */
314 /* f->varasm is used by code generation. */
315 /* f->eh->eh_return_stub_label is used by code generation. */
317 lang_hooks
.function
.final (f
);
321 /* Clear out all parts of the state in F that can safely be discarded
322 after the function has been compiled, to let garbage collection
323 reclaim the memory. */
326 free_after_compilation (struct function
*f
)
334 f
->x_avail_temp_slots
= NULL
;
335 f
->x_used_temp_slots
= NULL
;
336 f
->arg_offset_rtx
= NULL
;
337 f
->return_rtx
= NULL
;
338 f
->internal_arg_pointer
= NULL
;
339 f
->x_nonlocal_goto_handler_labels
= NULL
;
340 f
->x_return_label
= NULL
;
341 f
->x_naked_return_label
= NULL
;
342 f
->x_stack_slot_list
= NULL
;
343 f
->x_tail_recursion_reentry
= NULL
;
344 f
->x_arg_pointer_save_area
= NULL
;
345 f
->x_parm_birth_insn
= NULL
;
346 f
->original_arg_vector
= NULL
;
347 f
->original_decl_initial
= NULL
;
348 f
->epilogue_delay_list
= NULL
;
351 /* Allocate fixed slots in the stack frame of the current function. */
353 /* Return size needed for stack frame based on slots so far allocated in
355 This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY;
356 the caller may have to do that. */
359 get_func_frame_size (struct function
*f
)
361 #ifdef FRAME_GROWS_DOWNWARD
362 return -f
->x_frame_offset
;
364 return f
->x_frame_offset
;
368 /* Return size needed for stack frame based on slots so far allocated.
369 This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY;
370 the caller may have to do that. */
372 get_frame_size (void)
374 return get_func_frame_size (cfun
);
377 /* Allocate a stack slot of SIZE bytes and return a MEM rtx for it
378 with machine mode MODE.
380 ALIGN controls the amount of alignment for the address of the slot:
381 0 means according to MODE,
382 -1 means use BIGGEST_ALIGNMENT and round size to multiple of that,
383 -2 means use BITS_PER_UNIT,
384 positive specifies alignment boundary in bits.
386 We do not round to stack_boundary here.
388 FUNCTION specifies the function to allocate in. */
391 assign_stack_local_1 (enum machine_mode mode
, HOST_WIDE_INT size
, int align
,
392 struct function
*function
)
395 int bigend_correction
= 0;
396 unsigned int alignment
;
397 int frame_off
, frame_alignment
, frame_phase
;
404 alignment
= BIGGEST_ALIGNMENT
;
406 alignment
= GET_MODE_ALIGNMENT (mode
);
408 /* Allow the target to (possibly) increase the alignment of this
410 type
= lang_hooks
.types
.type_for_mode (mode
, 0);
412 alignment
= LOCAL_ALIGNMENT (type
, alignment
);
414 alignment
/= BITS_PER_UNIT
;
416 else if (align
== -1)
418 alignment
= BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
;
419 size
= CEIL_ROUND (size
, alignment
);
421 else if (align
== -2)
422 alignment
= 1; /* BITS_PER_UNIT / BITS_PER_UNIT */
424 alignment
= align
/ BITS_PER_UNIT
;
426 #ifdef FRAME_GROWS_DOWNWARD
427 function
->x_frame_offset
-= size
;
430 /* Ignore alignment we can't do with expected alignment of the boundary. */
431 if (alignment
* BITS_PER_UNIT
> PREFERRED_STACK_BOUNDARY
)
432 alignment
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
434 if (function
->stack_alignment_needed
< alignment
* BITS_PER_UNIT
)
435 function
->stack_alignment_needed
= alignment
* BITS_PER_UNIT
;
437 /* Calculate how many bytes the start of local variables is off from
439 frame_alignment
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
440 frame_off
= STARTING_FRAME_OFFSET
% frame_alignment
;
441 frame_phase
= frame_off
? frame_alignment
- frame_off
: 0;
443 /* Round the frame offset to the specified alignment. The default is
444 to always honor requests to align the stack but a port may choose to
445 do its own stack alignment by defining STACK_ALIGNMENT_NEEDED. */
446 if (STACK_ALIGNMENT_NEEDED
450 /* We must be careful here, since FRAME_OFFSET might be negative and
451 division with a negative dividend isn't as well defined as we might
452 like. So we instead assume that ALIGNMENT is a power of two and
453 use logical operations which are unambiguous. */
454 #ifdef FRAME_GROWS_DOWNWARD
455 function
->x_frame_offset
456 = (FLOOR_ROUND (function
->x_frame_offset
- frame_phase
,
457 (unsigned HOST_WIDE_INT
) alignment
)
460 function
->x_frame_offset
461 = (CEIL_ROUND (function
->x_frame_offset
- frame_phase
,
462 (unsigned HOST_WIDE_INT
) alignment
)
467 /* On a big-endian machine, if we are allocating more space than we will use,
468 use the least significant bytes of those that are allocated. */
469 if (BYTES_BIG_ENDIAN
&& mode
!= BLKmode
)
470 bigend_correction
= size
- GET_MODE_SIZE (mode
);
472 /* If we have already instantiated virtual registers, return the actual
473 address relative to the frame pointer. */
474 if (function
== cfun
&& virtuals_instantiated
)
475 addr
= plus_constant (frame_pointer_rtx
,
477 (frame_offset
+ bigend_correction
478 + STARTING_FRAME_OFFSET
, Pmode
));
480 addr
= plus_constant (virtual_stack_vars_rtx
,
482 (function
->x_frame_offset
+ bigend_correction
,
485 #ifndef FRAME_GROWS_DOWNWARD
486 function
->x_frame_offset
+= size
;
489 x
= gen_rtx_MEM (mode
, addr
);
491 function
->x_stack_slot_list
492 = gen_rtx_EXPR_LIST (VOIDmode
, x
, function
->x_stack_slot_list
);
497 /* Wrapper around assign_stack_local_1; assign a local stack slot for the
501 assign_stack_local (enum machine_mode mode
, HOST_WIDE_INT size
, int align
)
503 return assign_stack_local_1 (mode
, size
, align
, cfun
);
507 /* Removes temporary slot TEMP from LIST. */
510 cut_slot_from_list (struct temp_slot
*temp
, struct temp_slot
**list
)
513 temp
->next
->prev
= temp
->prev
;
515 temp
->prev
->next
= temp
->next
;
519 temp
->prev
= temp
->next
= NULL
;
522 /* Inserts temporary slot TEMP to LIST. */
525 insert_slot_to_list (struct temp_slot
*temp
, struct temp_slot
**list
)
529 (*list
)->prev
= temp
;
534 /* Returns the list of used temp slots at LEVEL. */
536 static struct temp_slot
**
537 temp_slots_at_level (int level
)
541 if (!used_temp_slots
)
542 VARRAY_GENERIC_PTR_INIT (used_temp_slots
, 3, "used_temp_slots");
544 while (level
>= (int) VARRAY_ACTIVE_SIZE (used_temp_slots
))
545 VARRAY_PUSH_GENERIC_PTR (used_temp_slots
, NULL
);
547 return (struct temp_slot
**) &VARRAY_GENERIC_PTR (used_temp_slots
, level
);
550 /* Returns the maximal temporary slot level. */
553 max_slot_level (void)
555 if (!used_temp_slots
)
558 return VARRAY_ACTIVE_SIZE (used_temp_slots
) - 1;
561 /* Moves temporary slot TEMP to LEVEL. */
564 move_slot_to_level (struct temp_slot
*temp
, int level
)
566 cut_slot_from_list (temp
, temp_slots_at_level (temp
->level
));
567 insert_slot_to_list (temp
, temp_slots_at_level (level
));
571 /* Make temporary slot TEMP available. */
574 make_slot_available (struct temp_slot
*temp
)
576 cut_slot_from_list (temp
, temp_slots_at_level (temp
->level
));
577 insert_slot_to_list (temp
, &avail_temp_slots
);
582 /* Allocate a temporary stack slot and record it for possible later
585 MODE is the machine mode to be given to the returned rtx.
587 SIZE is the size in units of the space required. We do no rounding here
588 since assign_stack_local will do any required rounding.
590 KEEP is 1 if this slot is to be retained after a call to
591 free_temp_slots. Automatic variables for a block are allocated
592 with this flag. KEEP is 2 if we allocate a longer term temporary,
593 whose lifetime is controlled by CLEANUP_POINT_EXPRs. KEEP is 3
594 if we are to allocate something at an inner level to be treated as
595 a variable in the block (e.g., a SAVE_EXPR).
597 TYPE is the type that will be used for the stack slot. */
600 assign_stack_temp_for_type (enum machine_mode mode
, HOST_WIDE_INT size
, int keep
,
604 struct temp_slot
*p
, *best_p
= 0, *selected
= NULL
, **pp
;
607 /* If SIZE is -1 it means that somebody tried to allocate a temporary
608 of a variable size. */
613 align
= BIGGEST_ALIGNMENT
;
615 align
= GET_MODE_ALIGNMENT (mode
);
618 type
= lang_hooks
.types
.type_for_mode (mode
, 0);
621 align
= LOCAL_ALIGNMENT (type
, align
);
623 /* Try to find an available, already-allocated temporary of the proper
624 mode which meets the size and alignment requirements. Choose the
625 smallest one with the closest alignment. */
626 for (p
= avail_temp_slots
; p
; p
= p
->next
)
628 if (p
->align
>= align
&& p
->size
>= size
&& GET_MODE (p
->slot
) == mode
629 && objects_must_conflict_p (p
->type
, type
)
630 && (best_p
== 0 || best_p
->size
> p
->size
631 || (best_p
->size
== p
->size
&& best_p
->align
> p
->align
)))
633 if (p
->align
== align
&& p
->size
== size
)
636 cut_slot_from_list (selected
, &avail_temp_slots
);
644 /* Make our best, if any, the one to use. */
648 cut_slot_from_list (selected
, &avail_temp_slots
);
650 /* If there are enough aligned bytes left over, make them into a new
651 temp_slot so that the extra bytes don't get wasted. Do this only
652 for BLKmode slots, so that we can be sure of the alignment. */
653 if (GET_MODE (best_p
->slot
) == BLKmode
)
655 int alignment
= best_p
->align
/ BITS_PER_UNIT
;
656 HOST_WIDE_INT rounded_size
= CEIL_ROUND (size
, alignment
);
658 if (best_p
->size
- rounded_size
>= alignment
)
660 p
= ggc_alloc (sizeof (struct temp_slot
));
661 p
->in_use
= p
->addr_taken
= 0;
662 p
->size
= best_p
->size
- rounded_size
;
663 p
->base_offset
= best_p
->base_offset
+ rounded_size
;
664 p
->full_size
= best_p
->full_size
- rounded_size
;
665 p
->slot
= gen_rtx_MEM (BLKmode
,
666 plus_constant (XEXP (best_p
->slot
, 0),
668 p
->align
= best_p
->align
;
670 p
->type
= best_p
->type
;
671 insert_slot_to_list (p
, &avail_temp_slots
);
673 stack_slot_list
= gen_rtx_EXPR_LIST (VOIDmode
, p
->slot
,
676 best_p
->size
= rounded_size
;
677 best_p
->full_size
= rounded_size
;
682 /* If we still didn't find one, make a new temporary. */
685 HOST_WIDE_INT frame_offset_old
= frame_offset
;
687 p
= ggc_alloc (sizeof (struct temp_slot
));
689 /* We are passing an explicit alignment request to assign_stack_local.
690 One side effect of that is assign_stack_local will not round SIZE
691 to ensure the frame offset remains suitably aligned.
693 So for requests which depended on the rounding of SIZE, we go ahead
694 and round it now. We also make sure ALIGNMENT is at least
695 BIGGEST_ALIGNMENT. */
696 if (mode
== BLKmode
&& align
< BIGGEST_ALIGNMENT
)
698 p
->slot
= assign_stack_local (mode
,
700 ? CEIL_ROUND (size
, (int) align
/ BITS_PER_UNIT
)
706 /* The following slot size computation is necessary because we don't
707 know the actual size of the temporary slot until assign_stack_local
708 has performed all the frame alignment and size rounding for the
709 requested temporary. Note that extra space added for alignment
710 can be either above or below this stack slot depending on which
711 way the frame grows. We include the extra space if and only if it
712 is above this slot. */
713 #ifdef FRAME_GROWS_DOWNWARD
714 p
->size
= frame_offset_old
- frame_offset
;
719 /* Now define the fields used by combine_temp_slots. */
720 #ifdef FRAME_GROWS_DOWNWARD
721 p
->base_offset
= frame_offset
;
722 p
->full_size
= frame_offset_old
- frame_offset
;
724 p
->base_offset
= frame_offset_old
;
725 p
->full_size
= frame_offset
- frame_offset_old
;
739 p
->level
= target_temp_slot_level
;
744 p
->level
= var_temp_slot_level
;
749 p
->level
= temp_slot_level
;
753 pp
= temp_slots_at_level (p
->level
);
754 insert_slot_to_list (p
, pp
);
756 /* Create a new MEM rtx to avoid clobbering MEM flags of old slots. */
757 slot
= gen_rtx_MEM (mode
, XEXP (p
->slot
, 0));
758 stack_slot_list
= gen_rtx_EXPR_LIST (VOIDmode
, slot
, stack_slot_list
);
760 /* If we know the alias set for the memory that will be used, use
761 it. If there's no TYPE, then we don't know anything about the
762 alias set for the memory. */
763 set_mem_alias_set (slot
, type
? get_alias_set (type
) : 0);
764 set_mem_align (slot
, align
);
766 /* If a type is specified, set the relevant flags. */
769 RTX_UNCHANGING_P (slot
) = (lang_hooks
.honor_readonly
770 && TYPE_READONLY (type
));
771 MEM_VOLATILE_P (slot
) = TYPE_VOLATILE (type
);
772 MEM_SET_IN_STRUCT_P (slot
, AGGREGATE_TYPE_P (type
));
778 /* Allocate a temporary stack slot and record it for possible later
779 reuse. First three arguments are same as in preceding function. */
782 assign_stack_temp (enum machine_mode mode
, HOST_WIDE_INT size
, int keep
)
784 return assign_stack_temp_for_type (mode
, size
, keep
, NULL_TREE
);
787 /* Assign a temporary.
788 If TYPE_OR_DECL is a decl, then we are doing it on behalf of the decl
789 and so that should be used in error messages. In either case, we
790 allocate of the given type.
791 KEEP is as for assign_stack_temp.
792 MEMORY_REQUIRED is 1 if the result must be addressable stack memory;
793 it is 0 if a register is OK.
794 DONT_PROMOTE is 1 if we should not promote values in register
798 assign_temp (tree type_or_decl
, int keep
, int memory_required
,
799 int dont_promote ATTRIBUTE_UNUSED
)
802 enum machine_mode mode
;
807 if (DECL_P (type_or_decl
))
808 decl
= type_or_decl
, type
= TREE_TYPE (decl
);
810 decl
= NULL
, type
= type_or_decl
;
812 mode
= TYPE_MODE (type
);
814 unsignedp
= TYPE_UNSIGNED (type
);
817 if (mode
== BLKmode
|| memory_required
)
819 HOST_WIDE_INT size
= int_size_in_bytes (type
);
823 /* Zero sized arrays are GNU C extension. Set size to 1 to avoid
824 problems with allocating the stack space. */
828 /* Unfortunately, we don't yet know how to allocate variable-sized
829 temporaries. However, sometimes we have a fixed upper limit on
830 the size (which is stored in TYPE_ARRAY_MAX_SIZE) and can use that
831 instead. This is the case for Chill variable-sized strings. */
832 if (size
== -1 && TREE_CODE (type
) == ARRAY_TYPE
833 && TYPE_ARRAY_MAX_SIZE (type
) != NULL_TREE
834 && host_integerp (TYPE_ARRAY_MAX_SIZE (type
), 1))
835 size
= tree_low_cst (TYPE_ARRAY_MAX_SIZE (type
), 1);
837 /* If we still haven't been able to get a size, see if the language
838 can compute a maximum size. */
840 && (size_tree
= lang_hooks
.types
.max_size (type
)) != 0
841 && host_integerp (size_tree
, 1))
842 size
= tree_low_cst (size_tree
, 1);
844 /* The size of the temporary may be too large to fit into an integer. */
845 /* ??? Not sure this should happen except for user silliness, so limit
846 this to things that aren't compiler-generated temporaries. The
847 rest of the time we'll abort in assign_stack_temp_for_type. */
848 if (decl
&& size
== -1
849 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
)
851 error ("%Jsize of variable '%D' is too large", decl
, decl
);
855 tmp
= assign_stack_temp_for_type (mode
, size
, keep
, type
);
861 mode
= promote_mode (type
, mode
, &unsignedp
, 0);
864 return gen_reg_rtx (mode
);
867 /* Combine temporary stack slots which are adjacent on the stack.
869 This allows for better use of already allocated stack space. This is only
870 done for BLKmode slots because we can be sure that we won't have alignment
871 problems in this case. */
874 combine_temp_slots (void)
876 struct temp_slot
*p
, *q
, *next
, *next_q
;
879 /* We can't combine slots, because the information about which slot
880 is in which alias set will be lost. */
881 if (flag_strict_aliasing
)
884 /* If there are a lot of temp slots, don't do anything unless
885 high levels of optimization. */
886 if (! flag_expensive_optimizations
)
887 for (p
= avail_temp_slots
, num_slots
= 0; p
; p
= p
->next
, num_slots
++)
888 if (num_slots
> 100 || (num_slots
> 10 && optimize
== 0))
891 for (p
= avail_temp_slots
; p
; p
= next
)
897 if (GET_MODE (p
->slot
) != BLKmode
)
900 for (q
= p
->next
; q
; q
= next_q
)
906 if (GET_MODE (q
->slot
) != BLKmode
)
909 if (p
->base_offset
+ p
->full_size
== q
->base_offset
)
911 /* Q comes after P; combine Q into P. */
913 p
->full_size
+= q
->full_size
;
916 else if (q
->base_offset
+ q
->full_size
== p
->base_offset
)
918 /* P comes after Q; combine P into Q. */
920 q
->full_size
+= p
->full_size
;
925 cut_slot_from_list (q
, &avail_temp_slots
);
928 /* Either delete P or advance past it. */
930 cut_slot_from_list (p
, &avail_temp_slots
);
934 /* Find the temp slot corresponding to the object at address X. */
936 static struct temp_slot
*
937 find_temp_slot_from_address (rtx x
)
943 for (i
= max_slot_level (); i
>= 0; i
--)
944 for (p
= *temp_slots_at_level (i
); p
; p
= p
->next
)
946 if (XEXP (p
->slot
, 0) == x
948 || (GET_CODE (x
) == PLUS
949 && XEXP (x
, 0) == virtual_stack_vars_rtx
950 && GET_CODE (XEXP (x
, 1)) == CONST_INT
951 && INTVAL (XEXP (x
, 1)) >= p
->base_offset
952 && INTVAL (XEXP (x
, 1)) < p
->base_offset
+ p
->full_size
))
955 else if (p
->address
!= 0 && GET_CODE (p
->address
) == EXPR_LIST
)
956 for (next
= p
->address
; next
; next
= XEXP (next
, 1))
957 if (XEXP (next
, 0) == x
)
961 /* If we have a sum involving a register, see if it points to a temp
963 if (GET_CODE (x
) == PLUS
&& REG_P (XEXP (x
, 0))
964 && (p
= find_temp_slot_from_address (XEXP (x
, 0))) != 0)
966 else if (GET_CODE (x
) == PLUS
&& REG_P (XEXP (x
, 1))
967 && (p
= find_temp_slot_from_address (XEXP (x
, 1))) != 0)
973 /* Indicate that NEW is an alternate way of referring to the temp slot
974 that previously was known by OLD. */
977 update_temp_slot_address (rtx old
, rtx
new)
981 if (rtx_equal_p (old
, new))
984 p
= find_temp_slot_from_address (old
);
986 /* If we didn't find one, see if both OLD is a PLUS. If so, and NEW
987 is a register, see if one operand of the PLUS is a temporary
988 location. If so, NEW points into it. Otherwise, if both OLD and
989 NEW are a PLUS and if there is a register in common between them.
990 If so, try a recursive call on those values. */
993 if (GET_CODE (old
) != PLUS
)
998 update_temp_slot_address (XEXP (old
, 0), new);
999 update_temp_slot_address (XEXP (old
, 1), new);
1002 else if (GET_CODE (new) != PLUS
)
1005 if (rtx_equal_p (XEXP (old
, 0), XEXP (new, 0)))
1006 update_temp_slot_address (XEXP (old
, 1), XEXP (new, 1));
1007 else if (rtx_equal_p (XEXP (old
, 1), XEXP (new, 0)))
1008 update_temp_slot_address (XEXP (old
, 0), XEXP (new, 1));
1009 else if (rtx_equal_p (XEXP (old
, 0), XEXP (new, 1)))
1010 update_temp_slot_address (XEXP (old
, 1), XEXP (new, 0));
1011 else if (rtx_equal_p (XEXP (old
, 1), XEXP (new, 1)))
1012 update_temp_slot_address (XEXP (old
, 0), XEXP (new, 0));
1017 /* Otherwise add an alias for the temp's address. */
1018 else if (p
->address
== 0)
1022 if (GET_CODE (p
->address
) != EXPR_LIST
)
1023 p
->address
= gen_rtx_EXPR_LIST (VOIDmode
, p
->address
, NULL_RTX
);
1025 p
->address
= gen_rtx_EXPR_LIST (VOIDmode
, new, p
->address
);
1029 /* If X could be a reference to a temporary slot, mark the fact that its
1030 address was taken. */
1033 mark_temp_addr_taken (rtx x
)
1035 struct temp_slot
*p
;
1040 /* If X is not in memory or is at a constant address, it cannot be in
1041 a temporary slot. */
1042 if (!MEM_P (x
) || CONSTANT_P (XEXP (x
, 0)))
1045 p
= find_temp_slot_from_address (XEXP (x
, 0));
1050 /* If X could be a reference to a temporary slot, mark that slot as
1051 belonging to the to one level higher than the current level. If X
1052 matched one of our slots, just mark that one. Otherwise, we can't
1053 easily predict which it is, so upgrade all of them. Kept slots
1054 need not be touched.
1056 This is called when an ({...}) construct occurs and a statement
1057 returns a value in memory. */
1060 preserve_temp_slots (rtx x
)
1062 struct temp_slot
*p
= 0, *next
;
1064 /* If there is no result, we still might have some objects whose address
1065 were taken, so we need to make sure they stay around. */
1068 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1073 move_slot_to_level (p
, temp_slot_level
- 1);
1079 /* If X is a register that is being used as a pointer, see if we have
1080 a temporary slot we know it points to. To be consistent with
1081 the code below, we really should preserve all non-kept slots
1082 if we can't find a match, but that seems to be much too costly. */
1083 if (REG_P (x
) && REG_POINTER (x
))
1084 p
= find_temp_slot_from_address (x
);
1086 /* If X is not in memory or is at a constant address, it cannot be in
1087 a temporary slot, but it can contain something whose address was
1089 if (p
== 0 && (!MEM_P (x
) || CONSTANT_P (XEXP (x
, 0))))
1091 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1096 move_slot_to_level (p
, temp_slot_level
- 1);
1102 /* First see if we can find a match. */
1104 p
= find_temp_slot_from_address (XEXP (x
, 0));
1108 /* Move everything at our level whose address was taken to our new
1109 level in case we used its address. */
1110 struct temp_slot
*q
;
1112 if (p
->level
== temp_slot_level
)
1114 for (q
= *temp_slots_at_level (temp_slot_level
); q
; q
= next
)
1118 if (p
!= q
&& q
->addr_taken
)
1119 move_slot_to_level (q
, temp_slot_level
- 1);
1122 move_slot_to_level (p
, temp_slot_level
- 1);
1128 /* Otherwise, preserve all non-kept slots at this level. */
1129 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1134 move_slot_to_level (p
, temp_slot_level
- 1);
1138 /* Free all temporaries used so far. This is normally called at the
1139 end of generating code for a statement. */
1142 free_temp_slots (void)
1144 struct temp_slot
*p
, *next
;
1146 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1151 make_slot_available (p
);
1154 combine_temp_slots ();
1157 /* Push deeper into the nesting level for stack temporaries. */
1160 push_temp_slots (void)
1165 /* Pop a temporary nesting level. All slots in use in the current level
1169 pop_temp_slots (void)
1171 struct temp_slot
*p
, *next
;
1173 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1176 make_slot_available (p
);
1179 combine_temp_slots ();
1184 /* Initialize temporary slots. */
1187 init_temp_slots (void)
1189 /* We have not allocated any temporaries yet. */
1190 avail_temp_slots
= 0;
1191 used_temp_slots
= 0;
1192 temp_slot_level
= 0;
1193 var_temp_slot_level
= 0;
1194 target_temp_slot_level
= 0;
1197 /* These routines are responsible for converting virtual register references
1198 to the actual hard register references once RTL generation is complete.
1200 The following four variables are used for communication between the
1201 routines. They contain the offsets of the virtual registers from their
1202 respective hard registers. */
1204 static int in_arg_offset
;
1205 static int var_offset
;
1206 static int dynamic_offset
;
1207 static int out_arg_offset
;
1208 static int cfa_offset
;
1210 /* In most machines, the stack pointer register is equivalent to the bottom
1213 #ifndef STACK_POINTER_OFFSET
1214 #define STACK_POINTER_OFFSET 0
1217 /* If not defined, pick an appropriate default for the offset of dynamically
1218 allocated memory depending on the value of ACCUMULATE_OUTGOING_ARGS,
1219 REG_PARM_STACK_SPACE, and OUTGOING_REG_PARM_STACK_SPACE. */
1221 #ifndef STACK_DYNAMIC_OFFSET
1223 /* The bottom of the stack points to the actual arguments. If
1224 REG_PARM_STACK_SPACE is defined, this includes the space for the register
1225 parameters. However, if OUTGOING_REG_PARM_STACK space is not defined,
1226 stack space for register parameters is not pushed by the caller, but
1227 rather part of the fixed stack areas and hence not included in
1228 `current_function_outgoing_args_size'. Nevertheless, we must allow
1229 for it when allocating stack dynamic objects. */
1231 #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE)
1232 #define STACK_DYNAMIC_OFFSET(FNDECL) \
1233 ((ACCUMULATE_OUTGOING_ARGS \
1234 ? (current_function_outgoing_args_size + REG_PARM_STACK_SPACE (FNDECL)) : 0)\
1235 + (STACK_POINTER_OFFSET)) \
1238 #define STACK_DYNAMIC_OFFSET(FNDECL) \
1239 ((ACCUMULATE_OUTGOING_ARGS ? current_function_outgoing_args_size : 0) \
1240 + (STACK_POINTER_OFFSET))
1244 /* On most machines, the CFA coincides with the first incoming parm. */
1246 #ifndef ARG_POINTER_CFA_OFFSET
1247 #define ARG_POINTER_CFA_OFFSET(FNDECL) FIRST_PARM_OFFSET (FNDECL)
1251 /* Pass through the INSNS of function FNDECL and convert virtual register
1252 references to hard register references. */
1255 instantiate_virtual_regs (void)
1259 /* Compute the offsets to use for this function. */
1260 in_arg_offset
= FIRST_PARM_OFFSET (current_function_decl
);
1261 var_offset
= STARTING_FRAME_OFFSET
;
1262 dynamic_offset
= STACK_DYNAMIC_OFFSET (current_function_decl
);
1263 out_arg_offset
= STACK_POINTER_OFFSET
;
1264 cfa_offset
= ARG_POINTER_CFA_OFFSET (current_function_decl
);
1266 /* Scan all variables and parameters of this function. For each that is
1267 in memory, instantiate all virtual registers if the result is a valid
1268 address. If not, we do it later. That will handle most uses of virtual
1269 regs on many machines. */
1270 instantiate_decls (current_function_decl
, 1);
1272 /* Initialize recognition, indicating that volatile is OK. */
1275 /* Scan through all the insns, instantiating every virtual register still
1277 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1278 if (GET_CODE (insn
) == INSN
|| GET_CODE (insn
) == JUMP_INSN
1279 || GET_CODE (insn
) == CALL_INSN
)
1281 instantiate_virtual_regs_1 (&PATTERN (insn
), insn
, 1);
1282 if (INSN_DELETED_P (insn
))
1284 instantiate_virtual_regs_1 (®_NOTES (insn
), NULL_RTX
, 0);
1285 /* Instantiate any virtual registers in CALL_INSN_FUNCTION_USAGE. */
1286 if (GET_CODE (insn
) == CALL_INSN
)
1287 instantiate_virtual_regs_1 (&CALL_INSN_FUNCTION_USAGE (insn
),
1290 /* Past this point all ASM statements should match. Verify that
1291 to avoid failures later in the compilation process. */
1292 if (asm_noperands (PATTERN (insn
)) >= 0
1293 && ! check_asm_operands (PATTERN (insn
)))
1294 instantiate_virtual_regs_lossage (insn
);
1297 /* Now instantiate the remaining register equivalences for debugging info.
1298 These will not be valid addresses. */
1299 instantiate_decls (current_function_decl
, 0);
1301 /* Indicate that, from now on, assign_stack_local should use
1302 frame_pointer_rtx. */
1303 virtuals_instantiated
= 1;
1306 /* Scan all decls in FNDECL (both variables and parameters) and instantiate
1307 all virtual registers in their DECL_RTL's.
1309 If VALID_ONLY, do this only if the resulting address is still valid.
1310 Otherwise, always do it. */
1313 instantiate_decls (tree fndecl
, int valid_only
)
1317 /* Process all parameters of the function. */
1318 for (decl
= DECL_ARGUMENTS (fndecl
); decl
; decl
= TREE_CHAIN (decl
))
1320 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (decl
));
1321 HOST_WIDE_INT size_rtl
;
1323 instantiate_decl (DECL_RTL (decl
), size
, valid_only
);
1325 /* If the parameter was promoted, then the incoming RTL mode may be
1326 larger than the declared type size. We must use the larger of
1328 size_rtl
= GET_MODE_SIZE (GET_MODE (DECL_INCOMING_RTL (decl
)));
1329 size
= MAX (size_rtl
, size
);
1330 instantiate_decl (DECL_INCOMING_RTL (decl
), size
, valid_only
);
1333 /* Now process all variables defined in the function or its subblocks. */
1334 instantiate_decls_1 (DECL_INITIAL (fndecl
), valid_only
);
1337 /* Subroutine of instantiate_decls: Process all decls in the given
1338 BLOCK node and all its subblocks. */
1341 instantiate_decls_1 (tree let
, int valid_only
)
1345 for (t
= BLOCK_VARS (let
); t
; t
= TREE_CHAIN (t
))
1346 if (DECL_RTL_SET_P (t
))
1347 instantiate_decl (DECL_RTL (t
),
1348 int_size_in_bytes (TREE_TYPE (t
)),
1351 /* Process all subblocks. */
1352 for (t
= BLOCK_SUBBLOCKS (let
); t
; t
= TREE_CHAIN (t
))
1353 instantiate_decls_1 (t
, valid_only
);
1356 /* Subroutine of the preceding procedures: Given RTL representing a
1357 decl and the size of the object, do any instantiation required.
1359 If VALID_ONLY is nonzero, it means that the RTL should only be
1360 changed if the new address is valid. */
1363 instantiate_decl (rtx x
, HOST_WIDE_INT size
, int valid_only
)
1365 enum machine_mode mode
;
1368 /* If this is not a MEM, no need to do anything. Similarly if the
1369 address is a constant or a register that is not a virtual register. */
1371 if (x
== 0 || !MEM_P (x
))
1375 if (CONSTANT_P (addr
)
1377 && (REGNO (addr
) < FIRST_VIRTUAL_REGISTER
1378 || REGNO (addr
) > LAST_VIRTUAL_REGISTER
)))
1381 /* If we should only do this if the address is valid, copy the address.
1382 We need to do this so we can undo any changes that might make the
1383 address invalid. This copy is unfortunate, but probably can't be
1387 addr
= copy_rtx (addr
);
1389 instantiate_virtual_regs_1 (&addr
, NULL_RTX
, 0);
1391 if (valid_only
&& size
>= 0)
1393 unsigned HOST_WIDE_INT decl_size
= size
;
1395 /* Now verify that the resulting address is valid for every integer or
1396 floating-point mode up to and including SIZE bytes long. We do this
1397 since the object might be accessed in any mode and frame addresses
1400 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
1401 mode
!= VOIDmode
&& GET_MODE_SIZE (mode
) <= decl_size
;
1402 mode
= GET_MODE_WIDER_MODE (mode
))
1403 if (! memory_address_p (mode
, addr
))
1406 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_FLOAT
);
1407 mode
!= VOIDmode
&& GET_MODE_SIZE (mode
) <= decl_size
;
1408 mode
= GET_MODE_WIDER_MODE (mode
))
1409 if (! memory_address_p (mode
, addr
))
1413 /* Put back the address now that we have updated it and we either know
1414 it is valid or we don't care whether it is valid. */
1419 /* Given a piece of RTX and a pointer to a HOST_WIDE_INT, if the RTX
1420 is a virtual register, return the equivalent hard register and set the
1421 offset indirectly through the pointer. Otherwise, return 0. */
1424 instantiate_new_reg (rtx x
, HOST_WIDE_INT
*poffset
)
1427 HOST_WIDE_INT offset
;
1429 if (x
== virtual_incoming_args_rtx
)
1430 new = arg_pointer_rtx
, offset
= in_arg_offset
;
1431 else if (x
== virtual_stack_vars_rtx
)
1432 new = frame_pointer_rtx
, offset
= var_offset
;
1433 else if (x
== virtual_stack_dynamic_rtx
)
1434 new = stack_pointer_rtx
, offset
= dynamic_offset
;
1435 else if (x
== virtual_outgoing_args_rtx
)
1436 new = stack_pointer_rtx
, offset
= out_arg_offset
;
1437 else if (x
== virtual_cfa_rtx
)
1438 new = arg_pointer_rtx
, offset
= cfa_offset
;
1447 /* Called when instantiate_virtual_regs has failed to update the instruction.
1448 Usually this means that non-matching instruction has been emit, however for
1449 asm statements it may be the problem in the constraints. */
1451 instantiate_virtual_regs_lossage (rtx insn
)
1453 if (asm_noperands (PATTERN (insn
)) >= 0)
1455 error_for_asm (insn
, "impossible constraint in `asm'");
1461 /* Given a pointer to a piece of rtx and an optional pointer to the
1462 containing object, instantiate any virtual registers present in it.
1464 If EXTRA_INSNS, we always do the replacement and generate
1465 any extra insns before OBJECT. If it zero, we do nothing if replacement
1468 Return 1 if we either had nothing to do or if we were able to do the
1469 needed replacement. Return 0 otherwise; we only return zero if
1470 EXTRA_INSNS is zero.
1472 We first try some simple transformations to avoid the creation of extra
1476 instantiate_virtual_regs_1 (rtx
*loc
, rtx object
, int extra_insns
)
1481 HOST_WIDE_INT offset
= 0;
1487 /* Re-start here to avoid recursion in common cases. */
1494 /* We may have detected and deleted invalid asm statements. */
1495 if (object
&& INSN_P (object
) && INSN_DELETED_P (object
))
1498 code
= GET_CODE (x
);
1500 /* Check for some special cases. */
1518 /* We are allowed to set the virtual registers. This means that
1519 the actual register should receive the source minus the
1520 appropriate offset. This is used, for example, in the handling
1521 of non-local gotos. */
1522 if ((new = instantiate_new_reg (SET_DEST (x
), &offset
)) != 0)
1524 rtx src
= SET_SRC (x
);
1526 /* We are setting the register, not using it, so the relevant
1527 offset is the negative of the offset to use were we using
1530 instantiate_virtual_regs_1 (&src
, NULL_RTX
, 0);
1532 /* The only valid sources here are PLUS or REG. Just do
1533 the simplest possible thing to handle them. */
1534 if (!REG_P (src
) && GET_CODE (src
) != PLUS
)
1536 instantiate_virtual_regs_lossage (object
);
1542 temp
= force_operand (src
, NULL_RTX
);
1545 temp
= force_operand (plus_constant (temp
, offset
), NULL_RTX
);
1549 emit_insn_before (seq
, object
);
1552 if (! validate_change (object
, &SET_SRC (x
), temp
, 0)
1554 instantiate_virtual_regs_lossage (object
);
1559 instantiate_virtual_regs_1 (&SET_DEST (x
), object
, extra_insns
);
1564 /* Handle special case of virtual register plus constant. */
1565 if (CONSTANT_P (XEXP (x
, 1)))
1567 rtx old
, new_offset
;
1569 /* Check for (plus (plus VIRT foo) (const_int)) first. */
1570 if (GET_CODE (XEXP (x
, 0)) == PLUS
)
1572 if ((new = instantiate_new_reg (XEXP (XEXP (x
, 0), 0), &offset
)))
1574 instantiate_virtual_regs_1 (&XEXP (XEXP (x
, 0), 1), object
,
1576 new = gen_rtx_PLUS (Pmode
, new, XEXP (XEXP (x
, 0), 1));
1585 #ifdef POINTERS_EXTEND_UNSIGNED
1586 /* If we have (plus (subreg (virtual-reg)) (const_int)), we know
1587 we can commute the PLUS and SUBREG because pointers into the
1588 frame are well-behaved. */
1589 else if (GET_CODE (XEXP (x
, 0)) == SUBREG
&& GET_MODE (x
) == ptr_mode
1590 && GET_CODE (XEXP (x
, 1)) == CONST_INT
1592 = instantiate_new_reg (SUBREG_REG (XEXP (x
, 0)),
1594 && validate_change (object
, loc
,
1595 plus_constant (gen_lowpart (ptr_mode
,
1598 + INTVAL (XEXP (x
, 1))),
1602 else if ((new = instantiate_new_reg (XEXP (x
, 0), &offset
)) == 0)
1604 /* We know the second operand is a constant. Unless the
1605 first operand is a REG (which has been already checked),
1606 it needs to be checked. */
1607 if (!REG_P (XEXP (x
, 0)))
1615 new_offset
= plus_constant (XEXP (x
, 1), offset
);
1617 /* If the new constant is zero, try to replace the sum with just
1619 if (new_offset
== const0_rtx
1620 && validate_change (object
, loc
, new, 0))
1623 /* Next try to replace the register and new offset.
1624 There are two changes to validate here and we can't assume that
1625 in the case of old offset equals new just changing the register
1626 will yield a valid insn. In the interests of a little efficiency,
1627 however, we only call validate change once (we don't queue up the
1628 changes and then call apply_change_group). */
1632 ? ! validate_change (object
, &XEXP (x
, 0), new, 0)
1633 : (XEXP (x
, 0) = new,
1634 ! validate_change (object
, &XEXP (x
, 1), new_offset
, 0)))
1642 /* Otherwise copy the new constant into a register and replace
1643 constant with that register. */
1644 temp
= gen_reg_rtx (Pmode
);
1646 if (validate_change (object
, &XEXP (x
, 1), temp
, 0))
1647 emit_insn_before (gen_move_insn (temp
, new_offset
), object
);
1650 /* If that didn't work, replace this expression with a
1651 register containing the sum. */
1654 new = gen_rtx_PLUS (Pmode
, new, new_offset
);
1657 temp
= force_operand (new, NULL_RTX
);
1661 emit_insn_before (seq
, object
);
1662 if (! validate_change (object
, loc
, temp
, 0)
1663 && ! validate_replace_rtx (x
, temp
, object
))
1665 instantiate_virtual_regs_lossage (object
);
1674 /* Fall through to generic two-operand expression case. */
1680 case DIV
: case UDIV
:
1681 case MOD
: case UMOD
:
1682 case AND
: case IOR
: case XOR
:
1683 case ROTATERT
: case ROTATE
:
1684 case ASHIFTRT
: case LSHIFTRT
: case ASHIFT
:
1686 case GE
: case GT
: case GEU
: case GTU
:
1687 case LE
: case LT
: case LEU
: case LTU
:
1688 if (XEXP (x
, 1) && ! CONSTANT_P (XEXP (x
, 1)))
1689 instantiate_virtual_regs_1 (&XEXP (x
, 1), object
, extra_insns
);
1694 /* Most cases of MEM that convert to valid addresses have already been
1695 handled by our scan of decls. The only special handling we
1696 need here is to make a copy of the rtx to ensure it isn't being
1697 shared if we have to change it to a pseudo.
1699 If the rtx is a simple reference to an address via a virtual register,
1700 it can potentially be shared. In such cases, first try to make it
1701 a valid address, which can also be shared. Otherwise, copy it and
1704 First check for common cases that need no processing. These are
1705 usually due to instantiation already being done on a previous instance
1709 if (CONSTANT_ADDRESS_P (temp
)
1710 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1711 || temp
== arg_pointer_rtx
1713 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
1714 || temp
== hard_frame_pointer_rtx
1716 || temp
== frame_pointer_rtx
)
1719 if (GET_CODE (temp
) == PLUS
1720 && CONSTANT_ADDRESS_P (XEXP (temp
, 1))
1721 && (XEXP (temp
, 0) == frame_pointer_rtx
1722 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
1723 || XEXP (temp
, 0) == hard_frame_pointer_rtx
1725 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1726 || XEXP (temp
, 0) == arg_pointer_rtx
1731 if (temp
== virtual_stack_vars_rtx
1732 || temp
== virtual_incoming_args_rtx
1733 || (GET_CODE (temp
) == PLUS
1734 && CONSTANT_ADDRESS_P (XEXP (temp
, 1))
1735 && (XEXP (temp
, 0) == virtual_stack_vars_rtx
1736 || XEXP (temp
, 0) == virtual_incoming_args_rtx
)))
1738 /* This MEM may be shared. If the substitution can be done without
1739 the need to generate new pseudos, we want to do it in place
1740 so all copies of the shared rtx benefit. The call below will
1741 only make substitutions if the resulting address is still
1744 Note that we cannot pass X as the object in the recursive call
1745 since the insn being processed may not allow all valid
1746 addresses. However, if we were not passed on object, we can
1747 only modify X without copying it if X will have a valid
1750 ??? Also note that this can still lose if OBJECT is an insn that
1751 has less restrictions on an address that some other insn.
1752 In that case, we will modify the shared address. This case
1753 doesn't seem very likely, though. One case where this could
1754 happen is in the case of a USE or CLOBBER reference, but we
1755 take care of that below. */
1757 if (instantiate_virtual_regs_1 (&XEXP (x
, 0),
1758 object
? object
: x
, 0))
1761 /* Otherwise make a copy and process that copy. We copy the entire
1762 RTL expression since it might be a PLUS which could also be
1764 *loc
= x
= copy_rtx (x
);
1767 /* Fall through to generic unary operation case. */
1770 case STRICT_LOW_PART
:
1772 case PRE_DEC
: case PRE_INC
: case POST_DEC
: case POST_INC
:
1773 case SIGN_EXTEND
: case ZERO_EXTEND
:
1774 case TRUNCATE
: case FLOAT_EXTEND
: case FLOAT_TRUNCATE
:
1775 case FLOAT
: case FIX
:
1776 case UNSIGNED_FIX
: case UNSIGNED_FLOAT
:
1781 case POPCOUNT
: case PARITY
:
1782 /* These case either have just one operand or we know that we need not
1783 check the rest of the operands. */
1789 /* If the operand is a MEM, see if the change is a valid MEM. If not,
1790 go ahead and make the invalid one, but do it to a copy. For a REG,
1791 just make the recursive call, since there's no chance of a problem. */
1793 if ((MEM_P (XEXP (x
, 0))
1794 && instantiate_virtual_regs_1 (&XEXP (XEXP (x
, 0), 0), XEXP (x
, 0),
1796 || (REG_P (XEXP (x
, 0))
1797 && instantiate_virtual_regs_1 (&XEXP (x
, 0), object
, 0)))
1800 XEXP (x
, 0) = copy_rtx (XEXP (x
, 0));
1805 /* Try to replace with a PLUS. If that doesn't work, compute the sum
1806 in front of this insn and substitute the temporary. */
1807 if ((new = instantiate_new_reg (x
, &offset
)) != 0)
1809 temp
= plus_constant (new, offset
);
1810 if (!validate_change (object
, loc
, temp
, 0))
1816 temp
= force_operand (temp
, NULL_RTX
);
1820 emit_insn_before (seq
, object
);
1821 if (! validate_change (object
, loc
, temp
, 0)
1822 && ! validate_replace_rtx (x
, temp
, object
))
1823 instantiate_virtual_regs_lossage (object
);
1833 /* Scan all subexpressions. */
1834 fmt
= GET_RTX_FORMAT (code
);
1835 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++, fmt
++)
1838 if (!instantiate_virtual_regs_1 (&XEXP (x
, i
), object
, extra_insns
))
1841 else if (*fmt
== 'E')
1842 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1843 if (! instantiate_virtual_regs_1 (&XVECEXP (x
, i
, j
), object
,
1850 /* Return 1 if EXP is an aggregate type (or a value with aggregate type).
1851 This means a type for which function calls must pass an address to the
1852 function or get an address back from the function.
1853 EXP may be a type node or an expression (whose type is tested). */
1856 aggregate_value_p (tree exp
, tree fntype
)
1858 int i
, regno
, nregs
;
1861 tree type
= (TYPE_P (exp
)) ? exp
: TREE_TYPE (exp
);
1864 switch (TREE_CODE (fntype
))
1867 fntype
= get_callee_fndecl (fntype
);
1868 fntype
= fntype
? TREE_TYPE (fntype
) : 0;
1871 fntype
= TREE_TYPE (fntype
);
1876 case IDENTIFIER_NODE
:
1880 /* We don't expect other rtl types here. */
1884 if (TREE_CODE (type
) == VOID_TYPE
)
1886 /* If the front end has decided that this needs to be passed by
1887 reference, do so. */
1888 if ((TREE_CODE (exp
) == PARM_DECL
|| TREE_CODE (exp
) == RESULT_DECL
)
1889 && DECL_BY_REFERENCE (exp
))
1891 if (targetm
.calls
.return_in_memory (type
, fntype
))
1893 /* Types that are TREE_ADDRESSABLE must be constructed in memory,
1894 and thus can't be returned in registers. */
1895 if (TREE_ADDRESSABLE (type
))
1897 if (flag_pcc_struct_return
&& AGGREGATE_TYPE_P (type
))
1899 /* Make sure we have suitable call-clobbered regs to return
1900 the value in; if not, we must return it in memory. */
1901 reg
= hard_function_value (type
, 0, 0);
1903 /* If we have something other than a REG (e.g. a PARALLEL), then assume
1908 regno
= REGNO (reg
);
1909 nregs
= hard_regno_nregs
[regno
][TYPE_MODE (type
)];
1910 for (i
= 0; i
< nregs
; i
++)
1911 if (! call_used_regs
[regno
+ i
])
1916 /* Return true if we should assign DECL a pseudo register; false if it
1917 should live on the local stack. */
1920 use_register_for_decl (tree decl
)
1922 /* Honor volatile. */
1923 if (TREE_SIDE_EFFECTS (decl
))
1926 /* Honor addressability. */
1927 if (TREE_ADDRESSABLE (decl
))
1930 /* Only register-like things go in registers. */
1931 if (DECL_MODE (decl
) == BLKmode
)
1934 /* If -ffloat-store specified, don't put explicit float variables
1936 /* ??? This should be checked after DECL_ARTIFICIAL, but tree-ssa
1937 propagates values across these stores, and it probably shouldn't. */
1938 if (flag_float_store
&& FLOAT_TYPE_P (TREE_TYPE (decl
)))
1941 /* Compiler-generated temporaries can always go in registers. */
1942 if (DECL_ARTIFICIAL (decl
))
1945 #ifdef NON_SAVING_SETJMP
1946 /* Protect variables not declared "register" from setjmp. */
1947 if (NON_SAVING_SETJMP
1948 && current_function_calls_setjmp
1949 && !DECL_REGISTER (decl
))
1953 return (optimize
|| DECL_REGISTER (decl
));
1956 /* Return true if TYPE should be passed by invisible reference. */
1959 pass_by_reference (CUMULATIVE_ARGS
*ca
, enum machine_mode mode
,
1960 tree type
, bool named_arg
)
1964 /* If this type contains non-trivial constructors, then it is
1965 forbidden for the middle-end to create any new copies. */
1966 if (TREE_ADDRESSABLE (type
))
1969 /* GCC post 3.4 passes *all* variable sized types by reference. */
1970 if (!TYPE_SIZE (type
) || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1974 return targetm
.calls
.pass_by_reference (ca
, mode
, type
, named_arg
);
1977 /* Structures to communicate between the subroutines of assign_parms.
1978 The first holds data persistent across all parameters, the second
1979 is cleared out for each parameter. */
1981 struct assign_parm_data_all
1983 CUMULATIVE_ARGS args_so_far
;
1984 struct args_size stack_args_size
;
1985 tree function_result_decl
;
1987 rtx conversion_insns
;
1988 HOST_WIDE_INT pretend_args_size
;
1989 HOST_WIDE_INT extra_pretend_bytes
;
1990 int reg_parm_stack_space
;
1993 struct assign_parm_data_one
1999 enum machine_mode nominal_mode
;
2000 enum machine_mode passed_mode
;
2001 enum machine_mode promoted_mode
;
2002 struct locate_and_pad_arg_data locate
;
2004 BOOL_BITFIELD named_arg
: 1;
2005 BOOL_BITFIELD last_named
: 1;
2006 BOOL_BITFIELD passed_pointer
: 1;
2007 BOOL_BITFIELD on_stack
: 1;
2008 BOOL_BITFIELD loaded_in_reg
: 1;
2011 /* A subroutine of assign_parms. Initialize ALL. */
2014 assign_parms_initialize_all (struct assign_parm_data_all
*all
)
2018 memset (all
, 0, sizeof (*all
));
2020 fntype
= TREE_TYPE (current_function_decl
);
2022 #ifdef INIT_CUMULATIVE_INCOMING_ARGS
2023 INIT_CUMULATIVE_INCOMING_ARGS (all
->args_so_far
, fntype
, NULL_RTX
);
2025 INIT_CUMULATIVE_ARGS (all
->args_so_far
, fntype
, NULL_RTX
,
2026 current_function_decl
, -1);
2029 #ifdef REG_PARM_STACK_SPACE
2030 all
->reg_parm_stack_space
= REG_PARM_STACK_SPACE (current_function_decl
);
2034 /* If ARGS contains entries with complex types, split the entry into two
2035 entries of the component type. Return a new list of substitutions are
2036 needed, else the old list. */
2039 split_complex_args (tree args
)
2043 /* Before allocating memory, check for the common case of no complex. */
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
))
2054 args
= copy_list (args
);
2056 for (p
= args
; p
; p
= TREE_CHAIN (p
))
2058 tree type
= TREE_TYPE (p
);
2059 if (TREE_CODE (type
) == COMPLEX_TYPE
2060 && targetm
.calls
.split_complex_arg (type
))
2063 tree subtype
= TREE_TYPE (type
);
2065 /* Rewrite the PARM_DECL's type with its component. */
2066 TREE_TYPE (p
) = subtype
;
2067 DECL_ARG_TYPE (p
) = TREE_TYPE (DECL_ARG_TYPE (p
));
2068 DECL_MODE (p
) = VOIDmode
;
2069 DECL_SIZE (p
) = NULL
;
2070 DECL_SIZE_UNIT (p
) = NULL
;
2073 /* Build a second synthetic decl. */
2074 decl
= build_decl (PARM_DECL
, NULL_TREE
, subtype
);
2075 DECL_ARG_TYPE (decl
) = DECL_ARG_TYPE (p
);
2076 layout_decl (decl
, 0);
2078 /* Splice it in; skip the new decl. */
2079 TREE_CHAIN (decl
) = TREE_CHAIN (p
);
2080 TREE_CHAIN (p
) = decl
;
2088 /* A subroutine of assign_parms. Adjust the parameter list to incorporate
2089 the hidden struct return argument, and (abi willing) complex args.
2090 Return the new parameter list. */
2093 assign_parms_augmented_arg_list (struct assign_parm_data_all
*all
)
2095 tree fndecl
= current_function_decl
;
2096 tree fntype
= TREE_TYPE (fndecl
);
2097 tree fnargs
= DECL_ARGUMENTS (fndecl
);
2099 /* If struct value address is treated as the first argument, make it so. */
2100 if (aggregate_value_p (DECL_RESULT (fndecl
), fndecl
)
2101 && ! current_function_returns_pcc_struct
2102 && targetm
.calls
.struct_value_rtx (TREE_TYPE (fndecl
), 1) == 0)
2104 tree type
= build_pointer_type (TREE_TYPE (fntype
));
2107 decl
= build_decl (PARM_DECL
, NULL_TREE
, type
);
2108 DECL_ARG_TYPE (decl
) = type
;
2109 DECL_ARTIFICIAL (decl
) = 1;
2111 TREE_CHAIN (decl
) = fnargs
;
2113 all
->function_result_decl
= decl
;
2116 all
->orig_fnargs
= fnargs
;
2118 /* If the target wants to split complex arguments into scalars, do so. */
2119 if (targetm
.calls
.split_complex_arg
)
2120 fnargs
= split_complex_args (fnargs
);
2125 /* A subroutine of assign_parms. Examine PARM and pull out type and mode
2126 data for the parameter. Incorporate ABI specifics such as pass-by-
2127 reference and type promotion. */
2130 assign_parm_find_data_types (struct assign_parm_data_all
*all
, tree parm
,
2131 struct assign_parm_data_one
*data
)
2133 tree nominal_type
, passed_type
;
2134 enum machine_mode nominal_mode
, passed_mode
, promoted_mode
;
2136 memset (data
, 0, sizeof (*data
));
2138 /* Set LAST_NAMED if this is last named arg before last anonymous args. */
2139 if (current_function_stdarg
)
2142 for (tem
= TREE_CHAIN (parm
); tem
; tem
= TREE_CHAIN (tem
))
2143 if (DECL_NAME (tem
))
2146 data
->last_named
= true;
2149 /* Set NAMED_ARG if this arg should be treated as a named arg. For
2150 most machines, if this is a varargs/stdarg function, then we treat
2151 the last named arg as if it were anonymous too. */
2152 if (targetm
.calls
.strict_argument_naming (&all
->args_so_far
))
2153 data
->named_arg
= 1;
2155 data
->named_arg
= !data
->last_named
;
2157 nominal_type
= TREE_TYPE (parm
);
2158 passed_type
= DECL_ARG_TYPE (parm
);
2160 /* Look out for errors propagating this far. Also, if the parameter's
2161 type is void then its value doesn't matter. */
2162 if (TREE_TYPE (parm
) == error_mark_node
2163 /* This can happen after weird syntax errors
2164 or if an enum type is defined among the parms. */
2165 || TREE_CODE (parm
) != PARM_DECL
2166 || passed_type
== NULL
2167 || VOID_TYPE_P (nominal_type
))
2169 nominal_type
= passed_type
= void_type_node
;
2170 nominal_mode
= passed_mode
= promoted_mode
= VOIDmode
;
2174 /* Find mode of arg as it is passed, and mode of arg as it should be
2175 during execution of this function. */
2176 passed_mode
= TYPE_MODE (passed_type
);
2177 nominal_mode
= TYPE_MODE (nominal_type
);
2179 /* If the parm is to be passed as a transparent union, use the type of
2180 the first field for the tests below. We have already verified that
2181 the modes are the same. */
2182 if (DECL_TRANSPARENT_UNION (parm
)
2183 || (TREE_CODE (passed_type
) == UNION_TYPE
2184 && TYPE_TRANSPARENT_UNION (passed_type
)))
2185 passed_type
= TREE_TYPE (TYPE_FIELDS (passed_type
));
2187 /* See if this arg was passed by invisible reference. */
2188 if (pass_by_reference (&all
->args_so_far
, passed_mode
,
2189 passed_type
, data
->named_arg
))
2191 passed_type
= nominal_type
= build_pointer_type (passed_type
);
2192 data
->passed_pointer
= true;
2193 passed_mode
= nominal_mode
= Pmode
;
2196 /* Find mode as it is passed by the ABI. */
2197 promoted_mode
= passed_mode
;
2198 if (targetm
.calls
.promote_function_args (TREE_TYPE (current_function_decl
)))
2200 int unsignedp
= TYPE_UNSIGNED (passed_type
);
2201 promoted_mode
= promote_mode (passed_type
, promoted_mode
,
2206 data
->nominal_type
= nominal_type
;
2207 data
->passed_type
= passed_type
;
2208 data
->nominal_mode
= nominal_mode
;
2209 data
->passed_mode
= passed_mode
;
2210 data
->promoted_mode
= promoted_mode
;
2213 /* A subroutine of assign_parms. Invoke setup_incoming_varargs. */
2216 assign_parms_setup_varargs (struct assign_parm_data_all
*all
,
2217 struct assign_parm_data_one
*data
, bool no_rtl
)
2219 int varargs_pretend_bytes
= 0;
2221 targetm
.calls
.setup_incoming_varargs (&all
->args_so_far
,
2222 data
->promoted_mode
,
2224 &varargs_pretend_bytes
, no_rtl
);
2226 /* If the back-end has requested extra stack space, record how much is
2227 needed. Do not change pretend_args_size otherwise since it may be
2228 nonzero from an earlier partial argument. */
2229 if (varargs_pretend_bytes
> 0)
2230 all
->pretend_args_size
= varargs_pretend_bytes
;
2233 /* A subroutine of assign_parms. Set DATA->ENTRY_PARM corresponding to
2234 the incoming location of the current parameter. */
2237 assign_parm_find_entry_rtl (struct assign_parm_data_all
*all
,
2238 struct assign_parm_data_one
*data
)
2240 HOST_WIDE_INT pretend_bytes
= 0;
2244 if (data
->promoted_mode
== VOIDmode
)
2246 data
->entry_parm
= data
->stack_parm
= const0_rtx
;
2250 #ifdef FUNCTION_INCOMING_ARG
2251 entry_parm
= FUNCTION_INCOMING_ARG (all
->args_so_far
, data
->promoted_mode
,
2252 data
->passed_type
, data
->named_arg
);
2254 entry_parm
= FUNCTION_ARG (all
->args_so_far
, data
->promoted_mode
,
2255 data
->passed_type
, data
->named_arg
);
2258 if (entry_parm
== 0)
2259 data
->promoted_mode
= data
->passed_mode
;
2261 /* Determine parm's home in the stack, in case it arrives in the stack
2262 or we should pretend it did. Compute the stack position and rtx where
2263 the argument arrives and its size.
2265 There is one complexity here: If this was a parameter that would
2266 have been passed in registers, but wasn't only because it is
2267 __builtin_va_alist, we want locate_and_pad_parm to treat it as if
2268 it came in a register so that REG_PARM_STACK_SPACE isn't skipped.
2269 In this case, we call FUNCTION_ARG with NAMED set to 1 instead of 0
2270 as it was the previous time. */
2271 in_regs
= entry_parm
!= 0;
2272 #ifdef STACK_PARMS_IN_REG_PARM_AREA
2275 if (!in_regs
&& !data
->named_arg
)
2277 if (targetm
.calls
.pretend_outgoing_varargs_named (&all
->args_so_far
))
2280 #ifdef FUNCTION_INCOMING_ARG
2281 tem
= FUNCTION_INCOMING_ARG (all
->args_so_far
, data
->promoted_mode
,
2282 data
->passed_type
, true);
2284 tem
= FUNCTION_ARG (all
->args_so_far
, data
->promoted_mode
,
2285 data
->passed_type
, true);
2287 in_regs
= tem
!= NULL
;
2291 /* If this parameter was passed both in registers and in the stack, use
2292 the copy on the stack. */
2293 if (targetm
.calls
.must_pass_in_stack (data
->promoted_mode
,
2301 partial
= FUNCTION_ARG_PARTIAL_NREGS (all
->args_so_far
,
2302 data
->promoted_mode
,
2305 data
->partial
= partial
;
2307 /* The caller might already have allocated stack space for the
2308 register parameters. */
2309 if (partial
!= 0 && all
->reg_parm_stack_space
== 0)
2311 /* Part of this argument is passed in registers and part
2312 is passed on the stack. Ask the prologue code to extend
2313 the stack part so that we can recreate the full value.
2315 PRETEND_BYTES is the size of the registers we need to store.
2316 CURRENT_FUNCTION_PRETEND_ARGS_SIZE is the amount of extra
2317 stack space that the prologue should allocate.
2319 Internally, gcc assumes that the argument pointer is aligned
2320 to STACK_BOUNDARY bits. This is used both for alignment
2321 optimizations (see init_emit) and to locate arguments that are
2322 aligned to more than PARM_BOUNDARY bits. We must preserve this
2323 invariant by rounding CURRENT_FUNCTION_PRETEND_ARGS_SIZE up to
2324 a stack boundary. */
2326 /* We assume at most one partial arg, and it must be the first
2327 argument on the stack. */
2328 if (all
->extra_pretend_bytes
|| all
->pretend_args_size
)
2331 pretend_bytes
= partial
* UNITS_PER_WORD
;
2332 all
->pretend_args_size
= CEIL_ROUND (pretend_bytes
, STACK_BYTES
);
2334 /* We want to align relative to the actual stack pointer, so
2335 don't include this in the stack size until later. */
2336 all
->extra_pretend_bytes
= all
->pretend_args_size
;
2340 locate_and_pad_parm (data
->promoted_mode
, data
->passed_type
, in_regs
,
2341 entry_parm
? data
->partial
: 0, current_function_decl
,
2342 &all
->stack_args_size
, &data
->locate
);
2344 /* Adjust offsets to include the pretend args. */
2345 pretend_bytes
= all
->extra_pretend_bytes
- pretend_bytes
;
2346 data
->locate
.slot_offset
.constant
+= pretend_bytes
;
2347 data
->locate
.offset
.constant
+= pretend_bytes
;
2349 data
->entry_parm
= entry_parm
;
2352 /* A subroutine of assign_parms. If there is actually space on the stack
2353 for this parm, count it in stack_args_size and return true. */
2356 assign_parm_is_stack_parm (struct assign_parm_data_all
*all
,
2357 struct assign_parm_data_one
*data
)
2359 /* Trivially true if we've no incomming register. */
2360 if (data
->entry_parm
== NULL
)
2362 /* Also true if we're partially in registers and partially not,
2363 since we've arranged to drop the entire argument on the stack. */
2364 else if (data
->partial
!= 0)
2366 /* Also true if the target says that it's passed in both registers
2367 and on the stack. */
2368 else if (GET_CODE (data
->entry_parm
) == PARALLEL
2369 && XEXP (XVECEXP (data
->entry_parm
, 0, 0), 0) == NULL_RTX
)
2371 /* Also true if the target says that there's stack allocated for
2372 all register parameters. */
2373 else if (all
->reg_parm_stack_space
> 0)
2375 /* Otherwise, no, this parameter has no ABI defined stack slot. */
2379 all
->stack_args_size
.constant
+= data
->locate
.size
.constant
;
2380 if (data
->locate
.size
.var
)
2381 ADD_PARM_SIZE (all
->stack_args_size
, data
->locate
.size
.var
);
2386 /* A subroutine of assign_parms. Given that this parameter is allocated
2387 stack space by the ABI, find it. */
2390 assign_parm_find_stack_rtl (tree parm
, struct assign_parm_data_one
*data
)
2392 rtx offset_rtx
, stack_parm
;
2393 unsigned int align
, boundary
;
2395 /* If we're passing this arg using a reg, make its stack home the
2396 aligned stack slot. */
2397 if (data
->entry_parm
)
2398 offset_rtx
= ARGS_SIZE_RTX (data
->locate
.slot_offset
);
2400 offset_rtx
= ARGS_SIZE_RTX (data
->locate
.offset
);
2402 stack_parm
= current_function_internal_arg_pointer
;
2403 if (offset_rtx
!= const0_rtx
)
2404 stack_parm
= gen_rtx_PLUS (Pmode
, stack_parm
, offset_rtx
);
2405 stack_parm
= gen_rtx_MEM (data
->promoted_mode
, stack_parm
);
2407 set_mem_attributes (stack_parm
, parm
, 1);
2409 boundary
= FUNCTION_ARG_BOUNDARY (data
->promoted_mode
, data
->passed_type
);
2412 /* If we're padding upward, we know that the alignment of the slot
2413 is FUNCTION_ARG_BOUNDARY. If we're using slot_offset, we're
2414 intentionally forcing upward padding. Otherwise we have to come
2415 up with a guess at the alignment based on OFFSET_RTX. */
2416 if (data
->locate
.where_pad
== upward
|| data
->entry_parm
)
2418 else if (GET_CODE (offset_rtx
) == CONST_INT
)
2420 align
= INTVAL (offset_rtx
) * BITS_PER_UNIT
| boundary
;
2421 align
= align
& -align
;
2424 set_mem_align (stack_parm
, align
);
2426 if (data
->entry_parm
)
2427 set_reg_attrs_for_parm (data
->entry_parm
, stack_parm
);
2429 data
->stack_parm
= stack_parm
;
2432 /* A subroutine of assign_parms. Adjust DATA->ENTRY_RTL such that it's
2433 always valid and contiguous. */
2436 assign_parm_adjust_entry_rtl (struct assign_parm_data_one
*data
)
2438 rtx entry_parm
= data
->entry_parm
;
2439 rtx stack_parm
= data
->stack_parm
;
2441 /* If this parm was passed part in regs and part in memory, pretend it
2442 arrived entirely in memory by pushing the register-part onto the stack.
2443 In the special case of a DImode or DFmode that is split, we could put
2444 it together in a pseudoreg directly, but for now that's not worth
2446 if (data
->partial
!= 0)
2448 /* Handle calls that pass values in multiple non-contiguous
2449 locations. The Irix 6 ABI has examples of this. */
2450 if (GET_CODE (entry_parm
) == PARALLEL
)
2451 emit_group_store (validize_mem (stack_parm
), entry_parm
,
2453 int_size_in_bytes (data
->passed_type
));
2455 move_block_from_reg (REGNO (entry_parm
), validize_mem (stack_parm
),
2458 entry_parm
= stack_parm
;
2461 /* If we didn't decide this parm came in a register, by default it came
2463 else if (entry_parm
== NULL
)
2464 entry_parm
= stack_parm
;
2466 /* When an argument is passed in multiple locations, we can't make use
2467 of this information, but we can save some copying if the whole argument
2468 is passed in a single register. */
2469 else if (GET_CODE (entry_parm
) == PARALLEL
2470 && data
->nominal_mode
!= BLKmode
2471 && data
->passed_mode
!= BLKmode
)
2473 size_t i
, len
= XVECLEN (entry_parm
, 0);
2475 for (i
= 0; i
< len
; i
++)
2476 if (XEXP (XVECEXP (entry_parm
, 0, i
), 0) != NULL_RTX
2477 && REG_P (XEXP (XVECEXP (entry_parm
, 0, i
), 0))
2478 && (GET_MODE (XEXP (XVECEXP (entry_parm
, 0, i
), 0))
2479 == data
->passed_mode
)
2480 && INTVAL (XEXP (XVECEXP (entry_parm
, 0, i
), 1)) == 0)
2482 entry_parm
= XEXP (XVECEXP (entry_parm
, 0, i
), 0);
2487 data
->entry_parm
= entry_parm
;
2490 /* A subroutine of assign_parms. Adjust DATA->STACK_RTL such that it's
2491 always valid and properly aligned. */
2495 assign_parm_adjust_stack_rtl (struct assign_parm_data_one
*data
)
2497 rtx stack_parm
= data
->stack_parm
;
2499 /* If we can't trust the parm stack slot to be aligned enough for its
2500 ultimate type, don't use that slot after entry. We'll make another
2501 stack slot, if we need one. */
2502 if (STRICT_ALIGNMENT
&& stack_parm
2503 && GET_MODE_ALIGNMENT (data
->nominal_mode
) > MEM_ALIGN (stack_parm
))
2506 /* If parm was passed in memory, and we need to convert it on entry,
2507 don't store it back in that same slot. */
2508 else if (data
->entry_parm
== stack_parm
2509 && data
->nominal_mode
!= BLKmode
2510 && data
->nominal_mode
!= data
->passed_mode
)
2513 data
->stack_parm
= stack_parm
;
2516 /* A subroutine of assign_parms. Return true if the current parameter
2517 should be stored as a BLKmode in the current frame. */
2520 assign_parm_setup_block_p (struct assign_parm_data_one
*data
)
2522 if (data
->nominal_mode
== BLKmode
)
2524 if (GET_CODE (data
->entry_parm
) == PARALLEL
)
2527 #ifdef BLOCK_REG_PADDING
2528 if (data
->locate
.where_pad
== (BYTES_BIG_ENDIAN
? upward
: downward
)
2529 && GET_MODE_SIZE (data
->promoted_mode
) < UNITS_PER_WORD
)
2536 /* A subroutine of assign_parms. Arrange for the parameter to be
2537 present and valid in DATA->STACK_RTL. */
2540 assign_parm_setup_block (tree parm
, struct assign_parm_data_one
*data
)
2542 rtx entry_parm
= data
->entry_parm
;
2543 rtx stack_parm
= data
->stack_parm
;
2545 /* If we've a non-block object that's nevertheless passed in parts,
2546 reconstitute it in register operations rather than on the stack. */
2547 if (GET_CODE (entry_parm
) == PARALLEL
2548 && data
->nominal_mode
!= BLKmode
2549 && XVECLEN (entry_parm
, 0) > 1
2552 rtx parmreg
= gen_reg_rtx (data
->nominal_mode
);
2554 emit_group_store (parmreg
, entry_parm
, data
->nominal_type
,
2555 int_size_in_bytes (data
->nominal_type
));
2556 SET_DECL_RTL (parm
, parmreg
);
2560 /* If a BLKmode arrives in registers, copy it to a stack slot. Handle
2561 calls that pass values in multiple non-contiguous locations. */
2562 if (REG_P (entry_parm
) || GET_CODE (entry_parm
) == PARALLEL
)
2564 HOST_WIDE_INT size
= int_size_in_bytes (data
->passed_type
);
2565 HOST_WIDE_INT size_stored
= CEIL_ROUND (size
, UNITS_PER_WORD
);
2568 /* Note that we will be storing an integral number of words.
2569 So we have to be careful to ensure that we allocate an
2570 integral number of words. We do this below in the
2571 assign_stack_local if space was not allocated in the argument
2572 list. If it was, this will not work if PARM_BOUNDARY is not
2573 a multiple of BITS_PER_WORD. It isn't clear how to fix this
2574 if it becomes a problem. Exception is when BLKmode arrives
2575 with arguments not conforming to word_mode. */
2577 if (stack_parm
== 0)
2579 stack_parm
= assign_stack_local (BLKmode
, size_stored
, 0);
2580 data
->stack_parm
= stack_parm
;
2581 PUT_MODE (stack_parm
, GET_MODE (entry_parm
));
2582 set_mem_attributes (stack_parm
, parm
, 1);
2584 else if (GET_CODE (entry_parm
) == PARALLEL
)
2586 else if (size
!= 0 && PARM_BOUNDARY
% BITS_PER_WORD
!= 0)
2589 mem
= validize_mem (stack_parm
);
2591 /* Handle values in multiple non-contiguous locations. */
2592 if (GET_CODE (entry_parm
) == PARALLEL
)
2593 emit_group_store (mem
, entry_parm
, data
->passed_type
, size
);
2598 /* If SIZE is that of a mode no bigger than a word, just use
2599 that mode's store operation. */
2600 else if (size
<= UNITS_PER_WORD
)
2602 enum machine_mode mode
2603 = mode_for_size (size
* BITS_PER_UNIT
, MODE_INT
, 0);
2606 #ifdef BLOCK_REG_PADDING
2607 && (size
== UNITS_PER_WORD
2608 || (BLOCK_REG_PADDING (mode
, data
->passed_type
, 1)
2609 != (BYTES_BIG_ENDIAN
? upward
: downward
)))
2613 rtx reg
= gen_rtx_REG (mode
, REGNO (entry_parm
));
2614 emit_move_insn (change_address (mem
, mode
, 0), reg
);
2617 /* Blocks smaller than a word on a BYTES_BIG_ENDIAN
2618 machine must be aligned to the left before storing
2619 to memory. Note that the previous test doesn't
2620 handle all cases (e.g. SIZE == 3). */
2621 else if (size
!= UNITS_PER_WORD
2622 #ifdef BLOCK_REG_PADDING
2623 && (BLOCK_REG_PADDING (mode
, data
->passed_type
, 1)
2631 int by
= (UNITS_PER_WORD
- size
) * BITS_PER_UNIT
;
2632 rtx reg
= gen_rtx_REG (word_mode
, REGNO (data
->entry_parm
));
2634 x
= expand_shift (LSHIFT_EXPR
, word_mode
, reg
,
2635 build_int_2 (by
, 0), NULL_RTX
, 1);
2636 tem
= change_address (mem
, word_mode
, 0);
2637 emit_move_insn (tem
, x
);
2640 move_block_from_reg (REGNO (data
->entry_parm
), mem
,
2641 size_stored
/ UNITS_PER_WORD
);
2644 move_block_from_reg (REGNO (data
->entry_parm
), mem
,
2645 size_stored
/ UNITS_PER_WORD
);
2648 SET_DECL_RTL (parm
, stack_parm
);
2651 /* A subroutine of assign_parms. Allocate a pseudo to hold the current
2652 parameter. Get it there. Perform all ABI specified conversions. */
2655 assign_parm_setup_reg (struct assign_parm_data_all
*all
, tree parm
,
2656 struct assign_parm_data_one
*data
)
2659 enum machine_mode promoted_nominal_mode
;
2660 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (parm
));
2661 bool did_conversion
= false;
2663 /* Store the parm in a pseudoregister during the function, but we may
2664 need to do it in a wider mode. */
2666 promoted_nominal_mode
2667 = promote_mode (data
->nominal_type
, data
->nominal_mode
, &unsignedp
, 0);
2669 parmreg
= gen_reg_rtx (promoted_nominal_mode
);
2671 if (!DECL_ARTIFICIAL (parm
))
2672 mark_user_reg (parmreg
);
2674 /* If this was an item that we received a pointer to,
2675 set DECL_RTL appropriately. */
2676 if (data
->passed_pointer
)
2678 rtx x
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data
->passed_type
)), parmreg
);
2679 set_mem_attributes (x
, parm
, 1);
2680 SET_DECL_RTL (parm
, x
);
2684 SET_DECL_RTL (parm
, parmreg
);
2685 maybe_set_unchanging (DECL_RTL (parm
), parm
);
2688 /* Copy the value into the register. */
2689 if (data
->nominal_mode
!= data
->passed_mode
2690 || promoted_nominal_mode
!= data
->promoted_mode
)
2694 /* ENTRY_PARM has been converted to PROMOTED_MODE, its
2695 mode, by the caller. We now have to convert it to
2696 NOMINAL_MODE, if different. However, PARMREG may be in
2697 a different mode than NOMINAL_MODE if it is being stored
2700 If ENTRY_PARM is a hard register, it might be in a register
2701 not valid for operating in its mode (e.g., an odd-numbered
2702 register for a DFmode). In that case, moves are the only
2703 thing valid, so we can't do a convert from there. This
2704 occurs when the calling sequence allow such misaligned
2707 In addition, the conversion may involve a call, which could
2708 clobber parameters which haven't been copied to pseudo
2709 registers yet. Therefore, we must first copy the parm to
2710 a pseudo reg here, and save the conversion until after all
2711 parameters have been moved. */
2713 rtx tempreg
= gen_reg_rtx (GET_MODE (data
->entry_parm
));
2715 emit_move_insn (tempreg
, validize_mem (data
->entry_parm
));
2717 push_to_sequence (all
->conversion_insns
);
2718 tempreg
= convert_to_mode (data
->nominal_mode
, tempreg
, unsignedp
);
2720 if (GET_CODE (tempreg
) == SUBREG
2721 && GET_MODE (tempreg
) == data
->nominal_mode
2722 && REG_P (SUBREG_REG (tempreg
))
2723 && data
->nominal_mode
== data
->passed_mode
2724 && GET_MODE (SUBREG_REG (tempreg
)) == GET_MODE (data
->entry_parm
)
2725 && GET_MODE_SIZE (GET_MODE (tempreg
))
2726 < GET_MODE_SIZE (GET_MODE (data
->entry_parm
)))
2728 /* The argument is already sign/zero extended, so note it
2730 SUBREG_PROMOTED_VAR_P (tempreg
) = 1;
2731 SUBREG_PROMOTED_UNSIGNED_SET (tempreg
, unsignedp
);
2734 /* TREE_USED gets set erroneously during expand_assignment. */
2735 save_tree_used
= TREE_USED (parm
);
2736 expand_assignment (parm
, make_tree (data
->nominal_type
, tempreg
), 0);
2737 TREE_USED (parm
) = save_tree_used
;
2738 all
->conversion_insns
= get_insns ();
2741 did_conversion
= true;
2744 emit_move_insn (parmreg
, validize_mem (data
->entry_parm
));
2746 /* If we were passed a pointer but the actual value can safely live
2747 in a register, put it in one. */
2748 if (data
->passed_pointer
2749 && TYPE_MODE (TREE_TYPE (parm
)) != BLKmode
2750 /* If by-reference argument was promoted, demote it. */
2751 && (TYPE_MODE (TREE_TYPE (parm
)) != GET_MODE (DECL_RTL (parm
))
2752 || use_register_for_decl (parm
)))
2754 /* We can't use nominal_mode, because it will have been set to
2755 Pmode above. We must use the actual mode of the parm. */
2756 parmreg
= gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm
)));
2757 mark_user_reg (parmreg
);
2759 if (GET_MODE (parmreg
) != GET_MODE (DECL_RTL (parm
)))
2761 rtx tempreg
= gen_reg_rtx (GET_MODE (DECL_RTL (parm
)));
2762 int unsigned_p
= TYPE_UNSIGNED (TREE_TYPE (parm
));
2764 push_to_sequence (all
->conversion_insns
);
2765 emit_move_insn (tempreg
, DECL_RTL (parm
));
2766 tempreg
= convert_to_mode (GET_MODE (parmreg
), tempreg
, unsigned_p
);
2767 emit_move_insn (parmreg
, tempreg
);
2768 all
->conversion_insns
= get_insns();
2771 did_conversion
= true;
2774 emit_move_insn (parmreg
, DECL_RTL (parm
));
2776 SET_DECL_RTL (parm
, parmreg
);
2778 /* STACK_PARM is the pointer, not the parm, and PARMREG is
2780 data
->stack_parm
= NULL
;
2783 /* If we are passed an arg by reference and it is our responsibility
2784 to make a copy, do it now.
2785 PASSED_TYPE and PASSED mode now refer to the pointer, not the
2786 original argument, so we must recreate them in the call to
2787 FUNCTION_ARG_CALLEE_COPIES. */
2788 /* ??? Later add code to handle the case that if the argument isn't
2789 modified, don't do the copy. */
2791 else if (data
->passed_pointer
)
2793 tree type
= TREE_TYPE (data
->passed_type
);
2795 if (FUNCTION_ARG_CALLEE_COPIES (all
->args_so_far
, TYPE_MODE (type
),
2796 type
, data
->named_arg
)
2797 && !TREE_ADDRESSABLE (type
))
2801 /* This sequence may involve a library call perhaps clobbering
2802 registers that haven't been copied to pseudos yet. */
2804 push_to_sequence (all
->conversion_insns
);
2806 if (!COMPLETE_TYPE_P (type
)
2807 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
2809 /* This is a variable sized object. */
2810 copy
= allocate_dynamic_stack_space (expr_size (parm
), NULL_RTX
,
2812 copy
= gen_rtx_MEM (BLKmode
, copy
);
2815 copy
= assign_stack_temp (TYPE_MODE (type
),
2816 int_size_in_bytes (type
), 1);
2817 set_mem_attributes (copy
, parm
, 1);
2819 store_expr (parm
, copy
, 0);
2820 emit_move_insn (parmreg
, XEXP (copy
, 0));
2821 all
->conversion_insns
= get_insns ();
2824 did_conversion
= true;
2828 /* Mark the register as eliminable if we did no conversion and it was
2829 copied from memory at a fixed offset, and the arg pointer was not
2830 copied to a pseudo-reg. If the arg pointer is a pseudo reg or the
2831 offset formed an invalid address, such memory-equivalences as we
2832 make here would screw up life analysis for it. */
2833 if (data
->nominal_mode
== data
->passed_mode
2835 && data
->stack_parm
!= 0
2836 && MEM_P (data
->stack_parm
)
2837 && data
->locate
.offset
.var
== 0
2838 && reg_mentioned_p (virtual_incoming_args_rtx
,
2839 XEXP (data
->stack_parm
, 0)))
2841 rtx linsn
= get_last_insn ();
2844 /* Mark complex types separately. */
2845 if (GET_CODE (parmreg
) == CONCAT
)
2847 enum machine_mode submode
2848 = GET_MODE_INNER (GET_MODE (parmreg
));
2849 int regnor
= REGNO (gen_realpart (submode
, parmreg
));
2850 int regnoi
= REGNO (gen_imagpart (submode
, parmreg
));
2851 rtx stackr
= gen_realpart (submode
, data
->stack_parm
);
2852 rtx stacki
= gen_imagpart (submode
, data
->stack_parm
);
2854 /* Scan backwards for the set of the real and
2856 for (sinsn
= linsn
; sinsn
!= 0;
2857 sinsn
= prev_nonnote_insn (sinsn
))
2859 set
= single_set (sinsn
);
2863 if (SET_DEST (set
) == regno_reg_rtx
[regnoi
])
2865 = gen_rtx_EXPR_LIST (REG_EQUIV
, stacki
,
2867 else if (SET_DEST (set
) == regno_reg_rtx
[regnor
])
2869 = gen_rtx_EXPR_LIST (REG_EQUIV
, stackr
,
2873 else if ((set
= single_set (linsn
)) != 0
2874 && SET_DEST (set
) == parmreg
)
2876 = gen_rtx_EXPR_LIST (REG_EQUIV
,
2877 data
->stack_parm
, REG_NOTES (linsn
));
2880 /* For pointer data type, suggest pointer register. */
2881 if (POINTER_TYPE_P (TREE_TYPE (parm
)))
2882 mark_reg_pointer (parmreg
,
2883 TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm
))));
2886 /* A subroutine of assign_parms. Allocate stack space to hold the current
2887 parameter. Get it there. Perform all ABI specified conversions. */
2890 assign_parm_setup_stack (struct assign_parm_data_all
*all
, tree parm
,
2891 struct assign_parm_data_one
*data
)
2893 /* Value must be stored in the stack slot STACK_PARM during function
2896 if (data
->promoted_mode
!= data
->nominal_mode
)
2898 /* Conversion is required. */
2899 rtx tempreg
= gen_reg_rtx (GET_MODE (data
->entry_parm
));
2901 emit_move_insn (tempreg
, validize_mem (data
->entry_parm
));
2903 push_to_sequence (all
->conversion_insns
);
2904 data
->entry_parm
= convert_to_mode (data
->nominal_mode
, tempreg
,
2905 TYPE_UNSIGNED (TREE_TYPE (parm
)));
2907 if (data
->stack_parm
)
2908 /* ??? This may need a big-endian conversion on sparc64. */
2910 = adjust_address (data
->stack_parm
, data
->nominal_mode
, 0);
2912 all
->conversion_insns
= get_insns ();
2916 if (data
->entry_parm
!= data
->stack_parm
)
2918 if (data
->stack_parm
== 0)
2921 = assign_stack_local (GET_MODE (data
->entry_parm
),
2922 GET_MODE_SIZE (GET_MODE (data
->entry_parm
)),
2924 set_mem_attributes (data
->stack_parm
, parm
, 1);
2927 if (data
->promoted_mode
!= data
->nominal_mode
)
2929 push_to_sequence (all
->conversion_insns
);
2930 emit_move_insn (validize_mem (data
->stack_parm
),
2931 validize_mem (data
->entry_parm
));
2932 all
->conversion_insns
= get_insns ();
2936 emit_move_insn (validize_mem (data
->stack_parm
),
2937 validize_mem (data
->entry_parm
));
2940 SET_DECL_RTL (parm
, data
->stack_parm
);
2943 /* A subroutine of assign_parms. If the ABI splits complex arguments, then
2944 undo the frobbing that we did in assign_parms_augmented_arg_list. */
2947 assign_parms_unsplit_complex (tree orig_fnargs
, tree fnargs
)
2951 for (parm
= orig_fnargs
; parm
; parm
= TREE_CHAIN (parm
))
2953 if (TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
2954 && targetm
.calls
.split_complex_arg (TREE_TYPE (parm
)))
2956 rtx tmp
, real
, imag
;
2957 enum machine_mode inner
= GET_MODE_INNER (DECL_MODE (parm
));
2959 real
= DECL_RTL (fnargs
);
2960 imag
= DECL_RTL (TREE_CHAIN (fnargs
));
2961 if (inner
!= GET_MODE (real
))
2963 real
= gen_lowpart_SUBREG (inner
, real
);
2964 imag
= gen_lowpart_SUBREG (inner
, imag
);
2966 tmp
= gen_rtx_CONCAT (DECL_MODE (parm
), real
, imag
);
2967 SET_DECL_RTL (parm
, tmp
);
2969 real
= DECL_INCOMING_RTL (fnargs
);
2970 imag
= DECL_INCOMING_RTL (TREE_CHAIN (fnargs
));
2971 if (inner
!= GET_MODE (real
))
2973 real
= gen_lowpart_SUBREG (inner
, real
);
2974 imag
= gen_lowpart_SUBREG (inner
, imag
);
2976 tmp
= gen_rtx_CONCAT (DECL_MODE (parm
), real
, imag
);
2977 set_decl_incoming_rtl (parm
, tmp
);
2978 fnargs
= TREE_CHAIN (fnargs
);
2982 SET_DECL_RTL (parm
, DECL_RTL (fnargs
));
2983 set_decl_incoming_rtl (parm
, DECL_INCOMING_RTL (fnargs
));
2985 /* Set MEM_EXPR to the original decl, i.e. to PARM,
2986 instead of the copy of decl, i.e. FNARGS. */
2987 if (DECL_INCOMING_RTL (parm
) && MEM_P (DECL_INCOMING_RTL (parm
)))
2988 set_mem_expr (DECL_INCOMING_RTL (parm
), parm
);
2991 fnargs
= TREE_CHAIN (fnargs
);
2995 /* Assign RTL expressions to the function's parameters. This may involve
2996 copying them into registers and using those registers as the DECL_RTL. */
2999 assign_parms (tree fndecl
)
3001 struct assign_parm_data_all all
;
3003 rtx internal_arg_pointer
;
3004 int varargs_setup
= 0;
3006 /* If the reg that the virtual arg pointer will be translated into is
3007 not a fixed reg or is the stack pointer, make a copy of the virtual
3008 arg pointer, and address parms via the copy. The frame pointer is
3009 considered fixed even though it is not marked as such.
3011 The second time through, simply use ap to avoid generating rtx. */
3013 if ((ARG_POINTER_REGNUM
== STACK_POINTER_REGNUM
3014 || ! (fixed_regs
[ARG_POINTER_REGNUM
]
3015 || ARG_POINTER_REGNUM
== FRAME_POINTER_REGNUM
)))
3016 internal_arg_pointer
= copy_to_reg (virtual_incoming_args_rtx
);
3018 internal_arg_pointer
= virtual_incoming_args_rtx
;
3019 current_function_internal_arg_pointer
= internal_arg_pointer
;
3021 assign_parms_initialize_all (&all
);
3022 fnargs
= assign_parms_augmented_arg_list (&all
);
3024 for (parm
= fnargs
; parm
; parm
= TREE_CHAIN (parm
))
3026 struct assign_parm_data_one data
;
3028 /* Extract the type of PARM; adjust it according to ABI. */
3029 assign_parm_find_data_types (&all
, parm
, &data
);
3031 /* Early out for errors and void parameters. */
3032 if (data
.passed_mode
== VOIDmode
)
3034 SET_DECL_RTL (parm
, const0_rtx
);
3035 DECL_INCOMING_RTL (parm
) = DECL_RTL (parm
);
3039 /* Handle stdargs. LAST_NAMED is a slight mis-nomer; it's also true
3040 for the unnamed dummy argument following the last named argument.
3041 See ABI silliness wrt strict_argument_naming and NAMED_ARG. So
3042 we only want to do this when we get to the actual last named
3043 argument, which will be the first time LAST_NAMED gets set. */
3044 if (data
.last_named
&& !varargs_setup
)
3046 varargs_setup
= true;
3047 assign_parms_setup_varargs (&all
, &data
, false);
3050 /* Find out where the parameter arrives in this function. */
3051 assign_parm_find_entry_rtl (&all
, &data
);
3053 /* Find out where stack space for this parameter might be. */
3054 if (assign_parm_is_stack_parm (&all
, &data
))
3056 assign_parm_find_stack_rtl (parm
, &data
);
3057 assign_parm_adjust_entry_rtl (&data
);
3060 /* Record permanently how this parm was passed. */
3061 set_decl_incoming_rtl (parm
, data
.entry_parm
);
3063 /* Update info on where next arg arrives in registers. */
3064 FUNCTION_ARG_ADVANCE (all
.args_so_far
, data
.promoted_mode
,
3065 data
.passed_type
, data
.named_arg
);
3067 assign_parm_adjust_stack_rtl (&data
);
3069 if (assign_parm_setup_block_p (&data
))
3070 assign_parm_setup_block (parm
, &data
);
3071 else if (data
.passed_pointer
|| use_register_for_decl (parm
))
3072 assign_parm_setup_reg (&all
, parm
, &data
);
3074 assign_parm_setup_stack (&all
, parm
, &data
);
3077 if (targetm
.calls
.split_complex_arg
&& fnargs
!= all
.orig_fnargs
)
3078 assign_parms_unsplit_complex (all
.orig_fnargs
, fnargs
);
3080 /* Output all parameter conversion instructions (possibly including calls)
3081 now that all parameters have been copied out of hard registers. */
3082 emit_insn (all
.conversion_insns
);
3084 /* If we are receiving a struct value address as the first argument, set up
3085 the RTL for the function result. As this might require code to convert
3086 the transmitted address to Pmode, we do this here to ensure that possible
3087 preliminary conversions of the address have been emitted already. */
3088 if (all
.function_result_decl
)
3090 tree result
= DECL_RESULT (current_function_decl
);
3091 rtx addr
= DECL_RTL (all
.function_result_decl
);
3094 if (DECL_BY_REFERENCE (result
))
3098 addr
= convert_memory_address (Pmode
, addr
);
3099 x
= gen_rtx_MEM (DECL_MODE (result
), addr
);
3100 set_mem_attributes (x
, result
, 1);
3102 SET_DECL_RTL (result
, x
);
3105 /* We have aligned all the args, so add space for the pretend args. */
3106 current_function_pretend_args_size
= all
.pretend_args_size
;
3107 all
.stack_args_size
.constant
+= all
.extra_pretend_bytes
;
3108 current_function_args_size
= all
.stack_args_size
.constant
;
3110 /* Adjust function incoming argument size for alignment and
3113 #ifdef REG_PARM_STACK_SPACE
3114 current_function_args_size
= MAX (current_function_args_size
,
3115 REG_PARM_STACK_SPACE (fndecl
));
3118 current_function_args_size
3119 = ((current_function_args_size
+ STACK_BYTES
- 1)
3120 / STACK_BYTES
) * STACK_BYTES
;
3122 #ifdef ARGS_GROW_DOWNWARD
3123 current_function_arg_offset_rtx
3124 = (all
.stack_args_size
.var
== 0 ? GEN_INT (-all
.stack_args_size
.constant
)
3125 : expand_expr (size_diffop (all
.stack_args_size
.var
,
3126 size_int (-all
.stack_args_size
.constant
)),
3127 NULL_RTX
, VOIDmode
, 0));
3129 current_function_arg_offset_rtx
= ARGS_SIZE_RTX (all
.stack_args_size
);
3132 /* See how many bytes, if any, of its args a function should try to pop
3135 current_function_pops_args
= RETURN_POPS_ARGS (fndecl
, TREE_TYPE (fndecl
),
3136 current_function_args_size
);
3138 /* For stdarg.h function, save info about
3139 regs and stack space used by the named args. */
3141 current_function_args_info
= all
.args_so_far
;
3143 /* Set the rtx used for the function return value. Put this in its
3144 own variable so any optimizers that need this information don't have
3145 to include tree.h. Do this here so it gets done when an inlined
3146 function gets output. */
3148 current_function_return_rtx
3149 = (DECL_RTL_SET_P (DECL_RESULT (fndecl
))
3150 ? DECL_RTL (DECL_RESULT (fndecl
)) : NULL_RTX
);
3152 /* If scalar return value was computed in a pseudo-reg, or was a named
3153 return value that got dumped to the stack, copy that to the hard
3155 if (DECL_RTL_SET_P (DECL_RESULT (fndecl
)))
3157 tree decl_result
= DECL_RESULT (fndecl
);
3158 rtx decl_rtl
= DECL_RTL (decl_result
);
3160 if (REG_P (decl_rtl
)
3161 ? REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
3162 : DECL_REGISTER (decl_result
))
3166 #ifdef FUNCTION_OUTGOING_VALUE
3167 real_decl_rtl
= FUNCTION_OUTGOING_VALUE (TREE_TYPE (decl_result
),
3170 real_decl_rtl
= FUNCTION_VALUE (TREE_TYPE (decl_result
),
3173 REG_FUNCTION_VALUE_P (real_decl_rtl
) = 1;
3174 /* The delay slot scheduler assumes that current_function_return_rtx
3175 holds the hard register containing the return value, not a
3176 temporary pseudo. */
3177 current_function_return_rtx
= real_decl_rtl
;
3182 /* Indicate whether REGNO is an incoming argument to the current function
3183 that was promoted to a wider mode. If so, return the RTX for the
3184 register (to get its mode). PMODE and PUNSIGNEDP are set to the mode
3185 that REGNO is promoted from and whether the promotion was signed or
3189 promoted_input_arg (unsigned int regno
, enum machine_mode
*pmode
, int *punsignedp
)
3193 for (arg
= DECL_ARGUMENTS (current_function_decl
); arg
;
3194 arg
= TREE_CHAIN (arg
))
3195 if (REG_P (DECL_INCOMING_RTL (arg
))
3196 && REGNO (DECL_INCOMING_RTL (arg
)) == regno
3197 && TYPE_MODE (DECL_ARG_TYPE (arg
)) == TYPE_MODE (TREE_TYPE (arg
)))
3199 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (arg
));
3200 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (arg
));
3202 mode
= promote_mode (TREE_TYPE (arg
), mode
, &unsignedp
, 1);
3203 if (mode
== GET_MODE (DECL_INCOMING_RTL (arg
))
3204 && mode
!= DECL_MODE (arg
))
3206 *pmode
= DECL_MODE (arg
);
3207 *punsignedp
= unsignedp
;
3208 return DECL_INCOMING_RTL (arg
);
3216 /* Compute the size and offset from the start of the stacked arguments for a
3217 parm passed in mode PASSED_MODE and with type TYPE.
3219 INITIAL_OFFSET_PTR points to the current offset into the stacked
3222 The starting offset and size for this parm are returned in
3223 LOCATE->OFFSET and LOCATE->SIZE, respectively. When IN_REGS is
3224 nonzero, the offset is that of stack slot, which is returned in
3225 LOCATE->SLOT_OFFSET. LOCATE->ALIGNMENT_PAD is the amount of
3226 padding required from the initial offset ptr to the stack slot.
3228 IN_REGS is nonzero if the argument will be passed in registers. It will
3229 never be set if REG_PARM_STACK_SPACE is not defined.
3231 FNDECL is the function in which the argument was defined.
3233 There are two types of rounding that are done. The first, controlled by
3234 FUNCTION_ARG_BOUNDARY, forces the offset from the start of the argument
3235 list to be aligned to the specific boundary (in bits). This rounding
3236 affects the initial and starting offsets, but not the argument size.
3238 The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY,
3239 optionally rounds the size of the parm to PARM_BOUNDARY. The
3240 initial offset is not affected by this rounding, while the size always
3241 is and the starting offset may be. */
3243 /* LOCATE->OFFSET will be negative for ARGS_GROW_DOWNWARD case;
3244 INITIAL_OFFSET_PTR is positive because locate_and_pad_parm's
3245 callers pass in the total size of args so far as
3246 INITIAL_OFFSET_PTR. LOCATE->SIZE is always positive. */
3249 locate_and_pad_parm (enum machine_mode passed_mode
, tree type
, int in_regs
,
3250 int partial
, tree fndecl ATTRIBUTE_UNUSED
,
3251 struct args_size
*initial_offset_ptr
,
3252 struct locate_and_pad_arg_data
*locate
)
3255 enum direction where_pad
;
3257 int reg_parm_stack_space
= 0;
3258 int part_size_in_regs
;
3260 #ifdef REG_PARM_STACK_SPACE
3261 reg_parm_stack_space
= REG_PARM_STACK_SPACE (fndecl
);
3263 /* If we have found a stack parm before we reach the end of the
3264 area reserved for registers, skip that area. */
3267 if (reg_parm_stack_space
> 0)
3269 if (initial_offset_ptr
->var
)
3271 initial_offset_ptr
->var
3272 = size_binop (MAX_EXPR
, ARGS_SIZE_TREE (*initial_offset_ptr
),
3273 ssize_int (reg_parm_stack_space
));
3274 initial_offset_ptr
->constant
= 0;
3276 else if (initial_offset_ptr
->constant
< reg_parm_stack_space
)
3277 initial_offset_ptr
->constant
= reg_parm_stack_space
;
3280 #endif /* REG_PARM_STACK_SPACE */
3282 part_size_in_regs
= 0;
3283 if (reg_parm_stack_space
== 0)
3284 part_size_in_regs
= ((partial
* UNITS_PER_WORD
)
3285 / (PARM_BOUNDARY
/ BITS_PER_UNIT
)
3286 * (PARM_BOUNDARY
/ BITS_PER_UNIT
));
3289 = type
? size_in_bytes (type
) : size_int (GET_MODE_SIZE (passed_mode
));
3290 where_pad
= FUNCTION_ARG_PADDING (passed_mode
, type
);
3291 boundary
= FUNCTION_ARG_BOUNDARY (passed_mode
, type
);
3292 locate
->where_pad
= where_pad
;
3294 #ifdef ARGS_GROW_DOWNWARD
3295 locate
->slot_offset
.constant
= -initial_offset_ptr
->constant
;
3296 if (initial_offset_ptr
->var
)
3297 locate
->slot_offset
.var
= size_binop (MINUS_EXPR
, ssize_int (0),
3298 initial_offset_ptr
->var
);
3302 if (where_pad
!= none
3303 && (!host_integerp (sizetree
, 1)
3304 || (tree_low_cst (sizetree
, 1) * BITS_PER_UNIT
) % PARM_BOUNDARY
))
3305 s2
= round_up (s2
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
3306 SUB_PARM_SIZE (locate
->slot_offset
, s2
);
3309 locate
->slot_offset
.constant
+= part_size_in_regs
;
3312 #ifdef REG_PARM_STACK_SPACE
3313 || REG_PARM_STACK_SPACE (fndecl
) > 0
3316 pad_to_arg_alignment (&locate
->slot_offset
, boundary
,
3317 &locate
->alignment_pad
);
3319 locate
->size
.constant
= (-initial_offset_ptr
->constant
3320 - locate
->slot_offset
.constant
);
3321 if (initial_offset_ptr
->var
)
3322 locate
->size
.var
= size_binop (MINUS_EXPR
,
3323 size_binop (MINUS_EXPR
,
3325 initial_offset_ptr
->var
),
3326 locate
->slot_offset
.var
);
3328 /* Pad_below needs the pre-rounded size to know how much to pad
3330 locate
->offset
= locate
->slot_offset
;
3331 if (where_pad
== downward
)
3332 pad_below (&locate
->offset
, passed_mode
, sizetree
);
3334 #else /* !ARGS_GROW_DOWNWARD */
3336 #ifdef REG_PARM_STACK_SPACE
3337 || REG_PARM_STACK_SPACE (fndecl
) > 0
3340 pad_to_arg_alignment (initial_offset_ptr
, boundary
,
3341 &locate
->alignment_pad
);
3342 locate
->slot_offset
= *initial_offset_ptr
;
3344 #ifdef PUSH_ROUNDING
3345 if (passed_mode
!= BLKmode
)
3346 sizetree
= size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree
)));
3349 /* Pad_below needs the pre-rounded size to know how much to pad below
3350 so this must be done before rounding up. */
3351 locate
->offset
= locate
->slot_offset
;
3352 if (where_pad
== downward
)
3353 pad_below (&locate
->offset
, passed_mode
, sizetree
);
3355 if (where_pad
!= none
3356 && (!host_integerp (sizetree
, 1)
3357 || (tree_low_cst (sizetree
, 1) * BITS_PER_UNIT
) % PARM_BOUNDARY
))
3358 sizetree
= round_up (sizetree
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
3360 ADD_PARM_SIZE (locate
->size
, sizetree
);
3362 locate
->size
.constant
-= part_size_in_regs
;
3363 #endif /* ARGS_GROW_DOWNWARD */
3366 /* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY.
3367 BOUNDARY is measured in bits, but must be a multiple of a storage unit. */
3370 pad_to_arg_alignment (struct args_size
*offset_ptr
, int boundary
,
3371 struct args_size
*alignment_pad
)
3373 tree save_var
= NULL_TREE
;
3374 HOST_WIDE_INT save_constant
= 0;
3375 int boundary_in_bytes
= boundary
/ BITS_PER_UNIT
;
3376 HOST_WIDE_INT sp_offset
= STACK_POINTER_OFFSET
;
3378 #ifdef SPARC_STACK_BOUNDARY_HACK
3379 /* The sparc port has a bug. It sometimes claims a STACK_BOUNDARY
3380 higher than the real alignment of %sp. However, when it does this,
3381 the alignment of %sp+STACK_POINTER_OFFSET will be STACK_BOUNDARY.
3382 This is a temporary hack while the sparc port is fixed. */
3383 if (SPARC_STACK_BOUNDARY_HACK
)
3387 if (boundary
> PARM_BOUNDARY
&& boundary
> STACK_BOUNDARY
)
3389 save_var
= offset_ptr
->var
;
3390 save_constant
= offset_ptr
->constant
;
3393 alignment_pad
->var
= NULL_TREE
;
3394 alignment_pad
->constant
= 0;
3396 if (boundary
> BITS_PER_UNIT
)
3398 if (offset_ptr
->var
)
3400 tree sp_offset_tree
= ssize_int (sp_offset
);
3401 tree offset
= size_binop (PLUS_EXPR
,
3402 ARGS_SIZE_TREE (*offset_ptr
),
3404 #ifdef ARGS_GROW_DOWNWARD
3405 tree rounded
= round_down (offset
, boundary
/ BITS_PER_UNIT
);
3407 tree rounded
= round_up (offset
, boundary
/ BITS_PER_UNIT
);
3410 offset_ptr
->var
= size_binop (MINUS_EXPR
, rounded
, sp_offset_tree
);
3411 /* ARGS_SIZE_TREE includes constant term. */
3412 offset_ptr
->constant
= 0;
3413 if (boundary
> PARM_BOUNDARY
&& boundary
> STACK_BOUNDARY
)
3414 alignment_pad
->var
= size_binop (MINUS_EXPR
, offset_ptr
->var
,
3419 offset_ptr
->constant
= -sp_offset
+
3420 #ifdef ARGS_GROW_DOWNWARD
3421 FLOOR_ROUND (offset_ptr
->constant
+ sp_offset
, boundary_in_bytes
);
3423 CEIL_ROUND (offset_ptr
->constant
+ sp_offset
, boundary_in_bytes
);
3425 if (boundary
> PARM_BOUNDARY
&& boundary
> STACK_BOUNDARY
)
3426 alignment_pad
->constant
= offset_ptr
->constant
- save_constant
;
3432 pad_below (struct args_size
*offset_ptr
, enum machine_mode passed_mode
, tree sizetree
)
3434 if (passed_mode
!= BLKmode
)
3436 if (GET_MODE_BITSIZE (passed_mode
) % PARM_BOUNDARY
)
3437 offset_ptr
->constant
3438 += (((GET_MODE_BITSIZE (passed_mode
) + PARM_BOUNDARY
- 1)
3439 / PARM_BOUNDARY
* PARM_BOUNDARY
/ BITS_PER_UNIT
)
3440 - GET_MODE_SIZE (passed_mode
));
3444 if (TREE_CODE (sizetree
) != INTEGER_CST
3445 || (TREE_INT_CST_LOW (sizetree
) * BITS_PER_UNIT
) % PARM_BOUNDARY
)
3447 /* Round the size up to multiple of PARM_BOUNDARY bits. */
3448 tree s2
= round_up (sizetree
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
3450 ADD_PARM_SIZE (*offset_ptr
, s2
);
3451 SUB_PARM_SIZE (*offset_ptr
, sizetree
);
3456 /* Walk the tree of blocks describing the binding levels within a function
3457 and warn about variables the might be killed by setjmp or vfork.
3458 This is done after calling flow_analysis and before global_alloc
3459 clobbers the pseudo-regs to hard regs. */
3462 setjmp_vars_warning (tree block
)
3466 for (decl
= BLOCK_VARS (block
); decl
; decl
= TREE_CHAIN (decl
))
3468 if (TREE_CODE (decl
) == VAR_DECL
3469 && DECL_RTL_SET_P (decl
)
3470 && REG_P (DECL_RTL (decl
))
3471 && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl
))))
3472 warning ("%Jvariable '%D' might be clobbered by `longjmp' or `vfork'",
3476 for (sub
= BLOCK_SUBBLOCKS (block
); sub
; sub
= TREE_CHAIN (sub
))
3477 setjmp_vars_warning (sub
);
3480 /* Do the appropriate part of setjmp_vars_warning
3481 but for arguments instead of local variables. */
3484 setjmp_args_warning (void)
3487 for (decl
= DECL_ARGUMENTS (current_function_decl
);
3488 decl
; decl
= TREE_CHAIN (decl
))
3489 if (DECL_RTL (decl
) != 0
3490 && REG_P (DECL_RTL (decl
))
3491 && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl
))))
3492 warning ("%Jargument '%D' might be clobbered by `longjmp' or `vfork'",
3497 /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
3498 and create duplicate blocks. */
3499 /* ??? Need an option to either create block fragments or to create
3500 abstract origin duplicates of a source block. It really depends
3501 on what optimization has been performed. */
3504 reorder_blocks (void)
3506 tree block
= DECL_INITIAL (current_function_decl
);
3507 varray_type block_stack
;
3509 if (block
== NULL_TREE
)
3512 VARRAY_TREE_INIT (block_stack
, 10, "block_stack");
3514 /* Reset the TREE_ASM_WRITTEN bit for all blocks. */
3515 clear_block_marks (block
);
3517 /* Prune the old trees away, so that they don't get in the way. */
3518 BLOCK_SUBBLOCKS (block
) = NULL_TREE
;
3519 BLOCK_CHAIN (block
) = NULL_TREE
;
3521 /* Recreate the block tree from the note nesting. */
3522 reorder_blocks_1 (get_insns (), block
, &block_stack
);
3523 BLOCK_SUBBLOCKS (block
) = blocks_nreverse (BLOCK_SUBBLOCKS (block
));
3525 /* Remove deleted blocks from the block fragment chains. */
3526 reorder_fix_fragments (block
);
3529 /* Helper function for reorder_blocks. Reset TREE_ASM_WRITTEN. */
3532 clear_block_marks (tree block
)
3536 TREE_ASM_WRITTEN (block
) = 0;
3537 clear_block_marks (BLOCK_SUBBLOCKS (block
));
3538 block
= BLOCK_CHAIN (block
);
3543 reorder_blocks_1 (rtx insns
, tree current_block
, varray_type
*p_block_stack
)
3547 for (insn
= insns
; insn
; insn
= NEXT_INSN (insn
))
3551 if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_BEG
)
3553 tree block
= NOTE_BLOCK (insn
);
3555 /* If we have seen this block before, that means it now
3556 spans multiple address regions. Create a new fragment. */
3557 if (TREE_ASM_WRITTEN (block
))
3559 tree new_block
= copy_node (block
);
3562 origin
= (BLOCK_FRAGMENT_ORIGIN (block
)
3563 ? BLOCK_FRAGMENT_ORIGIN (block
)
3565 BLOCK_FRAGMENT_ORIGIN (new_block
) = origin
;
3566 BLOCK_FRAGMENT_CHAIN (new_block
)
3567 = BLOCK_FRAGMENT_CHAIN (origin
);
3568 BLOCK_FRAGMENT_CHAIN (origin
) = new_block
;
3570 NOTE_BLOCK (insn
) = new_block
;
3574 BLOCK_SUBBLOCKS (block
) = 0;
3575 TREE_ASM_WRITTEN (block
) = 1;
3576 /* When there's only one block for the entire function,
3577 current_block == block and we mustn't do this, it
3578 will cause infinite recursion. */
3579 if (block
!= current_block
)
3581 BLOCK_SUPERCONTEXT (block
) = current_block
;
3582 BLOCK_CHAIN (block
) = BLOCK_SUBBLOCKS (current_block
);
3583 BLOCK_SUBBLOCKS (current_block
) = block
;
3584 current_block
= block
;
3586 VARRAY_PUSH_TREE (*p_block_stack
, block
);
3588 else if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_END
)
3590 NOTE_BLOCK (insn
) = VARRAY_TOP_TREE (*p_block_stack
);
3591 VARRAY_POP (*p_block_stack
);
3592 BLOCK_SUBBLOCKS (current_block
)
3593 = blocks_nreverse (BLOCK_SUBBLOCKS (current_block
));
3594 current_block
= BLOCK_SUPERCONTEXT (current_block
);
3600 /* Rationalize BLOCK_FRAGMENT_ORIGIN. If an origin block no longer
3601 appears in the block tree, select one of the fragments to become
3602 the new origin block. */
3605 reorder_fix_fragments (tree block
)
3609 tree dup_origin
= BLOCK_FRAGMENT_ORIGIN (block
);
3610 tree new_origin
= NULL_TREE
;
3614 if (! TREE_ASM_WRITTEN (dup_origin
))
3616 new_origin
= BLOCK_FRAGMENT_CHAIN (dup_origin
);
3618 /* Find the first of the remaining fragments. There must
3619 be at least one -- the current block. */
3620 while (! TREE_ASM_WRITTEN (new_origin
))
3621 new_origin
= BLOCK_FRAGMENT_CHAIN (new_origin
);
3622 BLOCK_FRAGMENT_ORIGIN (new_origin
) = NULL_TREE
;
3625 else if (! dup_origin
)
3628 /* Re-root the rest of the fragments to the new origin. In the
3629 case that DUP_ORIGIN was null, that means BLOCK was the origin
3630 of a chain of fragments and we want to remove those fragments
3631 that didn't make it to the output. */
3634 tree
*pp
= &BLOCK_FRAGMENT_CHAIN (new_origin
);
3639 if (TREE_ASM_WRITTEN (chain
))
3641 BLOCK_FRAGMENT_ORIGIN (chain
) = new_origin
;
3643 pp
= &BLOCK_FRAGMENT_CHAIN (chain
);
3645 chain
= BLOCK_FRAGMENT_CHAIN (chain
);
3650 reorder_fix_fragments (BLOCK_SUBBLOCKS (block
));
3651 block
= BLOCK_CHAIN (block
);
3655 /* Reverse the order of elements in the chain T of blocks,
3656 and return the new head of the chain (old last element). */
3659 blocks_nreverse (tree t
)
3661 tree prev
= 0, decl
, next
;
3662 for (decl
= t
; decl
; decl
= next
)
3664 next
= BLOCK_CHAIN (decl
);
3665 BLOCK_CHAIN (decl
) = prev
;
3671 /* Count the subblocks of the list starting with BLOCK. If VECTOR is
3672 non-NULL, list them all into VECTOR, in a depth-first preorder
3673 traversal of the block tree. Also clear TREE_ASM_WRITTEN in all
3677 all_blocks (tree block
, tree
*vector
)
3683 TREE_ASM_WRITTEN (block
) = 0;
3685 /* Record this block. */
3687 vector
[n_blocks
] = block
;
3691 /* Record the subblocks, and their subblocks... */
3692 n_blocks
+= all_blocks (BLOCK_SUBBLOCKS (block
),
3693 vector
? vector
+ n_blocks
: 0);
3694 block
= BLOCK_CHAIN (block
);
3700 /* Return a vector containing all the blocks rooted at BLOCK. The
3701 number of elements in the vector is stored in N_BLOCKS_P. The
3702 vector is dynamically allocated; it is the caller's responsibility
3703 to call `free' on the pointer returned. */
3706 get_block_vector (tree block
, int *n_blocks_p
)
3710 *n_blocks_p
= all_blocks (block
, NULL
);
3711 block_vector
= xmalloc (*n_blocks_p
* sizeof (tree
));
3712 all_blocks (block
, block_vector
);
3714 return block_vector
;
3717 static GTY(()) int next_block_index
= 2;
3719 /* Set BLOCK_NUMBER for all the blocks in FN. */
3722 number_blocks (tree fn
)
3728 /* For SDB and XCOFF debugging output, we start numbering the blocks
3729 from 1 within each function, rather than keeping a running
3731 #if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
3732 if (write_symbols
== SDB_DEBUG
|| write_symbols
== XCOFF_DEBUG
)
3733 next_block_index
= 1;
3736 block_vector
= get_block_vector (DECL_INITIAL (fn
), &n_blocks
);
3738 /* The top-level BLOCK isn't numbered at all. */
3739 for (i
= 1; i
< n_blocks
; ++i
)
3740 /* We number the blocks from two. */
3741 BLOCK_NUMBER (block_vector
[i
]) = next_block_index
++;
3743 free (block_vector
);
3748 /* If VAR is present in a subblock of BLOCK, return the subblock. */
3751 debug_find_var_in_block_tree (tree var
, tree block
)
3755 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
3759 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= TREE_CHAIN (t
))
3761 tree ret
= debug_find_var_in_block_tree (var
, t
);
3769 /* Allocate a function structure for FNDECL and set its contents
3773 allocate_struct_function (tree fndecl
)
3776 tree fntype
= fndecl
? TREE_TYPE (fndecl
) : NULL_TREE
;
3778 cfun
= ggc_alloc_cleared (sizeof (struct function
));
3780 cfun
->stack_alignment_needed
= STACK_BOUNDARY
;
3781 cfun
->preferred_stack_boundary
= STACK_BOUNDARY
;
3783 current_function_funcdef_no
= funcdef_no
++;
3785 cfun
->function_frequency
= FUNCTION_FREQUENCY_NORMAL
;
3787 init_stmt_for_function ();
3788 init_eh_for_function ();
3790 lang_hooks
.function
.init (cfun
);
3791 if (init_machine_status
)
3792 cfun
->machine
= (*init_machine_status
) ();
3797 DECL_STRUCT_FUNCTION (fndecl
) = cfun
;
3798 cfun
->decl
= fndecl
;
3800 result
= DECL_RESULT (fndecl
);
3801 if (aggregate_value_p (result
, fndecl
))
3803 #ifdef PCC_STATIC_STRUCT_RETURN
3804 current_function_returns_pcc_struct
= 1;
3806 current_function_returns_struct
= 1;
3809 current_function_returns_pointer
= POINTER_TYPE_P (TREE_TYPE (result
));
3811 current_function_stdarg
3813 && TYPE_ARG_TYPES (fntype
) != 0
3814 && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype
)))
3815 != void_type_node
));
3818 /* Reset cfun, and other non-struct-function variables to defaults as
3819 appropriate for emitting rtl at the start of a function. */
3822 prepare_function_start (tree fndecl
)
3824 if (fndecl
&& DECL_STRUCT_FUNCTION (fndecl
))
3825 cfun
= DECL_STRUCT_FUNCTION (fndecl
);
3827 allocate_struct_function (fndecl
);
3829 init_varasm_status (cfun
);
3832 cse_not_expected
= ! optimize
;
3834 /* Caller save not needed yet. */
3835 caller_save_needed
= 0;
3837 /* We haven't done register allocation yet. */
3840 /* Indicate that we have not instantiated virtual registers yet. */
3841 virtuals_instantiated
= 0;
3843 /* Indicate that we want CONCATs now. */
3844 generating_concat_p
= 1;
3846 /* Indicate we have no need of a frame pointer yet. */
3847 frame_pointer_needed
= 0;
3850 /* Initialize the rtl expansion mechanism so that we can do simple things
3851 like generate sequences. This is used to provide a context during global
3852 initialization of some passes. */
3854 init_dummy_function_start (void)
3856 prepare_function_start (NULL
);
3859 /* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node)
3860 and initialize static variables for generating RTL for the statements
3864 init_function_start (tree subr
)
3866 prepare_function_start (subr
);
3868 /* Prevent ever trying to delete the first instruction of a
3869 function. Also tell final how to output a linenum before the
3870 function prologue. Note linenums could be missing, e.g. when
3871 compiling a Java .class file. */
3872 if (! DECL_IS_BUILTIN (subr
))
3873 emit_line_note (DECL_SOURCE_LOCATION (subr
));
3875 /* Make sure first insn is a note even if we don't want linenums.
3876 This makes sure the first insn will never be deleted.
3877 Also, final expects a note to appear there. */
3878 emit_note (NOTE_INSN_DELETED
);
3880 /* Warn if this value is an aggregate type,
3881 regardless of which calling convention we are using for it. */
3882 if (warn_aggregate_return
3883 && AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr
))))
3884 warning ("function returns an aggregate");
3887 /* Make sure all values used by the optimization passes have sane
3890 init_function_for_compilation (void)
3894 /* No prologue/epilogue insns yet. */
3895 VARRAY_GROW (prologue
, 0);
3896 VARRAY_GROW (epilogue
, 0);
3897 VARRAY_GROW (sibcall_epilogue
, 0);
3900 /* Expand a call to __main at the beginning of a possible main function. */
3902 #if defined(INIT_SECTION_ASM_OP) && !defined(INVOKE__main)
3903 #undef HAS_INIT_SECTION
3904 #define HAS_INIT_SECTION
3908 expand_main_function (void)
3910 #ifdef FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN
3911 if (FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN
)
3913 int align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
3917 /* Forcibly align the stack. */
3918 #ifdef STACK_GROWS_DOWNWARD
3919 tmp
= expand_simple_binop (Pmode
, AND
, stack_pointer_rtx
, GEN_INT(-align
),
3920 stack_pointer_rtx
, 1, OPTAB_WIDEN
);
3922 tmp
= expand_simple_binop (Pmode
, PLUS
, stack_pointer_rtx
,
3923 GEN_INT (align
- 1), NULL_RTX
, 1, OPTAB_WIDEN
);
3924 tmp
= expand_simple_binop (Pmode
, AND
, tmp
, GEN_INT (-align
),
3925 stack_pointer_rtx
, 1, OPTAB_WIDEN
);
3927 if (tmp
!= stack_pointer_rtx
)
3928 emit_move_insn (stack_pointer_rtx
, tmp
);
3930 /* Enlist allocate_dynamic_stack_space to pick up the pieces. */
3931 tmp
= force_reg (Pmode
, const0_rtx
);
3932 allocate_dynamic_stack_space (tmp
, NULL_RTX
, BIGGEST_ALIGNMENT
);
3936 for (tmp
= get_last_insn (); tmp
; tmp
= PREV_INSN (tmp
))
3937 if (NOTE_P (tmp
) && NOTE_LINE_NUMBER (tmp
) == NOTE_INSN_FUNCTION_BEG
)
3940 emit_insn_before (seq
, tmp
);
3946 #ifndef HAS_INIT_SECTION
3947 emit_library_call (init_one_libfunc (NAME__MAIN
), LCT_NORMAL
, VOIDmode
, 0);
3951 /* The PENDING_SIZES represent the sizes of variable-sized types.
3952 Create RTL for the various sizes now (using temporary variables),
3953 so that we can refer to the sizes from the RTL we are generating
3954 for the current function. The PENDING_SIZES are a TREE_LIST. The
3955 TREE_VALUE of each node is a SAVE_EXPR. */
3958 expand_pending_sizes (tree pending_sizes
)
3962 /* Evaluate now the sizes of any types declared among the arguments. */
3963 for (tem
= pending_sizes
; tem
; tem
= TREE_CHAIN (tem
))
3964 expand_expr (TREE_VALUE (tem
), const0_rtx
, VOIDmode
, 0);
3967 /* Start the RTL for a new function, and set variables used for
3969 SUBR is the FUNCTION_DECL node.
3970 PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with
3971 the function's parameters, which must be run at any return statement. */
3974 expand_function_start (tree subr
)
3976 /* Make sure volatile mem refs aren't considered
3977 valid operands of arithmetic insns. */
3978 init_recog_no_volatile ();
3980 current_function_profile
3982 && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr
));
3984 current_function_limit_stack
3985 = (stack_limit_rtx
!= NULL_RTX
&& ! DECL_NO_LIMIT_STACK (subr
));
3987 /* Make the label for return statements to jump to. Do not special
3988 case machines with special return instructions -- they will be
3989 handled later during jump, ifcvt, or epilogue creation. */
3990 return_label
= gen_label_rtx ();
3992 /* Initialize rtx used to return the value. */
3993 /* Do this before assign_parms so that we copy the struct value address
3994 before any library calls that assign parms might generate. */
3996 /* Decide whether to return the value in memory or in a register. */
3997 if (aggregate_value_p (DECL_RESULT (subr
), subr
))
3999 /* Returning something that won't go in a register. */
4000 rtx value_address
= 0;
4002 #ifdef PCC_STATIC_STRUCT_RETURN
4003 if (current_function_returns_pcc_struct
)
4005 int size
= int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr
)));
4006 value_address
= assemble_static_space (size
);
4011 rtx sv
= targetm
.calls
.struct_value_rtx (TREE_TYPE (subr
), 1);
4012 /* Expect to be passed the address of a place to store the value.
4013 If it is passed as an argument, assign_parms will take care of
4017 value_address
= gen_reg_rtx (Pmode
);
4018 emit_move_insn (value_address
, sv
);
4023 rtx x
= gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr
)), value_address
);
4024 set_mem_attributes (x
, DECL_RESULT (subr
), 1);
4025 SET_DECL_RTL (DECL_RESULT (subr
), x
);
4028 else if (DECL_MODE (DECL_RESULT (subr
)) == VOIDmode
)
4029 /* If return mode is void, this decl rtl should not be used. */
4030 SET_DECL_RTL (DECL_RESULT (subr
), NULL_RTX
);
4033 /* Compute the return values into a pseudo reg, which we will copy
4034 into the true return register after the cleanups are done. */
4036 /* In order to figure out what mode to use for the pseudo, we
4037 figure out what the mode of the eventual return register will
4038 actually be, and use that. */
4040 = hard_function_value (TREE_TYPE (DECL_RESULT (subr
)),
4043 /* Structures that are returned in registers are not aggregate_value_p,
4044 so we may see a PARALLEL or a REG. */
4045 if (REG_P (hard_reg
))
4046 SET_DECL_RTL (DECL_RESULT (subr
), gen_reg_rtx (GET_MODE (hard_reg
)));
4047 else if (GET_CODE (hard_reg
) == PARALLEL
)
4048 SET_DECL_RTL (DECL_RESULT (subr
), gen_group_rtx (hard_reg
));
4052 /* Set DECL_REGISTER flag so that expand_function_end will copy the
4053 result to the real return register(s). */
4054 DECL_REGISTER (DECL_RESULT (subr
)) = 1;
4057 /* Initialize rtx for parameters and local variables.
4058 In some cases this requires emitting insns. */
4059 assign_parms (subr
);
4061 /* If function gets a static chain arg, store it. */
4062 if (cfun
->static_chain_decl
)
4064 tree parm
= cfun
->static_chain_decl
;
4065 rtx local
= gen_reg_rtx (Pmode
);
4067 set_decl_incoming_rtl (parm
, static_chain_incoming_rtx
);
4068 SET_DECL_RTL (parm
, local
);
4069 maybe_set_unchanging (local
, parm
);
4070 mark_reg_pointer (local
, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm
))));
4072 emit_move_insn (local
, static_chain_incoming_rtx
);
4075 /* If the function receives a non-local goto, then store the
4076 bits we need to restore the frame pointer. */
4077 if (cfun
->nonlocal_goto_save_area
)
4082 /* ??? We need to do this save early. Unfortunately here is
4083 before the frame variable gets declared. Help out... */
4084 expand_var (TREE_OPERAND (cfun
->nonlocal_goto_save_area
, 0));
4086 t_save
= build4 (ARRAY_REF
, ptr_type_node
,
4087 cfun
->nonlocal_goto_save_area
,
4088 integer_zero_node
, NULL_TREE
, NULL_TREE
);
4089 r_save
= expand_expr (t_save
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
4090 r_save
= convert_memory_address (Pmode
, r_save
);
4092 emit_move_insn (r_save
, virtual_stack_vars_rtx
);
4093 update_nonlocal_goto_save_area ();
4096 /* The following was moved from init_function_start.
4097 The move is supposed to make sdb output more accurate. */
4098 /* Indicate the beginning of the function body,
4099 as opposed to parm setup. */
4100 emit_note (NOTE_INSN_FUNCTION_BEG
);
4102 if (!NOTE_P (get_last_insn ()))
4103 emit_note (NOTE_INSN_DELETED
);
4104 parm_birth_insn
= get_last_insn ();
4106 if (current_function_profile
)
4109 PROFILE_HOOK (current_function_funcdef_no
);
4113 /* After the display initializations is where the tail-recursion label
4114 should go, if we end up needing one. Ensure we have a NOTE here
4115 since some things (like trampolines) get placed before this. */
4116 tail_recursion_reentry
= emit_note (NOTE_INSN_DELETED
);
4118 /* Evaluate now the sizes of any types declared among the arguments. */
4119 expand_pending_sizes (nreverse (get_pending_sizes ()));
4121 /* Make sure there is a line number after the function entry setup code. */
4122 force_next_line_note ();
4125 /* Undo the effects of init_dummy_function_start. */
4127 expand_dummy_function_end (void)
4129 /* End any sequences that failed to be closed due to syntax errors. */
4130 while (in_sequence_p ())
4133 /* Outside function body, can't compute type's actual size
4134 until next function's body starts. */
4136 free_after_parsing (cfun
);
4137 free_after_compilation (cfun
);
4141 /* Call DOIT for each hard register used as a return value from
4142 the current function. */
4145 diddle_return_value (void (*doit
) (rtx
, void *), void *arg
)
4147 rtx outgoing
= current_function_return_rtx
;
4152 if (REG_P (outgoing
))
4153 (*doit
) (outgoing
, arg
);
4154 else if (GET_CODE (outgoing
) == PARALLEL
)
4158 for (i
= 0; i
< XVECLEN (outgoing
, 0); i
++)
4160 rtx x
= XEXP (XVECEXP (outgoing
, 0, i
), 0);
4162 if (REG_P (x
) && REGNO (x
) < FIRST_PSEUDO_REGISTER
)
4169 do_clobber_return_reg (rtx reg
, void *arg ATTRIBUTE_UNUSED
)
4171 emit_insn (gen_rtx_CLOBBER (VOIDmode
, reg
));
4175 clobber_return_register (void)
4177 diddle_return_value (do_clobber_return_reg
, NULL
);
4179 /* In case we do use pseudo to return value, clobber it too. */
4180 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl
)))
4182 tree decl_result
= DECL_RESULT (current_function_decl
);
4183 rtx decl_rtl
= DECL_RTL (decl_result
);
4184 if (REG_P (decl_rtl
) && REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
)
4186 do_clobber_return_reg (decl_rtl
, NULL
);
4192 do_use_return_reg (rtx reg
, void *arg ATTRIBUTE_UNUSED
)
4194 emit_insn (gen_rtx_USE (VOIDmode
, reg
));
4198 use_return_register (void)
4200 diddle_return_value (do_use_return_reg
, NULL
);
4203 /* Possibly warn about unused parameters. */
4205 do_warn_unused_parameter (tree fn
)
4209 for (decl
= DECL_ARGUMENTS (fn
);
4210 decl
; decl
= TREE_CHAIN (decl
))
4211 if (!TREE_USED (decl
) && TREE_CODE (decl
) == PARM_DECL
4212 && DECL_NAME (decl
) && !DECL_ARTIFICIAL (decl
))
4213 warning ("%Junused parameter '%D'", decl
, decl
);
4216 static GTY(()) rtx initial_trampoline
;
4218 /* Generate RTL for the end of the current function. */
4221 expand_function_end (void)
4225 /* If arg_pointer_save_area was referenced only from a nested
4226 function, we will not have initialized it yet. Do that now. */
4227 if (arg_pointer_save_area
&& ! cfun
->arg_pointer_save_area_init
)
4228 get_arg_pointer_save_area (cfun
);
4230 /* If we are doing stack checking and this function makes calls,
4231 do a stack probe at the start of the function to ensure we have enough
4232 space for another stack frame. */
4233 if (flag_stack_check
&& ! STACK_CHECK_BUILTIN
)
4237 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
4241 probe_stack_range (STACK_CHECK_PROTECT
,
4242 GEN_INT (STACK_CHECK_MAX_FRAME_SIZE
));
4245 emit_insn_before (seq
, tail_recursion_reentry
);
4250 /* Possibly warn about unused parameters.
4251 When frontend does unit-at-a-time, the warning is already
4252 issued at finalization time. */
4253 if (warn_unused_parameter
4254 && !lang_hooks
.callgraph
.expand_function
)
4255 do_warn_unused_parameter (current_function_decl
);
4257 /* End any sequences that failed to be closed due to syntax errors. */
4258 while (in_sequence_p ())
4261 clear_pending_stack_adjust ();
4262 do_pending_stack_adjust ();
4264 /* @@@ This is a kludge. We want to ensure that instructions that
4265 may trap are not moved into the epilogue by scheduling, because
4266 we don't always emit unwind information for the epilogue.
4267 However, not all machine descriptions define a blockage insn, so
4268 emit an ASM_INPUT to act as one. */
4269 if (flag_non_call_exceptions
)
4270 emit_insn (gen_rtx_ASM_INPUT (VOIDmode
, ""));
4272 /* Mark the end of the function body.
4273 If control reaches this insn, the function can drop through
4274 without returning a value. */
4275 emit_note (NOTE_INSN_FUNCTION_END
);
4277 /* Must mark the last line number note in the function, so that the test
4278 coverage code can avoid counting the last line twice. This just tells
4279 the code to ignore the immediately following line note, since there
4280 already exists a copy of this note somewhere above. This line number
4281 note is still needed for debugging though, so we can't delete it. */
4282 if (flag_test_coverage
)
4283 emit_note (NOTE_INSN_REPEATED_LINE_NUMBER
);
4285 /* Output a linenumber for the end of the function.
4286 SDB depends on this. */
4287 force_next_line_note ();
4288 emit_line_note (input_location
);
4290 /* Before the return label (if any), clobber the return
4291 registers so that they are not propagated live to the rest of
4292 the function. This can only happen with functions that drop
4293 through; if there had been a return statement, there would
4294 have either been a return rtx, or a jump to the return label.
4296 We delay actual code generation after the current_function_value_rtx
4298 clobber_after
= get_last_insn ();
4300 /* Output the label for the actual return from the function,
4301 if one is expected. This happens either because a function epilogue
4302 is used instead of a return instruction, or because a return was done
4303 with a goto in order to run local cleanups, or because of pcc-style
4304 structure returning. */
4306 emit_label (return_label
);
4308 /* Let except.c know where it should emit the call to unregister
4309 the function context for sjlj exceptions. */
4310 if (flag_exceptions
&& USING_SJLJ_EXCEPTIONS
)
4311 sjlj_emit_function_exit_after (get_last_insn ());
4313 /* If we had calls to alloca, and this machine needs
4314 an accurate stack pointer to exit the function,
4315 insert some code to save and restore the stack pointer. */
4316 if (! EXIT_IGNORE_STACK
4317 && current_function_calls_alloca
)
4321 emit_stack_save (SAVE_FUNCTION
, &tem
, parm_birth_insn
);
4322 emit_stack_restore (SAVE_FUNCTION
, tem
, NULL_RTX
);
4325 /* If scalar return value was computed in a pseudo-reg, or was a named
4326 return value that got dumped to the stack, copy that to the hard
4328 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl
)))
4330 tree decl_result
= DECL_RESULT (current_function_decl
);
4331 rtx decl_rtl
= DECL_RTL (decl_result
);
4333 if (REG_P (decl_rtl
)
4334 ? REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
4335 : DECL_REGISTER (decl_result
))
4337 rtx real_decl_rtl
= current_function_return_rtx
;
4339 /* This should be set in assign_parms. */
4340 if (! REG_FUNCTION_VALUE_P (real_decl_rtl
))
4343 /* If this is a BLKmode structure being returned in registers,
4344 then use the mode computed in expand_return. Note that if
4345 decl_rtl is memory, then its mode may have been changed,
4346 but that current_function_return_rtx has not. */
4347 if (GET_MODE (real_decl_rtl
) == BLKmode
)
4348 PUT_MODE (real_decl_rtl
, GET_MODE (decl_rtl
));
4350 /* If a named return value dumped decl_return to memory, then
4351 we may need to re-do the PROMOTE_MODE signed/unsigned
4353 if (GET_MODE (real_decl_rtl
) != GET_MODE (decl_rtl
))
4355 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (decl_result
));
4357 if (targetm
.calls
.promote_function_return (TREE_TYPE (current_function_decl
)))
4358 promote_mode (TREE_TYPE (decl_result
), GET_MODE (decl_rtl
),
4361 convert_move (real_decl_rtl
, decl_rtl
, unsignedp
);
4363 else if (GET_CODE (real_decl_rtl
) == PARALLEL
)
4365 /* If expand_function_start has created a PARALLEL for decl_rtl,
4366 move the result to the real return registers. Otherwise, do
4367 a group load from decl_rtl for a named return. */
4368 if (GET_CODE (decl_rtl
) == PARALLEL
)
4369 emit_group_move (real_decl_rtl
, decl_rtl
);
4371 emit_group_load (real_decl_rtl
, decl_rtl
,
4372 TREE_TYPE (decl_result
),
4373 int_size_in_bytes (TREE_TYPE (decl_result
)));
4376 emit_move_insn (real_decl_rtl
, decl_rtl
);
4380 /* If returning a structure, arrange to return the address of the value
4381 in a place where debuggers expect to find it.
4383 If returning a structure PCC style,
4384 the caller also depends on this value.
4385 And current_function_returns_pcc_struct is not necessarily set. */
4386 if (current_function_returns_struct
4387 || current_function_returns_pcc_struct
)
4389 rtx value_address
= DECL_RTL (DECL_RESULT (current_function_decl
));
4390 tree type
= TREE_TYPE (DECL_RESULT (current_function_decl
));
4393 if (DECL_BY_REFERENCE (DECL_RESULT (current_function_decl
)))
4394 type
= TREE_TYPE (type
);
4396 value_address
= XEXP (value_address
, 0);
4398 #ifdef FUNCTION_OUTGOING_VALUE
4399 outgoing
= FUNCTION_OUTGOING_VALUE (build_pointer_type (type
),
4400 current_function_decl
);
4402 outgoing
= FUNCTION_VALUE (build_pointer_type (type
),
4403 current_function_decl
);
4406 /* Mark this as a function return value so integrate will delete the
4407 assignment and USE below when inlining this function. */
4408 REG_FUNCTION_VALUE_P (outgoing
) = 1;
4410 /* The address may be ptr_mode and OUTGOING may be Pmode. */
4411 value_address
= convert_memory_address (GET_MODE (outgoing
),
4414 emit_move_insn (outgoing
, value_address
);
4416 /* Show return register used to hold result (in this case the address
4418 current_function_return_rtx
= outgoing
;
4421 /* If this is an implementation of throw, do what's necessary to
4422 communicate between __builtin_eh_return and the epilogue. */
4423 expand_eh_return ();
4425 /* Emit the actual code to clobber return register. */
4430 clobber_return_register ();
4434 after
= emit_insn_after (seq
, clobber_after
);
4437 /* Output the label for the naked return from the function, if one is
4438 expected. This is currently used only by __builtin_return. */
4439 if (naked_return_label
)
4440 emit_label (naked_return_label
);
4442 /* ??? This should no longer be necessary since stupid is no longer with
4443 us, but there are some parts of the compiler (eg reload_combine, and
4444 sh mach_dep_reorg) that still try and compute their own lifetime info
4445 instead of using the general framework. */
4446 use_return_register ();
4450 get_arg_pointer_save_area (struct function
*f
)
4452 rtx ret
= f
->x_arg_pointer_save_area
;
4456 ret
= assign_stack_local_1 (Pmode
, GET_MODE_SIZE (Pmode
), 0, f
);
4457 f
->x_arg_pointer_save_area
= ret
;
4460 if (f
== cfun
&& ! f
->arg_pointer_save_area_init
)
4464 /* Save the arg pointer at the beginning of the function. The
4465 generated stack slot may not be a valid memory address, so we
4466 have to check it and fix it if necessary. */
4468 emit_move_insn (validize_mem (ret
), virtual_incoming_args_rtx
);
4472 push_topmost_sequence ();
4473 emit_insn_after (seq
, get_insns ());
4474 pop_topmost_sequence ();
4480 /* Extend a vector that records the INSN_UIDs of INSNS
4481 (a list of one or more insns). */
4484 record_insns (rtx insns
, varray_type
*vecp
)
4491 while (tmp
!= NULL_RTX
)
4494 tmp
= NEXT_INSN (tmp
);
4497 i
= VARRAY_SIZE (*vecp
);
4498 VARRAY_GROW (*vecp
, i
+ len
);
4500 while (tmp
!= NULL_RTX
)
4502 VARRAY_INT (*vecp
, i
) = INSN_UID (tmp
);
4504 tmp
= NEXT_INSN (tmp
);
4508 /* Set the locator of the insn chain starting at INSN to LOC. */
4510 set_insn_locators (rtx insn
, int loc
)
4512 while (insn
!= NULL_RTX
)
4515 INSN_LOCATOR (insn
) = loc
;
4516 insn
= NEXT_INSN (insn
);
4520 /* Determine how many INSN_UIDs in VEC are part of INSN. Because we can
4521 be running after reorg, SEQUENCE rtl is possible. */
4524 contains (rtx insn
, varray_type vec
)
4528 if (NONJUMP_INSN_P (insn
)
4529 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
4532 for (i
= XVECLEN (PATTERN (insn
), 0) - 1; i
>= 0; i
--)
4533 for (j
= VARRAY_SIZE (vec
) - 1; j
>= 0; --j
)
4534 if (INSN_UID (XVECEXP (PATTERN (insn
), 0, i
)) == VARRAY_INT (vec
, j
))
4540 for (j
= VARRAY_SIZE (vec
) - 1; j
>= 0; --j
)
4541 if (INSN_UID (insn
) == VARRAY_INT (vec
, j
))
4548 prologue_epilogue_contains (rtx insn
)
4550 if (contains (insn
, prologue
))
4552 if (contains (insn
, epilogue
))
4558 sibcall_epilogue_contains (rtx insn
)
4560 if (sibcall_epilogue
)
4561 return contains (insn
, sibcall_epilogue
);
4566 /* Insert gen_return at the end of block BB. This also means updating
4567 block_for_insn appropriately. */
4570 emit_return_into_block (basic_block bb
, rtx line_note
)
4572 emit_jump_insn_after (gen_return (), BB_END (bb
));
4574 emit_note_copy_after (line_note
, PREV_INSN (BB_END (bb
)));
4576 #endif /* HAVE_return */
4578 #if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX)
4580 /* These functions convert the epilogue into a variant that does not modify the
4581 stack pointer. This is used in cases where a function returns an object
4582 whose size is not known until it is computed. The called function leaves the
4583 object on the stack, leaves the stack depressed, and returns a pointer to
4586 What we need to do is track all modifications and references to the stack
4587 pointer, deleting the modifications and changing the references to point to
4588 the location the stack pointer would have pointed to had the modifications
4591 These functions need to be portable so we need to make as few assumptions
4592 about the epilogue as we can. However, the epilogue basically contains
4593 three things: instructions to reset the stack pointer, instructions to
4594 reload registers, possibly including the frame pointer, and an
4595 instruction to return to the caller.
4597 If we can't be sure of what a relevant epilogue insn is doing, we abort.
4598 We also make no attempt to validate the insns we make since if they are
4599 invalid, we probably can't do anything valid. The intent is that these
4600 routines get "smarter" as more and more machines start to use them and
4601 they try operating on different epilogues.
4603 We use the following structure to track what the part of the epilogue that
4604 we've already processed has done. We keep two copies of the SP equivalence,
4605 one for use during the insn we are processing and one for use in the next
4606 insn. The difference is because one part of a PARALLEL may adjust SP
4607 and the other may use it. */
4611 rtx sp_equiv_reg
; /* REG that SP is set from, perhaps SP. */
4612 HOST_WIDE_INT sp_offset
; /* Offset from SP_EQUIV_REG of present SP. */
4613 rtx new_sp_equiv_reg
; /* REG to be used at end of insn. */
4614 HOST_WIDE_INT new_sp_offset
; /* Offset to be used at end of insn. */
4615 rtx equiv_reg_src
; /* If nonzero, the value that SP_EQUIV_REG
4616 should be set to once we no longer need
4618 rtx const_equiv
[FIRST_PSEUDO_REGISTER
]; /* Any known constant equivalences
4622 static void handle_epilogue_set (rtx
, struct epi_info
*);
4623 static void update_epilogue_consts (rtx
, rtx
, void *);
4624 static void emit_equiv_load (struct epi_info
*);
4626 /* Modify INSN, a list of one or more insns that is part of the epilogue, to
4627 no modifications to the stack pointer. Return the new list of insns. */
4630 keep_stack_depressed (rtx insns
)
4633 struct epi_info info
;
4636 /* If the epilogue is just a single instruction, it must be OK as is. */
4637 if (NEXT_INSN (insns
) == NULL_RTX
)
4640 /* Otherwise, start a sequence, initialize the information we have, and
4641 process all the insns we were given. */
4644 info
.sp_equiv_reg
= stack_pointer_rtx
;
4646 info
.equiv_reg_src
= 0;
4648 for (j
= 0; j
< FIRST_PSEUDO_REGISTER
; j
++)
4649 info
.const_equiv
[j
] = 0;
4653 while (insn
!= NULL_RTX
)
4655 next
= NEXT_INSN (insn
);
4664 /* If this insn references the register that SP is equivalent to and
4665 we have a pending load to that register, we must force out the load
4666 first and then indicate we no longer know what SP's equivalent is. */
4667 if (info
.equiv_reg_src
!= 0
4668 && reg_referenced_p (info
.sp_equiv_reg
, PATTERN (insn
)))
4670 emit_equiv_load (&info
);
4671 info
.sp_equiv_reg
= 0;
4674 info
.new_sp_equiv_reg
= info
.sp_equiv_reg
;
4675 info
.new_sp_offset
= info
.sp_offset
;
4677 /* If this is a (RETURN) and the return address is on the stack,
4678 update the address and change to an indirect jump. */
4679 if (GET_CODE (PATTERN (insn
)) == RETURN
4680 || (GET_CODE (PATTERN (insn
)) == PARALLEL
4681 && GET_CODE (XVECEXP (PATTERN (insn
), 0, 0)) == RETURN
))
4683 rtx retaddr
= INCOMING_RETURN_ADDR_RTX
;
4685 HOST_WIDE_INT offset
= 0;
4686 rtx jump_insn
, jump_set
;
4688 /* If the return address is in a register, we can emit the insn
4689 unchanged. Otherwise, it must be a MEM and we see what the
4690 base register and offset are. In any case, we have to emit any
4691 pending load to the equivalent reg of SP, if any. */
4692 if (REG_P (retaddr
))
4694 emit_equiv_load (&info
);
4699 else if (MEM_P (retaddr
)
4700 && REG_P (XEXP (retaddr
, 0)))
4701 base
= gen_rtx_REG (Pmode
, REGNO (XEXP (retaddr
, 0))), offset
= 0;
4702 else if (MEM_P (retaddr
)
4703 && GET_CODE (XEXP (retaddr
, 0)) == PLUS
4704 && REG_P (XEXP (XEXP (retaddr
, 0), 0))
4705 && GET_CODE (XEXP (XEXP (retaddr
, 0), 1)) == CONST_INT
)
4707 base
= gen_rtx_REG (Pmode
, REGNO (XEXP (XEXP (retaddr
, 0), 0)));
4708 offset
= INTVAL (XEXP (XEXP (retaddr
, 0), 1));
4713 /* If the base of the location containing the return pointer
4714 is SP, we must update it with the replacement address. Otherwise,
4715 just build the necessary MEM. */
4716 retaddr
= plus_constant (base
, offset
);
4717 if (base
== stack_pointer_rtx
)
4718 retaddr
= simplify_replace_rtx (retaddr
, stack_pointer_rtx
,
4719 plus_constant (info
.sp_equiv_reg
,
4722 retaddr
= gen_rtx_MEM (Pmode
, retaddr
);
4724 /* If there is a pending load to the equivalent register for SP
4725 and we reference that register, we must load our address into
4726 a scratch register and then do that load. */
4727 if (info
.equiv_reg_src
4728 && reg_overlap_mentioned_p (info
.equiv_reg_src
, retaddr
))
4733 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
4734 if (HARD_REGNO_MODE_OK (regno
, Pmode
)
4735 && !fixed_regs
[regno
]
4736 && TEST_HARD_REG_BIT (regs_invalidated_by_call
, regno
)
4737 && !REGNO_REG_SET_P (EXIT_BLOCK_PTR
->global_live_at_start
,
4739 && !refers_to_regno_p (regno
,
4740 regno
+ hard_regno_nregs
[regno
]
4742 info
.equiv_reg_src
, NULL
)
4743 && info
.const_equiv
[regno
] == 0)
4746 if (regno
== FIRST_PSEUDO_REGISTER
)
4749 reg
= gen_rtx_REG (Pmode
, regno
);
4750 emit_move_insn (reg
, retaddr
);
4754 emit_equiv_load (&info
);
4755 jump_insn
= emit_jump_insn (gen_indirect_jump (retaddr
));
4757 /* Show the SET in the above insn is a RETURN. */
4758 jump_set
= single_set (jump_insn
);
4762 SET_IS_RETURN_P (jump_set
) = 1;
4765 /* If SP is not mentioned in the pattern and its equivalent register, if
4766 any, is not modified, just emit it. Otherwise, if neither is set,
4767 replace the reference to SP and emit the insn. If none of those are
4768 true, handle each SET individually. */
4769 else if (!reg_mentioned_p (stack_pointer_rtx
, PATTERN (insn
))
4770 && (info
.sp_equiv_reg
== stack_pointer_rtx
4771 || !reg_set_p (info
.sp_equiv_reg
, insn
)))
4773 else if (! reg_set_p (stack_pointer_rtx
, insn
)
4774 && (info
.sp_equiv_reg
== stack_pointer_rtx
4775 || !reg_set_p (info
.sp_equiv_reg
, insn
)))
4777 if (! validate_replace_rtx (stack_pointer_rtx
,
4778 plus_constant (info
.sp_equiv_reg
,
4785 else if (GET_CODE (PATTERN (insn
)) == SET
)
4786 handle_epilogue_set (PATTERN (insn
), &info
);
4787 else if (GET_CODE (PATTERN (insn
)) == PARALLEL
)
4789 for (j
= 0; j
< XVECLEN (PATTERN (insn
), 0); j
++)
4790 if (GET_CODE (XVECEXP (PATTERN (insn
), 0, j
)) == SET
)
4791 handle_epilogue_set (XVECEXP (PATTERN (insn
), 0, j
), &info
);
4796 info
.sp_equiv_reg
= info
.new_sp_equiv_reg
;
4797 info
.sp_offset
= info
.new_sp_offset
;
4799 /* Now update any constants this insn sets. */
4800 note_stores (PATTERN (insn
), update_epilogue_consts
, &info
);
4804 insns
= get_insns ();
4809 /* SET is a SET from an insn in the epilogue. P is a pointer to the epi_info
4810 structure that contains information about what we've seen so far. We
4811 process this SET by either updating that data or by emitting one or
4815 handle_epilogue_set (rtx set
, struct epi_info
*p
)
4817 /* First handle the case where we are setting SP. Record what it is being
4818 set from. If unknown, abort. */
4819 if (reg_set_p (stack_pointer_rtx
, set
))
4821 if (SET_DEST (set
) != stack_pointer_rtx
)
4824 if (GET_CODE (SET_SRC (set
)) == PLUS
)
4826 p
->new_sp_equiv_reg
= XEXP (SET_SRC (set
), 0);
4827 if (GET_CODE (XEXP (SET_SRC (set
), 1)) == CONST_INT
)
4828 p
->new_sp_offset
= INTVAL (XEXP (SET_SRC (set
), 1));
4829 else if (REG_P (XEXP (SET_SRC (set
), 1))
4830 && REGNO (XEXP (SET_SRC (set
), 1)) < FIRST_PSEUDO_REGISTER
4831 && p
->const_equiv
[REGNO (XEXP (SET_SRC (set
), 1))] != 0)
4833 = INTVAL (p
->const_equiv
[REGNO (XEXP (SET_SRC (set
), 1))]);
4838 p
->new_sp_equiv_reg
= SET_SRC (set
), p
->new_sp_offset
= 0;
4840 /* If we are adjusting SP, we adjust from the old data. */
4841 if (p
->new_sp_equiv_reg
== stack_pointer_rtx
)
4843 p
->new_sp_equiv_reg
= p
->sp_equiv_reg
;
4844 p
->new_sp_offset
+= p
->sp_offset
;
4847 if (p
->new_sp_equiv_reg
== 0 || !REG_P (p
->new_sp_equiv_reg
))
4853 /* Next handle the case where we are setting SP's equivalent register.
4854 If we already have a value to set it to, abort. We could update, but
4855 there seems little point in handling that case. Note that we have
4856 to allow for the case where we are setting the register set in
4857 the previous part of a PARALLEL inside a single insn. But use the
4858 old offset for any updates within this insn. We must allow for the case
4859 where the register is being set in a different (usually wider) mode than
4861 else if (p
->new_sp_equiv_reg
!= 0 && reg_set_p (p
->new_sp_equiv_reg
, set
))
4863 if (p
->equiv_reg_src
!= 0
4864 || !REG_P (p
->new_sp_equiv_reg
)
4865 || !REG_P (SET_DEST (set
))
4866 || GET_MODE_BITSIZE (GET_MODE (SET_DEST (set
))) > BITS_PER_WORD
4867 || REGNO (p
->new_sp_equiv_reg
) != REGNO (SET_DEST (set
)))
4871 = simplify_replace_rtx (SET_SRC (set
), stack_pointer_rtx
,
4872 plus_constant (p
->sp_equiv_reg
,
4876 /* Otherwise, replace any references to SP in the insn to its new value
4877 and emit the insn. */
4880 SET_SRC (set
) = simplify_replace_rtx (SET_SRC (set
), stack_pointer_rtx
,
4881 plus_constant (p
->sp_equiv_reg
,
4883 SET_DEST (set
) = simplify_replace_rtx (SET_DEST (set
), stack_pointer_rtx
,
4884 plus_constant (p
->sp_equiv_reg
,
4890 /* Update the tracking information for registers set to constants. */
4893 update_epilogue_consts (rtx dest
, rtx x
, void *data
)
4895 struct epi_info
*p
= (struct epi_info
*) data
;
4898 if (!REG_P (dest
) || REGNO (dest
) >= FIRST_PSEUDO_REGISTER
)
4901 /* If we are either clobbering a register or doing a partial set,
4902 show we don't know the value. */
4903 else if (GET_CODE (x
) == CLOBBER
|| ! rtx_equal_p (dest
, SET_DEST (x
)))
4904 p
->const_equiv
[REGNO (dest
)] = 0;
4906 /* If we are setting it to a constant, record that constant. */
4907 else if (GET_CODE (SET_SRC (x
)) == CONST_INT
)
4908 p
->const_equiv
[REGNO (dest
)] = SET_SRC (x
);
4910 /* If this is a binary operation between a register we have been tracking
4911 and a constant, see if we can compute a new constant value. */
4912 else if (ARITHMETIC_P (SET_SRC (x
))
4913 && REG_P (XEXP (SET_SRC (x
), 0))
4914 && REGNO (XEXP (SET_SRC (x
), 0)) < FIRST_PSEUDO_REGISTER
4915 && p
->const_equiv
[REGNO (XEXP (SET_SRC (x
), 0))] != 0
4916 && GET_CODE (XEXP (SET_SRC (x
), 1)) == CONST_INT
4917 && 0 != (new = simplify_binary_operation
4918 (GET_CODE (SET_SRC (x
)), GET_MODE (dest
),
4919 p
->const_equiv
[REGNO (XEXP (SET_SRC (x
), 0))],
4920 XEXP (SET_SRC (x
), 1)))
4921 && GET_CODE (new) == CONST_INT
)
4922 p
->const_equiv
[REGNO (dest
)] = new;
4924 /* Otherwise, we can't do anything with this value. */
4926 p
->const_equiv
[REGNO (dest
)] = 0;
4929 /* Emit an insn to do the load shown in p->equiv_reg_src, if needed. */
4932 emit_equiv_load (struct epi_info
*p
)
4934 if (p
->equiv_reg_src
!= 0)
4936 rtx dest
= p
->sp_equiv_reg
;
4938 if (GET_MODE (p
->equiv_reg_src
) != GET_MODE (dest
))
4939 dest
= gen_rtx_REG (GET_MODE (p
->equiv_reg_src
),
4940 REGNO (p
->sp_equiv_reg
));
4942 emit_move_insn (dest
, p
->equiv_reg_src
);
4943 p
->equiv_reg_src
= 0;
4948 /* Generate the prologue and epilogue RTL if the machine supports it. Thread
4949 this into place with notes indicating where the prologue ends and where
4950 the epilogue begins. Update the basic block information when possible. */
4953 thread_prologue_and_epilogue_insns (rtx f ATTRIBUTE_UNUSED
)
4957 #if defined (HAVE_sibcall_epilogue) || defined (HAVE_epilogue) || defined (HAVE_return) || defined (HAVE_prologue)
4960 #ifdef HAVE_prologue
4961 rtx prologue_end
= NULL_RTX
;
4963 #if defined (HAVE_epilogue) || defined(HAVE_return)
4964 rtx epilogue_end
= NULL_RTX
;
4967 #ifdef HAVE_prologue
4971 seq
= gen_prologue ();
4974 /* Retain a map of the prologue insns. */
4975 record_insns (seq
, &prologue
);
4976 prologue_end
= emit_note (NOTE_INSN_PROLOGUE_END
);
4980 set_insn_locators (seq
, prologue_locator
);
4982 /* Can't deal with multiple successors of the entry block
4983 at the moment. Function should always have at least one
4985 if (!ENTRY_BLOCK_PTR
->succ
|| ENTRY_BLOCK_PTR
->succ
->succ_next
)
4988 insert_insn_on_edge (seq
, ENTRY_BLOCK_PTR
->succ
);
4993 /* If the exit block has no non-fake predecessors, we don't need
4995 for (e
= EXIT_BLOCK_PTR
->pred
; e
; e
= e
->pred_next
)
4996 if ((e
->flags
& EDGE_FAKE
) == 0)
5002 if (optimize
&& HAVE_return
)
5004 /* If we're allowed to generate a simple return instruction,
5005 then by definition we don't need a full epilogue. Examine
5006 the block that falls through to EXIT. If it does not
5007 contain any code, examine its predecessors and try to
5008 emit (conditional) return instructions. */
5014 for (e
= EXIT_BLOCK_PTR
->pred
; e
; e
= e
->pred_next
)
5015 if (e
->flags
& EDGE_FALLTHRU
)
5021 /* Verify that there are no active instructions in the last block. */
5022 label
= BB_END (last
);
5023 while (label
&& !LABEL_P (label
))
5025 if (active_insn_p (label
))
5027 label
= PREV_INSN (label
);
5030 if (BB_HEAD (last
) == label
&& LABEL_P (label
))
5032 rtx epilogue_line_note
= NULL_RTX
;
5034 /* Locate the line number associated with the closing brace,
5035 if we can find one. */
5036 for (seq
= get_last_insn ();
5037 seq
&& ! active_insn_p (seq
);
5038 seq
= PREV_INSN (seq
))
5039 if (NOTE_P (seq
) && NOTE_LINE_NUMBER (seq
) > 0)
5041 epilogue_line_note
= seq
;
5045 for (e
= last
->pred
; e
; e
= e_next
)
5047 basic_block bb
= e
->src
;
5050 e_next
= e
->pred_next
;
5051 if (bb
== ENTRY_BLOCK_PTR
)
5055 if (!JUMP_P (jump
) || JUMP_LABEL (jump
) != label
)
5058 /* If we have an unconditional jump, we can replace that
5059 with a simple return instruction. */
5060 if (simplejump_p (jump
))
5062 emit_return_into_block (bb
, epilogue_line_note
);
5066 /* If we have a conditional jump, we can try to replace
5067 that with a conditional return instruction. */
5068 else if (condjump_p (jump
))
5070 if (! redirect_jump (jump
, 0, 0))
5073 /* If this block has only one successor, it both jumps
5074 and falls through to the fallthru block, so we can't
5076 if (bb
->succ
->succ_next
== NULL
)
5082 /* Fix up the CFG for the successful change we just made. */
5083 redirect_edge_succ (e
, EXIT_BLOCK_PTR
);
5086 /* Emit a return insn for the exit fallthru block. Whether
5087 this is still reachable will be determined later. */
5089 emit_barrier_after (BB_END (last
));
5090 emit_return_into_block (last
, epilogue_line_note
);
5091 epilogue_end
= BB_END (last
);
5092 last
->succ
->flags
&= ~EDGE_FALLTHRU
;
5097 /* Find the edge that falls through to EXIT. Other edges may exist
5098 due to RETURN instructions, but those don't need epilogues.
5099 There really shouldn't be a mixture -- either all should have
5100 been converted or none, however... */
5102 for (e
= EXIT_BLOCK_PTR
->pred
; e
; e
= e
->pred_next
)
5103 if (e
->flags
& EDGE_FALLTHRU
)
5108 #ifdef HAVE_epilogue
5112 epilogue_end
= emit_note (NOTE_INSN_EPILOGUE_BEG
);
5114 seq
= gen_epilogue ();
5116 #ifdef INCOMING_RETURN_ADDR_RTX
5117 /* If this function returns with the stack depressed and we can support
5118 it, massage the epilogue to actually do that. */
5119 if (TREE_CODE (TREE_TYPE (current_function_decl
)) == FUNCTION_TYPE
5120 && TYPE_RETURNS_STACK_DEPRESSED (TREE_TYPE (current_function_decl
)))
5121 seq
= keep_stack_depressed (seq
);
5124 emit_jump_insn (seq
);
5126 /* Retain a map of the epilogue insns. */
5127 record_insns (seq
, &epilogue
);
5128 set_insn_locators (seq
, epilogue_locator
);
5133 insert_insn_on_edge (seq
, e
);
5141 if (! next_active_insn (BB_END (e
->src
)))
5143 /* We have a fall-through edge to the exit block, the source is not
5144 at the end of the function, and there will be an assembler epilogue
5145 at the end of the function.
5146 We can't use force_nonfallthru here, because that would try to
5147 use return. Inserting a jump 'by hand' is extremely messy, so
5148 we take advantage of cfg_layout_finalize using
5149 fixup_fallthru_exit_predecessor. */
5150 cfg_layout_initialize (0);
5151 FOR_EACH_BB (cur_bb
)
5152 if (cur_bb
->index
>= 0 && cur_bb
->next_bb
->index
>= 0)
5153 cur_bb
->rbi
->next
= cur_bb
->next_bb
;
5154 cfg_layout_finalize ();
5159 commit_edge_insertions ();
5161 #ifdef HAVE_sibcall_epilogue
5162 /* Emit sibling epilogues before any sibling call sites. */
5163 for (e
= EXIT_BLOCK_PTR
->pred
; e
; e
= e
->pred_next
)
5165 basic_block bb
= e
->src
;
5166 rtx insn
= BB_END (bb
);
5171 || ! SIBLING_CALL_P (insn
))
5175 emit_insn (gen_sibcall_epilogue ());
5179 /* Retain a map of the epilogue insns. Used in life analysis to
5180 avoid getting rid of sibcall epilogue insns. Do this before we
5181 actually emit the sequence. */
5182 record_insns (seq
, &sibcall_epilogue
);
5183 set_insn_locators (seq
, epilogue_locator
);
5185 i
= PREV_INSN (insn
);
5186 newinsn
= emit_insn_before (seq
, insn
);
5190 #ifdef HAVE_prologue
5191 /* This is probably all useless now that we use locators. */
5196 /* GDB handles `break f' by setting a breakpoint on the first
5197 line note after the prologue. Which means (1) that if
5198 there are line number notes before where we inserted the
5199 prologue we should move them, and (2) we should generate a
5200 note before the end of the first basic block, if there isn't
5203 ??? This behavior is completely broken when dealing with
5204 multiple entry functions. We simply place the note always
5205 into first basic block and let alternate entry points
5209 for (insn
= prologue_end
; insn
; insn
= prev
)
5211 prev
= PREV_INSN (insn
);
5212 if (NOTE_P (insn
) && NOTE_LINE_NUMBER (insn
) > 0)
5214 /* Note that we cannot reorder the first insn in the
5215 chain, since rest_of_compilation relies on that
5216 remaining constant. */
5219 reorder_insns (insn
, insn
, prologue_end
);
5223 /* Find the last line number note in the first block. */
5224 for (insn
= BB_END (ENTRY_BLOCK_PTR
->next_bb
);
5225 insn
!= prologue_end
&& insn
;
5226 insn
= PREV_INSN (insn
))
5227 if (NOTE_P (insn
) && NOTE_LINE_NUMBER (insn
) > 0)
5230 /* If we didn't find one, make a copy of the first line number
5234 for (insn
= next_active_insn (prologue_end
);
5236 insn
= PREV_INSN (insn
))
5237 if (NOTE_P (insn
) && NOTE_LINE_NUMBER (insn
) > 0)
5239 emit_note_copy_after (insn
, prologue_end
);
5245 #ifdef HAVE_epilogue
5250 /* Similarly, move any line notes that appear after the epilogue.
5251 There is no need, however, to be quite so anal about the existence
5252 of such a note. Also move the NOTE_INSN_FUNCTION_END and (possibly)
5253 NOTE_INSN_FUNCTION_BEG notes, as those can be relevant for debug
5255 for (insn
= epilogue_end
; insn
; insn
= next
)
5257 next
= NEXT_INSN (insn
);
5259 && (NOTE_LINE_NUMBER (insn
) > 0
5260 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_FUNCTION_BEG
5261 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_FUNCTION_END
))
5262 reorder_insns (insn
, insn
, PREV_INSN (epilogue_end
));
5268 /* Reposition the prologue-end and epilogue-begin notes after instruction
5269 scheduling and delayed branch scheduling. */
5272 reposition_prologue_and_epilogue_notes (rtx f ATTRIBUTE_UNUSED
)
5274 #if defined (HAVE_prologue) || defined (HAVE_epilogue)
5275 rtx insn
, last
, note
;
5278 if ((len
= VARRAY_SIZE (prologue
)) > 0)
5282 /* Scan from the beginning until we reach the last prologue insn.
5283 We apparently can't depend on basic_block_{head,end} after
5285 for (insn
= f
; insn
; insn
= NEXT_INSN (insn
))
5289 if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_PROLOGUE_END
)
5292 else if (contains (insn
, prologue
))
5302 /* Find the prologue-end note if we haven't already, and
5303 move it to just after the last prologue insn. */
5306 for (note
= last
; (note
= NEXT_INSN (note
));)
5308 && NOTE_LINE_NUMBER (note
) == NOTE_INSN_PROLOGUE_END
)
5312 /* Avoid placing note between CODE_LABEL and BASIC_BLOCK note. */
5314 last
= NEXT_INSN (last
);
5315 reorder_insns (note
, note
, last
);
5319 if ((len
= VARRAY_SIZE (epilogue
)) > 0)
5323 /* Scan from the end until we reach the first epilogue insn.
5324 We apparently can't depend on basic_block_{head,end} after
5326 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
5330 if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_EPILOGUE_BEG
)
5333 else if (contains (insn
, epilogue
))
5343 /* Find the epilogue-begin note if we haven't already, and
5344 move it to just before the first epilogue insn. */
5347 for (note
= insn
; (note
= PREV_INSN (note
));)
5349 && NOTE_LINE_NUMBER (note
) == NOTE_INSN_EPILOGUE_BEG
)
5353 if (PREV_INSN (last
) != note
)
5354 reorder_insns (note
, note
, PREV_INSN (last
));
5357 #endif /* HAVE_prologue or HAVE_epilogue */
5360 /* Called once, at initialization, to initialize function.c. */
5363 init_function_once (void)
5365 VARRAY_INT_INIT (prologue
, 0, "prologue");
5366 VARRAY_INT_INIT (epilogue
, 0, "epilogue");
5367 VARRAY_INT_INIT (sibcall_epilogue
, 0, "sibcall_epilogue");
5370 /* Resets insn_block_boundaries array. */
5373 reset_block_changes (void)
5375 VARRAY_TREE_INIT (cfun
->ib_boundaries_block
, 100, "ib_boundaries_block");
5376 VARRAY_PUSH_TREE (cfun
->ib_boundaries_block
, NULL_TREE
);
5379 /* Record the boundary for BLOCK. */
5381 record_block_change (tree block
)
5389 last_block
= VARRAY_TOP_TREE (cfun
->ib_boundaries_block
);
5390 VARRAY_POP (cfun
->ib_boundaries_block
);
5392 for (i
= VARRAY_ACTIVE_SIZE (cfun
->ib_boundaries_block
); i
< n
; i
++)
5393 VARRAY_PUSH_TREE (cfun
->ib_boundaries_block
, last_block
);
5395 VARRAY_PUSH_TREE (cfun
->ib_boundaries_block
, block
);
5398 /* Finishes record of boundaries. */
5399 void finalize_block_changes (void)
5401 record_block_change (DECL_INITIAL (current_function_decl
));
5404 /* For INSN return the BLOCK it belongs to. */
5406 check_block_change (rtx insn
, tree
*block
)
5408 unsigned uid
= INSN_UID (insn
);
5410 if (uid
>= VARRAY_ACTIVE_SIZE (cfun
->ib_boundaries_block
))
5413 *block
= VARRAY_TREE (cfun
->ib_boundaries_block
, uid
);
5416 /* Releases the ib_boundaries_block records. */
5418 free_block_changes (void)
5420 cfun
->ib_boundaries_block
= NULL
;
5423 /* Returns the name of the current function. */
5425 current_function_name (void)
5427 return lang_hooks
.decl_printable_name (cfun
->decl
, 2);
5430 #include "gt-function.h"