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, 2005, 2006, 2007
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
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"
62 #include "tree-gimple.h"
63 #include "tree-pass.h"
69 /* So we can assign to cfun in this file. */
72 #ifndef LOCAL_ALIGNMENT
73 #define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT
76 #ifndef STACK_ALIGNMENT_NEEDED
77 #define STACK_ALIGNMENT_NEEDED 1
80 #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
82 /* Some systems use __main in a way incompatible with its use in gcc, in these
83 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
84 give the same symbol without quotes for an alternative entry point. You
85 must define both, or neither. */
87 #define NAME__MAIN "__main"
90 /* Round a value to the lowest integer less than it that is a multiple of
91 the required alignment. Avoid using division in case the value is
92 negative. Assume the alignment is a power of two. */
93 #define FLOOR_ROUND(VALUE,ALIGN) ((VALUE) & ~((ALIGN) - 1))
95 /* Similar, but round to the next highest integer that meets the
97 #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
99 /* Nonzero if function being compiled doesn't contain any calls
100 (ignoring the prologue and epilogue). This is set prior to
101 local register allocation and is valid for the remaining
103 int current_function_is_leaf
;
105 /* Nonzero if function being compiled doesn't modify the stack pointer
106 (ignoring the prologue and epilogue). This is only valid after
107 pass_stack_ptr_mod has run. */
108 int current_function_sp_is_unchanging
;
110 /* Nonzero if the function being compiled is a leaf function which only
111 uses leaf registers. This is valid after reload (specifically after
112 sched2) and is useful only if the port defines LEAF_REGISTERS. */
113 int current_function_uses_only_leaf_regs
;
115 /* Nonzero once virtual register instantiation has been done.
116 assign_stack_local uses frame_pointer_rtx when this is nonzero.
117 calls.c:emit_library_call_value_1 uses it to set up
118 post-instantiation libcalls. */
119 int virtuals_instantiated
;
121 /* Assign unique numbers to labels generated for profiling, debugging, etc. */
122 static GTY(()) int funcdef_no
;
124 /* These variables hold pointers to functions to create and destroy
125 target specific, per-function data structures. */
126 struct machine_function
* (*init_machine_status
) (void);
128 /* The currently compiled function. */
129 struct function
*cfun
= 0;
131 /* These arrays record the INSN_UIDs of the prologue and epilogue insns. */
132 static VEC(int,heap
) *prologue
;
133 static VEC(int,heap
) *epilogue
;
135 /* Array of INSN_UIDs to hold the INSN_UIDs for each sibcall epilogue
137 static VEC(int,heap
) *sibcall_epilogue
;
139 /* In order to evaluate some expressions, such as function calls returning
140 structures in memory, we need to temporarily allocate stack locations.
141 We record each allocated temporary in the following structure.
143 Associated with each temporary slot is a nesting level. When we pop up
144 one level, all temporaries associated with the previous level are freed.
145 Normally, all temporaries are freed after the execution of the statement
146 in which they were created. However, if we are inside a ({...}) grouping,
147 the result may be in a temporary and hence must be preserved. If the
148 result could be in a temporary, we preserve it if we can determine which
149 one it is in. If we cannot determine which temporary may contain the
150 result, all temporaries are preserved. A temporary is preserved by
151 pretending it was allocated at the previous nesting level.
153 Automatic variables are also assigned temporary slots, at the nesting
154 level where they are defined. They are marked a "kept" so that
155 free_temp_slots will not free them. */
157 struct temp_slot
GTY(())
159 /* Points to next temporary slot. */
160 struct temp_slot
*next
;
161 /* Points to previous temporary slot. */
162 struct temp_slot
*prev
;
164 /* The rtx to used to reference the slot. */
166 /* The rtx used to represent the address if not the address of the
167 slot above. May be an EXPR_LIST if multiple addresses exist. */
169 /* The alignment (in bits) of the slot. */
171 /* The size, in units, of the slot. */
173 /* The type of the object in the slot, or zero if it doesn't correspond
174 to a type. We use this to determine whether a slot can be reused.
175 It can be reused if objects of the type of the new slot will always
176 conflict with objects of the type of the old slot. */
178 /* Nonzero if this temporary is currently in use. */
180 /* Nonzero if this temporary has its address taken. */
182 /* Nesting level at which this slot is being used. */
184 /* Nonzero if this should survive a call to free_temp_slots. */
186 /* The offset of the slot from the frame_pointer, including extra space
187 for alignment. This info is for combine_temp_slots. */
188 HOST_WIDE_INT base_offset
;
189 /* The size of the slot, including extra space for alignment. This
190 info is for combine_temp_slots. */
191 HOST_WIDE_INT full_size
;
194 /* Forward declarations. */
196 static rtx
assign_stack_local_1 (enum machine_mode
, HOST_WIDE_INT
, int,
198 static struct temp_slot
*find_temp_slot_from_address (rtx
);
199 static void pad_to_arg_alignment (struct args_size
*, int, struct args_size
*);
200 static void pad_below (struct args_size
*, enum machine_mode
, tree
);
201 static void reorder_blocks_1 (rtx
, tree
, VEC(tree
,heap
) **);
202 static int all_blocks (tree
, tree
*);
203 static tree
*get_block_vector (tree
, int *);
204 extern tree
debug_find_var_in_block_tree (tree
, tree
);
205 /* We always define `record_insns' even if it's not used so that we
206 can always export `prologue_epilogue_contains'. */
207 static void record_insns (rtx
, VEC(int,heap
) **) ATTRIBUTE_UNUSED
;
208 static int contains (const_rtx
, VEC(int,heap
) **);
210 static void emit_return_into_block (basic_block
);
212 #if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX)
213 static rtx
keep_stack_depressed (rtx
);
215 static void prepare_function_start (void);
216 static void do_clobber_return_reg (rtx
, void *);
217 static void do_use_return_reg (rtx
, void *);
218 static void set_insn_locators (rtx
, int) ATTRIBUTE_UNUSED
;
220 /* Pointer to chain of `struct function' for containing functions. */
221 struct function
*outer_function_chain
;
223 /* Given a function decl for a containing function,
224 return the `struct function' for it. */
227 find_function_data (tree decl
)
231 for (p
= outer_function_chain
; p
; p
= p
->outer
)
238 /* Save the current context for compilation of a nested function.
239 This is called from language-specific code. The caller should use
240 the enter_nested langhook to save any language-specific state,
241 since this function knows only about language-independent
245 push_function_context_to (tree context ATTRIBUTE_UNUSED
)
250 allocate_struct_function (NULL
);
253 p
->outer
= outer_function_chain
;
254 outer_function_chain
= p
;
256 lang_hooks
.function
.enter_nested (p
);
262 push_function_context (void)
264 push_function_context_to (current_function_decl
);
267 /* Restore the last saved context, at the end of a nested function.
268 This function is called from language-specific code. */
271 pop_function_context_from (tree context ATTRIBUTE_UNUSED
)
273 struct function
*p
= outer_function_chain
;
276 outer_function_chain
= p
->outer
;
278 current_function_decl
= p
->decl
;
280 lang_hooks
.function
.leave_nested (p
);
282 /* Reset variables that have known state during rtx generation. */
283 virtuals_instantiated
= 0;
284 generating_concat_p
= 1;
288 pop_function_context (void)
290 pop_function_context_from (current_function_decl
);
293 /* Clear out all parts of the state in F that can safely be discarded
294 after the function has been parsed, but not compiled, to let
295 garbage collection reclaim the memory. */
298 free_after_parsing (struct function
*f
)
300 /* f->expr->forced_labels is used by code generation. */
301 /* f->emit->regno_reg_rtx is used by code generation. */
302 /* f->varasm is used by code generation. */
303 /* f->eh->eh_return_stub_label is used by code generation. */
305 lang_hooks
.function
.final (f
);
308 /* Clear out all parts of the state in F that can safely be discarded
309 after the function has been compiled, to let garbage collection
310 reclaim the memory. */
313 free_after_compilation (struct function
*f
)
315 VEC_free (int, heap
, prologue
);
316 VEC_free (int, heap
, epilogue
);
317 VEC_free (int, heap
, sibcall_epilogue
);
326 f
->x_avail_temp_slots
= NULL
;
327 f
->x_used_temp_slots
= NULL
;
328 f
->arg_offset_rtx
= NULL
;
329 f
->return_rtx
= NULL
;
330 f
->internal_arg_pointer
= NULL
;
331 f
->x_nonlocal_goto_handler_labels
= NULL
;
332 f
->x_return_label
= NULL
;
333 f
->x_naked_return_label
= NULL
;
334 f
->x_stack_slot_list
= NULL
;
335 f
->x_stack_check_probe_note
= NULL
;
336 f
->x_arg_pointer_save_area
= NULL
;
337 f
->x_parm_birth_insn
= NULL
;
338 f
->epilogue_delay_list
= NULL
;
341 /* Allocate fixed slots in the stack frame of the current function. */
343 /* Return size needed for stack frame based on slots so far allocated in
345 This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY;
346 the caller may have to do that. */
349 get_func_frame_size (struct function
*f
)
351 if (FRAME_GROWS_DOWNWARD
)
352 return -f
->x_frame_offset
;
354 return f
->x_frame_offset
;
357 /* Return size needed for stack frame based on slots so far allocated.
358 This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY;
359 the caller may have to do that. */
362 get_frame_size (void)
364 return get_func_frame_size (cfun
);
367 /* Issue an error message and return TRUE if frame OFFSET overflows in
368 the signed target pointer arithmetics for function FUNC. Otherwise
372 frame_offset_overflow (HOST_WIDE_INT offset
, tree func
)
374 unsigned HOST_WIDE_INT size
= FRAME_GROWS_DOWNWARD
? -offset
: offset
;
376 if (size
> ((unsigned HOST_WIDE_INT
) 1 << (GET_MODE_BITSIZE (Pmode
) - 1))
377 /* Leave room for the fixed part of the frame. */
378 - 64 * UNITS_PER_WORD
)
380 error ("%Jtotal size of local objects too large", func
);
387 /* Allocate a stack slot of SIZE bytes and return a MEM rtx for it
388 with machine mode MODE.
390 ALIGN controls the amount of alignment for the address of the slot:
391 0 means according to MODE,
392 -1 means use BIGGEST_ALIGNMENT and round size to multiple of that,
393 -2 means use BITS_PER_UNIT,
394 positive specifies alignment boundary in bits.
396 We do not round to stack_boundary here.
398 FUNCTION specifies the function to allocate in. */
401 assign_stack_local_1 (enum machine_mode mode
, HOST_WIDE_INT size
, int align
,
402 struct function
*function
)
405 int bigend_correction
= 0;
406 unsigned int alignment
;
407 int frame_off
, frame_alignment
, frame_phase
;
414 alignment
= BIGGEST_ALIGNMENT
;
416 alignment
= GET_MODE_ALIGNMENT (mode
);
418 /* Allow the target to (possibly) increase the alignment of this
420 type
= lang_hooks
.types
.type_for_mode (mode
, 0);
422 alignment
= LOCAL_ALIGNMENT (type
, alignment
);
424 alignment
/= BITS_PER_UNIT
;
426 else if (align
== -1)
428 alignment
= BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
;
429 size
= CEIL_ROUND (size
, alignment
);
431 else if (align
== -2)
432 alignment
= 1; /* BITS_PER_UNIT / BITS_PER_UNIT */
434 alignment
= align
/ BITS_PER_UNIT
;
436 if (FRAME_GROWS_DOWNWARD
)
437 function
->x_frame_offset
-= size
;
439 /* Ignore alignment we can't do with expected alignment of the boundary. */
440 if (alignment
* BITS_PER_UNIT
> PREFERRED_STACK_BOUNDARY
)
441 alignment
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
443 if (function
->stack_alignment_needed
< alignment
* BITS_PER_UNIT
)
444 function
->stack_alignment_needed
= alignment
* BITS_PER_UNIT
;
446 /* Calculate how many bytes the start of local variables is off from
448 frame_alignment
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
449 frame_off
= STARTING_FRAME_OFFSET
% frame_alignment
;
450 frame_phase
= frame_off
? frame_alignment
- frame_off
: 0;
452 /* Round the frame offset to the specified alignment. The default is
453 to always honor requests to align the stack but a port may choose to
454 do its own stack alignment by defining STACK_ALIGNMENT_NEEDED. */
455 if (STACK_ALIGNMENT_NEEDED
459 /* We must be careful here, since FRAME_OFFSET might be negative and
460 division with a negative dividend isn't as well defined as we might
461 like. So we instead assume that ALIGNMENT is a power of two and
462 use logical operations which are unambiguous. */
463 if (FRAME_GROWS_DOWNWARD
)
464 function
->x_frame_offset
465 = (FLOOR_ROUND (function
->x_frame_offset
- frame_phase
,
466 (unsigned HOST_WIDE_INT
) alignment
)
469 function
->x_frame_offset
470 = (CEIL_ROUND (function
->x_frame_offset
- frame_phase
,
471 (unsigned HOST_WIDE_INT
) alignment
)
475 /* On a big-endian machine, if we are allocating more space than we will use,
476 use the least significant bytes of those that are allocated. */
477 if (BYTES_BIG_ENDIAN
&& mode
!= BLKmode
&& GET_MODE_SIZE (mode
) < size
)
478 bigend_correction
= size
- GET_MODE_SIZE (mode
);
480 /* If we have already instantiated virtual registers, return the actual
481 address relative to the frame pointer. */
482 if (function
== cfun
&& virtuals_instantiated
)
483 addr
= plus_constant (frame_pointer_rtx
,
485 (frame_offset
+ bigend_correction
486 + STARTING_FRAME_OFFSET
, Pmode
));
488 addr
= plus_constant (virtual_stack_vars_rtx
,
490 (function
->x_frame_offset
+ bigend_correction
,
493 if (!FRAME_GROWS_DOWNWARD
)
494 function
->x_frame_offset
+= size
;
496 x
= gen_rtx_MEM (mode
, addr
);
497 MEM_NOTRAP_P (x
) = 1;
499 function
->x_stack_slot_list
500 = gen_rtx_EXPR_LIST (VOIDmode
, x
, function
->x_stack_slot_list
);
502 if (frame_offset_overflow (function
->x_frame_offset
, function
->decl
))
503 function
->x_frame_offset
= 0;
508 /* Wrapper around assign_stack_local_1; assign a local stack slot for the
512 assign_stack_local (enum machine_mode mode
, HOST_WIDE_INT size
, int align
)
514 return assign_stack_local_1 (mode
, size
, align
, cfun
);
518 /* Removes temporary slot TEMP from LIST. */
521 cut_slot_from_list (struct temp_slot
*temp
, struct temp_slot
**list
)
524 temp
->next
->prev
= temp
->prev
;
526 temp
->prev
->next
= temp
->next
;
530 temp
->prev
= temp
->next
= NULL
;
533 /* Inserts temporary slot TEMP to LIST. */
536 insert_slot_to_list (struct temp_slot
*temp
, struct temp_slot
**list
)
540 (*list
)->prev
= temp
;
545 /* Returns the list of used temp slots at LEVEL. */
547 static struct temp_slot
**
548 temp_slots_at_level (int level
)
550 if (level
>= (int) VEC_length (temp_slot_p
, used_temp_slots
))
551 VEC_safe_grow_cleared (temp_slot_p
, gc
, used_temp_slots
, level
+ 1);
553 return &(VEC_address (temp_slot_p
, used_temp_slots
)[level
]);
556 /* Returns the maximal temporary slot level. */
559 max_slot_level (void)
561 if (!used_temp_slots
)
564 return VEC_length (temp_slot_p
, used_temp_slots
) - 1;
567 /* Moves temporary slot TEMP to LEVEL. */
570 move_slot_to_level (struct temp_slot
*temp
, int level
)
572 cut_slot_from_list (temp
, temp_slots_at_level (temp
->level
));
573 insert_slot_to_list (temp
, temp_slots_at_level (level
));
577 /* Make temporary slot TEMP available. */
580 make_slot_available (struct temp_slot
*temp
)
582 cut_slot_from_list (temp
, temp_slots_at_level (temp
->level
));
583 insert_slot_to_list (temp
, &avail_temp_slots
);
588 /* Allocate a temporary stack slot and record it for possible later
591 MODE is the machine mode to be given to the returned rtx.
593 SIZE is the size in units of the space required. We do no rounding here
594 since assign_stack_local will do any required rounding.
596 KEEP is 1 if this slot is to be retained after a call to
597 free_temp_slots. Automatic variables for a block are allocated
598 with this flag. KEEP values of 2 or 3 were needed respectively
599 for variables whose lifetime is controlled by CLEANUP_POINT_EXPRs
600 or for SAVE_EXPRs, but they are now unused.
602 TYPE is the type that will be used for the stack slot. */
605 assign_stack_temp_for_type (enum machine_mode mode
, HOST_WIDE_INT size
,
609 struct temp_slot
*p
, *best_p
= 0, *selected
= NULL
, **pp
;
612 /* If SIZE is -1 it means that somebody tried to allocate a temporary
613 of a variable size. */
614 gcc_assert (size
!= -1);
616 /* These are now unused. */
617 gcc_assert (keep
<= 1);
620 align
= BIGGEST_ALIGNMENT
;
622 align
= GET_MODE_ALIGNMENT (mode
);
625 type
= lang_hooks
.types
.type_for_mode (mode
, 0);
628 align
= LOCAL_ALIGNMENT (type
, align
);
630 /* Try to find an available, already-allocated temporary of the proper
631 mode which meets the size and alignment requirements. Choose the
632 smallest one with the closest alignment.
634 If assign_stack_temp is called outside of the tree->rtl expansion,
635 we cannot reuse the stack slots (that may still refer to
636 VIRTUAL_STACK_VARS_REGNUM). */
637 if (!virtuals_instantiated
)
639 for (p
= avail_temp_slots
; p
; p
= p
->next
)
641 if (p
->align
>= align
&& p
->size
>= size
642 && GET_MODE (p
->slot
) == mode
643 && objects_must_conflict_p (p
->type
, type
)
644 && (best_p
== 0 || best_p
->size
> p
->size
645 || (best_p
->size
== p
->size
&& best_p
->align
> p
->align
)))
647 if (p
->align
== align
&& p
->size
== size
)
650 cut_slot_from_list (selected
, &avail_temp_slots
);
659 /* Make our best, if any, the one to use. */
663 cut_slot_from_list (selected
, &avail_temp_slots
);
665 /* If there are enough aligned bytes left over, make them into a new
666 temp_slot so that the extra bytes don't get wasted. Do this only
667 for BLKmode slots, so that we can be sure of the alignment. */
668 if (GET_MODE (best_p
->slot
) == BLKmode
)
670 int alignment
= best_p
->align
/ BITS_PER_UNIT
;
671 HOST_WIDE_INT rounded_size
= CEIL_ROUND (size
, alignment
);
673 if (best_p
->size
- rounded_size
>= alignment
)
675 p
= ggc_alloc (sizeof (struct temp_slot
));
676 p
->in_use
= p
->addr_taken
= 0;
677 p
->size
= best_p
->size
- rounded_size
;
678 p
->base_offset
= best_p
->base_offset
+ rounded_size
;
679 p
->full_size
= best_p
->full_size
- rounded_size
;
680 p
->slot
= adjust_address_nv (best_p
->slot
, BLKmode
, rounded_size
);
681 p
->align
= best_p
->align
;
683 p
->type
= best_p
->type
;
684 insert_slot_to_list (p
, &avail_temp_slots
);
686 stack_slot_list
= gen_rtx_EXPR_LIST (VOIDmode
, p
->slot
,
689 best_p
->size
= rounded_size
;
690 best_p
->full_size
= rounded_size
;
695 /* If we still didn't find one, make a new temporary. */
698 HOST_WIDE_INT frame_offset_old
= frame_offset
;
700 p
= ggc_alloc (sizeof (struct temp_slot
));
702 /* We are passing an explicit alignment request to assign_stack_local.
703 One side effect of that is assign_stack_local will not round SIZE
704 to ensure the frame offset remains suitably aligned.
706 So for requests which depended on the rounding of SIZE, we go ahead
707 and round it now. We also make sure ALIGNMENT is at least
708 BIGGEST_ALIGNMENT. */
709 gcc_assert (mode
!= BLKmode
|| align
== BIGGEST_ALIGNMENT
);
710 p
->slot
= assign_stack_local (mode
,
712 ? CEIL_ROUND (size
, (int) align
/ BITS_PER_UNIT
)
718 /* The following slot size computation is necessary because we don't
719 know the actual size of the temporary slot until assign_stack_local
720 has performed all the frame alignment and size rounding for the
721 requested temporary. Note that extra space added for alignment
722 can be either above or below this stack slot depending on which
723 way the frame grows. We include the extra space if and only if it
724 is above this slot. */
725 if (FRAME_GROWS_DOWNWARD
)
726 p
->size
= frame_offset_old
- frame_offset
;
730 /* Now define the fields used by combine_temp_slots. */
731 if (FRAME_GROWS_DOWNWARD
)
733 p
->base_offset
= frame_offset
;
734 p
->full_size
= frame_offset_old
- frame_offset
;
738 p
->base_offset
= frame_offset_old
;
739 p
->full_size
= frame_offset
- frame_offset_old
;
750 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 MEM_VOLATILE_P (slot
) = TYPE_VOLATILE (type
);
770 MEM_SET_IN_STRUCT_P (slot
, (AGGREGATE_TYPE_P (type
)
771 || TREE_CODE (type
) == COMPLEX_TYPE
));
773 MEM_NOTRAP_P (slot
) = 1;
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
);
822 /* Zero sized arrays are GNU C extension. Set size to 1 to avoid
823 problems with allocating the stack space. */
827 /* Unfortunately, we don't yet know how to allocate variable-sized
828 temporaries. However, sometimes we can find a fixed upper limit on
829 the size, so try that instead. */
831 size
= max_int_size_in_bytes (type
);
833 /* The size of the temporary may be too large to fit into an integer. */
834 /* ??? Not sure this should happen except for user silliness, so limit
835 this to things that aren't compiler-generated temporaries. The
836 rest of the time we'll die in assign_stack_temp_for_type. */
837 if (decl
&& size
== -1
838 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
)
840 error ("size of variable %q+D is too large", decl
);
844 tmp
= assign_stack_temp_for_type (mode
, size
, keep
, type
);
850 mode
= promote_mode (type
, mode
, &unsignedp
, 0);
853 return gen_reg_rtx (mode
);
856 /* Combine temporary stack slots which are adjacent on the stack.
858 This allows for better use of already allocated stack space. This is only
859 done for BLKmode slots because we can be sure that we won't have alignment
860 problems in this case. */
863 combine_temp_slots (void)
865 struct temp_slot
*p
, *q
, *next
, *next_q
;
868 /* We can't combine slots, because the information about which slot
869 is in which alias set will be lost. */
870 if (flag_strict_aliasing
)
873 /* If there are a lot of temp slots, don't do anything unless
874 high levels of optimization. */
875 if (! flag_expensive_optimizations
)
876 for (p
= avail_temp_slots
, num_slots
= 0; p
; p
= p
->next
, num_slots
++)
877 if (num_slots
> 100 || (num_slots
> 10 && optimize
== 0))
880 for (p
= avail_temp_slots
; p
; p
= next
)
886 if (GET_MODE (p
->slot
) != BLKmode
)
889 for (q
= p
->next
; q
; q
= next_q
)
895 if (GET_MODE (q
->slot
) != BLKmode
)
898 if (p
->base_offset
+ p
->full_size
== q
->base_offset
)
900 /* Q comes after P; combine Q into P. */
902 p
->full_size
+= q
->full_size
;
905 else if (q
->base_offset
+ q
->full_size
== p
->base_offset
)
907 /* P comes after Q; combine P into Q. */
909 q
->full_size
+= p
->full_size
;
914 cut_slot_from_list (q
, &avail_temp_slots
);
917 /* Either delete P or advance past it. */
919 cut_slot_from_list (p
, &avail_temp_slots
);
923 /* Find the temp slot corresponding to the object at address X. */
925 static struct temp_slot
*
926 find_temp_slot_from_address (rtx x
)
932 for (i
= max_slot_level (); i
>= 0; i
--)
933 for (p
= *temp_slots_at_level (i
); p
; p
= p
->next
)
935 if (XEXP (p
->slot
, 0) == x
937 || (GET_CODE (x
) == PLUS
938 && XEXP (x
, 0) == virtual_stack_vars_rtx
939 && GET_CODE (XEXP (x
, 1)) == CONST_INT
940 && INTVAL (XEXP (x
, 1)) >= p
->base_offset
941 && INTVAL (XEXP (x
, 1)) < p
->base_offset
+ p
->full_size
))
944 else if (p
->address
!= 0 && GET_CODE (p
->address
) == EXPR_LIST
)
945 for (next
= p
->address
; next
; next
= XEXP (next
, 1))
946 if (XEXP (next
, 0) == x
)
950 /* If we have a sum involving a register, see if it points to a temp
952 if (GET_CODE (x
) == PLUS
&& REG_P (XEXP (x
, 0))
953 && (p
= find_temp_slot_from_address (XEXP (x
, 0))) != 0)
955 else if (GET_CODE (x
) == PLUS
&& REG_P (XEXP (x
, 1))
956 && (p
= find_temp_slot_from_address (XEXP (x
, 1))) != 0)
962 /* Indicate that NEW is an alternate way of referring to the temp slot
963 that previously was known by OLD. */
966 update_temp_slot_address (rtx old
, rtx
new)
970 if (rtx_equal_p (old
, new))
973 p
= find_temp_slot_from_address (old
);
975 /* If we didn't find one, see if both OLD is a PLUS. If so, and NEW
976 is a register, see if one operand of the PLUS is a temporary
977 location. If so, NEW points into it. Otherwise, if both OLD and
978 NEW are a PLUS and if there is a register in common between them.
979 If so, try a recursive call on those values. */
982 if (GET_CODE (old
) != PLUS
)
987 update_temp_slot_address (XEXP (old
, 0), new);
988 update_temp_slot_address (XEXP (old
, 1), new);
991 else if (GET_CODE (new) != PLUS
)
994 if (rtx_equal_p (XEXP (old
, 0), XEXP (new, 0)))
995 update_temp_slot_address (XEXP (old
, 1), XEXP (new, 1));
996 else if (rtx_equal_p (XEXP (old
, 1), XEXP (new, 0)))
997 update_temp_slot_address (XEXP (old
, 0), XEXP (new, 1));
998 else if (rtx_equal_p (XEXP (old
, 0), XEXP (new, 1)))
999 update_temp_slot_address (XEXP (old
, 1), XEXP (new, 0));
1000 else if (rtx_equal_p (XEXP (old
, 1), XEXP (new, 1)))
1001 update_temp_slot_address (XEXP (old
, 0), XEXP (new, 0));
1006 /* Otherwise add an alias for the temp's address. */
1007 else if (p
->address
== 0)
1011 if (GET_CODE (p
->address
) != EXPR_LIST
)
1012 p
->address
= gen_rtx_EXPR_LIST (VOIDmode
, p
->address
, NULL_RTX
);
1014 p
->address
= gen_rtx_EXPR_LIST (VOIDmode
, new, p
->address
);
1018 /* If X could be a reference to a temporary slot, mark the fact that its
1019 address was taken. */
1022 mark_temp_addr_taken (rtx x
)
1024 struct temp_slot
*p
;
1029 /* If X is not in memory or is at a constant address, it cannot be in
1030 a temporary slot. */
1031 if (!MEM_P (x
) || CONSTANT_P (XEXP (x
, 0)))
1034 p
= find_temp_slot_from_address (XEXP (x
, 0));
1039 /* If X could be a reference to a temporary slot, mark that slot as
1040 belonging to the to one level higher than the current level. If X
1041 matched one of our slots, just mark that one. Otherwise, we can't
1042 easily predict which it is, so upgrade all of them. Kept slots
1043 need not be touched.
1045 This is called when an ({...}) construct occurs and a statement
1046 returns a value in memory. */
1049 preserve_temp_slots (rtx x
)
1051 struct temp_slot
*p
= 0, *next
;
1053 /* If there is no result, we still might have some objects whose address
1054 were taken, so we need to make sure they stay around. */
1057 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1062 move_slot_to_level (p
, temp_slot_level
- 1);
1068 /* If X is a register that is being used as a pointer, see if we have
1069 a temporary slot we know it points to. To be consistent with
1070 the code below, we really should preserve all non-kept slots
1071 if we can't find a match, but that seems to be much too costly. */
1072 if (REG_P (x
) && REG_POINTER (x
))
1073 p
= find_temp_slot_from_address (x
);
1075 /* If X is not in memory or is at a constant address, it cannot be in
1076 a temporary slot, but it can contain something whose address was
1078 if (p
== 0 && (!MEM_P (x
) || CONSTANT_P (XEXP (x
, 0))))
1080 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1085 move_slot_to_level (p
, temp_slot_level
- 1);
1091 /* First see if we can find a match. */
1093 p
= find_temp_slot_from_address (XEXP (x
, 0));
1097 /* Move everything at our level whose address was taken to our new
1098 level in case we used its address. */
1099 struct temp_slot
*q
;
1101 if (p
->level
== temp_slot_level
)
1103 for (q
= *temp_slots_at_level (temp_slot_level
); q
; q
= next
)
1107 if (p
!= q
&& q
->addr_taken
)
1108 move_slot_to_level (q
, temp_slot_level
- 1);
1111 move_slot_to_level (p
, temp_slot_level
- 1);
1117 /* Otherwise, preserve all non-kept slots at this level. */
1118 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1123 move_slot_to_level (p
, temp_slot_level
- 1);
1127 /* Free all temporaries used so far. This is normally called at the
1128 end of generating code for a statement. */
1131 free_temp_slots (void)
1133 struct temp_slot
*p
, *next
;
1135 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1140 make_slot_available (p
);
1143 combine_temp_slots ();
1146 /* Push deeper into the nesting level for stack temporaries. */
1149 push_temp_slots (void)
1154 /* Pop a temporary nesting level. All slots in use in the current level
1158 pop_temp_slots (void)
1160 struct temp_slot
*p
, *next
;
1162 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1165 make_slot_available (p
);
1168 combine_temp_slots ();
1173 /* Initialize temporary slots. */
1176 init_temp_slots (void)
1178 /* We have not allocated any temporaries yet. */
1179 avail_temp_slots
= 0;
1180 used_temp_slots
= 0;
1181 temp_slot_level
= 0;
1184 /* These routines are responsible for converting virtual register references
1185 to the actual hard register references once RTL generation is complete.
1187 The following four variables are used for communication between the
1188 routines. They contain the offsets of the virtual registers from their
1189 respective hard registers. */
1191 static int in_arg_offset
;
1192 static int var_offset
;
1193 static int dynamic_offset
;
1194 static int out_arg_offset
;
1195 static int cfa_offset
;
1197 /* In most machines, the stack pointer register is equivalent to the bottom
1200 #ifndef STACK_POINTER_OFFSET
1201 #define STACK_POINTER_OFFSET 0
1204 /* If not defined, pick an appropriate default for the offset of dynamically
1205 allocated memory depending on the value of ACCUMULATE_OUTGOING_ARGS,
1206 REG_PARM_STACK_SPACE, and OUTGOING_REG_PARM_STACK_SPACE. */
1208 #ifndef STACK_DYNAMIC_OFFSET
1210 /* The bottom of the stack points to the actual arguments. If
1211 REG_PARM_STACK_SPACE is defined, this includes the space for the register
1212 parameters. However, if OUTGOING_REG_PARM_STACK space is not defined,
1213 stack space for register parameters is not pushed by the caller, but
1214 rather part of the fixed stack areas and hence not included in
1215 `current_function_outgoing_args_size'. Nevertheless, we must allow
1216 for it when allocating stack dynamic objects. */
1218 #if defined(REG_PARM_STACK_SPACE)
1219 #define STACK_DYNAMIC_OFFSET(FNDECL) \
1220 ((ACCUMULATE_OUTGOING_ARGS \
1221 ? (current_function_outgoing_args_size \
1222 + (OUTGOING_REG_PARM_STACK_SPACE ? 0 : REG_PARM_STACK_SPACE (FNDECL))) \
1223 : 0) + (STACK_POINTER_OFFSET))
1225 #define STACK_DYNAMIC_OFFSET(FNDECL) \
1226 ((ACCUMULATE_OUTGOING_ARGS ? current_function_outgoing_args_size : 0) \
1227 + (STACK_POINTER_OFFSET))
1232 /* Given a piece of RTX and a pointer to a HOST_WIDE_INT, if the RTX
1233 is a virtual register, return the equivalent hard register and set the
1234 offset indirectly through the pointer. Otherwise, return 0. */
1237 instantiate_new_reg (rtx x
, HOST_WIDE_INT
*poffset
)
1240 HOST_WIDE_INT offset
;
1242 if (x
== virtual_incoming_args_rtx
)
1243 new = arg_pointer_rtx
, offset
= in_arg_offset
;
1244 else if (x
== virtual_stack_vars_rtx
)
1245 new = frame_pointer_rtx
, offset
= var_offset
;
1246 else if (x
== virtual_stack_dynamic_rtx
)
1247 new = stack_pointer_rtx
, offset
= dynamic_offset
;
1248 else if (x
== virtual_outgoing_args_rtx
)
1249 new = stack_pointer_rtx
, offset
= out_arg_offset
;
1250 else if (x
== virtual_cfa_rtx
)
1252 #ifdef FRAME_POINTER_CFA_OFFSET
1253 new = frame_pointer_rtx
;
1255 new = arg_pointer_rtx
;
1257 offset
= cfa_offset
;
1266 /* A subroutine of instantiate_virtual_regs, called via for_each_rtx.
1267 Instantiate any virtual registers present inside of *LOC. The expression
1268 is simplified, as much as possible, but is not to be considered "valid"
1269 in any sense implied by the target. If any change is made, set CHANGED
1273 instantiate_virtual_regs_in_rtx (rtx
*loc
, void *data
)
1275 HOST_WIDE_INT offset
;
1276 bool *changed
= (bool *) data
;
1283 switch (GET_CODE (x
))
1286 new = instantiate_new_reg (x
, &offset
);
1289 *loc
= plus_constant (new, offset
);
1296 new = instantiate_new_reg (XEXP (x
, 0), &offset
);
1299 new = plus_constant (new, offset
);
1300 *loc
= simplify_gen_binary (PLUS
, GET_MODE (x
), new, XEXP (x
, 1));
1306 /* FIXME -- from old code */
1307 /* If we have (plus (subreg (virtual-reg)) (const_int)), we know
1308 we can commute the PLUS and SUBREG because pointers into the
1309 frame are well-behaved. */
1319 /* A subroutine of instantiate_virtual_regs_in_insn. Return true if X
1320 matches the predicate for insn CODE operand OPERAND. */
1323 safe_insn_predicate (int code
, int operand
, rtx x
)
1325 const struct insn_operand_data
*op_data
;
1330 op_data
= &insn_data
[code
].operand
[operand
];
1331 if (op_data
->predicate
== NULL
)
1334 return op_data
->predicate (x
, op_data
->mode
);
1337 /* A subroutine of instantiate_virtual_regs. Instantiate any virtual
1338 registers present inside of insn. The result will be a valid insn. */
1341 instantiate_virtual_regs_in_insn (rtx insn
)
1343 HOST_WIDE_INT offset
;
1345 bool any_change
= false;
1346 rtx set
, new, x
, seq
;
1348 /* There are some special cases to be handled first. */
1349 set
= single_set (insn
);
1352 /* We're allowed to assign to a virtual register. This is interpreted
1353 to mean that the underlying register gets assigned the inverse
1354 transformation. This is used, for example, in the handling of
1356 new = instantiate_new_reg (SET_DEST (set
), &offset
);
1361 for_each_rtx (&SET_SRC (set
), instantiate_virtual_regs_in_rtx
, NULL
);
1362 x
= simplify_gen_binary (PLUS
, GET_MODE (new), SET_SRC (set
),
1364 x
= force_operand (x
, new);
1366 emit_move_insn (new, x
);
1371 emit_insn_before (seq
, insn
);
1376 /* Handle a straight copy from a virtual register by generating a
1377 new add insn. The difference between this and falling through
1378 to the generic case is avoiding a new pseudo and eliminating a
1379 move insn in the initial rtl stream. */
1380 new = instantiate_new_reg (SET_SRC (set
), &offset
);
1381 if (new && offset
!= 0
1382 && REG_P (SET_DEST (set
))
1383 && REGNO (SET_DEST (set
)) > LAST_VIRTUAL_REGISTER
)
1387 x
= expand_simple_binop (GET_MODE (SET_DEST (set
)), PLUS
,
1388 new, GEN_INT (offset
), SET_DEST (set
),
1389 1, OPTAB_LIB_WIDEN
);
1390 if (x
!= SET_DEST (set
))
1391 emit_move_insn (SET_DEST (set
), x
);
1396 emit_insn_before (seq
, insn
);
1401 extract_insn (insn
);
1402 insn_code
= INSN_CODE (insn
);
1404 /* Handle a plus involving a virtual register by determining if the
1405 operands remain valid if they're modified in place. */
1406 if (GET_CODE (SET_SRC (set
)) == PLUS
1407 && recog_data
.n_operands
>= 3
1408 && recog_data
.operand_loc
[1] == &XEXP (SET_SRC (set
), 0)
1409 && recog_data
.operand_loc
[2] == &XEXP (SET_SRC (set
), 1)
1410 && GET_CODE (recog_data
.operand
[2]) == CONST_INT
1411 && (new = instantiate_new_reg (recog_data
.operand
[1], &offset
)))
1413 offset
+= INTVAL (recog_data
.operand
[2]);
1415 /* If the sum is zero, then replace with a plain move. */
1417 && REG_P (SET_DEST (set
))
1418 && REGNO (SET_DEST (set
)) > LAST_VIRTUAL_REGISTER
)
1421 emit_move_insn (SET_DEST (set
), new);
1425 emit_insn_before (seq
, insn
);
1430 x
= gen_int_mode (offset
, recog_data
.operand_mode
[2]);
1432 /* Using validate_change and apply_change_group here leaves
1433 recog_data in an invalid state. Since we know exactly what
1434 we want to check, do those two by hand. */
1435 if (safe_insn_predicate (insn_code
, 1, new)
1436 && safe_insn_predicate (insn_code
, 2, x
))
1438 *recog_data
.operand_loc
[1] = recog_data
.operand
[1] = new;
1439 *recog_data
.operand_loc
[2] = recog_data
.operand
[2] = x
;
1442 /* Fall through into the regular operand fixup loop in
1443 order to take care of operands other than 1 and 2. */
1449 extract_insn (insn
);
1450 insn_code
= INSN_CODE (insn
);
1453 /* In the general case, we expect virtual registers to appear only in
1454 operands, and then only as either bare registers or inside memories. */
1455 for (i
= 0; i
< recog_data
.n_operands
; ++i
)
1457 x
= recog_data
.operand
[i
];
1458 switch (GET_CODE (x
))
1462 rtx addr
= XEXP (x
, 0);
1463 bool changed
= false;
1465 for_each_rtx (&addr
, instantiate_virtual_regs_in_rtx
, &changed
);
1470 x
= replace_equiv_address (x
, addr
);
1474 emit_insn_before (seq
, insn
);
1479 new = instantiate_new_reg (x
, &offset
);
1488 /* Careful, special mode predicates may have stuff in
1489 insn_data[insn_code].operand[i].mode that isn't useful
1490 to us for computing a new value. */
1491 /* ??? Recognize address_operand and/or "p" constraints
1492 to see if (plus new offset) is a valid before we put
1493 this through expand_simple_binop. */
1494 x
= expand_simple_binop (GET_MODE (x
), PLUS
, new,
1495 GEN_INT (offset
), NULL_RTX
,
1496 1, OPTAB_LIB_WIDEN
);
1499 emit_insn_before (seq
, insn
);
1504 new = instantiate_new_reg (SUBREG_REG (x
), &offset
);
1510 new = expand_simple_binop (GET_MODE (new), PLUS
, new,
1511 GEN_INT (offset
), NULL_RTX
,
1512 1, OPTAB_LIB_WIDEN
);
1515 emit_insn_before (seq
, insn
);
1517 x
= simplify_gen_subreg (recog_data
.operand_mode
[i
], new,
1518 GET_MODE (new), SUBREG_BYTE (x
));
1525 /* At this point, X contains the new value for the operand.
1526 Validate the new value vs the insn predicate. Note that
1527 asm insns will have insn_code -1 here. */
1528 if (!safe_insn_predicate (insn_code
, i
, x
))
1531 x
= force_reg (insn_data
[insn_code
].operand
[i
].mode
, x
);
1535 emit_insn_before (seq
, insn
);
1538 *recog_data
.operand_loc
[i
] = recog_data
.operand
[i
] = x
;
1544 /* Propagate operand changes into the duplicates. */
1545 for (i
= 0; i
< recog_data
.n_dups
; ++i
)
1546 *recog_data
.dup_loc
[i
]
1547 = copy_rtx (recog_data
.operand
[(unsigned)recog_data
.dup_num
[i
]]);
1549 /* Force re-recognition of the instruction for validation. */
1550 INSN_CODE (insn
) = -1;
1553 if (asm_noperands (PATTERN (insn
)) >= 0)
1555 if (!check_asm_operands (PATTERN (insn
)))
1557 error_for_asm (insn
, "impossible constraint in %<asm%>");
1563 if (recog_memoized (insn
) < 0)
1564 fatal_insn_not_found (insn
);
1568 /* Subroutine of instantiate_decls. Given RTL representing a decl,
1569 do any instantiation required. */
1572 instantiate_decl (rtx x
)
1579 /* If this is a CONCAT, recurse for the pieces. */
1580 if (GET_CODE (x
) == CONCAT
)
1582 instantiate_decl (XEXP (x
, 0));
1583 instantiate_decl (XEXP (x
, 1));
1587 /* If this is not a MEM, no need to do anything. Similarly if the
1588 address is a constant or a register that is not a virtual register. */
1593 if (CONSTANT_P (addr
)
1595 && (REGNO (addr
) < FIRST_VIRTUAL_REGISTER
1596 || REGNO (addr
) > LAST_VIRTUAL_REGISTER
)))
1599 for_each_rtx (&XEXP (x
, 0), instantiate_virtual_regs_in_rtx
, NULL
);
1602 /* Helper for instantiate_decls called via walk_tree: Process all decls
1603 in the given DECL_VALUE_EXPR. */
1606 instantiate_expr (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
1609 if (! EXPR_P (t
) && ! GIMPLE_STMT_P (t
))
1612 if (DECL_P (t
) && DECL_RTL_SET_P (t
))
1613 instantiate_decl (DECL_RTL (t
));
1618 /* Subroutine of instantiate_decls: Process all decls in the given
1619 BLOCK node and all its subblocks. */
1622 instantiate_decls_1 (tree let
)
1626 for (t
= BLOCK_VARS (let
); t
; t
= TREE_CHAIN (t
))
1628 if (DECL_RTL_SET_P (t
))
1629 instantiate_decl (DECL_RTL (t
));
1630 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (t
))
1632 tree v
= DECL_VALUE_EXPR (t
);
1633 walk_tree (&v
, instantiate_expr
, NULL
, NULL
);
1637 /* Process all subblocks. */
1638 for (t
= BLOCK_SUBBLOCKS (let
); t
; t
= TREE_CHAIN (t
))
1639 instantiate_decls_1 (t
);
1642 /* Scan all decls in FNDECL (both variables and parameters) and instantiate
1643 all virtual registers in their DECL_RTL's. */
1646 instantiate_decls (tree fndecl
)
1650 /* Process all parameters of the function. */
1651 for (decl
= DECL_ARGUMENTS (fndecl
); decl
; decl
= TREE_CHAIN (decl
))
1653 instantiate_decl (DECL_RTL (decl
));
1654 instantiate_decl (DECL_INCOMING_RTL (decl
));
1655 if (DECL_HAS_VALUE_EXPR_P (decl
))
1657 tree v
= DECL_VALUE_EXPR (decl
);
1658 walk_tree (&v
, instantiate_expr
, NULL
, NULL
);
1662 /* Now process all variables defined in the function or its subblocks. */
1663 instantiate_decls_1 (DECL_INITIAL (fndecl
));
1666 /* Pass through the INSNS of function FNDECL and convert virtual register
1667 references to hard register references. */
1670 instantiate_virtual_regs (void)
1674 /* Compute the offsets to use for this function. */
1675 in_arg_offset
= FIRST_PARM_OFFSET (current_function_decl
);
1676 var_offset
= STARTING_FRAME_OFFSET
;
1677 dynamic_offset
= STACK_DYNAMIC_OFFSET (current_function_decl
);
1678 out_arg_offset
= STACK_POINTER_OFFSET
;
1679 #ifdef FRAME_POINTER_CFA_OFFSET
1680 cfa_offset
= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
1682 cfa_offset
= ARG_POINTER_CFA_OFFSET (current_function_decl
);
1685 /* Initialize recognition, indicating that volatile is OK. */
1688 /* Scan through all the insns, instantiating every virtual register still
1690 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1693 /* These patterns in the instruction stream can never be recognized.
1694 Fortunately, they shouldn't contain virtual registers either. */
1695 if (GET_CODE (PATTERN (insn
)) == USE
1696 || GET_CODE (PATTERN (insn
)) == CLOBBER
1697 || GET_CODE (PATTERN (insn
)) == ADDR_VEC
1698 || GET_CODE (PATTERN (insn
)) == ADDR_DIFF_VEC
1699 || GET_CODE (PATTERN (insn
)) == ASM_INPUT
)
1702 instantiate_virtual_regs_in_insn (insn
);
1704 if (INSN_DELETED_P (insn
))
1707 for_each_rtx (®_NOTES (insn
), instantiate_virtual_regs_in_rtx
, NULL
);
1709 /* Instantiate any virtual registers in CALL_INSN_FUNCTION_USAGE. */
1710 if (GET_CODE (insn
) == CALL_INSN
)
1711 for_each_rtx (&CALL_INSN_FUNCTION_USAGE (insn
),
1712 instantiate_virtual_regs_in_rtx
, NULL
);
1715 /* Instantiate the virtual registers in the DECLs for debugging purposes. */
1716 instantiate_decls (current_function_decl
);
1718 /* Indicate that, from now on, assign_stack_local should use
1719 frame_pointer_rtx. */
1720 virtuals_instantiated
= 1;
1724 struct tree_opt_pass pass_instantiate_virtual_regs
=
1728 instantiate_virtual_regs
, /* execute */
1731 0, /* static_pass_number */
1733 0, /* properties_required */
1734 0, /* properties_provided */
1735 0, /* properties_destroyed */
1736 0, /* todo_flags_start */
1737 TODO_dump_func
, /* todo_flags_finish */
1742 /* Return 1 if EXP is an aggregate type (or a value with aggregate type).
1743 This means a type for which function calls must pass an address to the
1744 function or get an address back from the function.
1745 EXP may be a type node or an expression (whose type is tested). */
1748 aggregate_value_p (const_tree exp
, const_tree fntype
)
1750 int i
, regno
, nregs
;
1753 const_tree type
= (TYPE_P (exp
)) ? exp
: TREE_TYPE (exp
);
1755 /* DECL node associated with FNTYPE when relevant, which we might need to
1756 check for by-invisible-reference returns, typically for CALL_EXPR input
1758 const_tree fndecl
= NULL_TREE
;
1761 switch (TREE_CODE (fntype
))
1764 fndecl
= get_callee_fndecl (fntype
);
1765 fntype
= fndecl
? TREE_TYPE (fndecl
) : 0;
1769 fntype
= TREE_TYPE (fndecl
);
1774 case IDENTIFIER_NODE
:
1778 /* We don't expect other rtl types here. */
1782 if (TREE_CODE (type
) == VOID_TYPE
)
1785 /* If the front end has decided that this needs to be passed by
1786 reference, do so. */
1787 if ((TREE_CODE (exp
) == PARM_DECL
|| TREE_CODE (exp
) == RESULT_DECL
)
1788 && DECL_BY_REFERENCE (exp
))
1791 /* If the EXPression is a CALL_EXPR, honor DECL_BY_REFERENCE set on the
1792 called function RESULT_DECL, meaning the function returns in memory by
1793 invisible reference. This check lets front-ends not set TREE_ADDRESSABLE
1794 on the function type, which used to be the way to request such a return
1795 mechanism but might now be causing troubles at gimplification time if
1796 temporaries with the function type need to be created. */
1797 if (TREE_CODE (exp
) == CALL_EXPR
&& fndecl
&& DECL_RESULT (fndecl
)
1798 && DECL_BY_REFERENCE (DECL_RESULT (fndecl
)))
1801 if (targetm
.calls
.return_in_memory (type
, fntype
))
1803 /* Types that are TREE_ADDRESSABLE must be constructed in memory,
1804 and thus can't be returned in registers. */
1805 if (TREE_ADDRESSABLE (type
))
1807 if (flag_pcc_struct_return
&& AGGREGATE_TYPE_P (type
))
1809 /* Make sure we have suitable call-clobbered regs to return
1810 the value in; if not, we must return it in memory. */
1811 reg
= hard_function_value (type
, 0, fntype
, 0);
1813 /* If we have something other than a REG (e.g. a PARALLEL), then assume
1818 regno
= REGNO (reg
);
1819 nregs
= hard_regno_nregs
[regno
][TYPE_MODE (type
)];
1820 for (i
= 0; i
< nregs
; i
++)
1821 if (! call_used_regs
[regno
+ i
])
1826 /* Return true if we should assign DECL a pseudo register; false if it
1827 should live on the local stack. */
1830 use_register_for_decl (const_tree decl
)
1832 /* Honor volatile. */
1833 if (TREE_SIDE_EFFECTS (decl
))
1836 /* Honor addressability. */
1837 if (TREE_ADDRESSABLE (decl
))
1840 /* Only register-like things go in registers. */
1841 if (DECL_MODE (decl
) == BLKmode
)
1844 /* If -ffloat-store specified, don't put explicit float variables
1846 /* ??? This should be checked after DECL_ARTIFICIAL, but tree-ssa
1847 propagates values across these stores, and it probably shouldn't. */
1848 if (flag_float_store
&& FLOAT_TYPE_P (TREE_TYPE (decl
)))
1851 /* If we're not interested in tracking debugging information for
1852 this decl, then we can certainly put it in a register. */
1853 if (DECL_IGNORED_P (decl
))
1856 return (optimize
|| DECL_REGISTER (decl
));
1859 /* Return true if TYPE should be passed by invisible reference. */
1862 pass_by_reference (CUMULATIVE_ARGS
*ca
, enum machine_mode mode
,
1863 tree type
, bool named_arg
)
1867 /* If this type contains non-trivial constructors, then it is
1868 forbidden for the middle-end to create any new copies. */
1869 if (TREE_ADDRESSABLE (type
))
1872 /* GCC post 3.4 passes *all* variable sized types by reference. */
1873 if (!TYPE_SIZE (type
) || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1877 return targetm
.calls
.pass_by_reference (ca
, mode
, type
, named_arg
);
1880 /* Return true if TYPE, which is passed by reference, should be callee
1881 copied instead of caller copied. */
1884 reference_callee_copied (CUMULATIVE_ARGS
*ca
, enum machine_mode mode
,
1885 tree type
, bool named_arg
)
1887 if (type
&& TREE_ADDRESSABLE (type
))
1889 return targetm
.calls
.callee_copies (ca
, mode
, type
, named_arg
);
1892 /* Structures to communicate between the subroutines of assign_parms.
1893 The first holds data persistent across all parameters, the second
1894 is cleared out for each parameter. */
1896 struct assign_parm_data_all
1898 CUMULATIVE_ARGS args_so_far
;
1899 struct args_size stack_args_size
;
1900 tree function_result_decl
;
1902 rtx first_conversion_insn
;
1903 rtx last_conversion_insn
;
1904 HOST_WIDE_INT pretend_args_size
;
1905 HOST_WIDE_INT extra_pretend_bytes
;
1906 int reg_parm_stack_space
;
1909 struct assign_parm_data_one
1915 enum machine_mode nominal_mode
;
1916 enum machine_mode passed_mode
;
1917 enum machine_mode promoted_mode
;
1918 struct locate_and_pad_arg_data locate
;
1920 BOOL_BITFIELD named_arg
: 1;
1921 BOOL_BITFIELD passed_pointer
: 1;
1922 BOOL_BITFIELD on_stack
: 1;
1923 BOOL_BITFIELD loaded_in_reg
: 1;
1926 /* A subroutine of assign_parms. Initialize ALL. */
1929 assign_parms_initialize_all (struct assign_parm_data_all
*all
)
1933 memset (all
, 0, sizeof (*all
));
1935 fntype
= TREE_TYPE (current_function_decl
);
1937 #ifdef INIT_CUMULATIVE_INCOMING_ARGS
1938 INIT_CUMULATIVE_INCOMING_ARGS (all
->args_so_far
, fntype
, NULL_RTX
);
1940 INIT_CUMULATIVE_ARGS (all
->args_so_far
, fntype
, NULL_RTX
,
1941 current_function_decl
, -1);
1944 #ifdef REG_PARM_STACK_SPACE
1945 all
->reg_parm_stack_space
= REG_PARM_STACK_SPACE (current_function_decl
);
1949 /* If ARGS contains entries with complex types, split the entry into two
1950 entries of the component type. Return a new list of substitutions are
1951 needed, else the old list. */
1954 split_complex_args (tree args
)
1958 /* Before allocating memory, check for the common case of no complex. */
1959 for (p
= args
; p
; p
= TREE_CHAIN (p
))
1961 tree type
= TREE_TYPE (p
);
1962 if (TREE_CODE (type
) == COMPLEX_TYPE
1963 && targetm
.calls
.split_complex_arg (type
))
1969 args
= copy_list (args
);
1971 for (p
= args
; p
; p
= TREE_CHAIN (p
))
1973 tree type
= TREE_TYPE (p
);
1974 if (TREE_CODE (type
) == COMPLEX_TYPE
1975 && targetm
.calls
.split_complex_arg (type
))
1978 tree subtype
= TREE_TYPE (type
);
1979 bool addressable
= TREE_ADDRESSABLE (p
);
1981 /* Rewrite the PARM_DECL's type with its component. */
1982 TREE_TYPE (p
) = subtype
;
1983 DECL_ARG_TYPE (p
) = TREE_TYPE (DECL_ARG_TYPE (p
));
1984 DECL_MODE (p
) = VOIDmode
;
1985 DECL_SIZE (p
) = NULL
;
1986 DECL_SIZE_UNIT (p
) = NULL
;
1987 /* If this arg must go in memory, put it in a pseudo here.
1988 We can't allow it to go in memory as per normal parms,
1989 because the usual place might not have the imag part
1990 adjacent to the real part. */
1991 DECL_ARTIFICIAL (p
) = addressable
;
1992 DECL_IGNORED_P (p
) = addressable
;
1993 TREE_ADDRESSABLE (p
) = 0;
1996 /* Build a second synthetic decl. */
1997 decl
= build_decl (PARM_DECL
, NULL_TREE
, subtype
);
1998 DECL_ARG_TYPE (decl
) = DECL_ARG_TYPE (p
);
1999 DECL_ARTIFICIAL (decl
) = addressable
;
2000 DECL_IGNORED_P (decl
) = addressable
;
2001 layout_decl (decl
, 0);
2003 /* Splice it in; skip the new decl. */
2004 TREE_CHAIN (decl
) = TREE_CHAIN (p
);
2005 TREE_CHAIN (p
) = decl
;
2013 /* A subroutine of assign_parms. Adjust the parameter list to incorporate
2014 the hidden struct return argument, and (abi willing) complex args.
2015 Return the new parameter list. */
2018 assign_parms_augmented_arg_list (struct assign_parm_data_all
*all
)
2020 tree fndecl
= current_function_decl
;
2021 tree fntype
= TREE_TYPE (fndecl
);
2022 tree fnargs
= DECL_ARGUMENTS (fndecl
);
2024 /* If struct value address is treated as the first argument, make it so. */
2025 if (aggregate_value_p (DECL_RESULT (fndecl
), fndecl
)
2026 && ! current_function_returns_pcc_struct
2027 && targetm
.calls
.struct_value_rtx (TREE_TYPE (fndecl
), 1) == 0)
2029 tree type
= build_pointer_type (TREE_TYPE (fntype
));
2032 decl
= build_decl (PARM_DECL
, NULL_TREE
, type
);
2033 DECL_ARG_TYPE (decl
) = type
;
2034 DECL_ARTIFICIAL (decl
) = 1;
2035 DECL_IGNORED_P (decl
) = 1;
2037 TREE_CHAIN (decl
) = fnargs
;
2039 all
->function_result_decl
= decl
;
2042 all
->orig_fnargs
= fnargs
;
2044 /* If the target wants to split complex arguments into scalars, do so. */
2045 if (targetm
.calls
.split_complex_arg
)
2046 fnargs
= split_complex_args (fnargs
);
2051 /* A subroutine of assign_parms. Examine PARM and pull out type and mode
2052 data for the parameter. Incorporate ABI specifics such as pass-by-
2053 reference and type promotion. */
2056 assign_parm_find_data_types (struct assign_parm_data_all
*all
, tree parm
,
2057 struct assign_parm_data_one
*data
)
2059 tree nominal_type
, passed_type
;
2060 enum machine_mode nominal_mode
, passed_mode
, promoted_mode
;
2062 memset (data
, 0, sizeof (*data
));
2064 /* NAMED_ARG is a mis-nomer. We really mean 'non-varadic'. */
2065 if (!current_function_stdarg
)
2066 data
->named_arg
= 1; /* No varadic parms. */
2067 else if (TREE_CHAIN (parm
))
2068 data
->named_arg
= 1; /* Not the last non-varadic parm. */
2069 else if (targetm
.calls
.strict_argument_naming (&all
->args_so_far
))
2070 data
->named_arg
= 1; /* Only varadic ones are unnamed. */
2072 data
->named_arg
= 0; /* Treat as varadic. */
2074 nominal_type
= TREE_TYPE (parm
);
2075 passed_type
= DECL_ARG_TYPE (parm
);
2077 /* Look out for errors propagating this far. Also, if the parameter's
2078 type is void then its value doesn't matter. */
2079 if (TREE_TYPE (parm
) == error_mark_node
2080 /* This can happen after weird syntax errors
2081 or if an enum type is defined among the parms. */
2082 || TREE_CODE (parm
) != PARM_DECL
2083 || passed_type
== NULL
2084 || VOID_TYPE_P (nominal_type
))
2086 nominal_type
= passed_type
= void_type_node
;
2087 nominal_mode
= passed_mode
= promoted_mode
= VOIDmode
;
2091 /* Find mode of arg as it is passed, and mode of arg as it should be
2092 during execution of this function. */
2093 passed_mode
= TYPE_MODE (passed_type
);
2094 nominal_mode
= TYPE_MODE (nominal_type
);
2096 /* If the parm is to be passed as a transparent union, use the type of
2097 the first field for the tests below. We have already verified that
2098 the modes are the same. */
2099 if (TREE_CODE (passed_type
) == UNION_TYPE
2100 && TYPE_TRANSPARENT_UNION (passed_type
))
2101 passed_type
= TREE_TYPE (TYPE_FIELDS (passed_type
));
2103 /* See if this arg was passed by invisible reference. */
2104 if (pass_by_reference (&all
->args_so_far
, passed_mode
,
2105 passed_type
, data
->named_arg
))
2107 passed_type
= nominal_type
= build_pointer_type (passed_type
);
2108 data
->passed_pointer
= true;
2109 passed_mode
= nominal_mode
= Pmode
;
2112 /* Find mode as it is passed by the ABI. */
2113 promoted_mode
= passed_mode
;
2114 if (targetm
.calls
.promote_function_args (TREE_TYPE (current_function_decl
)))
2116 int unsignedp
= TYPE_UNSIGNED (passed_type
);
2117 promoted_mode
= promote_mode (passed_type
, promoted_mode
,
2122 data
->nominal_type
= nominal_type
;
2123 data
->passed_type
= passed_type
;
2124 data
->nominal_mode
= nominal_mode
;
2125 data
->passed_mode
= passed_mode
;
2126 data
->promoted_mode
= promoted_mode
;
2129 /* A subroutine of assign_parms. Invoke setup_incoming_varargs. */
2132 assign_parms_setup_varargs (struct assign_parm_data_all
*all
,
2133 struct assign_parm_data_one
*data
, bool no_rtl
)
2135 int varargs_pretend_bytes
= 0;
2137 targetm
.calls
.setup_incoming_varargs (&all
->args_so_far
,
2138 data
->promoted_mode
,
2140 &varargs_pretend_bytes
, no_rtl
);
2142 /* If the back-end has requested extra stack space, record how much is
2143 needed. Do not change pretend_args_size otherwise since it may be
2144 nonzero from an earlier partial argument. */
2145 if (varargs_pretend_bytes
> 0)
2146 all
->pretend_args_size
= varargs_pretend_bytes
;
2149 /* A subroutine of assign_parms. Set DATA->ENTRY_PARM corresponding to
2150 the incoming location of the current parameter. */
2153 assign_parm_find_entry_rtl (struct assign_parm_data_all
*all
,
2154 struct assign_parm_data_one
*data
)
2156 HOST_WIDE_INT pretend_bytes
= 0;
2160 if (data
->promoted_mode
== VOIDmode
)
2162 data
->entry_parm
= data
->stack_parm
= const0_rtx
;
2166 #ifdef FUNCTION_INCOMING_ARG
2167 entry_parm
= FUNCTION_INCOMING_ARG (all
->args_so_far
, data
->promoted_mode
,
2168 data
->passed_type
, data
->named_arg
);
2170 entry_parm
= FUNCTION_ARG (all
->args_so_far
, data
->promoted_mode
,
2171 data
->passed_type
, data
->named_arg
);
2174 if (entry_parm
== 0)
2175 data
->promoted_mode
= data
->passed_mode
;
2177 /* Determine parm's home in the stack, in case it arrives in the stack
2178 or we should pretend it did. Compute the stack position and rtx where
2179 the argument arrives and its size.
2181 There is one complexity here: If this was a parameter that would
2182 have been passed in registers, but wasn't only because it is
2183 __builtin_va_alist, we want locate_and_pad_parm to treat it as if
2184 it came in a register so that REG_PARM_STACK_SPACE isn't skipped.
2185 In this case, we call FUNCTION_ARG with NAMED set to 1 instead of 0
2186 as it was the previous time. */
2187 in_regs
= entry_parm
!= 0;
2188 #ifdef STACK_PARMS_IN_REG_PARM_AREA
2191 if (!in_regs
&& !data
->named_arg
)
2193 if (targetm
.calls
.pretend_outgoing_varargs_named (&all
->args_so_far
))
2196 #ifdef FUNCTION_INCOMING_ARG
2197 tem
= FUNCTION_INCOMING_ARG (all
->args_so_far
, data
->promoted_mode
,
2198 data
->passed_type
, true);
2200 tem
= FUNCTION_ARG (all
->args_so_far
, data
->promoted_mode
,
2201 data
->passed_type
, true);
2203 in_regs
= tem
!= NULL
;
2207 /* If this parameter was passed both in registers and in the stack, use
2208 the copy on the stack. */
2209 if (targetm
.calls
.must_pass_in_stack (data
->promoted_mode
,
2217 partial
= targetm
.calls
.arg_partial_bytes (&all
->args_so_far
,
2218 data
->promoted_mode
,
2221 data
->partial
= partial
;
2223 /* The caller might already have allocated stack space for the
2224 register parameters. */
2225 if (partial
!= 0 && all
->reg_parm_stack_space
== 0)
2227 /* Part of this argument is passed in registers and part
2228 is passed on the stack. Ask the prologue code to extend
2229 the stack part so that we can recreate the full value.
2231 PRETEND_BYTES is the size of the registers we need to store.
2232 CURRENT_FUNCTION_PRETEND_ARGS_SIZE is the amount of extra
2233 stack space that the prologue should allocate.
2235 Internally, gcc assumes that the argument pointer is aligned
2236 to STACK_BOUNDARY bits. This is used both for alignment
2237 optimizations (see init_emit) and to locate arguments that are
2238 aligned to more than PARM_BOUNDARY bits. We must preserve this
2239 invariant by rounding CURRENT_FUNCTION_PRETEND_ARGS_SIZE up to
2240 a stack boundary. */
2242 /* We assume at most one partial arg, and it must be the first
2243 argument on the stack. */
2244 gcc_assert (!all
->extra_pretend_bytes
&& !all
->pretend_args_size
);
2246 pretend_bytes
= partial
;
2247 all
->pretend_args_size
= CEIL_ROUND (pretend_bytes
, STACK_BYTES
);
2249 /* We want to align relative to the actual stack pointer, so
2250 don't include this in the stack size until later. */
2251 all
->extra_pretend_bytes
= all
->pretend_args_size
;
2255 locate_and_pad_parm (data
->promoted_mode
, data
->passed_type
, in_regs
,
2256 entry_parm
? data
->partial
: 0, current_function_decl
,
2257 &all
->stack_args_size
, &data
->locate
);
2259 /* Adjust offsets to include the pretend args. */
2260 pretend_bytes
= all
->extra_pretend_bytes
- pretend_bytes
;
2261 data
->locate
.slot_offset
.constant
+= pretend_bytes
;
2262 data
->locate
.offset
.constant
+= pretend_bytes
;
2264 data
->entry_parm
= entry_parm
;
2267 /* A subroutine of assign_parms. If there is actually space on the stack
2268 for this parm, count it in stack_args_size and return true. */
2271 assign_parm_is_stack_parm (struct assign_parm_data_all
*all
,
2272 struct assign_parm_data_one
*data
)
2274 /* Trivially true if we've no incoming register. */
2275 if (data
->entry_parm
== NULL
)
2277 /* Also true if we're partially in registers and partially not,
2278 since we've arranged to drop the entire argument on the stack. */
2279 else if (data
->partial
!= 0)
2281 /* Also true if the target says that it's passed in both registers
2282 and on the stack. */
2283 else if (GET_CODE (data
->entry_parm
) == PARALLEL
2284 && XEXP (XVECEXP (data
->entry_parm
, 0, 0), 0) == NULL_RTX
)
2286 /* Also true if the target says that there's stack allocated for
2287 all register parameters. */
2288 else if (all
->reg_parm_stack_space
> 0)
2290 /* Otherwise, no, this parameter has no ABI defined stack slot. */
2294 all
->stack_args_size
.constant
+= data
->locate
.size
.constant
;
2295 if (data
->locate
.size
.var
)
2296 ADD_PARM_SIZE (all
->stack_args_size
, data
->locate
.size
.var
);
2301 /* A subroutine of assign_parms. Given that this parameter is allocated
2302 stack space by the ABI, find it. */
2305 assign_parm_find_stack_rtl (tree parm
, struct assign_parm_data_one
*data
)
2307 rtx offset_rtx
, stack_parm
;
2308 unsigned int align
, boundary
;
2310 /* If we're passing this arg using a reg, make its stack home the
2311 aligned stack slot. */
2312 if (data
->entry_parm
)
2313 offset_rtx
= ARGS_SIZE_RTX (data
->locate
.slot_offset
);
2315 offset_rtx
= ARGS_SIZE_RTX (data
->locate
.offset
);
2317 stack_parm
= current_function_internal_arg_pointer
;
2318 if (offset_rtx
!= const0_rtx
)
2319 stack_parm
= gen_rtx_PLUS (Pmode
, stack_parm
, offset_rtx
);
2320 stack_parm
= gen_rtx_MEM (data
->promoted_mode
, stack_parm
);
2322 set_mem_attributes (stack_parm
, parm
, 1);
2324 boundary
= data
->locate
.boundary
;
2325 align
= BITS_PER_UNIT
;
2327 /* If we're padding upward, we know that the alignment of the slot
2328 is FUNCTION_ARG_BOUNDARY. If we're using slot_offset, we're
2329 intentionally forcing upward padding. Otherwise we have to come
2330 up with a guess at the alignment based on OFFSET_RTX. */
2331 if (data
->locate
.where_pad
!= downward
|| data
->entry_parm
)
2333 else if (GET_CODE (offset_rtx
) == CONST_INT
)
2335 align
= INTVAL (offset_rtx
) * BITS_PER_UNIT
| boundary
;
2336 align
= align
& -align
;
2338 set_mem_align (stack_parm
, align
);
2340 if (data
->entry_parm
)
2341 set_reg_attrs_for_parm (data
->entry_parm
, stack_parm
);
2343 data
->stack_parm
= stack_parm
;
2346 /* A subroutine of assign_parms. Adjust DATA->ENTRY_RTL such that it's
2347 always valid and contiguous. */
2350 assign_parm_adjust_entry_rtl (struct assign_parm_data_one
*data
)
2352 rtx entry_parm
= data
->entry_parm
;
2353 rtx stack_parm
= data
->stack_parm
;
2355 /* If this parm was passed part in regs and part in memory, pretend it
2356 arrived entirely in memory by pushing the register-part onto the stack.
2357 In the special case of a DImode or DFmode that is split, we could put
2358 it together in a pseudoreg directly, but for now that's not worth
2360 if (data
->partial
!= 0)
2362 /* Handle calls that pass values in multiple non-contiguous
2363 locations. The Irix 6 ABI has examples of this. */
2364 if (GET_CODE (entry_parm
) == PARALLEL
)
2365 emit_group_store (validize_mem (stack_parm
), entry_parm
,
2367 int_size_in_bytes (data
->passed_type
));
2370 gcc_assert (data
->partial
% UNITS_PER_WORD
== 0);
2371 move_block_from_reg (REGNO (entry_parm
), validize_mem (stack_parm
),
2372 data
->partial
/ UNITS_PER_WORD
);
2375 entry_parm
= stack_parm
;
2378 /* If we didn't decide this parm came in a register, by default it came
2380 else if (entry_parm
== NULL
)
2381 entry_parm
= stack_parm
;
2383 /* When an argument is passed in multiple locations, we can't make use
2384 of this information, but we can save some copying if the whole argument
2385 is passed in a single register. */
2386 else if (GET_CODE (entry_parm
) == PARALLEL
2387 && data
->nominal_mode
!= BLKmode
2388 && data
->passed_mode
!= BLKmode
)
2390 size_t i
, len
= XVECLEN (entry_parm
, 0);
2392 for (i
= 0; i
< len
; i
++)
2393 if (XEXP (XVECEXP (entry_parm
, 0, i
), 0) != NULL_RTX
2394 && REG_P (XEXP (XVECEXP (entry_parm
, 0, i
), 0))
2395 && (GET_MODE (XEXP (XVECEXP (entry_parm
, 0, i
), 0))
2396 == data
->passed_mode
)
2397 && INTVAL (XEXP (XVECEXP (entry_parm
, 0, i
), 1)) == 0)
2399 entry_parm
= XEXP (XVECEXP (entry_parm
, 0, i
), 0);
2404 data
->entry_parm
= entry_parm
;
2407 /* A subroutine of assign_parms. Adjust DATA->STACK_RTL such that it's
2408 always valid and properly aligned. */
2411 assign_parm_adjust_stack_rtl (struct assign_parm_data_one
*data
)
2413 rtx stack_parm
= data
->stack_parm
;
2415 /* If we can't trust the parm stack slot to be aligned enough for its
2416 ultimate type, don't use that slot after entry. We'll make another
2417 stack slot, if we need one. */
2419 && ((STRICT_ALIGNMENT
2420 && GET_MODE_ALIGNMENT (data
->nominal_mode
) > MEM_ALIGN (stack_parm
))
2421 || (data
->nominal_type
2422 && TYPE_ALIGN (data
->nominal_type
) > MEM_ALIGN (stack_parm
)
2423 && MEM_ALIGN (stack_parm
) < PREFERRED_STACK_BOUNDARY
)))
2426 /* If parm was passed in memory, and we need to convert it on entry,
2427 don't store it back in that same slot. */
2428 else if (data
->entry_parm
== stack_parm
2429 && data
->nominal_mode
!= BLKmode
2430 && data
->nominal_mode
!= data
->passed_mode
)
2433 /* If stack protection is in effect for this function, don't leave any
2434 pointers in their passed stack slots. */
2435 else if (cfun
->stack_protect_guard
2436 && (flag_stack_protect
== 2
2437 || data
->passed_pointer
2438 || POINTER_TYPE_P (data
->nominal_type
)))
2441 data
->stack_parm
= stack_parm
;
2444 /* A subroutine of assign_parms. Return true if the current parameter
2445 should be stored as a BLKmode in the current frame. */
2448 assign_parm_setup_block_p (struct assign_parm_data_one
*data
)
2450 if (data
->nominal_mode
== BLKmode
)
2452 if (GET_CODE (data
->entry_parm
) == PARALLEL
)
2455 #ifdef BLOCK_REG_PADDING
2456 /* Only assign_parm_setup_block knows how to deal with register arguments
2457 that are padded at the least significant end. */
2458 if (REG_P (data
->entry_parm
)
2459 && GET_MODE_SIZE (data
->promoted_mode
) < UNITS_PER_WORD
2460 && (BLOCK_REG_PADDING (data
->passed_mode
, data
->passed_type
, 1)
2461 == (BYTES_BIG_ENDIAN
? upward
: downward
)))
2468 /* A subroutine of assign_parms. Arrange for the parameter to be
2469 present and valid in DATA->STACK_RTL. */
2472 assign_parm_setup_block (struct assign_parm_data_all
*all
,
2473 tree parm
, struct assign_parm_data_one
*data
)
2475 rtx entry_parm
= data
->entry_parm
;
2476 rtx stack_parm
= data
->stack_parm
;
2478 HOST_WIDE_INT size_stored
;
2479 rtx orig_entry_parm
= entry_parm
;
2481 if (GET_CODE (entry_parm
) == PARALLEL
)
2482 entry_parm
= emit_group_move_into_temps (entry_parm
);
2484 /* If we've a non-block object that's nevertheless passed in parts,
2485 reconstitute it in register operations rather than on the stack. */
2486 if (GET_CODE (entry_parm
) == PARALLEL
2487 && data
->nominal_mode
!= BLKmode
)
2489 rtx elt0
= XEXP (XVECEXP (orig_entry_parm
, 0, 0), 0);
2491 if ((XVECLEN (entry_parm
, 0) > 1
2492 || hard_regno_nregs
[REGNO (elt0
)][GET_MODE (elt0
)] > 1)
2493 && use_register_for_decl (parm
))
2495 rtx parmreg
= gen_reg_rtx (data
->nominal_mode
);
2497 push_to_sequence2 (all
->first_conversion_insn
,
2498 all
->last_conversion_insn
);
2500 /* For values returned in multiple registers, handle possible
2501 incompatible calls to emit_group_store.
2503 For example, the following would be invalid, and would have to
2504 be fixed by the conditional below:
2506 emit_group_store ((reg:SF), (parallel:DF))
2507 emit_group_store ((reg:SI), (parallel:DI))
2509 An example of this are doubles in e500 v2:
2510 (parallel:DF (expr_list (reg:SI) (const_int 0))
2511 (expr_list (reg:SI) (const_int 4))). */
2512 if (data
->nominal_mode
!= data
->passed_mode
)
2514 rtx t
= gen_reg_rtx (GET_MODE (entry_parm
));
2515 emit_group_store (t
, entry_parm
, NULL_TREE
,
2516 GET_MODE_SIZE (GET_MODE (entry_parm
)));
2517 convert_move (parmreg
, t
, 0);
2520 emit_group_store (parmreg
, entry_parm
, data
->nominal_type
,
2521 int_size_in_bytes (data
->nominal_type
));
2523 all
->first_conversion_insn
= get_insns ();
2524 all
->last_conversion_insn
= get_last_insn ();
2527 SET_DECL_RTL (parm
, parmreg
);
2532 size
= int_size_in_bytes (data
->passed_type
);
2533 size_stored
= CEIL_ROUND (size
, UNITS_PER_WORD
);
2534 if (stack_parm
== 0)
2536 DECL_ALIGN (parm
) = MAX (DECL_ALIGN (parm
), BITS_PER_WORD
);
2537 stack_parm
= assign_stack_local (BLKmode
, size_stored
,
2539 if (GET_MODE_SIZE (GET_MODE (entry_parm
)) == size
)
2540 PUT_MODE (stack_parm
, GET_MODE (entry_parm
));
2541 set_mem_attributes (stack_parm
, parm
, 1);
2544 /* If a BLKmode arrives in registers, copy it to a stack slot. Handle
2545 calls that pass values in multiple non-contiguous locations. */
2546 if (REG_P (entry_parm
) || GET_CODE (entry_parm
) == PARALLEL
)
2550 /* Note that we will be storing an integral number of words.
2551 So we have to be careful to ensure that we allocate an
2552 integral number of words. We do this above when we call
2553 assign_stack_local if space was not allocated in the argument
2554 list. If it was, this will not work if PARM_BOUNDARY is not
2555 a multiple of BITS_PER_WORD. It isn't clear how to fix this
2556 if it becomes a problem. Exception is when BLKmode arrives
2557 with arguments not conforming to word_mode. */
2559 if (data
->stack_parm
== 0)
2561 else if (GET_CODE (entry_parm
) == PARALLEL
)
2564 gcc_assert (!size
|| !(PARM_BOUNDARY
% BITS_PER_WORD
));
2566 mem
= validize_mem (stack_parm
);
2568 /* Handle values in multiple non-contiguous locations. */
2569 if (GET_CODE (entry_parm
) == PARALLEL
)
2571 push_to_sequence2 (all
->first_conversion_insn
,
2572 all
->last_conversion_insn
);
2573 emit_group_store (mem
, entry_parm
, data
->passed_type
, size
);
2574 all
->first_conversion_insn
= get_insns ();
2575 all
->last_conversion_insn
= get_last_insn ();
2582 /* If SIZE is that of a mode no bigger than a word, just use
2583 that mode's store operation. */
2584 else if (size
<= UNITS_PER_WORD
)
2586 enum machine_mode mode
2587 = mode_for_size (size
* BITS_PER_UNIT
, MODE_INT
, 0);
2590 #ifdef BLOCK_REG_PADDING
2591 && (size
== UNITS_PER_WORD
2592 || (BLOCK_REG_PADDING (mode
, data
->passed_type
, 1)
2593 != (BYTES_BIG_ENDIAN
? upward
: downward
)))
2599 /* We are really truncating a word_mode value containing
2600 SIZE bytes into a value of mode MODE. If such an
2601 operation requires no actual instructions, we can refer
2602 to the value directly in mode MODE, otherwise we must
2603 start with the register in word_mode and explicitly
2605 if (TRULY_NOOP_TRUNCATION (size
* BITS_PER_UNIT
, BITS_PER_WORD
))
2606 reg
= gen_rtx_REG (mode
, REGNO (entry_parm
));
2609 reg
= gen_rtx_REG (word_mode
, REGNO (entry_parm
));
2610 reg
= convert_to_mode (mode
, copy_to_reg (reg
), 1);
2612 emit_move_insn (change_address (mem
, mode
, 0), reg
);
2615 /* Blocks smaller than a word on a BYTES_BIG_ENDIAN
2616 machine must be aligned to the left before storing
2617 to memory. Note that the previous test doesn't
2618 handle all cases (e.g. SIZE == 3). */
2619 else if (size
!= UNITS_PER_WORD
2620 #ifdef BLOCK_REG_PADDING
2621 && (BLOCK_REG_PADDING (mode
, data
->passed_type
, 1)
2629 int by
= (UNITS_PER_WORD
- size
) * BITS_PER_UNIT
;
2630 rtx reg
= gen_rtx_REG (word_mode
, REGNO (entry_parm
));
2632 x
= expand_shift (LSHIFT_EXPR
, word_mode
, reg
,
2633 build_int_cst (NULL_TREE
, by
),
2635 tem
= change_address (mem
, word_mode
, 0);
2636 emit_move_insn (tem
, x
);
2639 move_block_from_reg (REGNO (entry_parm
), mem
,
2640 size_stored
/ UNITS_PER_WORD
);
2643 move_block_from_reg (REGNO (entry_parm
), mem
,
2644 size_stored
/ UNITS_PER_WORD
);
2646 else if (data
->stack_parm
== 0)
2648 push_to_sequence2 (all
->first_conversion_insn
, all
->last_conversion_insn
);
2649 emit_block_move (stack_parm
, data
->entry_parm
, GEN_INT (size
),
2651 all
->first_conversion_insn
= get_insns ();
2652 all
->last_conversion_insn
= get_last_insn ();
2656 data
->stack_parm
= stack_parm
;
2657 SET_DECL_RTL (parm
, stack_parm
);
2660 /* A subroutine of assign_parms. Allocate a pseudo to hold the current
2661 parameter. Get it there. Perform all ABI specified conversions. */
2664 assign_parm_setup_reg (struct assign_parm_data_all
*all
, tree parm
,
2665 struct assign_parm_data_one
*data
)
2668 enum machine_mode promoted_nominal_mode
;
2669 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (parm
));
2670 bool did_conversion
= false;
2672 /* Store the parm in a pseudoregister during the function, but we may
2673 need to do it in a wider mode. */
2675 /* This is not really promoting for a call. However we need to be
2676 consistent with assign_parm_find_data_types and expand_expr_real_1. */
2677 promoted_nominal_mode
2678 = promote_mode (data
->nominal_type
, data
->nominal_mode
, &unsignedp
, 1);
2680 parmreg
= gen_reg_rtx (promoted_nominal_mode
);
2682 if (!DECL_ARTIFICIAL (parm
))
2683 mark_user_reg (parmreg
);
2685 /* If this was an item that we received a pointer to,
2686 set DECL_RTL appropriately. */
2687 if (data
->passed_pointer
)
2689 rtx x
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data
->passed_type
)), parmreg
);
2690 set_mem_attributes (x
, parm
, 1);
2691 SET_DECL_RTL (parm
, x
);
2694 SET_DECL_RTL (parm
, parmreg
);
2696 /* Copy the value into the register. */
2697 if (data
->nominal_mode
!= data
->passed_mode
2698 || promoted_nominal_mode
!= data
->promoted_mode
)
2702 /* ENTRY_PARM has been converted to PROMOTED_MODE, its
2703 mode, by the caller. We now have to convert it to
2704 NOMINAL_MODE, if different. However, PARMREG may be in
2705 a different mode than NOMINAL_MODE if it is being stored
2708 If ENTRY_PARM is a hard register, it might be in a register
2709 not valid for operating in its mode (e.g., an odd-numbered
2710 register for a DFmode). In that case, moves are the only
2711 thing valid, so we can't do a convert from there. This
2712 occurs when the calling sequence allow such misaligned
2715 In addition, the conversion may involve a call, which could
2716 clobber parameters which haven't been copied to pseudo
2717 registers yet. Therefore, we must first copy the parm to
2718 a pseudo reg here, and save the conversion until after all
2719 parameters have been moved. */
2721 rtx tempreg
= gen_reg_rtx (GET_MODE (data
->entry_parm
));
2723 emit_move_insn (tempreg
, validize_mem (data
->entry_parm
));
2725 push_to_sequence2 (all
->first_conversion_insn
, all
->last_conversion_insn
);
2726 tempreg
= convert_to_mode (data
->nominal_mode
, tempreg
, unsignedp
);
2728 if (GET_CODE (tempreg
) == SUBREG
2729 && GET_MODE (tempreg
) == data
->nominal_mode
2730 && REG_P (SUBREG_REG (tempreg
))
2731 && data
->nominal_mode
== data
->passed_mode
2732 && GET_MODE (SUBREG_REG (tempreg
)) == GET_MODE (data
->entry_parm
)
2733 && GET_MODE_SIZE (GET_MODE (tempreg
))
2734 < GET_MODE_SIZE (GET_MODE (data
->entry_parm
)))
2736 /* The argument is already sign/zero extended, so note it
2738 SUBREG_PROMOTED_VAR_P (tempreg
) = 1;
2739 SUBREG_PROMOTED_UNSIGNED_SET (tempreg
, unsignedp
);
2742 /* TREE_USED gets set erroneously during expand_assignment. */
2743 save_tree_used
= TREE_USED (parm
);
2744 expand_assignment (parm
, make_tree (data
->nominal_type
, tempreg
), false);
2745 TREE_USED (parm
) = save_tree_used
;
2746 all
->first_conversion_insn
= get_insns ();
2747 all
->last_conversion_insn
= get_last_insn ();
2750 did_conversion
= true;
2753 emit_move_insn (parmreg
, validize_mem (data
->entry_parm
));
2755 /* If we were passed a pointer but the actual value can safely live
2756 in a register, put it in one. */
2757 if (data
->passed_pointer
2758 && TYPE_MODE (TREE_TYPE (parm
)) != BLKmode
2759 /* If by-reference argument was promoted, demote it. */
2760 && (TYPE_MODE (TREE_TYPE (parm
)) != GET_MODE (DECL_RTL (parm
))
2761 || use_register_for_decl (parm
)))
2763 /* We can't use nominal_mode, because it will have been set to
2764 Pmode above. We must use the actual mode of the parm. */
2765 parmreg
= gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm
)));
2766 mark_user_reg (parmreg
);
2768 if (GET_MODE (parmreg
) != GET_MODE (DECL_RTL (parm
)))
2770 rtx tempreg
= gen_reg_rtx (GET_MODE (DECL_RTL (parm
)));
2771 int unsigned_p
= TYPE_UNSIGNED (TREE_TYPE (parm
));
2773 push_to_sequence2 (all
->first_conversion_insn
,
2774 all
->last_conversion_insn
);
2775 emit_move_insn (tempreg
, DECL_RTL (parm
));
2776 tempreg
= convert_to_mode (GET_MODE (parmreg
), tempreg
, unsigned_p
);
2777 emit_move_insn (parmreg
, tempreg
);
2778 all
->first_conversion_insn
= get_insns ();
2779 all
->last_conversion_insn
= get_last_insn ();
2782 did_conversion
= true;
2785 emit_move_insn (parmreg
, DECL_RTL (parm
));
2787 SET_DECL_RTL (parm
, parmreg
);
2789 /* STACK_PARM is the pointer, not the parm, and PARMREG is
2791 data
->stack_parm
= NULL
;
2794 /* Mark the register as eliminable if we did no conversion and it was
2795 copied from memory at a fixed offset, and the arg pointer was not
2796 copied to a pseudo-reg. If the arg pointer is a pseudo reg or the
2797 offset formed an invalid address, such memory-equivalences as we
2798 make here would screw up life analysis for it. */
2799 if (data
->nominal_mode
== data
->passed_mode
2801 && data
->stack_parm
!= 0
2802 && MEM_P (data
->stack_parm
)
2803 && data
->locate
.offset
.var
== 0
2804 && reg_mentioned_p (virtual_incoming_args_rtx
,
2805 XEXP (data
->stack_parm
, 0)))
2807 rtx linsn
= get_last_insn ();
2810 /* Mark complex types separately. */
2811 if (GET_CODE (parmreg
) == CONCAT
)
2813 enum machine_mode submode
2814 = GET_MODE_INNER (GET_MODE (parmreg
));
2815 int regnor
= REGNO (XEXP (parmreg
, 0));
2816 int regnoi
= REGNO (XEXP (parmreg
, 1));
2817 rtx stackr
= adjust_address_nv (data
->stack_parm
, submode
, 0);
2818 rtx stacki
= adjust_address_nv (data
->stack_parm
, submode
,
2819 GET_MODE_SIZE (submode
));
2821 /* Scan backwards for the set of the real and
2823 for (sinsn
= linsn
; sinsn
!= 0;
2824 sinsn
= prev_nonnote_insn (sinsn
))
2826 set
= single_set (sinsn
);
2830 if (SET_DEST (set
) == regno_reg_rtx
[regnoi
])
2831 set_unique_reg_note (sinsn
, REG_EQUIV
, stacki
);
2832 else if (SET_DEST (set
) == regno_reg_rtx
[regnor
])
2833 set_unique_reg_note (sinsn
, REG_EQUIV
, stackr
);
2836 else if ((set
= single_set (linsn
)) != 0
2837 && SET_DEST (set
) == parmreg
)
2838 set_unique_reg_note (linsn
, REG_EQUIV
, data
->stack_parm
);
2841 /* For pointer data type, suggest pointer register. */
2842 if (POINTER_TYPE_P (TREE_TYPE (parm
)))
2843 mark_reg_pointer (parmreg
,
2844 TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm
))));
2847 /* A subroutine of assign_parms. Allocate stack space to hold the current
2848 parameter. Get it there. Perform all ABI specified conversions. */
2851 assign_parm_setup_stack (struct assign_parm_data_all
*all
, tree parm
,
2852 struct assign_parm_data_one
*data
)
2854 /* Value must be stored in the stack slot STACK_PARM during function
2856 bool to_conversion
= false;
2858 if (data
->promoted_mode
!= data
->nominal_mode
)
2860 /* Conversion is required. */
2861 rtx tempreg
= gen_reg_rtx (GET_MODE (data
->entry_parm
));
2863 emit_move_insn (tempreg
, validize_mem (data
->entry_parm
));
2865 push_to_sequence2 (all
->first_conversion_insn
, all
->last_conversion_insn
);
2866 to_conversion
= true;
2868 data
->entry_parm
= convert_to_mode (data
->nominal_mode
, tempreg
,
2869 TYPE_UNSIGNED (TREE_TYPE (parm
)));
2871 if (data
->stack_parm
)
2872 /* ??? This may need a big-endian conversion on sparc64. */
2874 = adjust_address (data
->stack_parm
, data
->nominal_mode
, 0);
2877 if (data
->entry_parm
!= data
->stack_parm
)
2881 if (data
->stack_parm
== 0)
2884 = assign_stack_local (GET_MODE (data
->entry_parm
),
2885 GET_MODE_SIZE (GET_MODE (data
->entry_parm
)),
2886 TYPE_ALIGN (data
->passed_type
));
2887 set_mem_attributes (data
->stack_parm
, parm
, 1);
2890 dest
= validize_mem (data
->stack_parm
);
2891 src
= validize_mem (data
->entry_parm
);
2895 /* Use a block move to handle potentially misaligned entry_parm. */
2897 push_to_sequence2 (all
->first_conversion_insn
,
2898 all
->last_conversion_insn
);
2899 to_conversion
= true;
2901 emit_block_move (dest
, src
,
2902 GEN_INT (int_size_in_bytes (data
->passed_type
)),
2906 emit_move_insn (dest
, src
);
2911 all
->first_conversion_insn
= get_insns ();
2912 all
->last_conversion_insn
= get_last_insn ();
2916 SET_DECL_RTL (parm
, data
->stack_parm
);
2919 /* A subroutine of assign_parms. If the ABI splits complex arguments, then
2920 undo the frobbing that we did in assign_parms_augmented_arg_list. */
2923 assign_parms_unsplit_complex (struct assign_parm_data_all
*all
, tree fnargs
)
2926 tree orig_fnargs
= all
->orig_fnargs
;
2928 for (parm
= orig_fnargs
; parm
; parm
= TREE_CHAIN (parm
))
2930 if (TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
2931 && targetm
.calls
.split_complex_arg (TREE_TYPE (parm
)))
2933 rtx tmp
, real
, imag
;
2934 enum machine_mode inner
= GET_MODE_INNER (DECL_MODE (parm
));
2936 real
= DECL_RTL (fnargs
);
2937 imag
= DECL_RTL (TREE_CHAIN (fnargs
));
2938 if (inner
!= GET_MODE (real
))
2940 real
= gen_lowpart_SUBREG (inner
, real
);
2941 imag
= gen_lowpart_SUBREG (inner
, imag
);
2944 if (TREE_ADDRESSABLE (parm
))
2947 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (parm
));
2949 /* split_complex_arg put the real and imag parts in
2950 pseudos. Move them to memory. */
2951 tmp
= assign_stack_local (DECL_MODE (parm
), size
,
2952 TYPE_ALIGN (TREE_TYPE (parm
)));
2953 set_mem_attributes (tmp
, parm
, 1);
2954 rmem
= adjust_address_nv (tmp
, inner
, 0);
2955 imem
= adjust_address_nv (tmp
, inner
, GET_MODE_SIZE (inner
));
2956 push_to_sequence2 (all
->first_conversion_insn
,
2957 all
->last_conversion_insn
);
2958 emit_move_insn (rmem
, real
);
2959 emit_move_insn (imem
, imag
);
2960 all
->first_conversion_insn
= get_insns ();
2961 all
->last_conversion_insn
= get_last_insn ();
2965 tmp
= gen_rtx_CONCAT (DECL_MODE (parm
), real
, imag
);
2966 SET_DECL_RTL (parm
, tmp
);
2968 real
= DECL_INCOMING_RTL (fnargs
);
2969 imag
= DECL_INCOMING_RTL (TREE_CHAIN (fnargs
));
2970 if (inner
!= GET_MODE (real
))
2972 real
= gen_lowpart_SUBREG (inner
, real
);
2973 imag
= gen_lowpart_SUBREG (inner
, imag
);
2975 tmp
= gen_rtx_CONCAT (DECL_MODE (parm
), real
, imag
);
2976 set_decl_incoming_rtl (parm
, tmp
);
2977 fnargs
= TREE_CHAIN (fnargs
);
2981 SET_DECL_RTL (parm
, DECL_RTL (fnargs
));
2982 set_decl_incoming_rtl (parm
, DECL_INCOMING_RTL (fnargs
));
2984 /* Set MEM_EXPR to the original decl, i.e. to PARM,
2985 instead of the copy of decl, i.e. FNARGS. */
2986 if (DECL_INCOMING_RTL (parm
) && MEM_P (DECL_INCOMING_RTL (parm
)))
2987 set_mem_expr (DECL_INCOMING_RTL (parm
), parm
);
2990 fnargs
= TREE_CHAIN (fnargs
);
2994 /* Assign RTL expressions to the function's parameters. This may involve
2995 copying them into registers and using those registers as the DECL_RTL. */
2998 assign_parms (tree fndecl
)
3000 struct assign_parm_data_all all
;
3003 current_function_internal_arg_pointer
3004 = targetm
.calls
.internal_arg_pointer ();
3006 assign_parms_initialize_all (&all
);
3007 fnargs
= assign_parms_augmented_arg_list (&all
);
3009 for (parm
= fnargs
; parm
; parm
= TREE_CHAIN (parm
))
3011 struct assign_parm_data_one data
;
3013 /* Extract the type of PARM; adjust it according to ABI. */
3014 assign_parm_find_data_types (&all
, parm
, &data
);
3016 /* Early out for errors and void parameters. */
3017 if (data
.passed_mode
== VOIDmode
)
3019 SET_DECL_RTL (parm
, const0_rtx
);
3020 DECL_INCOMING_RTL (parm
) = DECL_RTL (parm
);
3024 if (current_function_stdarg
&& !TREE_CHAIN (parm
))
3025 assign_parms_setup_varargs (&all
, &data
, false);
3027 /* Find out where the parameter arrives in this function. */
3028 assign_parm_find_entry_rtl (&all
, &data
);
3030 /* Find out where stack space for this parameter might be. */
3031 if (assign_parm_is_stack_parm (&all
, &data
))
3033 assign_parm_find_stack_rtl (parm
, &data
);
3034 assign_parm_adjust_entry_rtl (&data
);
3037 /* Record permanently how this parm was passed. */
3038 set_decl_incoming_rtl (parm
, data
.entry_parm
);
3040 /* Update info on where next arg arrives in registers. */
3041 FUNCTION_ARG_ADVANCE (all
.args_so_far
, data
.promoted_mode
,
3042 data
.passed_type
, data
.named_arg
);
3044 assign_parm_adjust_stack_rtl (&data
);
3046 if (assign_parm_setup_block_p (&data
))
3047 assign_parm_setup_block (&all
, parm
, &data
);
3048 else if (data
.passed_pointer
|| use_register_for_decl (parm
))
3049 assign_parm_setup_reg (&all
, parm
, &data
);
3051 assign_parm_setup_stack (&all
, parm
, &data
);
3054 if (targetm
.calls
.split_complex_arg
&& fnargs
!= all
.orig_fnargs
)
3055 assign_parms_unsplit_complex (&all
, fnargs
);
3057 /* Output all parameter conversion instructions (possibly including calls)
3058 now that all parameters have been copied out of hard registers. */
3059 emit_insn (all
.first_conversion_insn
);
3061 /* If we are receiving a struct value address as the first argument, set up
3062 the RTL for the function result. As this might require code to convert
3063 the transmitted address to Pmode, we do this here to ensure that possible
3064 preliminary conversions of the address have been emitted already. */
3065 if (all
.function_result_decl
)
3067 tree result
= DECL_RESULT (current_function_decl
);
3068 rtx addr
= DECL_RTL (all
.function_result_decl
);
3071 if (DECL_BY_REFERENCE (result
))
3075 addr
= convert_memory_address (Pmode
, addr
);
3076 x
= gen_rtx_MEM (DECL_MODE (result
), addr
);
3077 set_mem_attributes (x
, result
, 1);
3079 SET_DECL_RTL (result
, x
);
3082 /* We have aligned all the args, so add space for the pretend args. */
3083 current_function_pretend_args_size
= all
.pretend_args_size
;
3084 all
.stack_args_size
.constant
+= all
.extra_pretend_bytes
;
3085 current_function_args_size
= all
.stack_args_size
.constant
;
3087 /* Adjust function incoming argument size for alignment and
3090 #ifdef REG_PARM_STACK_SPACE
3091 current_function_args_size
= MAX (current_function_args_size
,
3092 REG_PARM_STACK_SPACE (fndecl
));
3095 current_function_args_size
= CEIL_ROUND (current_function_args_size
,
3096 PARM_BOUNDARY
/ BITS_PER_UNIT
);
3098 #ifdef ARGS_GROW_DOWNWARD
3099 current_function_arg_offset_rtx
3100 = (all
.stack_args_size
.var
== 0 ? GEN_INT (-all
.stack_args_size
.constant
)
3101 : expand_expr (size_diffop (all
.stack_args_size
.var
,
3102 size_int (-all
.stack_args_size
.constant
)),
3103 NULL_RTX
, VOIDmode
, 0));
3105 current_function_arg_offset_rtx
= ARGS_SIZE_RTX (all
.stack_args_size
);
3108 /* See how many bytes, if any, of its args a function should try to pop
3111 current_function_pops_args
= RETURN_POPS_ARGS (fndecl
, TREE_TYPE (fndecl
),
3112 current_function_args_size
);
3114 /* For stdarg.h function, save info about
3115 regs and stack space used by the named args. */
3117 current_function_args_info
= all
.args_so_far
;
3119 /* Set the rtx used for the function return value. Put this in its
3120 own variable so any optimizers that need this information don't have
3121 to include tree.h. Do this here so it gets done when an inlined
3122 function gets output. */
3124 current_function_return_rtx
3125 = (DECL_RTL_SET_P (DECL_RESULT (fndecl
))
3126 ? DECL_RTL (DECL_RESULT (fndecl
)) : NULL_RTX
);
3128 /* If scalar return value was computed in a pseudo-reg, or was a named
3129 return value that got dumped to the stack, copy that to the hard
3131 if (DECL_RTL_SET_P (DECL_RESULT (fndecl
)))
3133 tree decl_result
= DECL_RESULT (fndecl
);
3134 rtx decl_rtl
= DECL_RTL (decl_result
);
3136 if (REG_P (decl_rtl
)
3137 ? REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
3138 : DECL_REGISTER (decl_result
))
3142 real_decl_rtl
= targetm
.calls
.function_value (TREE_TYPE (decl_result
),
3144 REG_FUNCTION_VALUE_P (real_decl_rtl
) = 1;
3145 /* The delay slot scheduler assumes that current_function_return_rtx
3146 holds the hard register containing the return value, not a
3147 temporary pseudo. */
3148 current_function_return_rtx
= real_decl_rtl
;
3153 /* A subroutine of gimplify_parameters, invoked via walk_tree.
3154 For all seen types, gimplify their sizes. */
3157 gimplify_parm_type (tree
*tp
, int *walk_subtrees
, void *data
)
3164 if (POINTER_TYPE_P (t
))
3166 else if (TYPE_SIZE (t
) && !TREE_CONSTANT (TYPE_SIZE (t
))
3167 && !TYPE_SIZES_GIMPLIFIED (t
))
3169 gimplify_type_sizes (t
, (tree
*) data
);
3177 /* Gimplify the parameter list for current_function_decl. This involves
3178 evaluating SAVE_EXPRs of variable sized parameters and generating code
3179 to implement callee-copies reference parameters. Returns a list of
3180 statements to add to the beginning of the function, or NULL if nothing
3184 gimplify_parameters (void)
3186 struct assign_parm_data_all all
;
3187 tree fnargs
, parm
, stmts
= NULL
;
3189 assign_parms_initialize_all (&all
);
3190 fnargs
= assign_parms_augmented_arg_list (&all
);
3192 for (parm
= fnargs
; parm
; parm
= TREE_CHAIN (parm
))
3194 struct assign_parm_data_one data
;
3196 /* Extract the type of PARM; adjust it according to ABI. */
3197 assign_parm_find_data_types (&all
, parm
, &data
);
3199 /* Early out for errors and void parameters. */
3200 if (data
.passed_mode
== VOIDmode
|| DECL_SIZE (parm
) == NULL
)
3203 /* Update info on where next arg arrives in registers. */
3204 FUNCTION_ARG_ADVANCE (all
.args_so_far
, data
.promoted_mode
,
3205 data
.passed_type
, data
.named_arg
);
3207 /* ??? Once upon a time variable_size stuffed parameter list
3208 SAVE_EXPRs (amongst others) onto a pending sizes list. This
3209 turned out to be less than manageable in the gimple world.
3210 Now we have to hunt them down ourselves. */
3211 walk_tree_without_duplicates (&data
.passed_type
,
3212 gimplify_parm_type
, &stmts
);
3214 if (!TREE_CONSTANT (DECL_SIZE (parm
)))
3216 gimplify_one_sizepos (&DECL_SIZE (parm
), &stmts
);
3217 gimplify_one_sizepos (&DECL_SIZE_UNIT (parm
), &stmts
);
3220 if (data
.passed_pointer
)
3222 tree type
= TREE_TYPE (data
.passed_type
);
3223 if (reference_callee_copied (&all
.args_so_far
, TYPE_MODE (type
),
3224 type
, data
.named_arg
))
3228 /* For constant sized objects, this is trivial; for
3229 variable-sized objects, we have to play games. */
3230 if (TREE_CONSTANT (DECL_SIZE (parm
)))
3232 local
= create_tmp_var (type
, get_name (parm
));
3233 DECL_IGNORED_P (local
) = 0;
3237 tree ptr_type
, addr
;
3239 ptr_type
= build_pointer_type (type
);
3240 addr
= create_tmp_var (ptr_type
, get_name (parm
));
3241 DECL_IGNORED_P (addr
) = 0;
3242 local
= build_fold_indirect_ref (addr
);
3244 t
= built_in_decls
[BUILT_IN_ALLOCA
];
3245 t
= build_call_expr (t
, 1, DECL_SIZE_UNIT (parm
));
3246 t
= fold_convert (ptr_type
, t
);
3247 t
= build_gimple_modify_stmt (addr
, t
);
3248 gimplify_and_add (t
, &stmts
);
3251 t
= build_gimple_modify_stmt (local
, parm
);
3252 gimplify_and_add (t
, &stmts
);
3254 SET_DECL_VALUE_EXPR (parm
, local
);
3255 DECL_HAS_VALUE_EXPR_P (parm
) = 1;
3263 /* Compute the size and offset from the start of the stacked arguments for a
3264 parm passed in mode PASSED_MODE and with type TYPE.
3266 INITIAL_OFFSET_PTR points to the current offset into the stacked
3269 The starting offset and size for this parm are returned in
3270 LOCATE->OFFSET and LOCATE->SIZE, respectively. When IN_REGS is
3271 nonzero, the offset is that of stack slot, which is returned in
3272 LOCATE->SLOT_OFFSET. LOCATE->ALIGNMENT_PAD is the amount of
3273 padding required from the initial offset ptr to the stack slot.
3275 IN_REGS is nonzero if the argument will be passed in registers. It will
3276 never be set if REG_PARM_STACK_SPACE is not defined.
3278 FNDECL is the function in which the argument was defined.
3280 There are two types of rounding that are done. The first, controlled by
3281 FUNCTION_ARG_BOUNDARY, forces the offset from the start of the argument
3282 list to be aligned to the specific boundary (in bits). This rounding
3283 affects the initial and starting offsets, but not the argument size.
3285 The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY,
3286 optionally rounds the size of the parm to PARM_BOUNDARY. The
3287 initial offset is not affected by this rounding, while the size always
3288 is and the starting offset may be. */
3290 /* LOCATE->OFFSET will be negative for ARGS_GROW_DOWNWARD case;
3291 INITIAL_OFFSET_PTR is positive because locate_and_pad_parm's
3292 callers pass in the total size of args so far as
3293 INITIAL_OFFSET_PTR. LOCATE->SIZE is always positive. */
3296 locate_and_pad_parm (enum machine_mode passed_mode
, tree type
, int in_regs
,
3297 int partial
, tree fndecl ATTRIBUTE_UNUSED
,
3298 struct args_size
*initial_offset_ptr
,
3299 struct locate_and_pad_arg_data
*locate
)
3302 enum direction where_pad
;
3303 unsigned int boundary
;
3304 int reg_parm_stack_space
= 0;
3305 int part_size_in_regs
;
3307 #ifdef REG_PARM_STACK_SPACE
3308 reg_parm_stack_space
= REG_PARM_STACK_SPACE (fndecl
);
3310 /* If we have found a stack parm before we reach the end of the
3311 area reserved for registers, skip that area. */
3314 if (reg_parm_stack_space
> 0)
3316 if (initial_offset_ptr
->var
)
3318 initial_offset_ptr
->var
3319 = size_binop (MAX_EXPR
, ARGS_SIZE_TREE (*initial_offset_ptr
),
3320 ssize_int (reg_parm_stack_space
));
3321 initial_offset_ptr
->constant
= 0;
3323 else if (initial_offset_ptr
->constant
< reg_parm_stack_space
)
3324 initial_offset_ptr
->constant
= reg_parm_stack_space
;
3327 #endif /* REG_PARM_STACK_SPACE */
3329 part_size_in_regs
= (reg_parm_stack_space
== 0 ? partial
: 0);
3332 = type
? size_in_bytes (type
) : size_int (GET_MODE_SIZE (passed_mode
));
3333 where_pad
= FUNCTION_ARG_PADDING (passed_mode
, type
);
3334 boundary
= FUNCTION_ARG_BOUNDARY (passed_mode
, type
);
3335 locate
->where_pad
= where_pad
;
3336 locate
->boundary
= boundary
;
3338 /* Remember if the outgoing parameter requires extra alignment on the
3339 calling function side. */
3340 if (boundary
> PREFERRED_STACK_BOUNDARY
)
3341 boundary
= PREFERRED_STACK_BOUNDARY
;
3342 if (cfun
->stack_alignment_needed
< boundary
)
3343 cfun
->stack_alignment_needed
= boundary
;
3345 #ifdef ARGS_GROW_DOWNWARD
3346 locate
->slot_offset
.constant
= -initial_offset_ptr
->constant
;
3347 if (initial_offset_ptr
->var
)
3348 locate
->slot_offset
.var
= size_binop (MINUS_EXPR
, ssize_int (0),
3349 initial_offset_ptr
->var
);
3353 if (where_pad
!= none
3354 && (!host_integerp (sizetree
, 1)
3355 || (tree_low_cst (sizetree
, 1) * BITS_PER_UNIT
) % PARM_BOUNDARY
))
3356 s2
= round_up (s2
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
3357 SUB_PARM_SIZE (locate
->slot_offset
, s2
);
3360 locate
->slot_offset
.constant
+= part_size_in_regs
;
3363 #ifdef REG_PARM_STACK_SPACE
3364 || REG_PARM_STACK_SPACE (fndecl
) > 0
3367 pad_to_arg_alignment (&locate
->slot_offset
, boundary
,
3368 &locate
->alignment_pad
);
3370 locate
->size
.constant
= (-initial_offset_ptr
->constant
3371 - locate
->slot_offset
.constant
);
3372 if (initial_offset_ptr
->var
)
3373 locate
->size
.var
= size_binop (MINUS_EXPR
,
3374 size_binop (MINUS_EXPR
,
3376 initial_offset_ptr
->var
),
3377 locate
->slot_offset
.var
);
3379 /* Pad_below needs the pre-rounded size to know how much to pad
3381 locate
->offset
= locate
->slot_offset
;
3382 if (where_pad
== downward
)
3383 pad_below (&locate
->offset
, passed_mode
, sizetree
);
3385 #else /* !ARGS_GROW_DOWNWARD */
3387 #ifdef REG_PARM_STACK_SPACE
3388 || REG_PARM_STACK_SPACE (fndecl
) > 0
3391 pad_to_arg_alignment (initial_offset_ptr
, boundary
,
3392 &locate
->alignment_pad
);
3393 locate
->slot_offset
= *initial_offset_ptr
;
3395 #ifdef PUSH_ROUNDING
3396 if (passed_mode
!= BLKmode
)
3397 sizetree
= size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree
)));
3400 /* Pad_below needs the pre-rounded size to know how much to pad below
3401 so this must be done before rounding up. */
3402 locate
->offset
= locate
->slot_offset
;
3403 if (where_pad
== downward
)
3404 pad_below (&locate
->offset
, passed_mode
, sizetree
);
3406 if (where_pad
!= none
3407 && (!host_integerp (sizetree
, 1)
3408 || (tree_low_cst (sizetree
, 1) * BITS_PER_UNIT
) % PARM_BOUNDARY
))
3409 sizetree
= round_up (sizetree
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
3411 ADD_PARM_SIZE (locate
->size
, sizetree
);
3413 locate
->size
.constant
-= part_size_in_regs
;
3414 #endif /* ARGS_GROW_DOWNWARD */
3417 /* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY.
3418 BOUNDARY is measured in bits, but must be a multiple of a storage unit. */
3421 pad_to_arg_alignment (struct args_size
*offset_ptr
, int boundary
,
3422 struct args_size
*alignment_pad
)
3424 tree save_var
= NULL_TREE
;
3425 HOST_WIDE_INT save_constant
= 0;
3426 int boundary_in_bytes
= boundary
/ BITS_PER_UNIT
;
3427 HOST_WIDE_INT sp_offset
= STACK_POINTER_OFFSET
;
3429 #ifdef SPARC_STACK_BOUNDARY_HACK
3430 /* ??? The SPARC port may claim a STACK_BOUNDARY higher than
3431 the real alignment of %sp. However, when it does this, the
3432 alignment of %sp+STACK_POINTER_OFFSET is STACK_BOUNDARY. */
3433 if (SPARC_STACK_BOUNDARY_HACK
)
3437 if (boundary
> PARM_BOUNDARY
&& boundary
> STACK_BOUNDARY
)
3439 save_var
= offset_ptr
->var
;
3440 save_constant
= offset_ptr
->constant
;
3443 alignment_pad
->var
= NULL_TREE
;
3444 alignment_pad
->constant
= 0;
3446 if (boundary
> BITS_PER_UNIT
)
3448 if (offset_ptr
->var
)
3450 tree sp_offset_tree
= ssize_int (sp_offset
);
3451 tree offset
= size_binop (PLUS_EXPR
,
3452 ARGS_SIZE_TREE (*offset_ptr
),
3454 #ifdef ARGS_GROW_DOWNWARD
3455 tree rounded
= round_down (offset
, boundary
/ BITS_PER_UNIT
);
3457 tree rounded
= round_up (offset
, boundary
/ BITS_PER_UNIT
);
3460 offset_ptr
->var
= size_binop (MINUS_EXPR
, rounded
, sp_offset_tree
);
3461 /* ARGS_SIZE_TREE includes constant term. */
3462 offset_ptr
->constant
= 0;
3463 if (boundary
> PARM_BOUNDARY
&& boundary
> STACK_BOUNDARY
)
3464 alignment_pad
->var
= size_binop (MINUS_EXPR
, offset_ptr
->var
,
3469 offset_ptr
->constant
= -sp_offset
+
3470 #ifdef ARGS_GROW_DOWNWARD
3471 FLOOR_ROUND (offset_ptr
->constant
+ sp_offset
, boundary_in_bytes
);
3473 CEIL_ROUND (offset_ptr
->constant
+ sp_offset
, boundary_in_bytes
);
3475 if (boundary
> PARM_BOUNDARY
&& boundary
> STACK_BOUNDARY
)
3476 alignment_pad
->constant
= offset_ptr
->constant
- save_constant
;
3482 pad_below (struct args_size
*offset_ptr
, enum machine_mode passed_mode
, tree sizetree
)
3484 if (passed_mode
!= BLKmode
)
3486 if (GET_MODE_BITSIZE (passed_mode
) % PARM_BOUNDARY
)
3487 offset_ptr
->constant
3488 += (((GET_MODE_BITSIZE (passed_mode
) + PARM_BOUNDARY
- 1)
3489 / PARM_BOUNDARY
* PARM_BOUNDARY
/ BITS_PER_UNIT
)
3490 - GET_MODE_SIZE (passed_mode
));
3494 if (TREE_CODE (sizetree
) != INTEGER_CST
3495 || (TREE_INT_CST_LOW (sizetree
) * BITS_PER_UNIT
) % PARM_BOUNDARY
)
3497 /* Round the size up to multiple of PARM_BOUNDARY bits. */
3498 tree s2
= round_up (sizetree
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
3500 ADD_PARM_SIZE (*offset_ptr
, s2
);
3501 SUB_PARM_SIZE (*offset_ptr
, sizetree
);
3507 /* True if register REGNO was alive at a place where `setjmp' was
3508 called and was set more than once or is an argument. Such regs may
3509 be clobbered by `longjmp'. */
3512 regno_clobbered_at_setjmp (bitmap setjmp_crosses
, int regno
)
3514 /* There appear to be cases where some local vars never reach the
3515 backend but have bogus regnos. */
3516 if (regno
>= max_reg_num ())
3519 return ((REG_N_SETS (regno
) > 1
3520 || REGNO_REG_SET_P (df_get_live_out (ENTRY_BLOCK_PTR
), regno
))
3521 && REGNO_REG_SET_P (setjmp_crosses
, regno
));
3524 /* Walk the tree of blocks describing the binding levels within a
3525 function and warn about variables the might be killed by setjmp or
3526 vfork. This is done after calling flow_analysis before register
3527 allocation since that will clobber the pseudo-regs to hard
3531 setjmp_vars_warning (bitmap setjmp_crosses
, tree block
)
3535 for (decl
= BLOCK_VARS (block
); decl
; decl
= TREE_CHAIN (decl
))
3537 if (TREE_CODE (decl
) == VAR_DECL
3538 && DECL_RTL_SET_P (decl
)
3539 && REG_P (DECL_RTL (decl
))
3540 && regno_clobbered_at_setjmp (setjmp_crosses
, REGNO (DECL_RTL (decl
))))
3541 warning (OPT_Wclobbered
, "variable %q+D might be clobbered by"
3542 " %<longjmp%> or %<vfork%>", decl
);
3545 for (sub
= BLOCK_SUBBLOCKS (block
); sub
; sub
= TREE_CHAIN (sub
))
3546 setjmp_vars_warning (setjmp_crosses
, sub
);
3549 /* Do the appropriate part of setjmp_vars_warning
3550 but for arguments instead of local variables. */
3553 setjmp_args_warning (bitmap setjmp_crosses
)
3556 for (decl
= DECL_ARGUMENTS (current_function_decl
);
3557 decl
; decl
= TREE_CHAIN (decl
))
3558 if (DECL_RTL (decl
) != 0
3559 && REG_P (DECL_RTL (decl
))
3560 && regno_clobbered_at_setjmp (setjmp_crosses
, REGNO (DECL_RTL (decl
))))
3561 warning (OPT_Wclobbered
,
3562 "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>",
3566 /* Generate warning messages for variables live across setjmp. */
3569 generate_setjmp_warnings (void)
3571 bitmap setjmp_crosses
= regstat_get_setjmp_crosses ();
3573 if (n_basic_blocks
== NUM_FIXED_BLOCKS
3574 || bitmap_empty_p (setjmp_crosses
))
3577 setjmp_vars_warning (setjmp_crosses
, DECL_INITIAL (current_function_decl
));
3578 setjmp_args_warning (setjmp_crosses
);
3582 /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
3583 and create duplicate blocks. */
3584 /* ??? Need an option to either create block fragments or to create
3585 abstract origin duplicates of a source block. It really depends
3586 on what optimization has been performed. */
3589 reorder_blocks (void)
3591 tree block
= DECL_INITIAL (current_function_decl
);
3592 VEC(tree
,heap
) *block_stack
;
3594 if (block
== NULL_TREE
)
3597 block_stack
= VEC_alloc (tree
, heap
, 10);
3599 /* Reset the TREE_ASM_WRITTEN bit for all blocks. */
3600 clear_block_marks (block
);
3602 /* Prune the old trees away, so that they don't get in the way. */
3603 BLOCK_SUBBLOCKS (block
) = NULL_TREE
;
3604 BLOCK_CHAIN (block
) = NULL_TREE
;
3606 /* Recreate the block tree from the note nesting. */
3607 reorder_blocks_1 (get_insns (), block
, &block_stack
);
3608 BLOCK_SUBBLOCKS (block
) = blocks_nreverse (BLOCK_SUBBLOCKS (block
));
3610 VEC_free (tree
, heap
, block_stack
);
3613 /* Helper function for reorder_blocks. Reset TREE_ASM_WRITTEN. */
3616 clear_block_marks (tree block
)
3620 TREE_ASM_WRITTEN (block
) = 0;
3621 clear_block_marks (BLOCK_SUBBLOCKS (block
));
3622 block
= BLOCK_CHAIN (block
);
3627 reorder_blocks_1 (rtx insns
, tree current_block
, VEC(tree
,heap
) **p_block_stack
)
3631 for (insn
= insns
; insn
; insn
= NEXT_INSN (insn
))
3635 if (NOTE_KIND (insn
) == NOTE_INSN_BLOCK_BEG
)
3637 tree block
= NOTE_BLOCK (insn
);
3640 origin
= (BLOCK_FRAGMENT_ORIGIN (block
)
3641 ? BLOCK_FRAGMENT_ORIGIN (block
)
3644 /* If we have seen this block before, that means it now
3645 spans multiple address regions. Create a new fragment. */
3646 if (TREE_ASM_WRITTEN (block
))
3648 tree new_block
= copy_node (block
);
3650 BLOCK_FRAGMENT_ORIGIN (new_block
) = origin
;
3651 BLOCK_FRAGMENT_CHAIN (new_block
)
3652 = BLOCK_FRAGMENT_CHAIN (origin
);
3653 BLOCK_FRAGMENT_CHAIN (origin
) = new_block
;
3655 NOTE_BLOCK (insn
) = new_block
;
3659 BLOCK_SUBBLOCKS (block
) = 0;
3660 TREE_ASM_WRITTEN (block
) = 1;
3661 /* When there's only one block for the entire function,
3662 current_block == block and we mustn't do this, it
3663 will cause infinite recursion. */
3664 if (block
!= current_block
)
3666 if (block
!= origin
)
3667 gcc_assert (BLOCK_SUPERCONTEXT (origin
) == current_block
);
3669 BLOCK_SUPERCONTEXT (block
) = current_block
;
3670 BLOCK_CHAIN (block
) = BLOCK_SUBBLOCKS (current_block
);
3671 BLOCK_SUBBLOCKS (current_block
) = block
;
3672 current_block
= origin
;
3674 VEC_safe_push (tree
, heap
, *p_block_stack
, block
);
3676 else if (NOTE_KIND (insn
) == NOTE_INSN_BLOCK_END
)
3678 NOTE_BLOCK (insn
) = VEC_pop (tree
, *p_block_stack
);
3679 BLOCK_SUBBLOCKS (current_block
)
3680 = blocks_nreverse (BLOCK_SUBBLOCKS (current_block
));
3681 current_block
= BLOCK_SUPERCONTEXT (current_block
);
3687 /* Reverse the order of elements in the chain T of blocks,
3688 and return the new head of the chain (old last element). */
3691 blocks_nreverse (tree t
)
3693 tree prev
= 0, decl
, next
;
3694 for (decl
= t
; decl
; decl
= next
)
3696 next
= BLOCK_CHAIN (decl
);
3697 BLOCK_CHAIN (decl
) = prev
;
3703 /* Count the subblocks of the list starting with BLOCK. If VECTOR is
3704 non-NULL, list them all into VECTOR, in a depth-first preorder
3705 traversal of the block tree. Also clear TREE_ASM_WRITTEN in all
3709 all_blocks (tree block
, tree
*vector
)
3715 TREE_ASM_WRITTEN (block
) = 0;
3717 /* Record this block. */
3719 vector
[n_blocks
] = block
;
3723 /* Record the subblocks, and their subblocks... */
3724 n_blocks
+= all_blocks (BLOCK_SUBBLOCKS (block
),
3725 vector
? vector
+ n_blocks
: 0);
3726 block
= BLOCK_CHAIN (block
);
3732 /* Return a vector containing all the blocks rooted at BLOCK. The
3733 number of elements in the vector is stored in N_BLOCKS_P. The
3734 vector is dynamically allocated; it is the caller's responsibility
3735 to call `free' on the pointer returned. */
3738 get_block_vector (tree block
, int *n_blocks_p
)
3742 *n_blocks_p
= all_blocks (block
, NULL
);
3743 block_vector
= XNEWVEC (tree
, *n_blocks_p
);
3744 all_blocks (block
, block_vector
);
3746 return block_vector
;
3749 static GTY(()) int next_block_index
= 2;
3751 /* Set BLOCK_NUMBER for all the blocks in FN. */
3754 number_blocks (tree fn
)
3760 /* For SDB and XCOFF debugging output, we start numbering the blocks
3761 from 1 within each function, rather than keeping a running
3763 #if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
3764 if (write_symbols
== SDB_DEBUG
|| write_symbols
== XCOFF_DEBUG
)
3765 next_block_index
= 1;
3768 block_vector
= get_block_vector (DECL_INITIAL (fn
), &n_blocks
);
3770 /* The top-level BLOCK isn't numbered at all. */
3771 for (i
= 1; i
< n_blocks
; ++i
)
3772 /* We number the blocks from two. */
3773 BLOCK_NUMBER (block_vector
[i
]) = next_block_index
++;
3775 free (block_vector
);
3780 /* If VAR is present in a subblock of BLOCK, return the subblock. */
3783 debug_find_var_in_block_tree (tree var
, tree block
)
3787 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
3791 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= TREE_CHAIN (t
))
3793 tree ret
= debug_find_var_in_block_tree (var
, t
);
3801 /* Keep track of whether we're in a dummy function context. If we are,
3802 we don't want to invoke the set_current_function hook, because we'll
3803 get into trouble if the hook calls target_reinit () recursively or
3804 when the initial initialization is not yet complete. */
3806 static bool in_dummy_function
;
3808 /* Invoke the target hook when setting cfun. */
3811 invoke_set_current_function_hook (tree fndecl
)
3813 if (!in_dummy_function
)
3814 targetm
.set_current_function (fndecl
);
3817 /* cfun should never be set directly; use this function. */
3820 set_cfun (struct function
*new_cfun
)
3822 if (cfun
!= new_cfun
)
3825 invoke_set_current_function_hook (new_cfun
? new_cfun
->decl
: NULL_TREE
);
3829 /* Keep track of the cfun stack. */
3831 typedef struct function
*function_p
;
3833 DEF_VEC_P(function_p
);
3834 DEF_VEC_ALLOC_P(function_p
,heap
);
3836 /* Initialized with NOGC, making this poisonous to the garbage collector. */
3838 static VEC(function_p
,heap
) *cfun_stack
;
3840 /* We save the value of in_system_header here when pushing the first
3841 function on the cfun stack, and we restore it from here when
3842 popping the last function. */
3844 static bool saved_in_system_header
;
3846 /* Push the current cfun onto the stack, and set cfun to new_cfun. */
3849 push_cfun (struct function
*new_cfun
)
3852 saved_in_system_header
= in_system_header
;
3853 VEC_safe_push (function_p
, heap
, cfun_stack
, cfun
);
3855 in_system_header
= DECL_IN_SYSTEM_HEADER (new_cfun
->decl
);
3856 set_cfun (new_cfun
);
3859 /* Pop cfun from the stack. */
3864 struct function
*new_cfun
= VEC_pop (function_p
, cfun_stack
);
3865 in_system_header
= ((new_cfun
== NULL
) ? saved_in_system_header
3866 : DECL_IN_SYSTEM_HEADER (new_cfun
->decl
));
3867 set_cfun (new_cfun
);
3870 /* Return value of funcdef and increase it. */
3872 get_next_funcdef_no (void)
3874 return funcdef_no
++;
3877 /* Allocate a function structure for FNDECL and set its contents
3878 to the defaults. Set cfun to the newly-allocated object.
3879 Some of the helper functions invoked during initialization assume
3880 that cfun has already been set. Therefore, assign the new object
3881 directly into cfun and invoke the back end hook explicitly at the
3882 very end, rather than initializing a temporary and calling set_cfun
3887 allocate_struct_function (tree fndecl
)
3890 tree fntype
= fndecl
? TREE_TYPE (fndecl
) : NULL_TREE
;
3892 cfun
= ggc_alloc_cleared (sizeof (struct function
));
3894 cfun
->stack_alignment_needed
= STACK_BOUNDARY
;
3895 cfun
->preferred_stack_boundary
= STACK_BOUNDARY
;
3897 current_function_funcdef_no
= get_next_funcdef_no ();
3899 cfun
->function_frequency
= FUNCTION_FREQUENCY_NORMAL
;
3901 init_eh_for_function ();
3903 lang_hooks
.function
.init (cfun
);
3904 if (init_machine_status
)
3905 cfun
->machine
= (*init_machine_status
) ();
3909 DECL_STRUCT_FUNCTION (fndecl
) = cfun
;
3910 cfun
->decl
= fndecl
;
3912 result
= DECL_RESULT (fndecl
);
3913 if (aggregate_value_p (result
, fndecl
))
3915 #ifdef PCC_STATIC_STRUCT_RETURN
3916 current_function_returns_pcc_struct
= 1;
3918 current_function_returns_struct
= 1;
3921 current_function_stdarg
3923 && TYPE_ARG_TYPES (fntype
) != 0
3924 && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype
)))
3925 != void_type_node
));
3927 /* Assume all registers in stdarg functions need to be saved. */
3928 cfun
->va_list_gpr_size
= VA_LIST_MAX_GPR_SIZE
;
3929 cfun
->va_list_fpr_size
= VA_LIST_MAX_FPR_SIZE
;
3932 invoke_set_current_function_hook (fndecl
);
3935 /* This is like allocate_struct_function, but pushes a new cfun for FNDECL
3936 instead of just setting it. */
3939 push_struct_function (tree fndecl
)
3942 saved_in_system_header
= in_system_header
;
3943 VEC_safe_push (function_p
, heap
, cfun_stack
, cfun
);
3945 in_system_header
= DECL_IN_SYSTEM_HEADER (fndecl
);
3946 allocate_struct_function (fndecl
);
3949 /* Reset cfun, and other non-struct-function variables to defaults as
3950 appropriate for emitting rtl at the start of a function. */
3953 prepare_function_start (void)
3956 init_varasm_status (cfun
);
3959 cse_not_expected
= ! optimize
;
3961 /* Caller save not needed yet. */
3962 caller_save_needed
= 0;
3964 /* We haven't done register allocation yet. */
3967 /* Indicate that we have not instantiated virtual registers yet. */
3968 virtuals_instantiated
= 0;
3970 /* Indicate that we want CONCATs now. */
3971 generating_concat_p
= 1;
3973 /* Indicate we have no need of a frame pointer yet. */
3974 frame_pointer_needed
= 0;
3977 /* Initialize the rtl expansion mechanism so that we can do simple things
3978 like generate sequences. This is used to provide a context during global
3979 initialization of some passes. You must call expand_dummy_function_end
3980 to exit this context. */
3983 init_dummy_function_start (void)
3985 gcc_assert (!in_dummy_function
);
3986 in_dummy_function
= true;
3987 push_struct_function (NULL_TREE
);
3988 prepare_function_start ();
3991 /* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node)
3992 and initialize static variables for generating RTL for the statements
3996 init_function_start (tree subr
)
3998 if (subr
&& DECL_STRUCT_FUNCTION (subr
))
3999 set_cfun (DECL_STRUCT_FUNCTION (subr
));
4001 allocate_struct_function (subr
);
4002 prepare_function_start ();
4004 /* Warn if this value is an aggregate type,
4005 regardless of which calling convention we are using for it. */
4006 if (AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr
))))
4007 warning (OPT_Waggregate_return
, "function returns an aggregate");
4010 /* Make sure all values used by the optimization passes have sane
4013 init_function_for_compilation (void)
4017 /* No prologue/epilogue insns yet. Make sure that these vectors are
4019 gcc_assert (VEC_length (int, prologue
) == 0);
4020 gcc_assert (VEC_length (int, epilogue
) == 0);
4021 gcc_assert (VEC_length (int, sibcall_epilogue
) == 0);
4025 struct tree_opt_pass pass_init_function
=
4029 init_function_for_compilation
, /* execute */
4032 0, /* static_pass_number */
4034 0, /* properties_required */
4035 0, /* properties_provided */
4036 0, /* properties_destroyed */
4037 0, /* todo_flags_start */
4038 0, /* todo_flags_finish */
4044 expand_main_function (void)
4046 #if (defined(INVOKE__main) \
4047 || (!defined(HAS_INIT_SECTION) \
4048 && !defined(INIT_SECTION_ASM_OP) \
4049 && !defined(INIT_ARRAY_SECTION_ASM_OP)))
4050 emit_library_call (init_one_libfunc (NAME__MAIN
), LCT_NORMAL
, VOIDmode
, 0);
4054 /* Expand code to initialize the stack_protect_guard. This is invoked at
4055 the beginning of a function to be protected. */
4057 #ifndef HAVE_stack_protect_set
4058 # define HAVE_stack_protect_set 0
4059 # define gen_stack_protect_set(x,y) (gcc_unreachable (), NULL_RTX)
4063 stack_protect_prologue (void)
4065 tree guard_decl
= targetm
.stack_protect_guard ();
4068 /* Avoid expand_expr here, because we don't want guard_decl pulled
4069 into registers unless absolutely necessary. And we know that
4070 cfun->stack_protect_guard is a local stack slot, so this skips
4072 x
= validize_mem (DECL_RTL (cfun
->stack_protect_guard
));
4073 y
= validize_mem (DECL_RTL (guard_decl
));
4075 /* Allow the target to copy from Y to X without leaking Y into a
4077 if (HAVE_stack_protect_set
)
4079 rtx insn
= gen_stack_protect_set (x
, y
);
4087 /* Otherwise do a straight move. */
4088 emit_move_insn (x
, y
);
4091 /* Expand code to verify the stack_protect_guard. This is invoked at
4092 the end of a function to be protected. */
4094 #ifndef HAVE_stack_protect_test
4095 # define HAVE_stack_protect_test 0
4096 # define gen_stack_protect_test(x, y, z) (gcc_unreachable (), NULL_RTX)
4100 stack_protect_epilogue (void)
4102 tree guard_decl
= targetm
.stack_protect_guard ();
4103 rtx label
= gen_label_rtx ();
4106 /* Avoid expand_expr here, because we don't want guard_decl pulled
4107 into registers unless absolutely necessary. And we know that
4108 cfun->stack_protect_guard is a local stack slot, so this skips
4110 x
= validize_mem (DECL_RTL (cfun
->stack_protect_guard
));
4111 y
= validize_mem (DECL_RTL (guard_decl
));
4113 /* Allow the target to compare Y with X without leaking either into
4115 switch (HAVE_stack_protect_test
!= 0)
4118 tmp
= gen_stack_protect_test (x
, y
, label
);
4127 emit_cmp_and_jump_insns (x
, y
, EQ
, NULL_RTX
, ptr_mode
, 1, label
);
4131 /* The noreturn predictor has been moved to the tree level. The rtl-level
4132 predictors estimate this branch about 20%, which isn't enough to get
4133 things moved out of line. Since this is the only extant case of adding
4134 a noreturn function at the rtl level, it doesn't seem worth doing ought
4135 except adding the prediction by hand. */
4136 tmp
= get_last_insn ();
4138 predict_insn_def (tmp
, PRED_NORETURN
, TAKEN
);
4140 expand_expr_stmt (targetm
.stack_protect_fail ());
4144 /* Start the RTL for a new function, and set variables used for
4146 SUBR is the FUNCTION_DECL node.
4147 PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with
4148 the function's parameters, which must be run at any return statement. */
4151 expand_function_start (tree subr
)
4153 /* Make sure volatile mem refs aren't considered
4154 valid operands of arithmetic insns. */
4155 init_recog_no_volatile ();
4157 current_function_profile
4159 && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr
));
4161 current_function_limit_stack
4162 = (stack_limit_rtx
!= NULL_RTX
&& ! DECL_NO_LIMIT_STACK (subr
));
4164 /* Make the label for return statements to jump to. Do not special
4165 case machines with special return instructions -- they will be
4166 handled later during jump, ifcvt, or epilogue creation. */
4167 return_label
= gen_label_rtx ();
4169 /* Initialize rtx used to return the value. */
4170 /* Do this before assign_parms so that we copy the struct value address
4171 before any library calls that assign parms might generate. */
4173 /* Decide whether to return the value in memory or in a register. */
4174 if (aggregate_value_p (DECL_RESULT (subr
), subr
))
4176 /* Returning something that won't go in a register. */
4177 rtx value_address
= 0;
4179 #ifdef PCC_STATIC_STRUCT_RETURN
4180 if (current_function_returns_pcc_struct
)
4182 int size
= int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr
)));
4183 value_address
= assemble_static_space (size
);
4188 rtx sv
= targetm
.calls
.struct_value_rtx (TREE_TYPE (subr
), 2);
4189 /* Expect to be passed the address of a place to store the value.
4190 If it is passed as an argument, assign_parms will take care of
4194 value_address
= gen_reg_rtx (Pmode
);
4195 emit_move_insn (value_address
, sv
);
4200 rtx x
= value_address
;
4201 if (!DECL_BY_REFERENCE (DECL_RESULT (subr
)))
4203 x
= gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr
)), x
);
4204 set_mem_attributes (x
, DECL_RESULT (subr
), 1);
4206 SET_DECL_RTL (DECL_RESULT (subr
), x
);
4209 else if (DECL_MODE (DECL_RESULT (subr
)) == VOIDmode
)
4210 /* If return mode is void, this decl rtl should not be used. */
4211 SET_DECL_RTL (DECL_RESULT (subr
), NULL_RTX
);
4214 /* Compute the return values into a pseudo reg, which we will copy
4215 into the true return register after the cleanups are done. */
4216 tree return_type
= TREE_TYPE (DECL_RESULT (subr
));
4217 if (TYPE_MODE (return_type
) != BLKmode
4218 && targetm
.calls
.return_in_msb (return_type
))
4219 /* expand_function_end will insert the appropriate padding in
4220 this case. Use the return value's natural (unpadded) mode
4221 within the function proper. */
4222 SET_DECL_RTL (DECL_RESULT (subr
),
4223 gen_reg_rtx (TYPE_MODE (return_type
)));
4226 /* In order to figure out what mode to use for the pseudo, we
4227 figure out what the mode of the eventual return register will
4228 actually be, and use that. */
4229 rtx hard_reg
= hard_function_value (return_type
, subr
, 0, 1);
4231 /* Structures that are returned in registers are not
4232 aggregate_value_p, so we may see a PARALLEL or a REG. */
4233 if (REG_P (hard_reg
))
4234 SET_DECL_RTL (DECL_RESULT (subr
),
4235 gen_reg_rtx (GET_MODE (hard_reg
)));
4238 gcc_assert (GET_CODE (hard_reg
) == PARALLEL
);
4239 SET_DECL_RTL (DECL_RESULT (subr
), gen_group_rtx (hard_reg
));
4243 /* Set DECL_REGISTER flag so that expand_function_end will copy the
4244 result to the real return register(s). */
4245 DECL_REGISTER (DECL_RESULT (subr
)) = 1;
4248 /* Initialize rtx for parameters and local variables.
4249 In some cases this requires emitting insns. */
4250 assign_parms (subr
);
4252 /* If function gets a static chain arg, store it. */
4253 if (cfun
->static_chain_decl
)
4255 tree parm
= cfun
->static_chain_decl
;
4256 rtx local
= gen_reg_rtx (Pmode
);
4258 set_decl_incoming_rtl (parm
, static_chain_incoming_rtx
);
4259 SET_DECL_RTL (parm
, local
);
4260 mark_reg_pointer (local
, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm
))));
4262 emit_move_insn (local
, static_chain_incoming_rtx
);
4265 /* If the function receives a non-local goto, then store the
4266 bits we need to restore the frame pointer. */
4267 if (cfun
->nonlocal_goto_save_area
)
4272 /* ??? We need to do this save early. Unfortunately here is
4273 before the frame variable gets declared. Help out... */
4274 expand_var (TREE_OPERAND (cfun
->nonlocal_goto_save_area
, 0));
4276 t_save
= build4 (ARRAY_REF
, ptr_type_node
,
4277 cfun
->nonlocal_goto_save_area
,
4278 integer_zero_node
, NULL_TREE
, NULL_TREE
);
4279 r_save
= expand_expr (t_save
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
4280 r_save
= convert_memory_address (Pmode
, r_save
);
4282 emit_move_insn (r_save
, virtual_stack_vars_rtx
);
4283 update_nonlocal_goto_save_area ();
4286 /* The following was moved from init_function_start.
4287 The move is supposed to make sdb output more accurate. */
4288 /* Indicate the beginning of the function body,
4289 as opposed to parm setup. */
4290 emit_note (NOTE_INSN_FUNCTION_BEG
);
4292 gcc_assert (NOTE_P (get_last_insn ()));
4294 parm_birth_insn
= get_last_insn ();
4296 if (current_function_profile
)
4299 PROFILE_HOOK (current_function_funcdef_no
);
4303 /* After the display initializations is where the stack checking
4305 if(flag_stack_check
)
4306 stack_check_probe_note
= emit_note (NOTE_INSN_DELETED
);
4308 /* Make sure there is a line number after the function entry setup code. */
4309 force_next_line_note ();
4312 /* Undo the effects of init_dummy_function_start. */
4314 expand_dummy_function_end (void)
4316 gcc_assert (in_dummy_function
);
4318 /* End any sequences that failed to be closed due to syntax errors. */
4319 while (in_sequence_p ())
4322 /* Outside function body, can't compute type's actual size
4323 until next function's body starts. */
4325 free_after_parsing (cfun
);
4326 free_after_compilation (cfun
);
4328 in_dummy_function
= false;
4331 /* Call DOIT for each hard register used as a return value from
4332 the current function. */
4335 diddle_return_value (void (*doit
) (rtx
, void *), void *arg
)
4337 rtx outgoing
= current_function_return_rtx
;
4342 if (REG_P (outgoing
))
4343 (*doit
) (outgoing
, arg
);
4344 else if (GET_CODE (outgoing
) == PARALLEL
)
4348 for (i
= 0; i
< XVECLEN (outgoing
, 0); i
++)
4350 rtx x
= XEXP (XVECEXP (outgoing
, 0, i
), 0);
4352 if (REG_P (x
) && REGNO (x
) < FIRST_PSEUDO_REGISTER
)
4359 do_clobber_return_reg (rtx reg
, void *arg ATTRIBUTE_UNUSED
)
4361 emit_insn (gen_rtx_CLOBBER (VOIDmode
, reg
));
4365 clobber_return_register (void)
4367 diddle_return_value (do_clobber_return_reg
, NULL
);
4369 /* In case we do use pseudo to return value, clobber it too. */
4370 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl
)))
4372 tree decl_result
= DECL_RESULT (current_function_decl
);
4373 rtx decl_rtl
= DECL_RTL (decl_result
);
4374 if (REG_P (decl_rtl
) && REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
)
4376 do_clobber_return_reg (decl_rtl
, NULL
);
4382 do_use_return_reg (rtx reg
, void *arg ATTRIBUTE_UNUSED
)
4384 emit_insn (gen_rtx_USE (VOIDmode
, reg
));
4388 use_return_register (void)
4390 diddle_return_value (do_use_return_reg
, NULL
);
4393 /* Possibly warn about unused parameters. */
4395 do_warn_unused_parameter (tree fn
)
4399 for (decl
= DECL_ARGUMENTS (fn
);
4400 decl
; decl
= TREE_CHAIN (decl
))
4401 if (!TREE_USED (decl
) && TREE_CODE (decl
) == PARM_DECL
4402 && DECL_NAME (decl
) && !DECL_ARTIFICIAL (decl
)
4403 && !TREE_NO_WARNING (decl
))
4404 warning (OPT_Wunused_parameter
, "unused parameter %q+D", decl
);
4407 static GTY(()) rtx initial_trampoline
;
4409 /* Generate RTL for the end of the current function. */
4412 expand_function_end (void)
4416 /* If arg_pointer_save_area was referenced only from a nested
4417 function, we will not have initialized it yet. Do that now. */
4418 if (arg_pointer_save_area
&& ! cfun
->arg_pointer_save_area_init
)
4419 get_arg_pointer_save_area (cfun
);
4421 /* If we are doing stack checking and this function makes calls,
4422 do a stack probe at the start of the function to ensure we have enough
4423 space for another stack frame. */
4424 if (flag_stack_check
&& ! STACK_CHECK_BUILTIN
)
4428 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
4432 probe_stack_range (STACK_CHECK_PROTECT
,
4433 GEN_INT (STACK_CHECK_MAX_FRAME_SIZE
));
4436 emit_insn_before (seq
, stack_check_probe_note
);
4441 /* End any sequences that failed to be closed due to syntax errors. */
4442 while (in_sequence_p ())
4445 clear_pending_stack_adjust ();
4446 do_pending_stack_adjust ();
4448 /* Output a linenumber for the end of the function.
4449 SDB depends on this. */
4450 force_next_line_note ();
4451 set_curr_insn_source_location (input_location
);
4453 /* Before the return label (if any), clobber the return
4454 registers so that they are not propagated live to the rest of
4455 the function. This can only happen with functions that drop
4456 through; if there had been a return statement, there would
4457 have either been a return rtx, or a jump to the return label.
4459 We delay actual code generation after the current_function_value_rtx
4461 clobber_after
= get_last_insn ();
4463 /* Output the label for the actual return from the function. */
4464 emit_label (return_label
);
4466 if (USING_SJLJ_EXCEPTIONS
)
4468 /* Let except.c know where it should emit the call to unregister
4469 the function context for sjlj exceptions. */
4470 if (flag_exceptions
)
4471 sjlj_emit_function_exit_after (get_last_insn ());
4475 /* We want to ensure that instructions that may trap are not
4476 moved into the epilogue by scheduling, because we don't
4477 always emit unwind information for the epilogue. */
4478 if (flag_non_call_exceptions
)
4479 emit_insn (gen_blockage ());
4482 /* If this is an implementation of throw, do what's necessary to
4483 communicate between __builtin_eh_return and the epilogue. */
4484 expand_eh_return ();
4486 /* If scalar return value was computed in a pseudo-reg, or was a named
4487 return value that got dumped to the stack, copy that to the hard
4489 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl
)))
4491 tree decl_result
= DECL_RESULT (current_function_decl
);
4492 rtx decl_rtl
= DECL_RTL (decl_result
);
4494 if (REG_P (decl_rtl
)
4495 ? REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
4496 : DECL_REGISTER (decl_result
))
4498 rtx real_decl_rtl
= current_function_return_rtx
;
4500 /* This should be set in assign_parms. */
4501 gcc_assert (REG_FUNCTION_VALUE_P (real_decl_rtl
));
4503 /* If this is a BLKmode structure being returned in registers,
4504 then use the mode computed in expand_return. Note that if
4505 decl_rtl is memory, then its mode may have been changed,
4506 but that current_function_return_rtx has not. */
4507 if (GET_MODE (real_decl_rtl
) == BLKmode
)
4508 PUT_MODE (real_decl_rtl
, GET_MODE (decl_rtl
));
4510 /* If a non-BLKmode return value should be padded at the least
4511 significant end of the register, shift it left by the appropriate
4512 amount. BLKmode results are handled using the group load/store
4514 if (TYPE_MODE (TREE_TYPE (decl_result
)) != BLKmode
4515 && targetm
.calls
.return_in_msb (TREE_TYPE (decl_result
)))
4517 emit_move_insn (gen_rtx_REG (GET_MODE (decl_rtl
),
4518 REGNO (real_decl_rtl
)),
4520 shift_return_value (GET_MODE (decl_rtl
), true, real_decl_rtl
);
4522 /* If a named return value dumped decl_return to memory, then
4523 we may need to re-do the PROMOTE_MODE signed/unsigned
4525 else if (GET_MODE (real_decl_rtl
) != GET_MODE (decl_rtl
))
4527 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (decl_result
));
4529 if (targetm
.calls
.promote_function_return (TREE_TYPE (current_function_decl
)))
4530 promote_mode (TREE_TYPE (decl_result
), GET_MODE (decl_rtl
),
4533 convert_move (real_decl_rtl
, decl_rtl
, unsignedp
);
4535 else if (GET_CODE (real_decl_rtl
) == PARALLEL
)
4537 /* If expand_function_start has created a PARALLEL for decl_rtl,
4538 move the result to the real return registers. Otherwise, do
4539 a group load from decl_rtl for a named return. */
4540 if (GET_CODE (decl_rtl
) == PARALLEL
)
4541 emit_group_move (real_decl_rtl
, decl_rtl
);
4543 emit_group_load (real_decl_rtl
, decl_rtl
,
4544 TREE_TYPE (decl_result
),
4545 int_size_in_bytes (TREE_TYPE (decl_result
)));
4547 /* In the case of complex integer modes smaller than a word, we'll
4548 need to generate some non-trivial bitfield insertions. Do that
4549 on a pseudo and not the hard register. */
4550 else if (GET_CODE (decl_rtl
) == CONCAT
4551 && GET_MODE_CLASS (GET_MODE (decl_rtl
)) == MODE_COMPLEX_INT
4552 && GET_MODE_BITSIZE (GET_MODE (decl_rtl
)) <= BITS_PER_WORD
)
4554 int old_generating_concat_p
;
4557 old_generating_concat_p
= generating_concat_p
;
4558 generating_concat_p
= 0;
4559 tmp
= gen_reg_rtx (GET_MODE (decl_rtl
));
4560 generating_concat_p
= old_generating_concat_p
;
4562 emit_move_insn (tmp
, decl_rtl
);
4563 emit_move_insn (real_decl_rtl
, tmp
);
4566 emit_move_insn (real_decl_rtl
, decl_rtl
);
4570 /* If returning a structure, arrange to return the address of the value
4571 in a place where debuggers expect to find it.
4573 If returning a structure PCC style,
4574 the caller also depends on this value.
4575 And current_function_returns_pcc_struct is not necessarily set. */
4576 if (current_function_returns_struct
4577 || current_function_returns_pcc_struct
)
4579 rtx value_address
= DECL_RTL (DECL_RESULT (current_function_decl
));
4580 tree type
= TREE_TYPE (DECL_RESULT (current_function_decl
));
4583 if (DECL_BY_REFERENCE (DECL_RESULT (current_function_decl
)))
4584 type
= TREE_TYPE (type
);
4586 value_address
= XEXP (value_address
, 0);
4588 outgoing
= targetm
.calls
.function_value (build_pointer_type (type
),
4589 current_function_decl
, true);
4591 /* Mark this as a function return value so integrate will delete the
4592 assignment and USE below when inlining this function. */
4593 REG_FUNCTION_VALUE_P (outgoing
) = 1;
4595 /* The address may be ptr_mode and OUTGOING may be Pmode. */
4596 value_address
= convert_memory_address (GET_MODE (outgoing
),
4599 emit_move_insn (outgoing
, value_address
);
4601 /* Show return register used to hold result (in this case the address
4603 current_function_return_rtx
= outgoing
;
4606 /* Emit the actual code to clobber return register. */
4611 clobber_return_register ();
4612 expand_naked_return ();
4616 emit_insn_after (seq
, clobber_after
);
4619 /* Output the label for the naked return from the function. */
4620 emit_label (naked_return_label
);
4622 /* @@@ This is a kludge. We want to ensure that instructions that
4623 may trap are not moved into the epilogue by scheduling, because
4624 we don't always emit unwind information for the epilogue. */
4625 if (! USING_SJLJ_EXCEPTIONS
&& flag_non_call_exceptions
)
4626 emit_insn (gen_blockage ());
4628 /* If stack protection is enabled for this function, check the guard. */
4629 if (cfun
->stack_protect_guard
)
4630 stack_protect_epilogue ();
4632 /* If we had calls to alloca, and this machine needs
4633 an accurate stack pointer to exit the function,
4634 insert some code to save and restore the stack pointer. */
4635 if (! EXIT_IGNORE_STACK
4636 && current_function_calls_alloca
)
4640 emit_stack_save (SAVE_FUNCTION
, &tem
, parm_birth_insn
);
4641 emit_stack_restore (SAVE_FUNCTION
, tem
, NULL_RTX
);
4644 /* ??? This should no longer be necessary since stupid is no longer with
4645 us, but there are some parts of the compiler (eg reload_combine, and
4646 sh mach_dep_reorg) that still try and compute their own lifetime info
4647 instead of using the general framework. */
4648 use_return_register ();
4652 get_arg_pointer_save_area (struct function
*f
)
4654 rtx ret
= f
->x_arg_pointer_save_area
;
4658 ret
= assign_stack_local_1 (Pmode
, GET_MODE_SIZE (Pmode
), 0, f
);
4659 f
->x_arg_pointer_save_area
= ret
;
4662 if (f
== cfun
&& ! f
->arg_pointer_save_area_init
)
4666 /* Save the arg pointer at the beginning of the function. The
4667 generated stack slot may not be a valid memory address, so we
4668 have to check it and fix it if necessary. */
4670 emit_move_insn (validize_mem (ret
), virtual_incoming_args_rtx
);
4674 push_topmost_sequence ();
4675 emit_insn_after (seq
, entry_of_function ());
4676 pop_topmost_sequence ();
4682 /* Extend a vector that records the INSN_UIDs of INSNS
4683 (a list of one or more insns). */
4686 record_insns (rtx insns
, VEC(int,heap
) **vecp
)
4690 for (tmp
= insns
; tmp
!= NULL_RTX
; tmp
= NEXT_INSN (tmp
))
4691 VEC_safe_push (int, heap
, *vecp
, INSN_UID (tmp
));
4694 /* Set the locator of the insn chain starting at INSN to LOC. */
4696 set_insn_locators (rtx insn
, int loc
)
4698 while (insn
!= NULL_RTX
)
4701 INSN_LOCATOR (insn
) = loc
;
4702 insn
= NEXT_INSN (insn
);
4706 /* Determine how many INSN_UIDs in VEC are part of INSN. Because we can
4707 be running after reorg, SEQUENCE rtl is possible. */
4710 contains (const_rtx insn
, VEC(int,heap
) **vec
)
4714 if (NONJUMP_INSN_P (insn
)
4715 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
4718 for (i
= XVECLEN (PATTERN (insn
), 0) - 1; i
>= 0; i
--)
4719 for (j
= VEC_length (int, *vec
) - 1; j
>= 0; --j
)
4720 if (INSN_UID (XVECEXP (PATTERN (insn
), 0, i
))
4721 == VEC_index (int, *vec
, j
))
4727 for (j
= VEC_length (int, *vec
) - 1; j
>= 0; --j
)
4728 if (INSN_UID (insn
) == VEC_index (int, *vec
, j
))
4735 prologue_epilogue_contains (const_rtx insn
)
4737 if (contains (insn
, &prologue
))
4739 if (contains (insn
, &epilogue
))
4745 sibcall_epilogue_contains (const_rtx insn
)
4747 if (sibcall_epilogue
)
4748 return contains (insn
, &sibcall_epilogue
);
4753 /* Insert gen_return at the end of block BB. This also means updating
4754 block_for_insn appropriately. */
4757 emit_return_into_block (basic_block bb
)
4759 emit_jump_insn_after (gen_return (), BB_END (bb
));
4761 #endif /* HAVE_return */
4763 #if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX)
4765 /* These functions convert the epilogue into a variant that does not
4766 modify the stack pointer. This is used in cases where a function
4767 returns an object whose size is not known until it is computed.
4768 The called function leaves the object on the stack, leaves the
4769 stack depressed, and returns a pointer to the object.
4771 What we need to do is track all modifications and references to the
4772 stack pointer, deleting the modifications and changing the
4773 references to point to the location the stack pointer would have
4774 pointed to had the modifications taken place.
4776 These functions need to be portable so we need to make as few
4777 assumptions about the epilogue as we can. However, the epilogue
4778 basically contains three things: instructions to reset the stack
4779 pointer, instructions to reload registers, possibly including the
4780 frame pointer, and an instruction to return to the caller.
4782 We must be sure of what a relevant epilogue insn is doing. We also
4783 make no attempt to validate the insns we make since if they are
4784 invalid, we probably can't do anything valid. The intent is that
4785 these routines get "smarter" as more and more machines start to use
4786 them and they try operating on different epilogues.
4788 We use the following structure to track what the part of the
4789 epilogue that we've already processed has done. We keep two copies
4790 of the SP equivalence, one for use during the insn we are
4791 processing and one for use in the next insn. The difference is
4792 because one part of a PARALLEL may adjust SP and the other may use
4797 rtx sp_equiv_reg
; /* REG that SP is set from, perhaps SP. */
4798 HOST_WIDE_INT sp_offset
; /* Offset from SP_EQUIV_REG of present SP. */
4799 rtx new_sp_equiv_reg
; /* REG to be used at end of insn. */
4800 HOST_WIDE_INT new_sp_offset
; /* Offset to be used at end of insn. */
4801 rtx equiv_reg_src
; /* If nonzero, the value that SP_EQUIV_REG
4802 should be set to once we no longer need
4804 rtx const_equiv
[FIRST_PSEUDO_REGISTER
]; /* Any known constant equivalences
4808 static void handle_epilogue_set (rtx
, struct epi_info
*);
4809 static void update_epilogue_consts (rtx
, const_rtx
, void *);
4810 static void emit_equiv_load (struct epi_info
*);
4812 /* Modify INSN, a list of one or more insns that is part of the epilogue, to
4813 no modifications to the stack pointer. Return the new list of insns. */
4816 keep_stack_depressed (rtx insns
)
4819 struct epi_info info
;
4822 /* If the epilogue is just a single instruction, it must be OK as is. */
4823 if (NEXT_INSN (insns
) == NULL_RTX
)
4826 /* Otherwise, start a sequence, initialize the information we have, and
4827 process all the insns we were given. */
4830 info
.sp_equiv_reg
= stack_pointer_rtx
;
4832 info
.equiv_reg_src
= 0;
4834 for (j
= 0; j
< FIRST_PSEUDO_REGISTER
; j
++)
4835 info
.const_equiv
[j
] = 0;
4839 while (insn
!= NULL_RTX
)
4841 next
= NEXT_INSN (insn
);
4850 /* If this insn references the register that SP is equivalent to and
4851 we have a pending load to that register, we must force out the load
4852 first and then indicate we no longer know what SP's equivalent is. */
4853 if (info
.equiv_reg_src
!= 0
4854 && reg_referenced_p (info
.sp_equiv_reg
, PATTERN (insn
)))
4856 emit_equiv_load (&info
);
4857 info
.sp_equiv_reg
= 0;
4860 info
.new_sp_equiv_reg
= info
.sp_equiv_reg
;
4861 info
.new_sp_offset
= info
.sp_offset
;
4863 /* If this is a (RETURN) and the return address is on the stack,
4864 update the address and change to an indirect jump. */
4865 if (GET_CODE (PATTERN (insn
)) == RETURN
4866 || (GET_CODE (PATTERN (insn
)) == PARALLEL
4867 && GET_CODE (XVECEXP (PATTERN (insn
), 0, 0)) == RETURN
))
4869 rtx retaddr
= INCOMING_RETURN_ADDR_RTX
;
4871 HOST_WIDE_INT offset
= 0;
4872 rtx jump_insn
, jump_set
;
4874 /* If the return address is in a register, we can emit the insn
4875 unchanged. Otherwise, it must be a MEM and we see what the
4876 base register and offset are. In any case, we have to emit any
4877 pending load to the equivalent reg of SP, if any. */
4878 if (REG_P (retaddr
))
4880 emit_equiv_load (&info
);
4888 gcc_assert (MEM_P (retaddr
));
4890 ret_ptr
= XEXP (retaddr
, 0);
4892 if (REG_P (ret_ptr
))
4894 base
= gen_rtx_REG (Pmode
, REGNO (ret_ptr
));
4899 gcc_assert (GET_CODE (ret_ptr
) == PLUS
4900 && REG_P (XEXP (ret_ptr
, 0))
4901 && GET_CODE (XEXP (ret_ptr
, 1)) == CONST_INT
);
4902 base
= gen_rtx_REG (Pmode
, REGNO (XEXP (ret_ptr
, 0)));
4903 offset
= INTVAL (XEXP (ret_ptr
, 1));
4907 /* If the base of the location containing the return pointer
4908 is SP, we must update it with the replacement address. Otherwise,
4909 just build the necessary MEM. */
4910 retaddr
= plus_constant (base
, offset
);
4911 if (base
== stack_pointer_rtx
)
4912 retaddr
= simplify_replace_rtx (retaddr
, stack_pointer_rtx
,
4913 plus_constant (info
.sp_equiv_reg
,
4916 retaddr
= gen_rtx_MEM (Pmode
, retaddr
);
4917 MEM_NOTRAP_P (retaddr
) = 1;
4919 /* If there is a pending load to the equivalent register for SP
4920 and we reference that register, we must load our address into
4921 a scratch register and then do that load. */
4922 if (info
.equiv_reg_src
4923 && reg_overlap_mentioned_p (info
.equiv_reg_src
, retaddr
))
4928 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
4929 if (HARD_REGNO_MODE_OK (regno
, Pmode
)
4930 && !fixed_regs
[regno
]
4931 && TEST_HARD_REG_BIT (regs_invalidated_by_call
, regno
)
4933 (DF_LR_IN (EXIT_BLOCK_PTR
), regno
)
4934 && !refers_to_regno_p (regno
,
4935 end_hard_regno (Pmode
, regno
),
4936 info
.equiv_reg_src
, NULL
)
4937 && info
.const_equiv
[regno
] == 0)
4940 gcc_assert (regno
< FIRST_PSEUDO_REGISTER
);
4942 reg
= gen_rtx_REG (Pmode
, regno
);
4943 emit_move_insn (reg
, retaddr
);
4947 emit_equiv_load (&info
);
4948 jump_insn
= emit_jump_insn (gen_indirect_jump (retaddr
));
4950 /* Show the SET in the above insn is a RETURN. */
4951 jump_set
= single_set (jump_insn
);
4952 gcc_assert (jump_set
);
4953 SET_IS_RETURN_P (jump_set
) = 1;
4956 /* If SP is not mentioned in the pattern and its equivalent register, if
4957 any, is not modified, just emit it. Otherwise, if neither is set,
4958 replace the reference to SP and emit the insn. If none of those are
4959 true, handle each SET individually. */
4960 else if (!reg_mentioned_p (stack_pointer_rtx
, PATTERN (insn
))
4961 && (info
.sp_equiv_reg
== stack_pointer_rtx
4962 || !reg_set_p (info
.sp_equiv_reg
, insn
)))
4964 else if (! reg_set_p (stack_pointer_rtx
, insn
)
4965 && (info
.sp_equiv_reg
== stack_pointer_rtx
4966 || !reg_set_p (info
.sp_equiv_reg
, insn
)))
4970 changed
= validate_replace_rtx (stack_pointer_rtx
,
4971 plus_constant (info
.sp_equiv_reg
,
4974 gcc_assert (changed
);
4978 else if (GET_CODE (PATTERN (insn
)) == SET
)
4979 handle_epilogue_set (PATTERN (insn
), &info
);
4980 else if (GET_CODE (PATTERN (insn
)) == PARALLEL
)
4982 for (j
= 0; j
< XVECLEN (PATTERN (insn
), 0); j
++)
4983 if (GET_CODE (XVECEXP (PATTERN (insn
), 0, j
)) == SET
)
4984 handle_epilogue_set (XVECEXP (PATTERN (insn
), 0, j
), &info
);
4989 info
.sp_equiv_reg
= info
.new_sp_equiv_reg
;
4990 info
.sp_offset
= info
.new_sp_offset
;
4992 /* Now update any constants this insn sets. */
4993 note_stores (PATTERN (insn
), update_epilogue_consts
, &info
);
4997 insns
= get_insns ();
5002 /* SET is a SET from an insn in the epilogue. P is a pointer to the epi_info
5003 structure that contains information about what we've seen so far. We
5004 process this SET by either updating that data or by emitting one or
5008 handle_epilogue_set (rtx set
, struct epi_info
*p
)
5010 /* First handle the case where we are setting SP. Record what it is being
5011 set from, which we must be able to determine */
5012 if (reg_set_p (stack_pointer_rtx
, set
))
5014 gcc_assert (SET_DEST (set
) == stack_pointer_rtx
);
5016 if (GET_CODE (SET_SRC (set
)) == PLUS
)
5018 p
->new_sp_equiv_reg
= XEXP (SET_SRC (set
), 0);
5019 if (GET_CODE (XEXP (SET_SRC (set
), 1)) == CONST_INT
)
5020 p
->new_sp_offset
= INTVAL (XEXP (SET_SRC (set
), 1));
5023 gcc_assert (REG_P (XEXP (SET_SRC (set
), 1))
5024 && (REGNO (XEXP (SET_SRC (set
), 1))
5025 < FIRST_PSEUDO_REGISTER
)
5026 && p
->const_equiv
[REGNO (XEXP (SET_SRC (set
), 1))]);
5028 = INTVAL (p
->const_equiv
[REGNO (XEXP (SET_SRC (set
), 1))]);
5032 p
->new_sp_equiv_reg
= SET_SRC (set
), p
->new_sp_offset
= 0;
5034 /* If we are adjusting SP, we adjust from the old data. */
5035 if (p
->new_sp_equiv_reg
== stack_pointer_rtx
)
5037 p
->new_sp_equiv_reg
= p
->sp_equiv_reg
;
5038 p
->new_sp_offset
+= p
->sp_offset
;
5041 gcc_assert (p
->new_sp_equiv_reg
&& REG_P (p
->new_sp_equiv_reg
));
5046 /* Next handle the case where we are setting SP's equivalent
5047 register. We must not already have a value to set it to. We
5048 could update, but there seems little point in handling that case.
5049 Note that we have to allow for the case where we are setting the
5050 register set in the previous part of a PARALLEL inside a single
5051 insn. But use the old offset for any updates within this insn.
5052 We must allow for the case where the register is being set in a
5053 different (usually wider) mode than Pmode). */
5054 else if (p
->new_sp_equiv_reg
!= 0 && reg_set_p (p
->new_sp_equiv_reg
, set
))
5056 gcc_assert (!p
->equiv_reg_src
5057 && REG_P (p
->new_sp_equiv_reg
)
5058 && REG_P (SET_DEST (set
))
5059 && (GET_MODE_BITSIZE (GET_MODE (SET_DEST (set
)))
5061 && REGNO (p
->new_sp_equiv_reg
) == REGNO (SET_DEST (set
)));
5063 = simplify_replace_rtx (SET_SRC (set
), stack_pointer_rtx
,
5064 plus_constant (p
->sp_equiv_reg
,
5068 /* Otherwise, replace any references to SP in the insn to its new value
5069 and emit the insn. */
5072 SET_SRC (set
) = simplify_replace_rtx (SET_SRC (set
), stack_pointer_rtx
,
5073 plus_constant (p
->sp_equiv_reg
,
5075 SET_DEST (set
) = simplify_replace_rtx (SET_DEST (set
), stack_pointer_rtx
,
5076 plus_constant (p
->sp_equiv_reg
,
5082 /* Update the tracking information for registers set to constants. */
5085 update_epilogue_consts (rtx dest
, const_rtx x
, void *data
)
5087 struct epi_info
*p
= (struct epi_info
*) data
;
5090 if (!REG_P (dest
) || REGNO (dest
) >= FIRST_PSEUDO_REGISTER
)
5093 /* If we are either clobbering a register or doing a partial set,
5094 show we don't know the value. */
5095 else if (GET_CODE (x
) == CLOBBER
|| ! rtx_equal_p (dest
, SET_DEST (x
)))
5096 p
->const_equiv
[REGNO (dest
)] = 0;
5098 /* If we are setting it to a constant, record that constant. */
5099 else if (GET_CODE (SET_SRC (x
)) == CONST_INT
)
5100 p
->const_equiv
[REGNO (dest
)] = SET_SRC (x
);
5102 /* If this is a binary operation between a register we have been tracking
5103 and a constant, see if we can compute a new constant value. */
5104 else if (ARITHMETIC_P (SET_SRC (x
))
5105 && REG_P (XEXP (SET_SRC (x
), 0))
5106 && REGNO (XEXP (SET_SRC (x
), 0)) < FIRST_PSEUDO_REGISTER
5107 && p
->const_equiv
[REGNO (XEXP (SET_SRC (x
), 0))] != 0
5108 && GET_CODE (XEXP (SET_SRC (x
), 1)) == CONST_INT
5109 && 0 != (new = simplify_binary_operation
5110 (GET_CODE (SET_SRC (x
)), GET_MODE (dest
),
5111 p
->const_equiv
[REGNO (XEXP (SET_SRC (x
), 0))],
5112 XEXP (SET_SRC (x
), 1)))
5113 && GET_CODE (new) == CONST_INT
)
5114 p
->const_equiv
[REGNO (dest
)] = new;
5116 /* Otherwise, we can't do anything with this value. */
5118 p
->const_equiv
[REGNO (dest
)] = 0;
5121 /* Emit an insn to do the load shown in p->equiv_reg_src, if needed. */
5124 emit_equiv_load (struct epi_info
*p
)
5126 if (p
->equiv_reg_src
!= 0)
5128 rtx dest
= p
->sp_equiv_reg
;
5130 if (GET_MODE (p
->equiv_reg_src
) != GET_MODE (dest
))
5131 dest
= gen_rtx_REG (GET_MODE (p
->equiv_reg_src
),
5132 REGNO (p
->sp_equiv_reg
));
5134 emit_move_insn (dest
, p
->equiv_reg_src
);
5135 p
->equiv_reg_src
= 0;
5140 /* Generate the prologue and epilogue RTL if the machine supports it. Thread
5141 this into place with notes indicating where the prologue ends and where
5142 the epilogue begins. Update the basic block information when possible. */
5145 thread_prologue_and_epilogue_insns (void)
5149 #if defined (HAVE_sibcall_epilogue) || defined (HAVE_epilogue) || defined (HAVE_return) || defined (HAVE_prologue)
5152 #if defined (HAVE_epilogue) || defined(HAVE_return)
5153 rtx epilogue_end
= NULL_RTX
;
5157 #ifdef HAVE_prologue
5161 seq
= gen_prologue ();
5164 /* Insert an explicit USE for the frame pointer
5165 if the profiling is on and the frame pointer is required. */
5166 if (current_function_profile
&& frame_pointer_needed
)
5167 emit_insn (gen_rtx_USE (VOIDmode
, hard_frame_pointer_rtx
));
5169 /* Retain a map of the prologue insns. */
5170 record_insns (seq
, &prologue
);
5171 emit_note (NOTE_INSN_PROLOGUE_END
);
5173 #ifndef PROFILE_BEFORE_PROLOGUE
5174 /* Ensure that instructions are not moved into the prologue when
5175 profiling is on. The call to the profiling routine can be
5176 emitted within the live range of a call-clobbered register. */
5177 if (current_function_profile
)
5178 emit_insn (gen_blockage ());
5183 set_insn_locators (seq
, prologue_locator
);
5185 /* Can't deal with multiple successors of the entry block
5186 at the moment. Function should always have at least one
5188 gcc_assert (single_succ_p (ENTRY_BLOCK_PTR
));
5190 insert_insn_on_edge (seq
, single_succ_edge (ENTRY_BLOCK_PTR
));
5195 /* If the exit block has no non-fake predecessors, we don't need
5197 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
5198 if ((e
->flags
& EDGE_FAKE
) == 0)
5204 if (optimize
&& HAVE_return
)
5206 /* If we're allowed to generate a simple return instruction,
5207 then by definition we don't need a full epilogue. Examine
5208 the block that falls through to EXIT. If it does not
5209 contain any code, examine its predecessors and try to
5210 emit (conditional) return instructions. */
5215 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
5216 if (e
->flags
& EDGE_FALLTHRU
)
5222 /* Verify that there are no active instructions in the last block. */
5223 label
= BB_END (last
);
5224 while (label
&& !LABEL_P (label
))
5226 if (active_insn_p (label
))
5228 label
= PREV_INSN (label
);
5231 if (BB_HEAD (last
) == label
&& LABEL_P (label
))
5235 for (ei2
= ei_start (last
->preds
); (e
= ei_safe_edge (ei2
)); )
5237 basic_block bb
= e
->src
;
5240 if (bb
== ENTRY_BLOCK_PTR
)
5247 if (!JUMP_P (jump
) || JUMP_LABEL (jump
) != label
)
5253 /* If we have an unconditional jump, we can replace that
5254 with a simple return instruction. */
5255 if (simplejump_p (jump
))
5257 emit_return_into_block (bb
);
5261 /* If we have a conditional jump, we can try to replace
5262 that with a conditional return instruction. */
5263 else if (condjump_p (jump
))
5265 if (! redirect_jump (jump
, 0, 0))
5271 /* If this block has only one successor, it both jumps
5272 and falls through to the fallthru block, so we can't
5274 if (single_succ_p (bb
))
5286 /* Fix up the CFG for the successful change we just made. */
5287 redirect_edge_succ (e
, EXIT_BLOCK_PTR
);
5290 /* Emit a return insn for the exit fallthru block. Whether
5291 this is still reachable will be determined later. */
5293 emit_barrier_after (BB_END (last
));
5294 emit_return_into_block (last
);
5295 epilogue_end
= BB_END (last
);
5296 single_succ_edge (last
)->flags
&= ~EDGE_FALLTHRU
;
5301 /* Find the edge that falls through to EXIT. Other edges may exist
5302 due to RETURN instructions, but those don't need epilogues.
5303 There really shouldn't be a mixture -- either all should have
5304 been converted or none, however... */
5306 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
5307 if (e
->flags
& EDGE_FALLTHRU
)
5312 #ifdef HAVE_epilogue
5316 epilogue_end
= emit_note (NOTE_INSN_EPILOGUE_BEG
);
5318 seq
= gen_epilogue ();
5320 #ifdef INCOMING_RETURN_ADDR_RTX
5321 /* If this function returns with the stack depressed and we can support
5322 it, massage the epilogue to actually do that. */
5323 if (TREE_CODE (TREE_TYPE (current_function_decl
)) == FUNCTION_TYPE
5324 && TYPE_RETURNS_STACK_DEPRESSED (TREE_TYPE (current_function_decl
)))
5325 seq
= keep_stack_depressed (seq
);
5328 emit_jump_insn (seq
);
5330 /* Retain a map of the epilogue insns. */
5331 record_insns (seq
, &epilogue
);
5332 set_insn_locators (seq
, epilogue_locator
);
5337 insert_insn_on_edge (seq
, e
);
5345 if (! next_active_insn (BB_END (e
->src
)))
5347 /* We have a fall-through edge to the exit block, the source is not
5348 at the end of the function, and there will be an assembler epilogue
5349 at the end of the function.
5350 We can't use force_nonfallthru here, because that would try to
5351 use return. Inserting a jump 'by hand' is extremely messy, so
5352 we take advantage of cfg_layout_finalize using
5353 fixup_fallthru_exit_predecessor. */
5354 cfg_layout_initialize (0);
5355 FOR_EACH_BB (cur_bb
)
5356 if (cur_bb
->index
>= NUM_FIXED_BLOCKS
5357 && cur_bb
->next_bb
->index
>= NUM_FIXED_BLOCKS
)
5358 cur_bb
->aux
= cur_bb
->next_bb
;
5359 cfg_layout_finalize ();
5365 commit_edge_insertions ();
5367 /* The epilogue insns we inserted may cause the exit edge to no longer
5369 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
5371 if (((e
->flags
& EDGE_FALLTHRU
) != 0)
5372 && returnjump_p (BB_END (e
->src
)))
5373 e
->flags
&= ~EDGE_FALLTHRU
;
5377 #ifdef HAVE_sibcall_epilogue
5378 /* Emit sibling epilogues before any sibling call sites. */
5379 for (ei
= ei_start (EXIT_BLOCK_PTR
->preds
); (e
= ei_safe_edge (ei
)); )
5381 basic_block bb
= e
->src
;
5382 rtx insn
= BB_END (bb
);
5385 || ! SIBLING_CALL_P (insn
))
5392 emit_insn (gen_sibcall_epilogue ());
5396 /* Retain a map of the epilogue insns. Used in life analysis to
5397 avoid getting rid of sibcall epilogue insns. Do this before we
5398 actually emit the sequence. */
5399 record_insns (seq
, &sibcall_epilogue
);
5400 set_insn_locators (seq
, epilogue_locator
);
5402 emit_insn_before (seq
, insn
);
5407 #ifdef HAVE_epilogue
5412 /* Similarly, move any line notes that appear after the epilogue.
5413 There is no need, however, to be quite so anal about the existence
5414 of such a note. Also possibly move
5415 NOTE_INSN_FUNCTION_BEG notes, as those can be relevant for debug
5417 for (insn
= epilogue_end
; insn
; insn
= next
)
5419 next
= NEXT_INSN (insn
);
5421 && (NOTE_KIND (insn
) == NOTE_INSN_FUNCTION_BEG
))
5422 reorder_insns (insn
, insn
, PREV_INSN (epilogue_end
));
5427 /* Threading the prologue and epilogue changes the artificial refs
5428 in the entry and exit blocks. */
5429 epilogue_completed
= 1;
5430 df_update_entry_exit_and_calls ();
5433 /* Reposition the prologue-end and epilogue-begin notes after instruction
5434 scheduling and delayed branch scheduling. */
5437 reposition_prologue_and_epilogue_notes (void)
5439 #if defined (HAVE_prologue) || defined (HAVE_epilogue)
5440 rtx insn
, last
, note
;
5443 if ((len
= VEC_length (int, prologue
)) > 0)
5447 /* Scan from the beginning until we reach the last prologue insn.
5448 We apparently can't depend on basic_block_{head,end} after
5450 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
5454 if (NOTE_KIND (insn
) == NOTE_INSN_PROLOGUE_END
)
5457 else if (contains (insn
, &prologue
))
5467 /* Find the prologue-end note if we haven't already, and
5468 move it to just after the last prologue insn. */
5471 for (note
= last
; (note
= NEXT_INSN (note
));)
5473 && NOTE_KIND (note
) == NOTE_INSN_PROLOGUE_END
)
5477 /* Avoid placing note between CODE_LABEL and BASIC_BLOCK note. */
5479 last
= NEXT_INSN (last
);
5480 reorder_insns (note
, note
, last
);
5484 if ((len
= VEC_length (int, epilogue
)) > 0)
5488 /* Scan from the end until we reach the first epilogue insn.
5489 We apparently can't depend on basic_block_{head,end} after
5491 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
5495 if (NOTE_KIND (insn
) == NOTE_INSN_EPILOGUE_BEG
)
5498 else if (contains (insn
, &epilogue
))
5508 /* Find the epilogue-begin note if we haven't already, and
5509 move it to just before the first epilogue insn. */
5512 for (note
= insn
; (note
= PREV_INSN (note
));)
5514 && NOTE_KIND (note
) == NOTE_INSN_EPILOGUE_BEG
)
5518 if (PREV_INSN (last
) != note
)
5519 reorder_insns (note
, note
, PREV_INSN (last
));
5522 #endif /* HAVE_prologue or HAVE_epilogue */
5525 /* Returns the name of the current function. */
5527 current_function_name (void)
5529 return lang_hooks
.decl_printable_name (cfun
->decl
, 2);
5532 /* Returns the raw (mangled) name of the current function. */
5534 current_function_assembler_name (void)
5536 return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (cfun
->decl
));
5541 rest_of_handle_check_leaf_regs (void)
5543 #ifdef LEAF_REGISTERS
5544 current_function_uses_only_leaf_regs
5545 = optimize
> 0 && only_leaf_regs_used () && leaf_function_p ();
5550 /* Insert a TYPE into the used types hash table of CFUN. */
5552 used_types_insert_helper (tree type
, struct function
*func
)
5554 if (type
!= NULL
&& func
!= NULL
)
5558 if (func
->used_types_hash
== NULL
)
5559 func
->used_types_hash
= htab_create_ggc (37, htab_hash_pointer
,
5560 htab_eq_pointer
, NULL
);
5561 slot
= htab_find_slot (func
->used_types_hash
, type
, INSERT
);
5567 /* Given a type, insert it into the used hash table in cfun. */
5569 used_types_insert (tree t
)
5571 while (POINTER_TYPE_P (t
) || TREE_CODE (t
) == ARRAY_TYPE
)
5573 t
= TYPE_MAIN_VARIANT (t
);
5574 if (debug_info_level
> DINFO_LEVEL_NONE
)
5575 used_types_insert_helper (t
, cfun
);
5578 struct tree_opt_pass pass_leaf_regs
=
5582 rest_of_handle_check_leaf_regs
, /* execute */
5585 0, /* static_pass_number */
5587 0, /* properties_required */
5588 0, /* properties_provided */
5589 0, /* properties_destroyed */
5590 0, /* todo_flags_start */
5591 0, /* todo_flags_finish */
5596 rest_of_handle_thread_prologue_and_epilogue (void)
5599 cleanup_cfg (CLEANUP_EXPENSIVE
);
5600 /* On some machines, the prologue and epilogue code, or parts thereof,
5601 can be represented as RTL. Doing so lets us schedule insns between
5602 it and the rest of the code and also allows delayed branch
5603 scheduling to operate in the epilogue. */
5605 thread_prologue_and_epilogue_insns ();
5609 struct tree_opt_pass pass_thread_prologue_and_epilogue
=
5611 "pro_and_epilogue", /* name */
5613 rest_of_handle_thread_prologue_and_epilogue
, /* execute */
5616 0, /* static_pass_number */
5617 TV_THREAD_PROLOGUE_AND_EPILOGUE
, /* tv_id */
5618 0, /* properties_required */
5619 0, /* properties_provided */
5620 0, /* properties_destroyed */
5621 TODO_verify_flow
, /* todo_flags_start */
5624 TODO_df_finish
| TODO_verify_rtl_sharing
|
5625 TODO_ggc_collect
, /* todo_flags_finish */
5630 /* This mini-pass fixes fall-out from SSA in asm statements that have
5631 in-out constraints. Say you start with
5634 asm ("": "+mr" (inout));
5637 which is transformed very early to use explicit output and match operands:
5640 asm ("": "=mr" (inout) : "0" (inout));
5643 Or, after SSA and copyprop,
5645 asm ("": "=mr" (inout_2) : "0" (inout_1));
5648 Clearly inout_2 and inout_1 can't be coalesced easily anymore, as
5649 they represent two separate values, so they will get different pseudo
5650 registers during expansion. Then, since the two operands need to match
5651 per the constraints, but use different pseudo registers, reload can
5652 only register a reload for these operands. But reloads can only be
5653 satisfied by hardregs, not by memory, so we need a register for this
5654 reload, just because we are presented with non-matching operands.
5655 So, even though we allow memory for this operand, no memory can be
5656 used for it, just because the two operands don't match. This can
5657 cause reload failures on register-starved targets.
5659 So it's a symptom of reload not being able to use memory for reloads
5660 or, alternatively it's also a symptom of both operands not coming into
5661 reload as matching (in which case the pseudo could go to memory just
5662 fine, as the alternative allows it, and no reload would be necessary).
5663 We fix the latter problem here, by transforming
5665 asm ("": "=mr" (inout_2) : "0" (inout_1));
5670 asm ("": "=mr" (inout_2) : "0" (inout_2)); */
5673 match_asm_constraints_1 (rtx insn
, rtx
*p_sets
, int noutputs
)
5676 bool changed
= false;
5677 rtx op
= SET_SRC (p_sets
[0]);
5678 int ninputs
= ASM_OPERANDS_INPUT_LENGTH (op
);
5679 rtvec inputs
= ASM_OPERANDS_INPUT_VEC (op
);
5681 for (i
= 0; i
< ninputs
; i
++)
5683 rtx input
, output
, insns
;
5684 const char *constraint
= ASM_OPERANDS_INPUT_CONSTRAINT (op
, i
);
5688 match
= strtoul (constraint
, &end
, 10);
5689 if (end
== constraint
)
5692 gcc_assert (match
< noutputs
);
5693 output
= SET_DEST (p_sets
[match
]);
5694 input
= RTVEC_ELT (inputs
, i
);
5695 /* Only do the transformation for pseudos. */
5696 if (! REG_P (output
)
5697 || rtx_equal_p (output
, input
)
5698 || (GET_MODE (input
) != VOIDmode
5699 && GET_MODE (input
) != GET_MODE (output
)))
5702 /* We can't do anything if the output is also used as input,
5703 as we're going to overwrite it. */
5704 for (j
= 0; j
< ninputs
; j
++)
5705 if (reg_overlap_mentioned_p (output
, RTVEC_ELT (inputs
, j
)))
5711 emit_move_insn (output
, input
);
5712 insns
= get_insns ();
5714 emit_insn_before (insns
, insn
);
5716 /* Now replace all mentions of the input with output. We can't
5717 just replace the occurence in inputs[i], as the register might
5718 also be used in some other input (or even in an address of an
5719 output), which would mean possibly increasing the number of
5720 inputs by one (namely 'output' in addition), which might pose
5721 a too complicated problem for reload to solve. E.g. this situation:
5723 asm ("" : "=r" (output), "=m" (input) : "0" (input))
5725 Here 'input' is used in two occurrences as input (once for the
5726 input operand, once for the address in the second output operand).
5727 If we would replace only the occurence of the input operand (to
5728 make the matching) we would be left with this:
5731 asm ("" : "=r" (output), "=m" (input) : "0" (output))
5733 Now we suddenly have two different input values (containing the same
5734 value, but different pseudos) where we formerly had only one.
5735 With more complicated asms this might lead to reload failures
5736 which wouldn't have happen without this pass. So, iterate over
5737 all operands and replace all occurrences of the register used. */
5738 for (j
= 0; j
< noutputs
; j
++)
5739 if (!rtx_equal_p (SET_DEST (p_sets
[j
]), input
)
5740 && reg_overlap_mentioned_p (input
, SET_DEST (p_sets
[j
])))
5741 SET_DEST (p_sets
[j
]) = replace_rtx (SET_DEST (p_sets
[j
]),
5743 for (j
= 0; j
< ninputs
; j
++)
5744 if (reg_overlap_mentioned_p (input
, RTVEC_ELT (inputs
, j
)))
5745 RTVEC_ELT (inputs
, j
) = replace_rtx (RTVEC_ELT (inputs
, j
),
5752 df_insn_rescan (insn
);
5756 rest_of_match_asm_constraints (void)
5759 rtx insn
, pat
, *p_sets
;
5762 if (!cfun
->has_asm_statement
)
5765 df_set_flags (DF_DEFER_INSN_RESCAN
);
5768 FOR_BB_INSNS (bb
, insn
)
5773 pat
= PATTERN (insn
);
5774 if (GET_CODE (pat
) == PARALLEL
)
5775 p_sets
= &XVECEXP (pat
, 0, 0), noutputs
= XVECLEN (pat
, 0);
5776 else if (GET_CODE (pat
) == SET
)
5777 p_sets
= &PATTERN (insn
), noutputs
= 1;
5781 if (GET_CODE (*p_sets
) == SET
5782 && GET_CODE (SET_SRC (*p_sets
)) == ASM_OPERANDS
)
5783 match_asm_constraints_1 (insn
, p_sets
, noutputs
);
5787 return TODO_df_finish
;
5790 struct tree_opt_pass pass_match_asm_constraints
=
5792 "asmcons", /* name */
5794 rest_of_match_asm_constraints
, /* execute */
5797 0, /* static_pass_number */
5799 0, /* properties_required */
5800 0, /* properties_provided */
5801 0, /* properties_destroyed */
5802 0, /* todo_flags_start */
5803 TODO_dump_func
, /* todo_flags_finish */
5808 #include "gt-function.h"