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, 2008
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
, false);
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_rtl (rtx x
)
1579 /* If this is a CONCAT, recurse for the pieces. */
1580 if (GET_CODE (x
) == CONCAT
)
1582 instantiate_decl_rtl (XEXP (x
, 0));
1583 instantiate_decl_rtl (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_rtl (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_rtl (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
= BLOCK_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_rtl (DECL_RTL (decl
));
1654 instantiate_decl_rtl (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 targetm
.instantiate_decls ();
1720 /* Indicate that, from now on, assign_stack_local should use
1721 frame_pointer_rtx. */
1722 virtuals_instantiated
= 1;
1726 struct tree_opt_pass pass_instantiate_virtual_regs
=
1730 instantiate_virtual_regs
, /* execute */
1733 0, /* static_pass_number */
1735 0, /* properties_required */
1736 0, /* properties_provided */
1737 0, /* properties_destroyed */
1738 0, /* todo_flags_start */
1739 TODO_dump_func
, /* todo_flags_finish */
1744 /* Return 1 if EXP is an aggregate type (or a value with aggregate type).
1745 This means a type for which function calls must pass an address to the
1746 function or get an address back from the function.
1747 EXP may be a type node or an expression (whose type is tested). */
1750 aggregate_value_p (const_tree exp
, const_tree fntype
)
1752 int i
, regno
, nregs
;
1755 const_tree type
= (TYPE_P (exp
)) ? exp
: TREE_TYPE (exp
);
1757 /* DECL node associated with FNTYPE when relevant, which we might need to
1758 check for by-invisible-reference returns, typically for CALL_EXPR input
1760 const_tree fndecl
= NULL_TREE
;
1763 switch (TREE_CODE (fntype
))
1766 fndecl
= get_callee_fndecl (fntype
);
1767 fntype
= fndecl
? TREE_TYPE (fndecl
) : 0;
1771 fntype
= TREE_TYPE (fndecl
);
1776 case IDENTIFIER_NODE
:
1780 /* We don't expect other rtl types here. */
1784 if (TREE_CODE (type
) == VOID_TYPE
)
1787 /* If the front end has decided that this needs to be passed by
1788 reference, do so. */
1789 if ((TREE_CODE (exp
) == PARM_DECL
|| TREE_CODE (exp
) == RESULT_DECL
)
1790 && DECL_BY_REFERENCE (exp
))
1793 /* If the EXPression is a CALL_EXPR, honor DECL_BY_REFERENCE set on the
1794 called function RESULT_DECL, meaning the function returns in memory by
1795 invisible reference. This check lets front-ends not set TREE_ADDRESSABLE
1796 on the function type, which used to be the way to request such a return
1797 mechanism but might now be causing troubles at gimplification time if
1798 temporaries with the function type need to be created. */
1799 if (TREE_CODE (exp
) == CALL_EXPR
&& fndecl
&& DECL_RESULT (fndecl
)
1800 && DECL_BY_REFERENCE (DECL_RESULT (fndecl
)))
1803 if (targetm
.calls
.return_in_memory (type
, fntype
))
1805 /* Types that are TREE_ADDRESSABLE must be constructed in memory,
1806 and thus can't be returned in registers. */
1807 if (TREE_ADDRESSABLE (type
))
1809 if (flag_pcc_struct_return
&& AGGREGATE_TYPE_P (type
))
1811 /* Make sure we have suitable call-clobbered regs to return
1812 the value in; if not, we must return it in memory. */
1813 reg
= hard_function_value (type
, 0, fntype
, 0);
1815 /* If we have something other than a REG (e.g. a PARALLEL), then assume
1820 regno
= REGNO (reg
);
1821 nregs
= hard_regno_nregs
[regno
][TYPE_MODE (type
)];
1822 for (i
= 0; i
< nregs
; i
++)
1823 if (! call_used_regs
[regno
+ i
])
1828 /* Return true if we should assign DECL a pseudo register; false if it
1829 should live on the local stack. */
1832 use_register_for_decl (const_tree decl
)
1834 /* Honor volatile. */
1835 if (TREE_SIDE_EFFECTS (decl
))
1838 /* Honor addressability. */
1839 if (TREE_ADDRESSABLE (decl
))
1842 /* Only register-like things go in registers. */
1843 if (DECL_MODE (decl
) == BLKmode
)
1846 /* If -ffloat-store specified, don't put explicit float variables
1848 /* ??? This should be checked after DECL_ARTIFICIAL, but tree-ssa
1849 propagates values across these stores, and it probably shouldn't. */
1850 if (flag_float_store
&& FLOAT_TYPE_P (TREE_TYPE (decl
)))
1853 /* If we're not interested in tracking debugging information for
1854 this decl, then we can certainly put it in a register. */
1855 if (DECL_IGNORED_P (decl
))
1858 return (optimize
|| DECL_REGISTER (decl
));
1861 /* Return true if TYPE should be passed by invisible reference. */
1864 pass_by_reference (CUMULATIVE_ARGS
*ca
, enum machine_mode mode
,
1865 tree type
, bool named_arg
)
1869 /* If this type contains non-trivial constructors, then it is
1870 forbidden for the middle-end to create any new copies. */
1871 if (TREE_ADDRESSABLE (type
))
1874 /* GCC post 3.4 passes *all* variable sized types by reference. */
1875 if (!TYPE_SIZE (type
) || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1879 return targetm
.calls
.pass_by_reference (ca
, mode
, type
, named_arg
);
1882 /* Return true if TYPE, which is passed by reference, should be callee
1883 copied instead of caller copied. */
1886 reference_callee_copied (CUMULATIVE_ARGS
*ca
, enum machine_mode mode
,
1887 tree type
, bool named_arg
)
1889 if (type
&& TREE_ADDRESSABLE (type
))
1891 return targetm
.calls
.callee_copies (ca
, mode
, type
, named_arg
);
1894 /* Structures to communicate between the subroutines of assign_parms.
1895 The first holds data persistent across all parameters, the second
1896 is cleared out for each parameter. */
1898 struct assign_parm_data_all
1900 CUMULATIVE_ARGS args_so_far
;
1901 struct args_size stack_args_size
;
1902 tree function_result_decl
;
1904 rtx first_conversion_insn
;
1905 rtx last_conversion_insn
;
1906 HOST_WIDE_INT pretend_args_size
;
1907 HOST_WIDE_INT extra_pretend_bytes
;
1908 int reg_parm_stack_space
;
1911 struct assign_parm_data_one
1917 enum machine_mode nominal_mode
;
1918 enum machine_mode passed_mode
;
1919 enum machine_mode promoted_mode
;
1920 struct locate_and_pad_arg_data locate
;
1922 BOOL_BITFIELD named_arg
: 1;
1923 BOOL_BITFIELD passed_pointer
: 1;
1924 BOOL_BITFIELD on_stack
: 1;
1925 BOOL_BITFIELD loaded_in_reg
: 1;
1928 /* A subroutine of assign_parms. Initialize ALL. */
1931 assign_parms_initialize_all (struct assign_parm_data_all
*all
)
1935 memset (all
, 0, sizeof (*all
));
1937 fntype
= TREE_TYPE (current_function_decl
);
1939 #ifdef INIT_CUMULATIVE_INCOMING_ARGS
1940 INIT_CUMULATIVE_INCOMING_ARGS (all
->args_so_far
, fntype
, NULL_RTX
);
1942 INIT_CUMULATIVE_ARGS (all
->args_so_far
, fntype
, NULL_RTX
,
1943 current_function_decl
, -1);
1946 #ifdef REG_PARM_STACK_SPACE
1947 all
->reg_parm_stack_space
= REG_PARM_STACK_SPACE (current_function_decl
);
1951 /* If ARGS contains entries with complex types, split the entry into two
1952 entries of the component type. Return a new list of substitutions are
1953 needed, else the old list. */
1956 split_complex_args (tree args
)
1960 /* Before allocating memory, check for the common case of no complex. */
1961 for (p
= args
; p
; p
= TREE_CHAIN (p
))
1963 tree type
= TREE_TYPE (p
);
1964 if (TREE_CODE (type
) == COMPLEX_TYPE
1965 && targetm
.calls
.split_complex_arg (type
))
1971 args
= copy_list (args
);
1973 for (p
= args
; p
; p
= TREE_CHAIN (p
))
1975 tree type
= TREE_TYPE (p
);
1976 if (TREE_CODE (type
) == COMPLEX_TYPE
1977 && targetm
.calls
.split_complex_arg (type
))
1980 tree subtype
= TREE_TYPE (type
);
1981 bool addressable
= TREE_ADDRESSABLE (p
);
1983 /* Rewrite the PARM_DECL's type with its component. */
1984 TREE_TYPE (p
) = subtype
;
1985 DECL_ARG_TYPE (p
) = TREE_TYPE (DECL_ARG_TYPE (p
));
1986 DECL_MODE (p
) = VOIDmode
;
1987 DECL_SIZE (p
) = NULL
;
1988 DECL_SIZE_UNIT (p
) = NULL
;
1989 /* If this arg must go in memory, put it in a pseudo here.
1990 We can't allow it to go in memory as per normal parms,
1991 because the usual place might not have the imag part
1992 adjacent to the real part. */
1993 DECL_ARTIFICIAL (p
) = addressable
;
1994 DECL_IGNORED_P (p
) = addressable
;
1995 TREE_ADDRESSABLE (p
) = 0;
1998 /* Build a second synthetic decl. */
1999 decl
= build_decl (PARM_DECL
, NULL_TREE
, subtype
);
2000 DECL_ARG_TYPE (decl
) = DECL_ARG_TYPE (p
);
2001 DECL_ARTIFICIAL (decl
) = addressable
;
2002 DECL_IGNORED_P (decl
) = addressable
;
2003 layout_decl (decl
, 0);
2005 /* Splice it in; skip the new decl. */
2006 TREE_CHAIN (decl
) = TREE_CHAIN (p
);
2007 TREE_CHAIN (p
) = decl
;
2015 /* A subroutine of assign_parms. Adjust the parameter list to incorporate
2016 the hidden struct return argument, and (abi willing) complex args.
2017 Return the new parameter list. */
2020 assign_parms_augmented_arg_list (struct assign_parm_data_all
*all
)
2022 tree fndecl
= current_function_decl
;
2023 tree fntype
= TREE_TYPE (fndecl
);
2024 tree fnargs
= DECL_ARGUMENTS (fndecl
);
2026 /* If struct value address is treated as the first argument, make it so. */
2027 if (aggregate_value_p (DECL_RESULT (fndecl
), fndecl
)
2028 && ! current_function_returns_pcc_struct
2029 && targetm
.calls
.struct_value_rtx (TREE_TYPE (fndecl
), 1) == 0)
2031 tree type
= build_pointer_type (TREE_TYPE (fntype
));
2034 decl
= build_decl (PARM_DECL
, NULL_TREE
, type
);
2035 DECL_ARG_TYPE (decl
) = type
;
2036 DECL_ARTIFICIAL (decl
) = 1;
2037 DECL_IGNORED_P (decl
) = 1;
2039 TREE_CHAIN (decl
) = fnargs
;
2041 all
->function_result_decl
= decl
;
2044 all
->orig_fnargs
= fnargs
;
2046 /* If the target wants to split complex arguments into scalars, do so. */
2047 if (targetm
.calls
.split_complex_arg
)
2048 fnargs
= split_complex_args (fnargs
);
2053 /* A subroutine of assign_parms. Examine PARM and pull out type and mode
2054 data for the parameter. Incorporate ABI specifics such as pass-by-
2055 reference and type promotion. */
2058 assign_parm_find_data_types (struct assign_parm_data_all
*all
, tree parm
,
2059 struct assign_parm_data_one
*data
)
2061 tree nominal_type
, passed_type
;
2062 enum machine_mode nominal_mode
, passed_mode
, promoted_mode
;
2064 memset (data
, 0, sizeof (*data
));
2066 /* NAMED_ARG is a mis-nomer. We really mean 'non-varadic'. */
2067 if (!current_function_stdarg
)
2068 data
->named_arg
= 1; /* No varadic parms. */
2069 else if (TREE_CHAIN (parm
))
2070 data
->named_arg
= 1; /* Not the last non-varadic parm. */
2071 else if (targetm
.calls
.strict_argument_naming (&all
->args_so_far
))
2072 data
->named_arg
= 1; /* Only varadic ones are unnamed. */
2074 data
->named_arg
= 0; /* Treat as varadic. */
2076 nominal_type
= TREE_TYPE (parm
);
2077 passed_type
= DECL_ARG_TYPE (parm
);
2079 /* Look out for errors propagating this far. Also, if the parameter's
2080 type is void then its value doesn't matter. */
2081 if (TREE_TYPE (parm
) == error_mark_node
2082 /* This can happen after weird syntax errors
2083 or if an enum type is defined among the parms. */
2084 || TREE_CODE (parm
) != PARM_DECL
2085 || passed_type
== NULL
2086 || VOID_TYPE_P (nominal_type
))
2088 nominal_type
= passed_type
= void_type_node
;
2089 nominal_mode
= passed_mode
= promoted_mode
= VOIDmode
;
2093 /* Find mode of arg as it is passed, and mode of arg as it should be
2094 during execution of this function. */
2095 passed_mode
= TYPE_MODE (passed_type
);
2096 nominal_mode
= TYPE_MODE (nominal_type
);
2098 /* If the parm is to be passed as a transparent union, use the type of
2099 the first field for the tests below. We have already verified that
2100 the modes are the same. */
2101 if (TREE_CODE (passed_type
) == UNION_TYPE
2102 && TYPE_TRANSPARENT_UNION (passed_type
))
2103 passed_type
= TREE_TYPE (TYPE_FIELDS (passed_type
));
2105 /* See if this arg was passed by invisible reference. */
2106 if (pass_by_reference (&all
->args_so_far
, passed_mode
,
2107 passed_type
, data
->named_arg
))
2109 passed_type
= nominal_type
= build_pointer_type (passed_type
);
2110 data
->passed_pointer
= true;
2111 passed_mode
= nominal_mode
= Pmode
;
2114 /* Find mode as it is passed by the ABI. */
2115 promoted_mode
= passed_mode
;
2116 if (targetm
.calls
.promote_function_args (TREE_TYPE (current_function_decl
)))
2118 int unsignedp
= TYPE_UNSIGNED (passed_type
);
2119 promoted_mode
= promote_mode (passed_type
, promoted_mode
,
2124 data
->nominal_type
= nominal_type
;
2125 data
->passed_type
= passed_type
;
2126 data
->nominal_mode
= nominal_mode
;
2127 data
->passed_mode
= passed_mode
;
2128 data
->promoted_mode
= promoted_mode
;
2131 /* A subroutine of assign_parms. Invoke setup_incoming_varargs. */
2134 assign_parms_setup_varargs (struct assign_parm_data_all
*all
,
2135 struct assign_parm_data_one
*data
, bool no_rtl
)
2137 int varargs_pretend_bytes
= 0;
2139 targetm
.calls
.setup_incoming_varargs (&all
->args_so_far
,
2140 data
->promoted_mode
,
2142 &varargs_pretend_bytes
, no_rtl
);
2144 /* If the back-end has requested extra stack space, record how much is
2145 needed. Do not change pretend_args_size otherwise since it may be
2146 nonzero from an earlier partial argument. */
2147 if (varargs_pretend_bytes
> 0)
2148 all
->pretend_args_size
= varargs_pretend_bytes
;
2151 /* A subroutine of assign_parms. Set DATA->ENTRY_PARM corresponding to
2152 the incoming location of the current parameter. */
2155 assign_parm_find_entry_rtl (struct assign_parm_data_all
*all
,
2156 struct assign_parm_data_one
*data
)
2158 HOST_WIDE_INT pretend_bytes
= 0;
2162 if (data
->promoted_mode
== VOIDmode
)
2164 data
->entry_parm
= data
->stack_parm
= const0_rtx
;
2168 #ifdef FUNCTION_INCOMING_ARG
2169 entry_parm
= FUNCTION_INCOMING_ARG (all
->args_so_far
, data
->promoted_mode
,
2170 data
->passed_type
, data
->named_arg
);
2172 entry_parm
= FUNCTION_ARG (all
->args_so_far
, data
->promoted_mode
,
2173 data
->passed_type
, data
->named_arg
);
2176 if (entry_parm
== 0)
2177 data
->promoted_mode
= data
->passed_mode
;
2179 /* Determine parm's home in the stack, in case it arrives in the stack
2180 or we should pretend it did. Compute the stack position and rtx where
2181 the argument arrives and its size.
2183 There is one complexity here: If this was a parameter that would
2184 have been passed in registers, but wasn't only because it is
2185 __builtin_va_alist, we want locate_and_pad_parm to treat it as if
2186 it came in a register so that REG_PARM_STACK_SPACE isn't skipped.
2187 In this case, we call FUNCTION_ARG with NAMED set to 1 instead of 0
2188 as it was the previous time. */
2189 in_regs
= entry_parm
!= 0;
2190 #ifdef STACK_PARMS_IN_REG_PARM_AREA
2193 if (!in_regs
&& !data
->named_arg
)
2195 if (targetm
.calls
.pretend_outgoing_varargs_named (&all
->args_so_far
))
2198 #ifdef FUNCTION_INCOMING_ARG
2199 tem
= FUNCTION_INCOMING_ARG (all
->args_so_far
, data
->promoted_mode
,
2200 data
->passed_type
, true);
2202 tem
= FUNCTION_ARG (all
->args_so_far
, data
->promoted_mode
,
2203 data
->passed_type
, true);
2205 in_regs
= tem
!= NULL
;
2209 /* If this parameter was passed both in registers and in the stack, use
2210 the copy on the stack. */
2211 if (targetm
.calls
.must_pass_in_stack (data
->promoted_mode
,
2219 partial
= targetm
.calls
.arg_partial_bytes (&all
->args_so_far
,
2220 data
->promoted_mode
,
2223 data
->partial
= partial
;
2225 /* The caller might already have allocated stack space for the
2226 register parameters. */
2227 if (partial
!= 0 && all
->reg_parm_stack_space
== 0)
2229 /* Part of this argument is passed in registers and part
2230 is passed on the stack. Ask the prologue code to extend
2231 the stack part so that we can recreate the full value.
2233 PRETEND_BYTES is the size of the registers we need to store.
2234 CURRENT_FUNCTION_PRETEND_ARGS_SIZE is the amount of extra
2235 stack space that the prologue should allocate.
2237 Internally, gcc assumes that the argument pointer is aligned
2238 to STACK_BOUNDARY bits. This is used both for alignment
2239 optimizations (see init_emit) and to locate arguments that are
2240 aligned to more than PARM_BOUNDARY bits. We must preserve this
2241 invariant by rounding CURRENT_FUNCTION_PRETEND_ARGS_SIZE up to
2242 a stack boundary. */
2244 /* We assume at most one partial arg, and it must be the first
2245 argument on the stack. */
2246 gcc_assert (!all
->extra_pretend_bytes
&& !all
->pretend_args_size
);
2248 pretend_bytes
= partial
;
2249 all
->pretend_args_size
= CEIL_ROUND (pretend_bytes
, STACK_BYTES
);
2251 /* We want to align relative to the actual stack pointer, so
2252 don't include this in the stack size until later. */
2253 all
->extra_pretend_bytes
= all
->pretend_args_size
;
2257 locate_and_pad_parm (data
->promoted_mode
, data
->passed_type
, in_regs
,
2258 entry_parm
? data
->partial
: 0, current_function_decl
,
2259 &all
->stack_args_size
, &data
->locate
);
2261 /* Adjust offsets to include the pretend args. */
2262 pretend_bytes
= all
->extra_pretend_bytes
- pretend_bytes
;
2263 data
->locate
.slot_offset
.constant
+= pretend_bytes
;
2264 data
->locate
.offset
.constant
+= pretend_bytes
;
2266 data
->entry_parm
= entry_parm
;
2269 /* A subroutine of assign_parms. If there is actually space on the stack
2270 for this parm, count it in stack_args_size and return true. */
2273 assign_parm_is_stack_parm (struct assign_parm_data_all
*all
,
2274 struct assign_parm_data_one
*data
)
2276 /* Trivially true if we've no incoming register. */
2277 if (data
->entry_parm
== NULL
)
2279 /* Also true if we're partially in registers and partially not,
2280 since we've arranged to drop the entire argument on the stack. */
2281 else if (data
->partial
!= 0)
2283 /* Also true if the target says that it's passed in both registers
2284 and on the stack. */
2285 else if (GET_CODE (data
->entry_parm
) == PARALLEL
2286 && XEXP (XVECEXP (data
->entry_parm
, 0, 0), 0) == NULL_RTX
)
2288 /* Also true if the target says that there's stack allocated for
2289 all register parameters. */
2290 else if (all
->reg_parm_stack_space
> 0)
2292 /* Otherwise, no, this parameter has no ABI defined stack slot. */
2296 all
->stack_args_size
.constant
+= data
->locate
.size
.constant
;
2297 if (data
->locate
.size
.var
)
2298 ADD_PARM_SIZE (all
->stack_args_size
, data
->locate
.size
.var
);
2303 /* A subroutine of assign_parms. Given that this parameter is allocated
2304 stack space by the ABI, find it. */
2307 assign_parm_find_stack_rtl (tree parm
, struct assign_parm_data_one
*data
)
2309 rtx offset_rtx
, stack_parm
;
2310 unsigned int align
, boundary
;
2312 /* If we're passing this arg using a reg, make its stack home the
2313 aligned stack slot. */
2314 if (data
->entry_parm
)
2315 offset_rtx
= ARGS_SIZE_RTX (data
->locate
.slot_offset
);
2317 offset_rtx
= ARGS_SIZE_RTX (data
->locate
.offset
);
2319 stack_parm
= current_function_internal_arg_pointer
;
2320 if (offset_rtx
!= const0_rtx
)
2321 stack_parm
= gen_rtx_PLUS (Pmode
, stack_parm
, offset_rtx
);
2322 stack_parm
= gen_rtx_MEM (data
->promoted_mode
, stack_parm
);
2324 set_mem_attributes (stack_parm
, parm
, 1);
2326 boundary
= data
->locate
.boundary
;
2327 align
= BITS_PER_UNIT
;
2329 /* If we're padding upward, we know that the alignment of the slot
2330 is FUNCTION_ARG_BOUNDARY. If we're using slot_offset, we're
2331 intentionally forcing upward padding. Otherwise we have to come
2332 up with a guess at the alignment based on OFFSET_RTX. */
2333 if (data
->locate
.where_pad
!= downward
|| data
->entry_parm
)
2335 else if (GET_CODE (offset_rtx
) == CONST_INT
)
2337 align
= INTVAL (offset_rtx
) * BITS_PER_UNIT
| boundary
;
2338 align
= align
& -align
;
2340 set_mem_align (stack_parm
, align
);
2342 if (data
->entry_parm
)
2343 set_reg_attrs_for_parm (data
->entry_parm
, stack_parm
);
2345 data
->stack_parm
= stack_parm
;
2348 /* A subroutine of assign_parms. Adjust DATA->ENTRY_RTL such that it's
2349 always valid and contiguous. */
2352 assign_parm_adjust_entry_rtl (struct assign_parm_data_one
*data
)
2354 rtx entry_parm
= data
->entry_parm
;
2355 rtx stack_parm
= data
->stack_parm
;
2357 /* If this parm was passed part in regs and part in memory, pretend it
2358 arrived entirely in memory by pushing the register-part onto the stack.
2359 In the special case of a DImode or DFmode that is split, we could put
2360 it together in a pseudoreg directly, but for now that's not worth
2362 if (data
->partial
!= 0)
2364 /* Handle calls that pass values in multiple non-contiguous
2365 locations. The Irix 6 ABI has examples of this. */
2366 if (GET_CODE (entry_parm
) == PARALLEL
)
2367 emit_group_store (validize_mem (stack_parm
), entry_parm
,
2369 int_size_in_bytes (data
->passed_type
));
2372 gcc_assert (data
->partial
% UNITS_PER_WORD
== 0);
2373 move_block_from_reg (REGNO (entry_parm
), validize_mem (stack_parm
),
2374 data
->partial
/ UNITS_PER_WORD
);
2377 entry_parm
= stack_parm
;
2380 /* If we didn't decide this parm came in a register, by default it came
2382 else if (entry_parm
== NULL
)
2383 entry_parm
= stack_parm
;
2385 /* When an argument is passed in multiple locations, we can't make use
2386 of this information, but we can save some copying if the whole argument
2387 is passed in a single register. */
2388 else if (GET_CODE (entry_parm
) == PARALLEL
2389 && data
->nominal_mode
!= BLKmode
2390 && data
->passed_mode
!= BLKmode
)
2392 size_t i
, len
= XVECLEN (entry_parm
, 0);
2394 for (i
= 0; i
< len
; i
++)
2395 if (XEXP (XVECEXP (entry_parm
, 0, i
), 0) != NULL_RTX
2396 && REG_P (XEXP (XVECEXP (entry_parm
, 0, i
), 0))
2397 && (GET_MODE (XEXP (XVECEXP (entry_parm
, 0, i
), 0))
2398 == data
->passed_mode
)
2399 && INTVAL (XEXP (XVECEXP (entry_parm
, 0, i
), 1)) == 0)
2401 entry_parm
= XEXP (XVECEXP (entry_parm
, 0, i
), 0);
2406 data
->entry_parm
= entry_parm
;
2409 /* A subroutine of assign_parms. Adjust DATA->STACK_RTL such that it's
2410 always valid and properly aligned. */
2413 assign_parm_adjust_stack_rtl (struct assign_parm_data_one
*data
)
2415 rtx stack_parm
= data
->stack_parm
;
2417 /* If we can't trust the parm stack slot to be aligned enough for its
2418 ultimate type, don't use that slot after entry. We'll make another
2419 stack slot, if we need one. */
2421 && ((STRICT_ALIGNMENT
2422 && GET_MODE_ALIGNMENT (data
->nominal_mode
) > MEM_ALIGN (stack_parm
))
2423 || (data
->nominal_type
2424 && TYPE_ALIGN (data
->nominal_type
) > MEM_ALIGN (stack_parm
)
2425 && MEM_ALIGN (stack_parm
) < PREFERRED_STACK_BOUNDARY
)))
2428 /* If parm was passed in memory, and we need to convert it on entry,
2429 don't store it back in that same slot. */
2430 else if (data
->entry_parm
== stack_parm
2431 && data
->nominal_mode
!= BLKmode
2432 && data
->nominal_mode
!= data
->passed_mode
)
2435 /* If stack protection is in effect for this function, don't leave any
2436 pointers in their passed stack slots. */
2437 else if (cfun
->stack_protect_guard
2438 && (flag_stack_protect
== 2
2439 || data
->passed_pointer
2440 || POINTER_TYPE_P (data
->nominal_type
)))
2443 data
->stack_parm
= stack_parm
;
2446 /* A subroutine of assign_parms. Return true if the current parameter
2447 should be stored as a BLKmode in the current frame. */
2450 assign_parm_setup_block_p (struct assign_parm_data_one
*data
)
2452 if (data
->nominal_mode
== BLKmode
)
2454 if (GET_CODE (data
->entry_parm
) == PARALLEL
)
2457 #ifdef BLOCK_REG_PADDING
2458 /* Only assign_parm_setup_block knows how to deal with register arguments
2459 that are padded at the least significant end. */
2460 if (REG_P (data
->entry_parm
)
2461 && GET_MODE_SIZE (data
->promoted_mode
) < UNITS_PER_WORD
2462 && (BLOCK_REG_PADDING (data
->passed_mode
, data
->passed_type
, 1)
2463 == (BYTES_BIG_ENDIAN
? upward
: downward
)))
2470 /* A subroutine of assign_parms. Arrange for the parameter to be
2471 present and valid in DATA->STACK_RTL. */
2474 assign_parm_setup_block (struct assign_parm_data_all
*all
,
2475 tree parm
, struct assign_parm_data_one
*data
)
2477 rtx entry_parm
= data
->entry_parm
;
2478 rtx stack_parm
= data
->stack_parm
;
2480 HOST_WIDE_INT size_stored
;
2481 rtx orig_entry_parm
= entry_parm
;
2483 if (GET_CODE (entry_parm
) == PARALLEL
)
2484 entry_parm
= emit_group_move_into_temps (entry_parm
);
2486 /* If we've a non-block object that's nevertheless passed in parts,
2487 reconstitute it in register operations rather than on the stack. */
2488 if (GET_CODE (entry_parm
) == PARALLEL
2489 && data
->nominal_mode
!= BLKmode
)
2491 rtx elt0
= XEXP (XVECEXP (orig_entry_parm
, 0, 0), 0);
2493 if ((XVECLEN (entry_parm
, 0) > 1
2494 || hard_regno_nregs
[REGNO (elt0
)][GET_MODE (elt0
)] > 1)
2495 && use_register_for_decl (parm
))
2497 rtx parmreg
= gen_reg_rtx (data
->nominal_mode
);
2499 push_to_sequence2 (all
->first_conversion_insn
,
2500 all
->last_conversion_insn
);
2502 /* For values returned in multiple registers, handle possible
2503 incompatible calls to emit_group_store.
2505 For example, the following would be invalid, and would have to
2506 be fixed by the conditional below:
2508 emit_group_store ((reg:SF), (parallel:DF))
2509 emit_group_store ((reg:SI), (parallel:DI))
2511 An example of this are doubles in e500 v2:
2512 (parallel:DF (expr_list (reg:SI) (const_int 0))
2513 (expr_list (reg:SI) (const_int 4))). */
2514 if (data
->nominal_mode
!= data
->passed_mode
)
2516 rtx t
= gen_reg_rtx (GET_MODE (entry_parm
));
2517 emit_group_store (t
, entry_parm
, NULL_TREE
,
2518 GET_MODE_SIZE (GET_MODE (entry_parm
)));
2519 convert_move (parmreg
, t
, 0);
2522 emit_group_store (parmreg
, entry_parm
, data
->nominal_type
,
2523 int_size_in_bytes (data
->nominal_type
));
2525 all
->first_conversion_insn
= get_insns ();
2526 all
->last_conversion_insn
= get_last_insn ();
2529 SET_DECL_RTL (parm
, parmreg
);
2534 size
= int_size_in_bytes (data
->passed_type
);
2535 size_stored
= CEIL_ROUND (size
, UNITS_PER_WORD
);
2536 if (stack_parm
== 0)
2538 DECL_ALIGN (parm
) = MAX (DECL_ALIGN (parm
), BITS_PER_WORD
);
2539 stack_parm
= assign_stack_local (BLKmode
, size_stored
,
2541 if (GET_MODE_SIZE (GET_MODE (entry_parm
)) == size
)
2542 PUT_MODE (stack_parm
, GET_MODE (entry_parm
));
2543 set_mem_attributes (stack_parm
, parm
, 1);
2546 /* If a BLKmode arrives in registers, copy it to a stack slot. Handle
2547 calls that pass values in multiple non-contiguous locations. */
2548 if (REG_P (entry_parm
) || GET_CODE (entry_parm
) == PARALLEL
)
2552 /* Note that we will be storing an integral number of words.
2553 So we have to be careful to ensure that we allocate an
2554 integral number of words. We do this above when we call
2555 assign_stack_local if space was not allocated in the argument
2556 list. If it was, this will not work if PARM_BOUNDARY is not
2557 a multiple of BITS_PER_WORD. It isn't clear how to fix this
2558 if it becomes a problem. Exception is when BLKmode arrives
2559 with arguments not conforming to word_mode. */
2561 if (data
->stack_parm
== 0)
2563 else if (GET_CODE (entry_parm
) == PARALLEL
)
2566 gcc_assert (!size
|| !(PARM_BOUNDARY
% BITS_PER_WORD
));
2568 mem
= validize_mem (stack_parm
);
2570 /* Handle values in multiple non-contiguous locations. */
2571 if (GET_CODE (entry_parm
) == PARALLEL
)
2573 push_to_sequence2 (all
->first_conversion_insn
,
2574 all
->last_conversion_insn
);
2575 emit_group_store (mem
, entry_parm
, data
->passed_type
, size
);
2576 all
->first_conversion_insn
= get_insns ();
2577 all
->last_conversion_insn
= get_last_insn ();
2584 /* If SIZE is that of a mode no bigger than a word, just use
2585 that mode's store operation. */
2586 else if (size
<= UNITS_PER_WORD
)
2588 enum machine_mode mode
2589 = mode_for_size (size
* BITS_PER_UNIT
, MODE_INT
, 0);
2592 #ifdef BLOCK_REG_PADDING
2593 && (size
== UNITS_PER_WORD
2594 || (BLOCK_REG_PADDING (mode
, data
->passed_type
, 1)
2595 != (BYTES_BIG_ENDIAN
? upward
: downward
)))
2601 /* We are really truncating a word_mode value containing
2602 SIZE bytes into a value of mode MODE. If such an
2603 operation requires no actual instructions, we can refer
2604 to the value directly in mode MODE, otherwise we must
2605 start with the register in word_mode and explicitly
2607 if (TRULY_NOOP_TRUNCATION (size
* BITS_PER_UNIT
, BITS_PER_WORD
))
2608 reg
= gen_rtx_REG (mode
, REGNO (entry_parm
));
2611 reg
= gen_rtx_REG (word_mode
, REGNO (entry_parm
));
2612 reg
= convert_to_mode (mode
, copy_to_reg (reg
), 1);
2614 emit_move_insn (change_address (mem
, mode
, 0), reg
);
2617 /* Blocks smaller than a word on a BYTES_BIG_ENDIAN
2618 machine must be aligned to the left before storing
2619 to memory. Note that the previous test doesn't
2620 handle all cases (e.g. SIZE == 3). */
2621 else if (size
!= UNITS_PER_WORD
2622 #ifdef BLOCK_REG_PADDING
2623 && (BLOCK_REG_PADDING (mode
, data
->passed_type
, 1)
2631 int by
= (UNITS_PER_WORD
- size
) * BITS_PER_UNIT
;
2632 rtx reg
= gen_rtx_REG (word_mode
, REGNO (entry_parm
));
2634 x
= expand_shift (LSHIFT_EXPR
, word_mode
, reg
,
2635 build_int_cst (NULL_TREE
, by
),
2637 tem
= change_address (mem
, word_mode
, 0);
2638 emit_move_insn (tem
, x
);
2641 move_block_from_reg (REGNO (entry_parm
), mem
,
2642 size_stored
/ UNITS_PER_WORD
);
2645 move_block_from_reg (REGNO (entry_parm
), mem
,
2646 size_stored
/ UNITS_PER_WORD
);
2648 else if (data
->stack_parm
== 0)
2650 push_to_sequence2 (all
->first_conversion_insn
, all
->last_conversion_insn
);
2651 emit_block_move (stack_parm
, data
->entry_parm
, GEN_INT (size
),
2653 all
->first_conversion_insn
= get_insns ();
2654 all
->last_conversion_insn
= get_last_insn ();
2658 data
->stack_parm
= stack_parm
;
2659 SET_DECL_RTL (parm
, stack_parm
);
2662 /* A subroutine of assign_parms. Allocate a pseudo to hold the current
2663 parameter. Get it there. Perform all ABI specified conversions. */
2666 assign_parm_setup_reg (struct assign_parm_data_all
*all
, tree parm
,
2667 struct assign_parm_data_one
*data
)
2670 enum machine_mode promoted_nominal_mode
;
2671 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (parm
));
2672 bool did_conversion
= false;
2674 /* Store the parm in a pseudoregister during the function, but we may
2675 need to do it in a wider mode. */
2677 /* This is not really promoting for a call. However we need to be
2678 consistent with assign_parm_find_data_types and expand_expr_real_1. */
2679 promoted_nominal_mode
2680 = promote_mode (data
->nominal_type
, data
->nominal_mode
, &unsignedp
, 1);
2682 parmreg
= gen_reg_rtx (promoted_nominal_mode
);
2684 if (!DECL_ARTIFICIAL (parm
))
2685 mark_user_reg (parmreg
);
2687 /* If this was an item that we received a pointer to,
2688 set DECL_RTL appropriately. */
2689 if (data
->passed_pointer
)
2691 rtx x
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data
->passed_type
)), parmreg
);
2692 set_mem_attributes (x
, parm
, 1);
2693 SET_DECL_RTL (parm
, x
);
2696 SET_DECL_RTL (parm
, parmreg
);
2698 /* Copy the value into the register. */
2699 if (data
->nominal_mode
!= data
->passed_mode
2700 || promoted_nominal_mode
!= data
->promoted_mode
)
2704 /* ENTRY_PARM has been converted to PROMOTED_MODE, its
2705 mode, by the caller. We now have to convert it to
2706 NOMINAL_MODE, if different. However, PARMREG may be in
2707 a different mode than NOMINAL_MODE if it is being stored
2710 If ENTRY_PARM is a hard register, it might be in a register
2711 not valid for operating in its mode (e.g., an odd-numbered
2712 register for a DFmode). In that case, moves are the only
2713 thing valid, so we can't do a convert from there. This
2714 occurs when the calling sequence allow such misaligned
2717 In addition, the conversion may involve a call, which could
2718 clobber parameters which haven't been copied to pseudo
2719 registers yet. Therefore, we must first copy the parm to
2720 a pseudo reg here, and save the conversion until after all
2721 parameters have been moved. */
2723 rtx tempreg
= gen_reg_rtx (GET_MODE (data
->entry_parm
));
2725 emit_move_insn (tempreg
, validize_mem (data
->entry_parm
));
2727 push_to_sequence2 (all
->first_conversion_insn
, all
->last_conversion_insn
);
2728 tempreg
= convert_to_mode (data
->nominal_mode
, tempreg
, unsignedp
);
2730 if (GET_CODE (tempreg
) == SUBREG
2731 && GET_MODE (tempreg
) == data
->nominal_mode
2732 && REG_P (SUBREG_REG (tempreg
))
2733 && data
->nominal_mode
== data
->passed_mode
2734 && GET_MODE (SUBREG_REG (tempreg
)) == GET_MODE (data
->entry_parm
)
2735 && GET_MODE_SIZE (GET_MODE (tempreg
))
2736 < GET_MODE_SIZE (GET_MODE (data
->entry_parm
)))
2738 /* The argument is already sign/zero extended, so note it
2740 SUBREG_PROMOTED_VAR_P (tempreg
) = 1;
2741 SUBREG_PROMOTED_UNSIGNED_SET (tempreg
, unsignedp
);
2744 /* TREE_USED gets set erroneously during expand_assignment. */
2745 save_tree_used
= TREE_USED (parm
);
2746 expand_assignment (parm
, make_tree (data
->nominal_type
, tempreg
), false);
2747 TREE_USED (parm
) = save_tree_used
;
2748 all
->first_conversion_insn
= get_insns ();
2749 all
->last_conversion_insn
= get_last_insn ();
2752 did_conversion
= true;
2755 emit_move_insn (parmreg
, validize_mem (data
->entry_parm
));
2757 /* If we were passed a pointer but the actual value can safely live
2758 in a register, put it in one. */
2759 if (data
->passed_pointer
2760 && TYPE_MODE (TREE_TYPE (parm
)) != BLKmode
2761 /* If by-reference argument was promoted, demote it. */
2762 && (TYPE_MODE (TREE_TYPE (parm
)) != GET_MODE (DECL_RTL (parm
))
2763 || use_register_for_decl (parm
)))
2765 /* We can't use nominal_mode, because it will have been set to
2766 Pmode above. We must use the actual mode of the parm. */
2767 parmreg
= gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm
)));
2768 mark_user_reg (parmreg
);
2770 if (GET_MODE (parmreg
) != GET_MODE (DECL_RTL (parm
)))
2772 rtx tempreg
= gen_reg_rtx (GET_MODE (DECL_RTL (parm
)));
2773 int unsigned_p
= TYPE_UNSIGNED (TREE_TYPE (parm
));
2775 push_to_sequence2 (all
->first_conversion_insn
,
2776 all
->last_conversion_insn
);
2777 emit_move_insn (tempreg
, DECL_RTL (parm
));
2778 tempreg
= convert_to_mode (GET_MODE (parmreg
), tempreg
, unsigned_p
);
2779 emit_move_insn (parmreg
, tempreg
);
2780 all
->first_conversion_insn
= get_insns ();
2781 all
->last_conversion_insn
= get_last_insn ();
2784 did_conversion
= true;
2787 emit_move_insn (parmreg
, DECL_RTL (parm
));
2789 SET_DECL_RTL (parm
, parmreg
);
2791 /* STACK_PARM is the pointer, not the parm, and PARMREG is
2793 data
->stack_parm
= NULL
;
2796 /* Mark the register as eliminable if we did no conversion and it was
2797 copied from memory at a fixed offset, and the arg pointer was not
2798 copied to a pseudo-reg. If the arg pointer is a pseudo reg or the
2799 offset formed an invalid address, such memory-equivalences as we
2800 make here would screw up life analysis for it. */
2801 if (data
->nominal_mode
== data
->passed_mode
2803 && data
->stack_parm
!= 0
2804 && MEM_P (data
->stack_parm
)
2805 && data
->locate
.offset
.var
== 0
2806 && reg_mentioned_p (virtual_incoming_args_rtx
,
2807 XEXP (data
->stack_parm
, 0)))
2809 rtx linsn
= get_last_insn ();
2812 /* Mark complex types separately. */
2813 if (GET_CODE (parmreg
) == CONCAT
)
2815 enum machine_mode submode
2816 = GET_MODE_INNER (GET_MODE (parmreg
));
2817 int regnor
= REGNO (XEXP (parmreg
, 0));
2818 int regnoi
= REGNO (XEXP (parmreg
, 1));
2819 rtx stackr
= adjust_address_nv (data
->stack_parm
, submode
, 0);
2820 rtx stacki
= adjust_address_nv (data
->stack_parm
, submode
,
2821 GET_MODE_SIZE (submode
));
2823 /* Scan backwards for the set of the real and
2825 for (sinsn
= linsn
; sinsn
!= 0;
2826 sinsn
= prev_nonnote_insn (sinsn
))
2828 set
= single_set (sinsn
);
2832 if (SET_DEST (set
) == regno_reg_rtx
[regnoi
])
2833 set_unique_reg_note (sinsn
, REG_EQUIV
, stacki
);
2834 else if (SET_DEST (set
) == regno_reg_rtx
[regnor
])
2835 set_unique_reg_note (sinsn
, REG_EQUIV
, stackr
);
2838 else if ((set
= single_set (linsn
)) != 0
2839 && SET_DEST (set
) == parmreg
)
2840 set_unique_reg_note (linsn
, REG_EQUIV
, data
->stack_parm
);
2843 /* For pointer data type, suggest pointer register. */
2844 if (POINTER_TYPE_P (TREE_TYPE (parm
)))
2845 mark_reg_pointer (parmreg
,
2846 TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm
))));
2849 /* A subroutine of assign_parms. Allocate stack space to hold the current
2850 parameter. Get it there. Perform all ABI specified conversions. */
2853 assign_parm_setup_stack (struct assign_parm_data_all
*all
, tree parm
,
2854 struct assign_parm_data_one
*data
)
2856 /* Value must be stored in the stack slot STACK_PARM during function
2858 bool to_conversion
= false;
2860 if (data
->promoted_mode
!= data
->nominal_mode
)
2862 /* Conversion is required. */
2863 rtx tempreg
= gen_reg_rtx (GET_MODE (data
->entry_parm
));
2865 emit_move_insn (tempreg
, validize_mem (data
->entry_parm
));
2867 push_to_sequence2 (all
->first_conversion_insn
, all
->last_conversion_insn
);
2868 to_conversion
= true;
2870 data
->entry_parm
= convert_to_mode (data
->nominal_mode
, tempreg
,
2871 TYPE_UNSIGNED (TREE_TYPE (parm
)));
2873 if (data
->stack_parm
)
2874 /* ??? This may need a big-endian conversion on sparc64. */
2876 = adjust_address (data
->stack_parm
, data
->nominal_mode
, 0);
2879 if (data
->entry_parm
!= data
->stack_parm
)
2883 if (data
->stack_parm
== 0)
2886 = assign_stack_local (GET_MODE (data
->entry_parm
),
2887 GET_MODE_SIZE (GET_MODE (data
->entry_parm
)),
2888 TYPE_ALIGN (data
->passed_type
));
2889 set_mem_attributes (data
->stack_parm
, parm
, 1);
2892 dest
= validize_mem (data
->stack_parm
);
2893 src
= validize_mem (data
->entry_parm
);
2897 /* Use a block move to handle potentially misaligned entry_parm. */
2899 push_to_sequence2 (all
->first_conversion_insn
,
2900 all
->last_conversion_insn
);
2901 to_conversion
= true;
2903 emit_block_move (dest
, src
,
2904 GEN_INT (int_size_in_bytes (data
->passed_type
)),
2908 emit_move_insn (dest
, src
);
2913 all
->first_conversion_insn
= get_insns ();
2914 all
->last_conversion_insn
= get_last_insn ();
2918 SET_DECL_RTL (parm
, data
->stack_parm
);
2921 /* A subroutine of assign_parms. If the ABI splits complex arguments, then
2922 undo the frobbing that we did in assign_parms_augmented_arg_list. */
2925 assign_parms_unsplit_complex (struct assign_parm_data_all
*all
, tree fnargs
)
2928 tree orig_fnargs
= all
->orig_fnargs
;
2930 for (parm
= orig_fnargs
; parm
; parm
= TREE_CHAIN (parm
))
2932 if (TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
2933 && targetm
.calls
.split_complex_arg (TREE_TYPE (parm
)))
2935 rtx tmp
, real
, imag
;
2936 enum machine_mode inner
= GET_MODE_INNER (DECL_MODE (parm
));
2938 real
= DECL_RTL (fnargs
);
2939 imag
= DECL_RTL (TREE_CHAIN (fnargs
));
2940 if (inner
!= GET_MODE (real
))
2942 real
= gen_lowpart_SUBREG (inner
, real
);
2943 imag
= gen_lowpart_SUBREG (inner
, imag
);
2946 if (TREE_ADDRESSABLE (parm
))
2949 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (parm
));
2951 /* split_complex_arg put the real and imag parts in
2952 pseudos. Move them to memory. */
2953 tmp
= assign_stack_local (DECL_MODE (parm
), size
,
2954 TYPE_ALIGN (TREE_TYPE (parm
)));
2955 set_mem_attributes (tmp
, parm
, 1);
2956 rmem
= adjust_address_nv (tmp
, inner
, 0);
2957 imem
= adjust_address_nv (tmp
, inner
, GET_MODE_SIZE (inner
));
2958 push_to_sequence2 (all
->first_conversion_insn
,
2959 all
->last_conversion_insn
);
2960 emit_move_insn (rmem
, real
);
2961 emit_move_insn (imem
, imag
);
2962 all
->first_conversion_insn
= get_insns ();
2963 all
->last_conversion_insn
= get_last_insn ();
2967 tmp
= gen_rtx_CONCAT (DECL_MODE (parm
), real
, imag
);
2968 SET_DECL_RTL (parm
, tmp
);
2970 real
= DECL_INCOMING_RTL (fnargs
);
2971 imag
= DECL_INCOMING_RTL (TREE_CHAIN (fnargs
));
2972 if (inner
!= GET_MODE (real
))
2974 real
= gen_lowpart_SUBREG (inner
, real
);
2975 imag
= gen_lowpart_SUBREG (inner
, imag
);
2977 tmp
= gen_rtx_CONCAT (DECL_MODE (parm
), real
, imag
);
2978 set_decl_incoming_rtl (parm
, tmp
, false);
2979 fnargs
= TREE_CHAIN (fnargs
);
2983 SET_DECL_RTL (parm
, DECL_RTL (fnargs
));
2984 set_decl_incoming_rtl (parm
, DECL_INCOMING_RTL (fnargs
), false);
2986 /* Set MEM_EXPR to the original decl, i.e. to PARM,
2987 instead of the copy of decl, i.e. FNARGS. */
2988 if (DECL_INCOMING_RTL (parm
) && MEM_P (DECL_INCOMING_RTL (parm
)))
2989 set_mem_expr (DECL_INCOMING_RTL (parm
), parm
);
2992 fnargs
= TREE_CHAIN (fnargs
);
2996 /* Assign RTL expressions to the function's parameters. This may involve
2997 copying them into registers and using those registers as the DECL_RTL. */
3000 assign_parms (tree fndecl
)
3002 struct assign_parm_data_all all
;
3005 current_function_internal_arg_pointer
3006 = targetm
.calls
.internal_arg_pointer ();
3008 assign_parms_initialize_all (&all
);
3009 fnargs
= assign_parms_augmented_arg_list (&all
);
3011 for (parm
= fnargs
; parm
; parm
= TREE_CHAIN (parm
))
3013 struct assign_parm_data_one data
;
3015 /* Extract the type of PARM; adjust it according to ABI. */
3016 assign_parm_find_data_types (&all
, parm
, &data
);
3018 /* Early out for errors and void parameters. */
3019 if (data
.passed_mode
== VOIDmode
)
3021 SET_DECL_RTL (parm
, const0_rtx
);
3022 DECL_INCOMING_RTL (parm
) = DECL_RTL (parm
);
3026 if (current_function_stdarg
&& !TREE_CHAIN (parm
))
3027 assign_parms_setup_varargs (&all
, &data
, false);
3029 /* Find out where the parameter arrives in this function. */
3030 assign_parm_find_entry_rtl (&all
, &data
);
3032 /* Find out where stack space for this parameter might be. */
3033 if (assign_parm_is_stack_parm (&all
, &data
))
3035 assign_parm_find_stack_rtl (parm
, &data
);
3036 assign_parm_adjust_entry_rtl (&data
);
3039 /* Record permanently how this parm was passed. */
3040 set_decl_incoming_rtl (parm
, data
.entry_parm
, data
.passed_pointer
);
3042 /* Update info on where next arg arrives in registers. */
3043 FUNCTION_ARG_ADVANCE (all
.args_so_far
, data
.promoted_mode
,
3044 data
.passed_type
, data
.named_arg
);
3046 assign_parm_adjust_stack_rtl (&data
);
3048 if (assign_parm_setup_block_p (&data
))
3049 assign_parm_setup_block (&all
, parm
, &data
);
3050 else if (data
.passed_pointer
|| use_register_for_decl (parm
))
3051 assign_parm_setup_reg (&all
, parm
, &data
);
3053 assign_parm_setup_stack (&all
, parm
, &data
);
3056 if (targetm
.calls
.split_complex_arg
&& fnargs
!= all
.orig_fnargs
)
3057 assign_parms_unsplit_complex (&all
, fnargs
);
3059 /* Output all parameter conversion instructions (possibly including calls)
3060 now that all parameters have been copied out of hard registers. */
3061 emit_insn (all
.first_conversion_insn
);
3063 /* If we are receiving a struct value address as the first argument, set up
3064 the RTL for the function result. As this might require code to convert
3065 the transmitted address to Pmode, we do this here to ensure that possible
3066 preliminary conversions of the address have been emitted already. */
3067 if (all
.function_result_decl
)
3069 tree result
= DECL_RESULT (current_function_decl
);
3070 rtx addr
= DECL_RTL (all
.function_result_decl
);
3073 if (DECL_BY_REFERENCE (result
))
3077 addr
= convert_memory_address (Pmode
, addr
);
3078 x
= gen_rtx_MEM (DECL_MODE (result
), addr
);
3079 set_mem_attributes (x
, result
, 1);
3081 SET_DECL_RTL (result
, x
);
3084 /* We have aligned all the args, so add space for the pretend args. */
3085 current_function_pretend_args_size
= all
.pretend_args_size
;
3086 all
.stack_args_size
.constant
+= all
.extra_pretend_bytes
;
3087 current_function_args_size
= all
.stack_args_size
.constant
;
3089 /* Adjust function incoming argument size for alignment and
3092 #ifdef REG_PARM_STACK_SPACE
3093 current_function_args_size
= MAX (current_function_args_size
,
3094 REG_PARM_STACK_SPACE (fndecl
));
3097 current_function_args_size
= CEIL_ROUND (current_function_args_size
,
3098 PARM_BOUNDARY
/ BITS_PER_UNIT
);
3100 #ifdef ARGS_GROW_DOWNWARD
3101 current_function_arg_offset_rtx
3102 = (all
.stack_args_size
.var
== 0 ? GEN_INT (-all
.stack_args_size
.constant
)
3103 : expand_expr (size_diffop (all
.stack_args_size
.var
,
3104 size_int (-all
.stack_args_size
.constant
)),
3105 NULL_RTX
, VOIDmode
, 0));
3107 current_function_arg_offset_rtx
= ARGS_SIZE_RTX (all
.stack_args_size
);
3110 /* See how many bytes, if any, of its args a function should try to pop
3113 current_function_pops_args
= RETURN_POPS_ARGS (fndecl
, TREE_TYPE (fndecl
),
3114 current_function_args_size
);
3116 /* For stdarg.h function, save info about
3117 regs and stack space used by the named args. */
3119 current_function_args_info
= all
.args_so_far
;
3121 /* Set the rtx used for the function return value. Put this in its
3122 own variable so any optimizers that need this information don't have
3123 to include tree.h. Do this here so it gets done when an inlined
3124 function gets output. */
3126 current_function_return_rtx
3127 = (DECL_RTL_SET_P (DECL_RESULT (fndecl
))
3128 ? DECL_RTL (DECL_RESULT (fndecl
)) : NULL_RTX
);
3130 /* If scalar return value was computed in a pseudo-reg, or was a named
3131 return value that got dumped to the stack, copy that to the hard
3133 if (DECL_RTL_SET_P (DECL_RESULT (fndecl
)))
3135 tree decl_result
= DECL_RESULT (fndecl
);
3136 rtx decl_rtl
= DECL_RTL (decl_result
);
3138 if (REG_P (decl_rtl
)
3139 ? REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
3140 : DECL_REGISTER (decl_result
))
3144 real_decl_rtl
= targetm
.calls
.function_value (TREE_TYPE (decl_result
),
3146 REG_FUNCTION_VALUE_P (real_decl_rtl
) = 1;
3147 /* The delay slot scheduler assumes that current_function_return_rtx
3148 holds the hard register containing the return value, not a
3149 temporary pseudo. */
3150 current_function_return_rtx
= real_decl_rtl
;
3155 /* A subroutine of gimplify_parameters, invoked via walk_tree.
3156 For all seen types, gimplify their sizes. */
3159 gimplify_parm_type (tree
*tp
, int *walk_subtrees
, void *data
)
3166 if (POINTER_TYPE_P (t
))
3168 else if (TYPE_SIZE (t
) && !TREE_CONSTANT (TYPE_SIZE (t
))
3169 && !TYPE_SIZES_GIMPLIFIED (t
))
3171 gimplify_type_sizes (t
, (tree
*) data
);
3179 /* Gimplify the parameter list for current_function_decl. This involves
3180 evaluating SAVE_EXPRs of variable sized parameters and generating code
3181 to implement callee-copies reference parameters. Returns a list of
3182 statements to add to the beginning of the function, or NULL if nothing
3186 gimplify_parameters (void)
3188 struct assign_parm_data_all all
;
3189 tree fnargs
, parm
, stmts
= NULL
;
3191 assign_parms_initialize_all (&all
);
3192 fnargs
= assign_parms_augmented_arg_list (&all
);
3194 for (parm
= fnargs
; parm
; parm
= TREE_CHAIN (parm
))
3196 struct assign_parm_data_one data
;
3198 /* Extract the type of PARM; adjust it according to ABI. */
3199 assign_parm_find_data_types (&all
, parm
, &data
);
3201 /* Early out for errors and void parameters. */
3202 if (data
.passed_mode
== VOIDmode
|| DECL_SIZE (parm
) == NULL
)
3205 /* Update info on where next arg arrives in registers. */
3206 FUNCTION_ARG_ADVANCE (all
.args_so_far
, data
.promoted_mode
,
3207 data
.passed_type
, data
.named_arg
);
3209 /* ??? Once upon a time variable_size stuffed parameter list
3210 SAVE_EXPRs (amongst others) onto a pending sizes list. This
3211 turned out to be less than manageable in the gimple world.
3212 Now we have to hunt them down ourselves. */
3213 walk_tree_without_duplicates (&data
.passed_type
,
3214 gimplify_parm_type
, &stmts
);
3216 if (!TREE_CONSTANT (DECL_SIZE (parm
)))
3218 gimplify_one_sizepos (&DECL_SIZE (parm
), &stmts
);
3219 gimplify_one_sizepos (&DECL_SIZE_UNIT (parm
), &stmts
);
3222 if (data
.passed_pointer
)
3224 tree type
= TREE_TYPE (data
.passed_type
);
3225 if (reference_callee_copied (&all
.args_so_far
, TYPE_MODE (type
),
3226 type
, data
.named_arg
))
3230 /* For constant sized objects, this is trivial; for
3231 variable-sized objects, we have to play games. */
3232 if (TREE_CONSTANT (DECL_SIZE (parm
)))
3234 local
= create_tmp_var (type
, get_name (parm
));
3235 DECL_IGNORED_P (local
) = 0;
3239 tree ptr_type
, addr
;
3241 ptr_type
= build_pointer_type (type
);
3242 addr
= create_tmp_var (ptr_type
, get_name (parm
));
3243 DECL_IGNORED_P (addr
) = 0;
3244 local
= build_fold_indirect_ref (addr
);
3246 t
= built_in_decls
[BUILT_IN_ALLOCA
];
3247 t
= build_call_expr (t
, 1, DECL_SIZE_UNIT (parm
));
3248 t
= fold_convert (ptr_type
, t
);
3249 t
= build_gimple_modify_stmt (addr
, t
);
3250 gimplify_and_add (t
, &stmts
);
3253 t
= build_gimple_modify_stmt (local
, parm
);
3254 gimplify_and_add (t
, &stmts
);
3256 SET_DECL_VALUE_EXPR (parm
, local
);
3257 DECL_HAS_VALUE_EXPR_P (parm
) = 1;
3265 /* Compute the size and offset from the start of the stacked arguments for a
3266 parm passed in mode PASSED_MODE and with type TYPE.
3268 INITIAL_OFFSET_PTR points to the current offset into the stacked
3271 The starting offset and size for this parm are returned in
3272 LOCATE->OFFSET and LOCATE->SIZE, respectively. When IN_REGS is
3273 nonzero, the offset is that of stack slot, which is returned in
3274 LOCATE->SLOT_OFFSET. LOCATE->ALIGNMENT_PAD is the amount of
3275 padding required from the initial offset ptr to the stack slot.
3277 IN_REGS is nonzero if the argument will be passed in registers. It will
3278 never be set if REG_PARM_STACK_SPACE is not defined.
3280 FNDECL is the function in which the argument was defined.
3282 There are two types of rounding that are done. The first, controlled by
3283 FUNCTION_ARG_BOUNDARY, forces the offset from the start of the argument
3284 list to be aligned to the specific boundary (in bits). This rounding
3285 affects the initial and starting offsets, but not the argument size.
3287 The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY,
3288 optionally rounds the size of the parm to PARM_BOUNDARY. The
3289 initial offset is not affected by this rounding, while the size always
3290 is and the starting offset may be. */
3292 /* LOCATE->OFFSET will be negative for ARGS_GROW_DOWNWARD case;
3293 INITIAL_OFFSET_PTR is positive because locate_and_pad_parm's
3294 callers pass in the total size of args so far as
3295 INITIAL_OFFSET_PTR. LOCATE->SIZE is always positive. */
3298 locate_and_pad_parm (enum machine_mode passed_mode
, tree type
, int in_regs
,
3299 int partial
, tree fndecl ATTRIBUTE_UNUSED
,
3300 struct args_size
*initial_offset_ptr
,
3301 struct locate_and_pad_arg_data
*locate
)
3304 enum direction where_pad
;
3305 unsigned int boundary
;
3306 int reg_parm_stack_space
= 0;
3307 int part_size_in_regs
;
3309 #ifdef REG_PARM_STACK_SPACE
3310 reg_parm_stack_space
= REG_PARM_STACK_SPACE (fndecl
);
3312 /* If we have found a stack parm before we reach the end of the
3313 area reserved for registers, skip that area. */
3316 if (reg_parm_stack_space
> 0)
3318 if (initial_offset_ptr
->var
)
3320 initial_offset_ptr
->var
3321 = size_binop (MAX_EXPR
, ARGS_SIZE_TREE (*initial_offset_ptr
),
3322 ssize_int (reg_parm_stack_space
));
3323 initial_offset_ptr
->constant
= 0;
3325 else if (initial_offset_ptr
->constant
< reg_parm_stack_space
)
3326 initial_offset_ptr
->constant
= reg_parm_stack_space
;
3329 #endif /* REG_PARM_STACK_SPACE */
3331 part_size_in_regs
= (reg_parm_stack_space
== 0 ? partial
: 0);
3334 = type
? size_in_bytes (type
) : size_int (GET_MODE_SIZE (passed_mode
));
3335 where_pad
= FUNCTION_ARG_PADDING (passed_mode
, type
);
3336 boundary
= FUNCTION_ARG_BOUNDARY (passed_mode
, type
);
3337 locate
->where_pad
= where_pad
;
3338 locate
->boundary
= boundary
;
3340 /* Remember if the outgoing parameter requires extra alignment on the
3341 calling function side. */
3342 if (boundary
> PREFERRED_STACK_BOUNDARY
)
3343 boundary
= PREFERRED_STACK_BOUNDARY
;
3344 if (cfun
->stack_alignment_needed
< boundary
)
3345 cfun
->stack_alignment_needed
= boundary
;
3347 #ifdef ARGS_GROW_DOWNWARD
3348 locate
->slot_offset
.constant
= -initial_offset_ptr
->constant
;
3349 if (initial_offset_ptr
->var
)
3350 locate
->slot_offset
.var
= size_binop (MINUS_EXPR
, ssize_int (0),
3351 initial_offset_ptr
->var
);
3355 if (where_pad
!= none
3356 && (!host_integerp (sizetree
, 1)
3357 || (tree_low_cst (sizetree
, 1) * BITS_PER_UNIT
) % PARM_BOUNDARY
))
3358 s2
= round_up (s2
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
3359 SUB_PARM_SIZE (locate
->slot_offset
, s2
);
3362 locate
->slot_offset
.constant
+= part_size_in_regs
;
3365 #ifdef REG_PARM_STACK_SPACE
3366 || REG_PARM_STACK_SPACE (fndecl
) > 0
3369 pad_to_arg_alignment (&locate
->slot_offset
, boundary
,
3370 &locate
->alignment_pad
);
3372 locate
->size
.constant
= (-initial_offset_ptr
->constant
3373 - locate
->slot_offset
.constant
);
3374 if (initial_offset_ptr
->var
)
3375 locate
->size
.var
= size_binop (MINUS_EXPR
,
3376 size_binop (MINUS_EXPR
,
3378 initial_offset_ptr
->var
),
3379 locate
->slot_offset
.var
);
3381 /* Pad_below needs the pre-rounded size to know how much to pad
3383 locate
->offset
= locate
->slot_offset
;
3384 if (where_pad
== downward
)
3385 pad_below (&locate
->offset
, passed_mode
, sizetree
);
3387 #else /* !ARGS_GROW_DOWNWARD */
3389 #ifdef REG_PARM_STACK_SPACE
3390 || REG_PARM_STACK_SPACE (fndecl
) > 0
3393 pad_to_arg_alignment (initial_offset_ptr
, boundary
,
3394 &locate
->alignment_pad
);
3395 locate
->slot_offset
= *initial_offset_ptr
;
3397 #ifdef PUSH_ROUNDING
3398 if (passed_mode
!= BLKmode
)
3399 sizetree
= size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree
)));
3402 /* Pad_below needs the pre-rounded size to know how much to pad below
3403 so this must be done before rounding up. */
3404 locate
->offset
= locate
->slot_offset
;
3405 if (where_pad
== downward
)
3406 pad_below (&locate
->offset
, passed_mode
, sizetree
);
3408 if (where_pad
!= none
3409 && (!host_integerp (sizetree
, 1)
3410 || (tree_low_cst (sizetree
, 1) * BITS_PER_UNIT
) % PARM_BOUNDARY
))
3411 sizetree
= round_up (sizetree
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
3413 ADD_PARM_SIZE (locate
->size
, sizetree
);
3415 locate
->size
.constant
-= part_size_in_regs
;
3416 #endif /* ARGS_GROW_DOWNWARD */
3419 /* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY.
3420 BOUNDARY is measured in bits, but must be a multiple of a storage unit. */
3423 pad_to_arg_alignment (struct args_size
*offset_ptr
, int boundary
,
3424 struct args_size
*alignment_pad
)
3426 tree save_var
= NULL_TREE
;
3427 HOST_WIDE_INT save_constant
= 0;
3428 int boundary_in_bytes
= boundary
/ BITS_PER_UNIT
;
3429 HOST_WIDE_INT sp_offset
= STACK_POINTER_OFFSET
;
3431 #ifdef SPARC_STACK_BOUNDARY_HACK
3432 /* ??? The SPARC port may claim a STACK_BOUNDARY higher than
3433 the real alignment of %sp. However, when it does this, the
3434 alignment of %sp+STACK_POINTER_OFFSET is STACK_BOUNDARY. */
3435 if (SPARC_STACK_BOUNDARY_HACK
)
3439 if (boundary
> PARM_BOUNDARY
&& boundary
> STACK_BOUNDARY
)
3441 save_var
= offset_ptr
->var
;
3442 save_constant
= offset_ptr
->constant
;
3445 alignment_pad
->var
= NULL_TREE
;
3446 alignment_pad
->constant
= 0;
3448 if (boundary
> BITS_PER_UNIT
)
3450 if (offset_ptr
->var
)
3452 tree sp_offset_tree
= ssize_int (sp_offset
);
3453 tree offset
= size_binop (PLUS_EXPR
,
3454 ARGS_SIZE_TREE (*offset_ptr
),
3456 #ifdef ARGS_GROW_DOWNWARD
3457 tree rounded
= round_down (offset
, boundary
/ BITS_PER_UNIT
);
3459 tree rounded
= round_up (offset
, boundary
/ BITS_PER_UNIT
);
3462 offset_ptr
->var
= size_binop (MINUS_EXPR
, rounded
, sp_offset_tree
);
3463 /* ARGS_SIZE_TREE includes constant term. */
3464 offset_ptr
->constant
= 0;
3465 if (boundary
> PARM_BOUNDARY
&& boundary
> STACK_BOUNDARY
)
3466 alignment_pad
->var
= size_binop (MINUS_EXPR
, offset_ptr
->var
,
3471 offset_ptr
->constant
= -sp_offset
+
3472 #ifdef ARGS_GROW_DOWNWARD
3473 FLOOR_ROUND (offset_ptr
->constant
+ sp_offset
, boundary_in_bytes
);
3475 CEIL_ROUND (offset_ptr
->constant
+ sp_offset
, boundary_in_bytes
);
3477 if (boundary
> PARM_BOUNDARY
&& boundary
> STACK_BOUNDARY
)
3478 alignment_pad
->constant
= offset_ptr
->constant
- save_constant
;
3484 pad_below (struct args_size
*offset_ptr
, enum machine_mode passed_mode
, tree sizetree
)
3486 if (passed_mode
!= BLKmode
)
3488 if (GET_MODE_BITSIZE (passed_mode
) % PARM_BOUNDARY
)
3489 offset_ptr
->constant
3490 += (((GET_MODE_BITSIZE (passed_mode
) + PARM_BOUNDARY
- 1)
3491 / PARM_BOUNDARY
* PARM_BOUNDARY
/ BITS_PER_UNIT
)
3492 - GET_MODE_SIZE (passed_mode
));
3496 if (TREE_CODE (sizetree
) != INTEGER_CST
3497 || (TREE_INT_CST_LOW (sizetree
) * BITS_PER_UNIT
) % PARM_BOUNDARY
)
3499 /* Round the size up to multiple of PARM_BOUNDARY bits. */
3500 tree s2
= round_up (sizetree
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
3502 ADD_PARM_SIZE (*offset_ptr
, s2
);
3503 SUB_PARM_SIZE (*offset_ptr
, sizetree
);
3509 /* True if register REGNO was alive at a place where `setjmp' was
3510 called and was set more than once or is an argument. Such regs may
3511 be clobbered by `longjmp'. */
3514 regno_clobbered_at_setjmp (bitmap setjmp_crosses
, int regno
)
3516 /* There appear to be cases where some local vars never reach the
3517 backend but have bogus regnos. */
3518 if (regno
>= max_reg_num ())
3521 return ((REG_N_SETS (regno
) > 1
3522 || REGNO_REG_SET_P (df_get_live_out (ENTRY_BLOCK_PTR
), regno
))
3523 && REGNO_REG_SET_P (setjmp_crosses
, regno
));
3526 /* Walk the tree of blocks describing the binding levels within a
3527 function and warn about variables the might be killed by setjmp or
3528 vfork. This is done after calling flow_analysis before register
3529 allocation since that will clobber the pseudo-regs to hard
3533 setjmp_vars_warning (bitmap setjmp_crosses
, tree block
)
3537 for (decl
= BLOCK_VARS (block
); decl
; decl
= TREE_CHAIN (decl
))
3539 if (TREE_CODE (decl
) == VAR_DECL
3540 && DECL_RTL_SET_P (decl
)
3541 && REG_P (DECL_RTL (decl
))
3542 && regno_clobbered_at_setjmp (setjmp_crosses
, REGNO (DECL_RTL (decl
))))
3543 warning (OPT_Wclobbered
, "variable %q+D might be clobbered by"
3544 " %<longjmp%> or %<vfork%>", decl
);
3547 for (sub
= BLOCK_SUBBLOCKS (block
); sub
; sub
= BLOCK_CHAIN (sub
))
3548 setjmp_vars_warning (setjmp_crosses
, sub
);
3551 /* Do the appropriate part of setjmp_vars_warning
3552 but for arguments instead of local variables. */
3555 setjmp_args_warning (bitmap setjmp_crosses
)
3558 for (decl
= DECL_ARGUMENTS (current_function_decl
);
3559 decl
; decl
= TREE_CHAIN (decl
))
3560 if (DECL_RTL (decl
) != 0
3561 && REG_P (DECL_RTL (decl
))
3562 && regno_clobbered_at_setjmp (setjmp_crosses
, REGNO (DECL_RTL (decl
))))
3563 warning (OPT_Wclobbered
,
3564 "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>",
3568 /* Generate warning messages for variables live across setjmp. */
3571 generate_setjmp_warnings (void)
3573 bitmap setjmp_crosses
= regstat_get_setjmp_crosses ();
3575 if (n_basic_blocks
== NUM_FIXED_BLOCKS
3576 || bitmap_empty_p (setjmp_crosses
))
3579 setjmp_vars_warning (setjmp_crosses
, DECL_INITIAL (current_function_decl
));
3580 setjmp_args_warning (setjmp_crosses
);
3584 /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
3585 and create duplicate blocks. */
3586 /* ??? Need an option to either create block fragments or to create
3587 abstract origin duplicates of a source block. It really depends
3588 on what optimization has been performed. */
3591 reorder_blocks (void)
3593 tree block
= DECL_INITIAL (current_function_decl
);
3594 VEC(tree
,heap
) *block_stack
;
3596 if (block
== NULL_TREE
)
3599 block_stack
= VEC_alloc (tree
, heap
, 10);
3601 /* Reset the TREE_ASM_WRITTEN bit for all blocks. */
3602 clear_block_marks (block
);
3604 /* Prune the old trees away, so that they don't get in the way. */
3605 BLOCK_SUBBLOCKS (block
) = NULL_TREE
;
3606 BLOCK_CHAIN (block
) = NULL_TREE
;
3608 /* Recreate the block tree from the note nesting. */
3609 reorder_blocks_1 (get_insns (), block
, &block_stack
);
3610 BLOCK_SUBBLOCKS (block
) = blocks_nreverse (BLOCK_SUBBLOCKS (block
));
3612 VEC_free (tree
, heap
, block_stack
);
3615 /* Helper function for reorder_blocks. Reset TREE_ASM_WRITTEN. */
3618 clear_block_marks (tree block
)
3622 TREE_ASM_WRITTEN (block
) = 0;
3623 clear_block_marks (BLOCK_SUBBLOCKS (block
));
3624 block
= BLOCK_CHAIN (block
);
3629 reorder_blocks_1 (rtx insns
, tree current_block
, VEC(tree
,heap
) **p_block_stack
)
3633 for (insn
= insns
; insn
; insn
= NEXT_INSN (insn
))
3637 if (NOTE_KIND (insn
) == NOTE_INSN_BLOCK_BEG
)
3639 tree block
= NOTE_BLOCK (insn
);
3642 origin
= (BLOCK_FRAGMENT_ORIGIN (block
)
3643 ? BLOCK_FRAGMENT_ORIGIN (block
)
3646 /* If we have seen this block before, that means it now
3647 spans multiple address regions. Create a new fragment. */
3648 if (TREE_ASM_WRITTEN (block
))
3650 tree new_block
= copy_node (block
);
3652 BLOCK_FRAGMENT_ORIGIN (new_block
) = origin
;
3653 BLOCK_FRAGMENT_CHAIN (new_block
)
3654 = BLOCK_FRAGMENT_CHAIN (origin
);
3655 BLOCK_FRAGMENT_CHAIN (origin
) = new_block
;
3657 NOTE_BLOCK (insn
) = new_block
;
3661 BLOCK_SUBBLOCKS (block
) = 0;
3662 TREE_ASM_WRITTEN (block
) = 1;
3663 /* When there's only one block for the entire function,
3664 current_block == block and we mustn't do this, it
3665 will cause infinite recursion. */
3666 if (block
!= current_block
)
3668 if (block
!= origin
)
3669 gcc_assert (BLOCK_SUPERCONTEXT (origin
) == current_block
);
3671 BLOCK_SUPERCONTEXT (block
) = current_block
;
3672 BLOCK_CHAIN (block
) = BLOCK_SUBBLOCKS (current_block
);
3673 BLOCK_SUBBLOCKS (current_block
) = block
;
3674 current_block
= origin
;
3676 VEC_safe_push (tree
, heap
, *p_block_stack
, block
);
3678 else if (NOTE_KIND (insn
) == NOTE_INSN_BLOCK_END
)
3680 NOTE_BLOCK (insn
) = VEC_pop (tree
, *p_block_stack
);
3681 BLOCK_SUBBLOCKS (current_block
)
3682 = blocks_nreverse (BLOCK_SUBBLOCKS (current_block
));
3683 current_block
= BLOCK_SUPERCONTEXT (current_block
);
3689 /* Reverse the order of elements in the chain T of blocks,
3690 and return the new head of the chain (old last element). */
3693 blocks_nreverse (tree t
)
3695 tree prev
= 0, decl
, next
;
3696 for (decl
= t
; decl
; decl
= next
)
3698 next
= BLOCK_CHAIN (decl
);
3699 BLOCK_CHAIN (decl
) = prev
;
3705 /* Count the subblocks of the list starting with BLOCK. If VECTOR is
3706 non-NULL, list them all into VECTOR, in a depth-first preorder
3707 traversal of the block tree. Also clear TREE_ASM_WRITTEN in all
3711 all_blocks (tree block
, tree
*vector
)
3717 TREE_ASM_WRITTEN (block
) = 0;
3719 /* Record this block. */
3721 vector
[n_blocks
] = block
;
3725 /* Record the subblocks, and their subblocks... */
3726 n_blocks
+= all_blocks (BLOCK_SUBBLOCKS (block
),
3727 vector
? vector
+ n_blocks
: 0);
3728 block
= BLOCK_CHAIN (block
);
3734 /* Return a vector containing all the blocks rooted at BLOCK. The
3735 number of elements in the vector is stored in N_BLOCKS_P. The
3736 vector is dynamically allocated; it is the caller's responsibility
3737 to call `free' on the pointer returned. */
3740 get_block_vector (tree block
, int *n_blocks_p
)
3744 *n_blocks_p
= all_blocks (block
, NULL
);
3745 block_vector
= XNEWVEC (tree
, *n_blocks_p
);
3746 all_blocks (block
, block_vector
);
3748 return block_vector
;
3751 static GTY(()) int next_block_index
= 2;
3753 /* Set BLOCK_NUMBER for all the blocks in FN. */
3756 number_blocks (tree fn
)
3762 /* For SDB and XCOFF debugging output, we start numbering the blocks
3763 from 1 within each function, rather than keeping a running
3765 #if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
3766 if (write_symbols
== SDB_DEBUG
|| write_symbols
== XCOFF_DEBUG
)
3767 next_block_index
= 1;
3770 block_vector
= get_block_vector (DECL_INITIAL (fn
), &n_blocks
);
3772 /* The top-level BLOCK isn't numbered at all. */
3773 for (i
= 1; i
< n_blocks
; ++i
)
3774 /* We number the blocks from two. */
3775 BLOCK_NUMBER (block_vector
[i
]) = next_block_index
++;
3777 free (block_vector
);
3782 /* If VAR is present in a subblock of BLOCK, return the subblock. */
3785 debug_find_var_in_block_tree (tree var
, tree block
)
3789 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
3793 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= TREE_CHAIN (t
))
3795 tree ret
= debug_find_var_in_block_tree (var
, t
);
3803 /* Keep track of whether we're in a dummy function context. If we are,
3804 we don't want to invoke the set_current_function hook, because we'll
3805 get into trouble if the hook calls target_reinit () recursively or
3806 when the initial initialization is not yet complete. */
3808 static bool in_dummy_function
;
3810 /* Invoke the target hook when setting cfun. */
3813 invoke_set_current_function_hook (tree fndecl
)
3815 if (!in_dummy_function
)
3816 targetm
.set_current_function (fndecl
);
3819 /* cfun should never be set directly; use this function. */
3822 set_cfun (struct function
*new_cfun
)
3824 if (cfun
!= new_cfun
)
3827 invoke_set_current_function_hook (new_cfun
? new_cfun
->decl
: NULL_TREE
);
3831 /* Keep track of the cfun stack. */
3833 typedef struct function
*function_p
;
3835 DEF_VEC_P(function_p
);
3836 DEF_VEC_ALLOC_P(function_p
,heap
);
3838 /* Initialized with NOGC, making this poisonous to the garbage collector. */
3840 static VEC(function_p
,heap
) *cfun_stack
;
3842 /* We save the value of in_system_header here when pushing the first
3843 function on the cfun stack, and we restore it from here when
3844 popping the last function. */
3846 static bool saved_in_system_header
;
3848 /* Push the current cfun onto the stack, and set cfun to new_cfun. */
3851 push_cfun (struct function
*new_cfun
)
3854 saved_in_system_header
= in_system_header
;
3855 VEC_safe_push (function_p
, heap
, cfun_stack
, cfun
);
3857 in_system_header
= DECL_IN_SYSTEM_HEADER (new_cfun
->decl
);
3858 set_cfun (new_cfun
);
3861 /* Pop cfun from the stack. */
3866 struct function
*new_cfun
= VEC_pop (function_p
, cfun_stack
);
3867 in_system_header
= ((new_cfun
== NULL
) ? saved_in_system_header
3868 : DECL_IN_SYSTEM_HEADER (new_cfun
->decl
));
3869 set_cfun (new_cfun
);
3872 /* Return value of funcdef and increase it. */
3874 get_next_funcdef_no (void)
3876 return funcdef_no
++;
3879 /* Allocate a function structure for FNDECL and set its contents
3880 to the defaults. Set cfun to the newly-allocated object.
3881 Some of the helper functions invoked during initialization assume
3882 that cfun has already been set. Therefore, assign the new object
3883 directly into cfun and invoke the back end hook explicitly at the
3884 very end, rather than initializing a temporary and calling set_cfun
3887 ABSTRACT_P is true if this is a function that will never be seen by
3888 the middle-end. Such functions are front-end concepts (like C++
3889 function templates) that do not correspond directly to functions
3890 placed in object files. */
3893 allocate_struct_function (tree fndecl
, bool abstract_p
)
3896 tree fntype
= fndecl
? TREE_TYPE (fndecl
) : NULL_TREE
;
3898 cfun
= ggc_alloc_cleared (sizeof (struct function
));
3900 cfun
->stack_alignment_needed
= STACK_BOUNDARY
;
3901 cfun
->preferred_stack_boundary
= STACK_BOUNDARY
;
3903 current_function_funcdef_no
= get_next_funcdef_no ();
3905 cfun
->function_frequency
= FUNCTION_FREQUENCY_NORMAL
;
3907 init_eh_for_function ();
3909 lang_hooks
.function
.init (cfun
);
3910 if (init_machine_status
)
3911 cfun
->machine
= (*init_machine_status
) ();
3915 DECL_STRUCT_FUNCTION (fndecl
) = cfun
;
3916 cfun
->decl
= fndecl
;
3918 result
= DECL_RESULT (fndecl
);
3919 if (!abstract_p
&& aggregate_value_p (result
, fndecl
))
3921 #ifdef PCC_STATIC_STRUCT_RETURN
3922 current_function_returns_pcc_struct
= 1;
3924 current_function_returns_struct
= 1;
3927 current_function_stdarg
3929 && TYPE_ARG_TYPES (fntype
) != 0
3930 && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype
)))
3931 != void_type_node
));
3933 /* Assume all registers in stdarg functions need to be saved. */
3934 cfun
->va_list_gpr_size
= VA_LIST_MAX_GPR_SIZE
;
3935 cfun
->va_list_fpr_size
= VA_LIST_MAX_FPR_SIZE
;
3938 invoke_set_current_function_hook (fndecl
);
3941 /* This is like allocate_struct_function, but pushes a new cfun for FNDECL
3942 instead of just setting it. */
3945 push_struct_function (tree fndecl
)
3948 saved_in_system_header
= in_system_header
;
3949 VEC_safe_push (function_p
, heap
, cfun_stack
, cfun
);
3951 in_system_header
= DECL_IN_SYSTEM_HEADER (fndecl
);
3952 allocate_struct_function (fndecl
, false);
3955 /* Reset cfun, and other non-struct-function variables to defaults as
3956 appropriate for emitting rtl at the start of a function. */
3959 prepare_function_start (void)
3962 init_varasm_status (cfun
);
3965 cse_not_expected
= ! optimize
;
3967 /* Caller save not needed yet. */
3968 caller_save_needed
= 0;
3970 /* We haven't done register allocation yet. */
3973 /* Indicate that we have not instantiated virtual registers yet. */
3974 virtuals_instantiated
= 0;
3976 /* Indicate that we want CONCATs now. */
3977 generating_concat_p
= 1;
3979 /* Indicate we have no need of a frame pointer yet. */
3980 frame_pointer_needed
= 0;
3983 /* Initialize the rtl expansion mechanism so that we can do simple things
3984 like generate sequences. This is used to provide a context during global
3985 initialization of some passes. You must call expand_dummy_function_end
3986 to exit this context. */
3989 init_dummy_function_start (void)
3991 gcc_assert (!in_dummy_function
);
3992 in_dummy_function
= true;
3993 push_struct_function (NULL_TREE
);
3994 prepare_function_start ();
3997 /* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node)
3998 and initialize static variables for generating RTL for the statements
4002 init_function_start (tree subr
)
4004 if (subr
&& DECL_STRUCT_FUNCTION (subr
))
4005 set_cfun (DECL_STRUCT_FUNCTION (subr
));
4007 allocate_struct_function (subr
, false);
4008 prepare_function_start ();
4010 /* Warn if this value is an aggregate type,
4011 regardless of which calling convention we are using for it. */
4012 if (AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr
))))
4013 warning (OPT_Waggregate_return
, "function returns an aggregate");
4016 /* Make sure all values used by the optimization passes have sane
4019 init_function_for_compilation (void)
4023 /* No prologue/epilogue insns yet. Make sure that these vectors are
4025 gcc_assert (VEC_length (int, prologue
) == 0);
4026 gcc_assert (VEC_length (int, epilogue
) == 0);
4027 gcc_assert (VEC_length (int, sibcall_epilogue
) == 0);
4031 struct tree_opt_pass pass_init_function
=
4035 init_function_for_compilation
, /* execute */
4038 0, /* static_pass_number */
4040 0, /* properties_required */
4041 0, /* properties_provided */
4042 0, /* properties_destroyed */
4043 0, /* todo_flags_start */
4044 0, /* todo_flags_finish */
4050 expand_main_function (void)
4052 #if (defined(INVOKE__main) \
4053 || (!defined(HAS_INIT_SECTION) \
4054 && !defined(INIT_SECTION_ASM_OP) \
4055 && !defined(INIT_ARRAY_SECTION_ASM_OP)))
4056 emit_library_call (init_one_libfunc (NAME__MAIN
), LCT_NORMAL
, VOIDmode
, 0);
4060 /* Expand code to initialize the stack_protect_guard. This is invoked at
4061 the beginning of a function to be protected. */
4063 #ifndef HAVE_stack_protect_set
4064 # define HAVE_stack_protect_set 0
4065 # define gen_stack_protect_set(x,y) (gcc_unreachable (), NULL_RTX)
4069 stack_protect_prologue (void)
4071 tree guard_decl
= targetm
.stack_protect_guard ();
4074 /* Avoid expand_expr here, because we don't want guard_decl pulled
4075 into registers unless absolutely necessary. And we know that
4076 cfun->stack_protect_guard is a local stack slot, so this skips
4078 x
= validize_mem (DECL_RTL (cfun
->stack_protect_guard
));
4079 y
= validize_mem (DECL_RTL (guard_decl
));
4081 /* Allow the target to copy from Y to X without leaking Y into a
4083 if (HAVE_stack_protect_set
)
4085 rtx insn
= gen_stack_protect_set (x
, y
);
4093 /* Otherwise do a straight move. */
4094 emit_move_insn (x
, y
);
4097 /* Expand code to verify the stack_protect_guard. This is invoked at
4098 the end of a function to be protected. */
4100 #ifndef HAVE_stack_protect_test
4101 # define HAVE_stack_protect_test 0
4102 # define gen_stack_protect_test(x, y, z) (gcc_unreachable (), NULL_RTX)
4106 stack_protect_epilogue (void)
4108 tree guard_decl
= targetm
.stack_protect_guard ();
4109 rtx label
= gen_label_rtx ();
4112 /* Avoid expand_expr here, because we don't want guard_decl pulled
4113 into registers unless absolutely necessary. And we know that
4114 cfun->stack_protect_guard is a local stack slot, so this skips
4116 x
= validize_mem (DECL_RTL (cfun
->stack_protect_guard
));
4117 y
= validize_mem (DECL_RTL (guard_decl
));
4119 /* Allow the target to compare Y with X without leaking either into
4121 switch (HAVE_stack_protect_test
!= 0)
4124 tmp
= gen_stack_protect_test (x
, y
, label
);
4133 emit_cmp_and_jump_insns (x
, y
, EQ
, NULL_RTX
, ptr_mode
, 1, label
);
4137 /* The noreturn predictor has been moved to the tree level. The rtl-level
4138 predictors estimate this branch about 20%, which isn't enough to get
4139 things moved out of line. Since this is the only extant case of adding
4140 a noreturn function at the rtl level, it doesn't seem worth doing ought
4141 except adding the prediction by hand. */
4142 tmp
= get_last_insn ();
4144 predict_insn_def (tmp
, PRED_NORETURN
, TAKEN
);
4146 expand_expr_stmt (targetm
.stack_protect_fail ());
4150 /* Start the RTL for a new function, and set variables used for
4152 SUBR is the FUNCTION_DECL node.
4153 PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with
4154 the function's parameters, which must be run at any return statement. */
4157 expand_function_start (tree subr
)
4159 /* Make sure volatile mem refs aren't considered
4160 valid operands of arithmetic insns. */
4161 init_recog_no_volatile ();
4163 current_function_profile
4165 && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr
));
4167 current_function_limit_stack
4168 = (stack_limit_rtx
!= NULL_RTX
&& ! DECL_NO_LIMIT_STACK (subr
));
4170 /* Make the label for return statements to jump to. Do not special
4171 case machines with special return instructions -- they will be
4172 handled later during jump, ifcvt, or epilogue creation. */
4173 return_label
= gen_label_rtx ();
4175 /* Initialize rtx used to return the value. */
4176 /* Do this before assign_parms so that we copy the struct value address
4177 before any library calls that assign parms might generate. */
4179 /* Decide whether to return the value in memory or in a register. */
4180 if (aggregate_value_p (DECL_RESULT (subr
), subr
))
4182 /* Returning something that won't go in a register. */
4183 rtx value_address
= 0;
4185 #ifdef PCC_STATIC_STRUCT_RETURN
4186 if (current_function_returns_pcc_struct
)
4188 int size
= int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr
)));
4189 value_address
= assemble_static_space (size
);
4194 rtx sv
= targetm
.calls
.struct_value_rtx (TREE_TYPE (subr
), 2);
4195 /* Expect to be passed the address of a place to store the value.
4196 If it is passed as an argument, assign_parms will take care of
4200 value_address
= gen_reg_rtx (Pmode
);
4201 emit_move_insn (value_address
, sv
);
4206 rtx x
= value_address
;
4207 if (!DECL_BY_REFERENCE (DECL_RESULT (subr
)))
4209 x
= gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr
)), x
);
4210 set_mem_attributes (x
, DECL_RESULT (subr
), 1);
4212 SET_DECL_RTL (DECL_RESULT (subr
), x
);
4215 else if (DECL_MODE (DECL_RESULT (subr
)) == VOIDmode
)
4216 /* If return mode is void, this decl rtl should not be used. */
4217 SET_DECL_RTL (DECL_RESULT (subr
), NULL_RTX
);
4220 /* Compute the return values into a pseudo reg, which we will copy
4221 into the true return register after the cleanups are done. */
4222 tree return_type
= TREE_TYPE (DECL_RESULT (subr
));
4223 if (TYPE_MODE (return_type
) != BLKmode
4224 && targetm
.calls
.return_in_msb (return_type
))
4225 /* expand_function_end will insert the appropriate padding in
4226 this case. Use the return value's natural (unpadded) mode
4227 within the function proper. */
4228 SET_DECL_RTL (DECL_RESULT (subr
),
4229 gen_reg_rtx (TYPE_MODE (return_type
)));
4232 /* In order to figure out what mode to use for the pseudo, we
4233 figure out what the mode of the eventual return register will
4234 actually be, and use that. */
4235 rtx hard_reg
= hard_function_value (return_type
, subr
, 0, 1);
4237 /* Structures that are returned in registers are not
4238 aggregate_value_p, so we may see a PARALLEL or a REG. */
4239 if (REG_P (hard_reg
))
4240 SET_DECL_RTL (DECL_RESULT (subr
),
4241 gen_reg_rtx (GET_MODE (hard_reg
)));
4244 gcc_assert (GET_CODE (hard_reg
) == PARALLEL
);
4245 SET_DECL_RTL (DECL_RESULT (subr
), gen_group_rtx (hard_reg
));
4249 /* Set DECL_REGISTER flag so that expand_function_end will copy the
4250 result to the real return register(s). */
4251 DECL_REGISTER (DECL_RESULT (subr
)) = 1;
4254 /* Initialize rtx for parameters and local variables.
4255 In some cases this requires emitting insns. */
4256 assign_parms (subr
);
4258 /* If function gets a static chain arg, store it. */
4259 if (cfun
->static_chain_decl
)
4261 tree parm
= cfun
->static_chain_decl
;
4262 rtx local
= gen_reg_rtx (Pmode
);
4264 set_decl_incoming_rtl (parm
, static_chain_incoming_rtx
, false);
4265 SET_DECL_RTL (parm
, local
);
4266 mark_reg_pointer (local
, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm
))));
4268 emit_move_insn (local
, static_chain_incoming_rtx
);
4271 /* If the function receives a non-local goto, then store the
4272 bits we need to restore the frame pointer. */
4273 if (cfun
->nonlocal_goto_save_area
)
4278 /* ??? We need to do this save early. Unfortunately here is
4279 before the frame variable gets declared. Help out... */
4280 expand_var (TREE_OPERAND (cfun
->nonlocal_goto_save_area
, 0));
4282 t_save
= build4 (ARRAY_REF
, ptr_type_node
,
4283 cfun
->nonlocal_goto_save_area
,
4284 integer_zero_node
, NULL_TREE
, NULL_TREE
);
4285 r_save
= expand_expr (t_save
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
4286 r_save
= convert_memory_address (Pmode
, r_save
);
4288 emit_move_insn (r_save
, virtual_stack_vars_rtx
);
4289 update_nonlocal_goto_save_area ();
4292 /* The following was moved from init_function_start.
4293 The move is supposed to make sdb output more accurate. */
4294 /* Indicate the beginning of the function body,
4295 as opposed to parm setup. */
4296 emit_note (NOTE_INSN_FUNCTION_BEG
);
4298 gcc_assert (NOTE_P (get_last_insn ()));
4300 parm_birth_insn
= get_last_insn ();
4302 if (current_function_profile
)
4305 PROFILE_HOOK (current_function_funcdef_no
);
4309 /* After the display initializations is where the stack checking
4311 if(flag_stack_check
)
4312 stack_check_probe_note
= emit_note (NOTE_INSN_DELETED
);
4314 /* Make sure there is a line number after the function entry setup code. */
4315 force_next_line_note ();
4318 /* Undo the effects of init_dummy_function_start. */
4320 expand_dummy_function_end (void)
4322 gcc_assert (in_dummy_function
);
4324 /* End any sequences that failed to be closed due to syntax errors. */
4325 while (in_sequence_p ())
4328 /* Outside function body, can't compute type's actual size
4329 until next function's body starts. */
4331 free_after_parsing (cfun
);
4332 free_after_compilation (cfun
);
4334 in_dummy_function
= false;
4337 /* Call DOIT for each hard register used as a return value from
4338 the current function. */
4341 diddle_return_value (void (*doit
) (rtx
, void *), void *arg
)
4343 rtx outgoing
= current_function_return_rtx
;
4348 if (REG_P (outgoing
))
4349 (*doit
) (outgoing
, arg
);
4350 else if (GET_CODE (outgoing
) == PARALLEL
)
4354 for (i
= 0; i
< XVECLEN (outgoing
, 0); i
++)
4356 rtx x
= XEXP (XVECEXP (outgoing
, 0, i
), 0);
4358 if (REG_P (x
) && REGNO (x
) < FIRST_PSEUDO_REGISTER
)
4365 do_clobber_return_reg (rtx reg
, void *arg ATTRIBUTE_UNUSED
)
4367 emit_insn (gen_rtx_CLOBBER (VOIDmode
, reg
));
4371 clobber_return_register (void)
4373 diddle_return_value (do_clobber_return_reg
, NULL
);
4375 /* In case we do use pseudo to return value, clobber it too. */
4376 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl
)))
4378 tree decl_result
= DECL_RESULT (current_function_decl
);
4379 rtx decl_rtl
= DECL_RTL (decl_result
);
4380 if (REG_P (decl_rtl
) && REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
)
4382 do_clobber_return_reg (decl_rtl
, NULL
);
4388 do_use_return_reg (rtx reg
, void *arg ATTRIBUTE_UNUSED
)
4390 emit_insn (gen_rtx_USE (VOIDmode
, reg
));
4394 use_return_register (void)
4396 diddle_return_value (do_use_return_reg
, NULL
);
4399 /* Possibly warn about unused parameters. */
4401 do_warn_unused_parameter (tree fn
)
4405 for (decl
= DECL_ARGUMENTS (fn
);
4406 decl
; decl
= TREE_CHAIN (decl
))
4407 if (!TREE_USED (decl
) && TREE_CODE (decl
) == PARM_DECL
4408 && DECL_NAME (decl
) && !DECL_ARTIFICIAL (decl
)
4409 && !TREE_NO_WARNING (decl
))
4410 warning (OPT_Wunused_parameter
, "unused parameter %q+D", decl
);
4413 static GTY(()) rtx initial_trampoline
;
4415 /* Generate RTL for the end of the current function. */
4418 expand_function_end (void)
4422 /* If arg_pointer_save_area was referenced only from a nested
4423 function, we will not have initialized it yet. Do that now. */
4424 if (arg_pointer_save_area
&& ! cfun
->arg_pointer_save_area_init
)
4425 get_arg_pointer_save_area (cfun
);
4427 /* If we are doing stack checking and this function makes calls,
4428 do a stack probe at the start of the function to ensure we have enough
4429 space for another stack frame. */
4430 if (flag_stack_check
&& ! STACK_CHECK_BUILTIN
)
4434 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
4438 probe_stack_range (STACK_CHECK_PROTECT
,
4439 GEN_INT (STACK_CHECK_MAX_FRAME_SIZE
));
4442 emit_insn_before (seq
, stack_check_probe_note
);
4447 /* End any sequences that failed to be closed due to syntax errors. */
4448 while (in_sequence_p ())
4451 clear_pending_stack_adjust ();
4452 do_pending_stack_adjust ();
4454 /* Output a linenumber for the end of the function.
4455 SDB depends on this. */
4456 force_next_line_note ();
4457 set_curr_insn_source_location (input_location
);
4459 /* Before the return label (if any), clobber the return
4460 registers so that they are not propagated live to the rest of
4461 the function. This can only happen with functions that drop
4462 through; if there had been a return statement, there would
4463 have either been a return rtx, or a jump to the return label.
4465 We delay actual code generation after the current_function_value_rtx
4467 clobber_after
= get_last_insn ();
4469 /* Output the label for the actual return from the function. */
4470 emit_label (return_label
);
4472 if (USING_SJLJ_EXCEPTIONS
)
4474 /* Let except.c know where it should emit the call to unregister
4475 the function context for sjlj exceptions. */
4476 if (flag_exceptions
)
4477 sjlj_emit_function_exit_after (get_last_insn ());
4481 /* We want to ensure that instructions that may trap are not
4482 moved into the epilogue by scheduling, because we don't
4483 always emit unwind information for the epilogue. */
4484 if (flag_non_call_exceptions
)
4485 emit_insn (gen_blockage ());
4488 /* If this is an implementation of throw, do what's necessary to
4489 communicate between __builtin_eh_return and the epilogue. */
4490 expand_eh_return ();
4492 /* If scalar return value was computed in a pseudo-reg, or was a named
4493 return value that got dumped to the stack, copy that to the hard
4495 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl
)))
4497 tree decl_result
= DECL_RESULT (current_function_decl
);
4498 rtx decl_rtl
= DECL_RTL (decl_result
);
4500 if (REG_P (decl_rtl
)
4501 ? REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
4502 : DECL_REGISTER (decl_result
))
4504 rtx real_decl_rtl
= current_function_return_rtx
;
4506 /* This should be set in assign_parms. */
4507 gcc_assert (REG_FUNCTION_VALUE_P (real_decl_rtl
));
4509 /* If this is a BLKmode structure being returned in registers,
4510 then use the mode computed in expand_return. Note that if
4511 decl_rtl is memory, then its mode may have been changed,
4512 but that current_function_return_rtx has not. */
4513 if (GET_MODE (real_decl_rtl
) == BLKmode
)
4514 PUT_MODE (real_decl_rtl
, GET_MODE (decl_rtl
));
4516 /* If a non-BLKmode return value should be padded at the least
4517 significant end of the register, shift it left by the appropriate
4518 amount. BLKmode results are handled using the group load/store
4520 if (TYPE_MODE (TREE_TYPE (decl_result
)) != BLKmode
4521 && targetm
.calls
.return_in_msb (TREE_TYPE (decl_result
)))
4523 emit_move_insn (gen_rtx_REG (GET_MODE (decl_rtl
),
4524 REGNO (real_decl_rtl
)),
4526 shift_return_value (GET_MODE (decl_rtl
), true, real_decl_rtl
);
4528 /* If a named return value dumped decl_return to memory, then
4529 we may need to re-do the PROMOTE_MODE signed/unsigned
4531 else if (GET_MODE (real_decl_rtl
) != GET_MODE (decl_rtl
))
4533 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (decl_result
));
4535 if (targetm
.calls
.promote_function_return (TREE_TYPE (current_function_decl
)))
4536 promote_mode (TREE_TYPE (decl_result
), GET_MODE (decl_rtl
),
4539 convert_move (real_decl_rtl
, decl_rtl
, unsignedp
);
4541 else if (GET_CODE (real_decl_rtl
) == PARALLEL
)
4543 /* If expand_function_start has created a PARALLEL for decl_rtl,
4544 move the result to the real return registers. Otherwise, do
4545 a group load from decl_rtl for a named return. */
4546 if (GET_CODE (decl_rtl
) == PARALLEL
)
4547 emit_group_move (real_decl_rtl
, decl_rtl
);
4549 emit_group_load (real_decl_rtl
, decl_rtl
,
4550 TREE_TYPE (decl_result
),
4551 int_size_in_bytes (TREE_TYPE (decl_result
)));
4553 /* In the case of complex integer modes smaller than a word, we'll
4554 need to generate some non-trivial bitfield insertions. Do that
4555 on a pseudo and not the hard register. */
4556 else if (GET_CODE (decl_rtl
) == CONCAT
4557 && GET_MODE_CLASS (GET_MODE (decl_rtl
)) == MODE_COMPLEX_INT
4558 && GET_MODE_BITSIZE (GET_MODE (decl_rtl
)) <= BITS_PER_WORD
)
4560 int old_generating_concat_p
;
4563 old_generating_concat_p
= generating_concat_p
;
4564 generating_concat_p
= 0;
4565 tmp
= gen_reg_rtx (GET_MODE (decl_rtl
));
4566 generating_concat_p
= old_generating_concat_p
;
4568 emit_move_insn (tmp
, decl_rtl
);
4569 emit_move_insn (real_decl_rtl
, tmp
);
4572 emit_move_insn (real_decl_rtl
, decl_rtl
);
4576 /* If returning a structure, arrange to return the address of the value
4577 in a place where debuggers expect to find it.
4579 If returning a structure PCC style,
4580 the caller also depends on this value.
4581 And current_function_returns_pcc_struct is not necessarily set. */
4582 if (current_function_returns_struct
4583 || current_function_returns_pcc_struct
)
4585 rtx value_address
= DECL_RTL (DECL_RESULT (current_function_decl
));
4586 tree type
= TREE_TYPE (DECL_RESULT (current_function_decl
));
4589 if (DECL_BY_REFERENCE (DECL_RESULT (current_function_decl
)))
4590 type
= TREE_TYPE (type
);
4592 value_address
= XEXP (value_address
, 0);
4594 outgoing
= targetm
.calls
.function_value (build_pointer_type (type
),
4595 current_function_decl
, true);
4597 /* Mark this as a function return value so integrate will delete the
4598 assignment and USE below when inlining this function. */
4599 REG_FUNCTION_VALUE_P (outgoing
) = 1;
4601 /* The address may be ptr_mode and OUTGOING may be Pmode. */
4602 value_address
= convert_memory_address (GET_MODE (outgoing
),
4605 emit_move_insn (outgoing
, value_address
);
4607 /* Show return register used to hold result (in this case the address
4609 current_function_return_rtx
= outgoing
;
4612 /* Emit the actual code to clobber return register. */
4617 clobber_return_register ();
4618 expand_naked_return ();
4622 emit_insn_after (seq
, clobber_after
);
4625 /* Output the label for the naked return from the function. */
4626 emit_label (naked_return_label
);
4628 /* @@@ This is a kludge. We want to ensure that instructions that
4629 may trap are not moved into the epilogue by scheduling, because
4630 we don't always emit unwind information for the epilogue. */
4631 if (! USING_SJLJ_EXCEPTIONS
&& flag_non_call_exceptions
)
4632 emit_insn (gen_blockage ());
4634 /* If stack protection is enabled for this function, check the guard. */
4635 if (cfun
->stack_protect_guard
)
4636 stack_protect_epilogue ();
4638 /* If we had calls to alloca, and this machine needs
4639 an accurate stack pointer to exit the function,
4640 insert some code to save and restore the stack pointer. */
4641 if (! EXIT_IGNORE_STACK
4642 && current_function_calls_alloca
)
4646 emit_stack_save (SAVE_FUNCTION
, &tem
, parm_birth_insn
);
4647 emit_stack_restore (SAVE_FUNCTION
, tem
, NULL_RTX
);
4650 /* ??? This should no longer be necessary since stupid is no longer with
4651 us, but there are some parts of the compiler (eg reload_combine, and
4652 sh mach_dep_reorg) that still try and compute their own lifetime info
4653 instead of using the general framework. */
4654 use_return_register ();
4658 get_arg_pointer_save_area (struct function
*f
)
4660 rtx ret
= f
->x_arg_pointer_save_area
;
4664 ret
= assign_stack_local_1 (Pmode
, GET_MODE_SIZE (Pmode
), 0, f
);
4665 f
->x_arg_pointer_save_area
= ret
;
4668 if (f
== cfun
&& ! f
->arg_pointer_save_area_init
)
4672 /* Save the arg pointer at the beginning of the function. The
4673 generated stack slot may not be a valid memory address, so we
4674 have to check it and fix it if necessary. */
4676 emit_move_insn (validize_mem (ret
), virtual_incoming_args_rtx
);
4680 push_topmost_sequence ();
4681 emit_insn_after (seq
, entry_of_function ());
4682 pop_topmost_sequence ();
4688 /* Extend a vector that records the INSN_UIDs of INSNS
4689 (a list of one or more insns). */
4692 record_insns (rtx insns
, VEC(int,heap
) **vecp
)
4696 for (tmp
= insns
; tmp
!= NULL_RTX
; tmp
= NEXT_INSN (tmp
))
4697 VEC_safe_push (int, heap
, *vecp
, INSN_UID (tmp
));
4700 /* Set the locator of the insn chain starting at INSN to LOC. */
4702 set_insn_locators (rtx insn
, int loc
)
4704 while (insn
!= NULL_RTX
)
4707 INSN_LOCATOR (insn
) = loc
;
4708 insn
= NEXT_INSN (insn
);
4712 /* Determine how many INSN_UIDs in VEC are part of INSN. Because we can
4713 be running after reorg, SEQUENCE rtl is possible. */
4716 contains (const_rtx insn
, VEC(int,heap
) **vec
)
4720 if (NONJUMP_INSN_P (insn
)
4721 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
4724 for (i
= XVECLEN (PATTERN (insn
), 0) - 1; i
>= 0; i
--)
4725 for (j
= VEC_length (int, *vec
) - 1; j
>= 0; --j
)
4726 if (INSN_UID (XVECEXP (PATTERN (insn
), 0, i
))
4727 == VEC_index (int, *vec
, j
))
4733 for (j
= VEC_length (int, *vec
) - 1; j
>= 0; --j
)
4734 if (INSN_UID (insn
) == VEC_index (int, *vec
, j
))
4741 prologue_epilogue_contains (const_rtx insn
)
4743 if (contains (insn
, &prologue
))
4745 if (contains (insn
, &epilogue
))
4751 sibcall_epilogue_contains (const_rtx insn
)
4753 if (sibcall_epilogue
)
4754 return contains (insn
, &sibcall_epilogue
);
4759 /* Insert gen_return at the end of block BB. This also means updating
4760 block_for_insn appropriately. */
4763 emit_return_into_block (basic_block bb
)
4765 emit_jump_insn_after (gen_return (), BB_END (bb
));
4767 #endif /* HAVE_return */
4769 #if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX)
4771 /* These functions convert the epilogue into a variant that does not
4772 modify the stack pointer. This is used in cases where a function
4773 returns an object whose size is not known until it is computed.
4774 The called function leaves the object on the stack, leaves the
4775 stack depressed, and returns a pointer to the object.
4777 What we need to do is track all modifications and references to the
4778 stack pointer, deleting the modifications and changing the
4779 references to point to the location the stack pointer would have
4780 pointed to had the modifications taken place.
4782 These functions need to be portable so we need to make as few
4783 assumptions about the epilogue as we can. However, the epilogue
4784 basically contains three things: instructions to reset the stack
4785 pointer, instructions to reload registers, possibly including the
4786 frame pointer, and an instruction to return to the caller.
4788 We must be sure of what a relevant epilogue insn is doing. We also
4789 make no attempt to validate the insns we make since if they are
4790 invalid, we probably can't do anything valid. The intent is that
4791 these routines get "smarter" as more and more machines start to use
4792 them and they try operating on different epilogues.
4794 We use the following structure to track what the part of the
4795 epilogue that we've already processed has done. We keep two copies
4796 of the SP equivalence, one for use during the insn we are
4797 processing and one for use in the next insn. The difference is
4798 because one part of a PARALLEL may adjust SP and the other may use
4803 rtx sp_equiv_reg
; /* REG that SP is set from, perhaps SP. */
4804 HOST_WIDE_INT sp_offset
; /* Offset from SP_EQUIV_REG of present SP. */
4805 rtx new_sp_equiv_reg
; /* REG to be used at end of insn. */
4806 HOST_WIDE_INT new_sp_offset
; /* Offset to be used at end of insn. */
4807 rtx equiv_reg_src
; /* If nonzero, the value that SP_EQUIV_REG
4808 should be set to once we no longer need
4810 rtx const_equiv
[FIRST_PSEUDO_REGISTER
]; /* Any known constant equivalences
4814 static void handle_epilogue_set (rtx
, struct epi_info
*);
4815 static void update_epilogue_consts (rtx
, const_rtx
, void *);
4816 static void emit_equiv_load (struct epi_info
*);
4818 /* Modify INSN, a list of one or more insns that is part of the epilogue, to
4819 no modifications to the stack pointer. Return the new list of insns. */
4822 keep_stack_depressed (rtx insns
)
4825 struct epi_info info
;
4828 /* If the epilogue is just a single instruction, it must be OK as is. */
4829 if (NEXT_INSN (insns
) == NULL_RTX
)
4832 /* Otherwise, start a sequence, initialize the information we have, and
4833 process all the insns we were given. */
4836 info
.sp_equiv_reg
= stack_pointer_rtx
;
4838 info
.equiv_reg_src
= 0;
4840 for (j
= 0; j
< FIRST_PSEUDO_REGISTER
; j
++)
4841 info
.const_equiv
[j
] = 0;
4845 while (insn
!= NULL_RTX
)
4847 next
= NEXT_INSN (insn
);
4856 /* If this insn references the register that SP is equivalent to and
4857 we have a pending load to that register, we must force out the load
4858 first and then indicate we no longer know what SP's equivalent is. */
4859 if (info
.equiv_reg_src
!= 0
4860 && reg_referenced_p (info
.sp_equiv_reg
, PATTERN (insn
)))
4862 emit_equiv_load (&info
);
4863 info
.sp_equiv_reg
= 0;
4866 info
.new_sp_equiv_reg
= info
.sp_equiv_reg
;
4867 info
.new_sp_offset
= info
.sp_offset
;
4869 /* If this is a (RETURN) and the return address is on the stack,
4870 update the address and change to an indirect jump. */
4871 if (GET_CODE (PATTERN (insn
)) == RETURN
4872 || (GET_CODE (PATTERN (insn
)) == PARALLEL
4873 && GET_CODE (XVECEXP (PATTERN (insn
), 0, 0)) == RETURN
))
4875 rtx retaddr
= INCOMING_RETURN_ADDR_RTX
;
4877 HOST_WIDE_INT offset
= 0;
4878 rtx jump_insn
, jump_set
;
4880 /* If the return address is in a register, we can emit the insn
4881 unchanged. Otherwise, it must be a MEM and we see what the
4882 base register and offset are. In any case, we have to emit any
4883 pending load to the equivalent reg of SP, if any. */
4884 if (REG_P (retaddr
))
4886 emit_equiv_load (&info
);
4894 gcc_assert (MEM_P (retaddr
));
4896 ret_ptr
= XEXP (retaddr
, 0);
4898 if (REG_P (ret_ptr
))
4900 base
= gen_rtx_REG (Pmode
, REGNO (ret_ptr
));
4905 gcc_assert (GET_CODE (ret_ptr
) == PLUS
4906 && REG_P (XEXP (ret_ptr
, 0))
4907 && GET_CODE (XEXP (ret_ptr
, 1)) == CONST_INT
);
4908 base
= gen_rtx_REG (Pmode
, REGNO (XEXP (ret_ptr
, 0)));
4909 offset
= INTVAL (XEXP (ret_ptr
, 1));
4913 /* If the base of the location containing the return pointer
4914 is SP, we must update it with the replacement address. Otherwise,
4915 just build the necessary MEM. */
4916 retaddr
= plus_constant (base
, offset
);
4917 if (base
== stack_pointer_rtx
)
4918 retaddr
= simplify_replace_rtx (retaddr
, stack_pointer_rtx
,
4919 plus_constant (info
.sp_equiv_reg
,
4922 retaddr
= gen_rtx_MEM (Pmode
, retaddr
);
4923 MEM_NOTRAP_P (retaddr
) = 1;
4925 /* If there is a pending load to the equivalent register for SP
4926 and we reference that register, we must load our address into
4927 a scratch register and then do that load. */
4928 if (info
.equiv_reg_src
4929 && reg_overlap_mentioned_p (info
.equiv_reg_src
, retaddr
))
4934 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
4935 if (HARD_REGNO_MODE_OK (regno
, Pmode
)
4936 && !fixed_regs
[regno
]
4937 && TEST_HARD_REG_BIT (regs_invalidated_by_call
, regno
)
4939 (DF_LR_IN (EXIT_BLOCK_PTR
), regno
)
4940 && !refers_to_regno_p (regno
,
4941 end_hard_regno (Pmode
, regno
),
4942 info
.equiv_reg_src
, NULL
)
4943 && info
.const_equiv
[regno
] == 0)
4946 gcc_assert (regno
< FIRST_PSEUDO_REGISTER
);
4948 reg
= gen_rtx_REG (Pmode
, regno
);
4949 emit_move_insn (reg
, retaddr
);
4953 emit_equiv_load (&info
);
4954 jump_insn
= emit_jump_insn (gen_indirect_jump (retaddr
));
4956 /* Show the SET in the above insn is a RETURN. */
4957 jump_set
= single_set (jump_insn
);
4958 gcc_assert (jump_set
);
4959 SET_IS_RETURN_P (jump_set
) = 1;
4962 /* If SP is not mentioned in the pattern and its equivalent register, if
4963 any, is not modified, just emit it. Otherwise, if neither is set,
4964 replace the reference to SP and emit the insn. If none of those are
4965 true, handle each SET individually. */
4966 else if (!reg_mentioned_p (stack_pointer_rtx
, PATTERN (insn
))
4967 && (info
.sp_equiv_reg
== stack_pointer_rtx
4968 || !reg_set_p (info
.sp_equiv_reg
, insn
)))
4970 else if (! reg_set_p (stack_pointer_rtx
, insn
)
4971 && (info
.sp_equiv_reg
== stack_pointer_rtx
4972 || !reg_set_p (info
.sp_equiv_reg
, insn
)))
4976 changed
= validate_replace_rtx (stack_pointer_rtx
,
4977 plus_constant (info
.sp_equiv_reg
,
4980 gcc_assert (changed
);
4984 else if (GET_CODE (PATTERN (insn
)) == SET
)
4985 handle_epilogue_set (PATTERN (insn
), &info
);
4986 else if (GET_CODE (PATTERN (insn
)) == PARALLEL
)
4988 for (j
= 0; j
< XVECLEN (PATTERN (insn
), 0); j
++)
4989 if (GET_CODE (XVECEXP (PATTERN (insn
), 0, j
)) == SET
)
4990 handle_epilogue_set (XVECEXP (PATTERN (insn
), 0, j
), &info
);
4995 info
.sp_equiv_reg
= info
.new_sp_equiv_reg
;
4996 info
.sp_offset
= info
.new_sp_offset
;
4998 /* Now update any constants this insn sets. */
4999 note_stores (PATTERN (insn
), update_epilogue_consts
, &info
);
5003 insns
= get_insns ();
5008 /* SET is a SET from an insn in the epilogue. P is a pointer to the epi_info
5009 structure that contains information about what we've seen so far. We
5010 process this SET by either updating that data or by emitting one or
5014 handle_epilogue_set (rtx set
, struct epi_info
*p
)
5016 /* First handle the case where we are setting SP. Record what it is being
5017 set from, which we must be able to determine */
5018 if (reg_set_p (stack_pointer_rtx
, set
))
5020 gcc_assert (SET_DEST (set
) == stack_pointer_rtx
);
5022 if (GET_CODE (SET_SRC (set
)) == PLUS
)
5024 p
->new_sp_equiv_reg
= XEXP (SET_SRC (set
), 0);
5025 if (GET_CODE (XEXP (SET_SRC (set
), 1)) == CONST_INT
)
5026 p
->new_sp_offset
= INTVAL (XEXP (SET_SRC (set
), 1));
5029 gcc_assert (REG_P (XEXP (SET_SRC (set
), 1))
5030 && (REGNO (XEXP (SET_SRC (set
), 1))
5031 < FIRST_PSEUDO_REGISTER
)
5032 && p
->const_equiv
[REGNO (XEXP (SET_SRC (set
), 1))]);
5034 = INTVAL (p
->const_equiv
[REGNO (XEXP (SET_SRC (set
), 1))]);
5038 p
->new_sp_equiv_reg
= SET_SRC (set
), p
->new_sp_offset
= 0;
5040 /* If we are adjusting SP, we adjust from the old data. */
5041 if (p
->new_sp_equiv_reg
== stack_pointer_rtx
)
5043 p
->new_sp_equiv_reg
= p
->sp_equiv_reg
;
5044 p
->new_sp_offset
+= p
->sp_offset
;
5047 gcc_assert (p
->new_sp_equiv_reg
&& REG_P (p
->new_sp_equiv_reg
));
5052 /* Next handle the case where we are setting SP's equivalent
5053 register. We must not already have a value to set it to. We
5054 could update, but there seems little point in handling that case.
5055 Note that we have to allow for the case where we are setting the
5056 register set in the previous part of a PARALLEL inside a single
5057 insn. But use the old offset for any updates within this insn.
5058 We must allow for the case where the register is being set in a
5059 different (usually wider) mode than Pmode). */
5060 else if (p
->new_sp_equiv_reg
!= 0 && reg_set_p (p
->new_sp_equiv_reg
, set
))
5062 gcc_assert (!p
->equiv_reg_src
5063 && REG_P (p
->new_sp_equiv_reg
)
5064 && REG_P (SET_DEST (set
))
5065 && (GET_MODE_BITSIZE (GET_MODE (SET_DEST (set
)))
5067 && REGNO (p
->new_sp_equiv_reg
) == REGNO (SET_DEST (set
)));
5069 = simplify_replace_rtx (SET_SRC (set
), stack_pointer_rtx
,
5070 plus_constant (p
->sp_equiv_reg
,
5074 /* Otherwise, replace any references to SP in the insn to its new value
5075 and emit the insn. */
5078 SET_SRC (set
) = simplify_replace_rtx (SET_SRC (set
), stack_pointer_rtx
,
5079 plus_constant (p
->sp_equiv_reg
,
5081 SET_DEST (set
) = simplify_replace_rtx (SET_DEST (set
), stack_pointer_rtx
,
5082 plus_constant (p
->sp_equiv_reg
,
5088 /* Update the tracking information for registers set to constants. */
5091 update_epilogue_consts (rtx dest
, const_rtx x
, void *data
)
5093 struct epi_info
*p
= (struct epi_info
*) data
;
5096 if (!REG_P (dest
) || REGNO (dest
) >= FIRST_PSEUDO_REGISTER
)
5099 /* If we are either clobbering a register or doing a partial set,
5100 show we don't know the value. */
5101 else if (GET_CODE (x
) == CLOBBER
|| ! rtx_equal_p (dest
, SET_DEST (x
)))
5102 p
->const_equiv
[REGNO (dest
)] = 0;
5104 /* If we are setting it to a constant, record that constant. */
5105 else if (GET_CODE (SET_SRC (x
)) == CONST_INT
)
5106 p
->const_equiv
[REGNO (dest
)] = SET_SRC (x
);
5108 /* If this is a binary operation between a register we have been tracking
5109 and a constant, see if we can compute a new constant value. */
5110 else if (ARITHMETIC_P (SET_SRC (x
))
5111 && REG_P (XEXP (SET_SRC (x
), 0))
5112 && REGNO (XEXP (SET_SRC (x
), 0)) < FIRST_PSEUDO_REGISTER
5113 && p
->const_equiv
[REGNO (XEXP (SET_SRC (x
), 0))] != 0
5114 && GET_CODE (XEXP (SET_SRC (x
), 1)) == CONST_INT
5115 && 0 != (new = simplify_binary_operation
5116 (GET_CODE (SET_SRC (x
)), GET_MODE (dest
),
5117 p
->const_equiv
[REGNO (XEXP (SET_SRC (x
), 0))],
5118 XEXP (SET_SRC (x
), 1)))
5119 && GET_CODE (new) == CONST_INT
)
5120 p
->const_equiv
[REGNO (dest
)] = new;
5122 /* Otherwise, we can't do anything with this value. */
5124 p
->const_equiv
[REGNO (dest
)] = 0;
5127 /* Emit an insn to do the load shown in p->equiv_reg_src, if needed. */
5130 emit_equiv_load (struct epi_info
*p
)
5132 if (p
->equiv_reg_src
!= 0)
5134 rtx dest
= p
->sp_equiv_reg
;
5136 if (GET_MODE (p
->equiv_reg_src
) != GET_MODE (dest
))
5137 dest
= gen_rtx_REG (GET_MODE (p
->equiv_reg_src
),
5138 REGNO (p
->sp_equiv_reg
));
5140 emit_move_insn (dest
, p
->equiv_reg_src
);
5141 p
->equiv_reg_src
= 0;
5146 /* Generate the prologue and epilogue RTL if the machine supports it. Thread
5147 this into place with notes indicating where the prologue ends and where
5148 the epilogue begins. Update the basic block information when possible. */
5151 thread_prologue_and_epilogue_insns (void)
5155 #if defined (HAVE_sibcall_epilogue) || defined (HAVE_epilogue) || defined (HAVE_return) || defined (HAVE_prologue)
5158 #if defined (HAVE_epilogue) || defined(HAVE_return)
5159 rtx epilogue_end
= NULL_RTX
;
5163 #ifdef HAVE_prologue
5167 seq
= gen_prologue ();
5170 /* Insert an explicit USE for the frame pointer
5171 if the profiling is on and the frame pointer is required. */
5172 if (current_function_profile
&& frame_pointer_needed
)
5173 emit_insn (gen_rtx_USE (VOIDmode
, hard_frame_pointer_rtx
));
5175 /* Retain a map of the prologue insns. */
5176 record_insns (seq
, &prologue
);
5177 emit_note (NOTE_INSN_PROLOGUE_END
);
5179 #ifndef PROFILE_BEFORE_PROLOGUE
5180 /* Ensure that instructions are not moved into the prologue when
5181 profiling is on. The call to the profiling routine can be
5182 emitted within the live range of a call-clobbered register. */
5183 if (current_function_profile
)
5184 emit_insn (gen_blockage ());
5189 set_insn_locators (seq
, prologue_locator
);
5191 /* Can't deal with multiple successors of the entry block
5192 at the moment. Function should always have at least one
5194 gcc_assert (single_succ_p (ENTRY_BLOCK_PTR
));
5196 insert_insn_on_edge (seq
, single_succ_edge (ENTRY_BLOCK_PTR
));
5201 /* If the exit block has no non-fake predecessors, we don't need
5203 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
5204 if ((e
->flags
& EDGE_FAKE
) == 0)
5210 if (optimize
&& HAVE_return
)
5212 /* If we're allowed to generate a simple return instruction,
5213 then by definition we don't need a full epilogue. Examine
5214 the block that falls through to EXIT. If it does not
5215 contain any code, examine its predecessors and try to
5216 emit (conditional) return instructions. */
5221 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
5222 if (e
->flags
& EDGE_FALLTHRU
)
5228 /* Verify that there are no active instructions in the last block. */
5229 label
= BB_END (last
);
5230 while (label
&& !LABEL_P (label
))
5232 if (active_insn_p (label
))
5234 label
= PREV_INSN (label
);
5237 if (BB_HEAD (last
) == label
&& LABEL_P (label
))
5241 for (ei2
= ei_start (last
->preds
); (e
= ei_safe_edge (ei2
)); )
5243 basic_block bb
= e
->src
;
5246 if (bb
== ENTRY_BLOCK_PTR
)
5253 if (!JUMP_P (jump
) || JUMP_LABEL (jump
) != label
)
5259 /* If we have an unconditional jump, we can replace that
5260 with a simple return instruction. */
5261 if (simplejump_p (jump
))
5263 emit_return_into_block (bb
);
5267 /* If we have a conditional jump, we can try to replace
5268 that with a conditional return instruction. */
5269 else if (condjump_p (jump
))
5271 if (! redirect_jump (jump
, 0, 0))
5277 /* If this block has only one successor, it both jumps
5278 and falls through to the fallthru block, so we can't
5280 if (single_succ_p (bb
))
5292 /* Fix up the CFG for the successful change we just made. */
5293 redirect_edge_succ (e
, EXIT_BLOCK_PTR
);
5296 /* Emit a return insn for the exit fallthru block. Whether
5297 this is still reachable will be determined later. */
5299 emit_barrier_after (BB_END (last
));
5300 emit_return_into_block (last
);
5301 epilogue_end
= BB_END (last
);
5302 single_succ_edge (last
)->flags
&= ~EDGE_FALLTHRU
;
5307 /* Find the edge that falls through to EXIT. Other edges may exist
5308 due to RETURN instructions, but those don't need epilogues.
5309 There really shouldn't be a mixture -- either all should have
5310 been converted or none, however... */
5312 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
5313 if (e
->flags
& EDGE_FALLTHRU
)
5318 #ifdef HAVE_epilogue
5322 epilogue_end
= emit_note (NOTE_INSN_EPILOGUE_BEG
);
5324 seq
= gen_epilogue ();
5326 #ifdef INCOMING_RETURN_ADDR_RTX
5327 /* If this function returns with the stack depressed and we can support
5328 it, massage the epilogue to actually do that. */
5329 if (TREE_CODE (TREE_TYPE (current_function_decl
)) == FUNCTION_TYPE
5330 && TYPE_RETURNS_STACK_DEPRESSED (TREE_TYPE (current_function_decl
)))
5331 seq
= keep_stack_depressed (seq
);
5334 emit_jump_insn (seq
);
5336 /* Retain a map of the epilogue insns. */
5337 record_insns (seq
, &epilogue
);
5338 set_insn_locators (seq
, epilogue_locator
);
5343 insert_insn_on_edge (seq
, e
);
5351 if (! next_active_insn (BB_END (e
->src
)))
5353 /* We have a fall-through edge to the exit block, the source is not
5354 at the end of the function, and there will be an assembler epilogue
5355 at the end of the function.
5356 We can't use force_nonfallthru here, because that would try to
5357 use return. Inserting a jump 'by hand' is extremely messy, so
5358 we take advantage of cfg_layout_finalize using
5359 fixup_fallthru_exit_predecessor. */
5360 cfg_layout_initialize (0);
5361 FOR_EACH_BB (cur_bb
)
5362 if (cur_bb
->index
>= NUM_FIXED_BLOCKS
5363 && cur_bb
->next_bb
->index
>= NUM_FIXED_BLOCKS
)
5364 cur_bb
->aux
= cur_bb
->next_bb
;
5365 cfg_layout_finalize ();
5371 commit_edge_insertions ();
5373 /* The epilogue insns we inserted may cause the exit edge to no longer
5375 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
5377 if (((e
->flags
& EDGE_FALLTHRU
) != 0)
5378 && returnjump_p (BB_END (e
->src
)))
5379 e
->flags
&= ~EDGE_FALLTHRU
;
5383 #ifdef HAVE_sibcall_epilogue
5384 /* Emit sibling epilogues before any sibling call sites. */
5385 for (ei
= ei_start (EXIT_BLOCK_PTR
->preds
); (e
= ei_safe_edge (ei
)); )
5387 basic_block bb
= e
->src
;
5388 rtx insn
= BB_END (bb
);
5391 || ! SIBLING_CALL_P (insn
))
5398 emit_insn (gen_sibcall_epilogue ());
5402 /* Retain a map of the epilogue insns. Used in life analysis to
5403 avoid getting rid of sibcall epilogue insns. Do this before we
5404 actually emit the sequence. */
5405 record_insns (seq
, &sibcall_epilogue
);
5406 set_insn_locators (seq
, epilogue_locator
);
5408 emit_insn_before (seq
, insn
);
5413 #ifdef HAVE_epilogue
5418 /* Similarly, move any line notes that appear after the epilogue.
5419 There is no need, however, to be quite so anal about the existence
5420 of such a note. Also possibly move
5421 NOTE_INSN_FUNCTION_BEG notes, as those can be relevant for debug
5423 for (insn
= epilogue_end
; insn
; insn
= next
)
5425 next
= NEXT_INSN (insn
);
5427 && (NOTE_KIND (insn
) == NOTE_INSN_FUNCTION_BEG
))
5428 reorder_insns (insn
, insn
, PREV_INSN (epilogue_end
));
5433 /* Threading the prologue and epilogue changes the artificial refs
5434 in the entry and exit blocks. */
5435 epilogue_completed
= 1;
5436 df_update_entry_exit_and_calls ();
5439 /* Reposition the prologue-end and epilogue-begin notes after instruction
5440 scheduling and delayed branch scheduling. */
5443 reposition_prologue_and_epilogue_notes (void)
5445 #if defined (HAVE_prologue) || defined (HAVE_epilogue)
5446 rtx insn
, last
, note
;
5449 if ((len
= VEC_length (int, prologue
)) > 0)
5453 /* Scan from the beginning until we reach the last prologue insn.
5454 We apparently can't depend on basic_block_{head,end} after
5456 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
5460 if (NOTE_KIND (insn
) == NOTE_INSN_PROLOGUE_END
)
5463 else if (contains (insn
, &prologue
))
5473 /* Find the prologue-end note if we haven't already, and
5474 move it to just after the last prologue insn. */
5477 for (note
= last
; (note
= NEXT_INSN (note
));)
5479 && NOTE_KIND (note
) == NOTE_INSN_PROLOGUE_END
)
5483 /* Avoid placing note between CODE_LABEL and BASIC_BLOCK note. */
5485 last
= NEXT_INSN (last
);
5486 reorder_insns (note
, note
, last
);
5490 if ((len
= VEC_length (int, epilogue
)) > 0)
5494 /* Scan from the end until we reach the first epilogue insn.
5495 We apparently can't depend on basic_block_{head,end} after
5497 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
5501 if (NOTE_KIND (insn
) == NOTE_INSN_EPILOGUE_BEG
)
5504 else if (contains (insn
, &epilogue
))
5514 /* Find the epilogue-begin note if we haven't already, and
5515 move it to just before the first epilogue insn. */
5518 for (note
= insn
; (note
= PREV_INSN (note
));)
5520 && NOTE_KIND (note
) == NOTE_INSN_EPILOGUE_BEG
)
5524 if (PREV_INSN (last
) != note
)
5525 reorder_insns (note
, note
, PREV_INSN (last
));
5528 #endif /* HAVE_prologue or HAVE_epilogue */
5531 /* Returns the name of the current function. */
5533 current_function_name (void)
5535 return lang_hooks
.decl_printable_name (cfun
->decl
, 2);
5538 /* Returns the raw (mangled) name of the current function. */
5540 current_function_assembler_name (void)
5542 return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (cfun
->decl
));
5547 rest_of_handle_check_leaf_regs (void)
5549 #ifdef LEAF_REGISTERS
5550 current_function_uses_only_leaf_regs
5551 = optimize
> 0 && only_leaf_regs_used () && leaf_function_p ();
5556 /* Insert a TYPE into the used types hash table of CFUN. */
5558 used_types_insert_helper (tree type
, struct function
*func
)
5560 if (type
!= NULL
&& func
!= NULL
)
5564 if (func
->used_types_hash
== NULL
)
5565 func
->used_types_hash
= htab_create_ggc (37, htab_hash_pointer
,
5566 htab_eq_pointer
, NULL
);
5567 slot
= htab_find_slot (func
->used_types_hash
, type
, INSERT
);
5573 /* Given a type, insert it into the used hash table in cfun. */
5575 used_types_insert (tree t
)
5577 while (POINTER_TYPE_P (t
) || TREE_CODE (t
) == ARRAY_TYPE
)
5579 t
= TYPE_MAIN_VARIANT (t
);
5580 if (debug_info_level
> DINFO_LEVEL_NONE
)
5581 used_types_insert_helper (t
, cfun
);
5584 struct tree_opt_pass pass_leaf_regs
=
5588 rest_of_handle_check_leaf_regs
, /* execute */
5591 0, /* static_pass_number */
5593 0, /* properties_required */
5594 0, /* properties_provided */
5595 0, /* properties_destroyed */
5596 0, /* todo_flags_start */
5597 0, /* todo_flags_finish */
5602 rest_of_handle_thread_prologue_and_epilogue (void)
5605 cleanup_cfg (CLEANUP_EXPENSIVE
);
5606 /* On some machines, the prologue and epilogue code, or parts thereof,
5607 can be represented as RTL. Doing so lets us schedule insns between
5608 it and the rest of the code and also allows delayed branch
5609 scheduling to operate in the epilogue. */
5611 thread_prologue_and_epilogue_insns ();
5615 struct tree_opt_pass pass_thread_prologue_and_epilogue
=
5617 "pro_and_epilogue", /* name */
5619 rest_of_handle_thread_prologue_and_epilogue
, /* execute */
5622 0, /* static_pass_number */
5623 TV_THREAD_PROLOGUE_AND_EPILOGUE
, /* tv_id */
5624 0, /* properties_required */
5625 0, /* properties_provided */
5626 0, /* properties_destroyed */
5627 TODO_verify_flow
, /* todo_flags_start */
5630 TODO_df_finish
| TODO_verify_rtl_sharing
|
5631 TODO_ggc_collect
, /* todo_flags_finish */
5636 /* This mini-pass fixes fall-out from SSA in asm statements that have
5637 in-out constraints. Say you start with
5640 asm ("": "+mr" (inout));
5643 which is transformed very early to use explicit output and match operands:
5646 asm ("": "=mr" (inout) : "0" (inout));
5649 Or, after SSA and copyprop,
5651 asm ("": "=mr" (inout_2) : "0" (inout_1));
5654 Clearly inout_2 and inout_1 can't be coalesced easily anymore, as
5655 they represent two separate values, so they will get different pseudo
5656 registers during expansion. Then, since the two operands need to match
5657 per the constraints, but use different pseudo registers, reload can
5658 only register a reload for these operands. But reloads can only be
5659 satisfied by hardregs, not by memory, so we need a register for this
5660 reload, just because we are presented with non-matching operands.
5661 So, even though we allow memory for this operand, no memory can be
5662 used for it, just because the two operands don't match. This can
5663 cause reload failures on register-starved targets.
5665 So it's a symptom of reload not being able to use memory for reloads
5666 or, alternatively it's also a symptom of both operands not coming into
5667 reload as matching (in which case the pseudo could go to memory just
5668 fine, as the alternative allows it, and no reload would be necessary).
5669 We fix the latter problem here, by transforming
5671 asm ("": "=mr" (inout_2) : "0" (inout_1));
5676 asm ("": "=mr" (inout_2) : "0" (inout_2)); */
5679 match_asm_constraints_1 (rtx insn
, rtx
*p_sets
, int noutputs
)
5682 bool changed
= false;
5683 rtx op
= SET_SRC (p_sets
[0]);
5684 int ninputs
= ASM_OPERANDS_INPUT_LENGTH (op
);
5685 rtvec inputs
= ASM_OPERANDS_INPUT_VEC (op
);
5686 bool *output_matched
= alloca (noutputs
* sizeof (bool));
5688 memset (output_matched
, 0, noutputs
* sizeof (bool));
5689 for (i
= 0; i
< ninputs
; i
++)
5691 rtx input
, output
, insns
;
5692 const char *constraint
= ASM_OPERANDS_INPUT_CONSTRAINT (op
, i
);
5696 match
= strtoul (constraint
, &end
, 10);
5697 if (end
== constraint
)
5700 gcc_assert (match
< noutputs
);
5701 output
= SET_DEST (p_sets
[match
]);
5702 input
= RTVEC_ELT (inputs
, i
);
5703 /* Only do the transformation for pseudos. */
5704 if (! REG_P (output
)
5705 || rtx_equal_p (output
, input
)
5706 || (GET_MODE (input
) != VOIDmode
5707 && GET_MODE (input
) != GET_MODE (output
)))
5710 /* We can't do anything if the output is also used as input,
5711 as we're going to overwrite it. */
5712 for (j
= 0; j
< ninputs
; j
++)
5713 if (reg_overlap_mentioned_p (output
, RTVEC_ELT (inputs
, j
)))
5718 /* Avoid changing the same input several times. For
5719 asm ("" : "=mr" (out1), "=mr" (out2) : "0" (in), "1" (in));
5720 only change in once (to out1), rather than changing it
5721 first to out1 and afterwards to out2. */
5724 for (j
= 0; j
< noutputs
; j
++)
5725 if (output_matched
[j
] && input
== SET_DEST (p_sets
[j
]))
5730 output_matched
[match
] = true;
5733 emit_move_insn (output
, input
);
5734 insns
= get_insns ();
5736 emit_insn_before (insns
, insn
);
5738 /* Now replace all mentions of the input with output. We can't
5739 just replace the occurence in inputs[i], as the register might
5740 also be used in some other input (or even in an address of an
5741 output), which would mean possibly increasing the number of
5742 inputs by one (namely 'output' in addition), which might pose
5743 a too complicated problem for reload to solve. E.g. this situation:
5745 asm ("" : "=r" (output), "=m" (input) : "0" (input))
5747 Here 'input' is used in two occurrences as input (once for the
5748 input operand, once for the address in the second output operand).
5749 If we would replace only the occurence of the input operand (to
5750 make the matching) we would be left with this:
5753 asm ("" : "=r" (output), "=m" (input) : "0" (output))
5755 Now we suddenly have two different input values (containing the same
5756 value, but different pseudos) where we formerly had only one.
5757 With more complicated asms this might lead to reload failures
5758 which wouldn't have happen without this pass. So, iterate over
5759 all operands and replace all occurrences of the register used. */
5760 for (j
= 0; j
< noutputs
; j
++)
5761 if (!rtx_equal_p (SET_DEST (p_sets
[j
]), input
)
5762 && reg_overlap_mentioned_p (input
, SET_DEST (p_sets
[j
])))
5763 SET_DEST (p_sets
[j
]) = replace_rtx (SET_DEST (p_sets
[j
]),
5765 for (j
= 0; j
< ninputs
; j
++)
5766 if (reg_overlap_mentioned_p (input
, RTVEC_ELT (inputs
, j
)))
5767 RTVEC_ELT (inputs
, j
) = replace_rtx (RTVEC_ELT (inputs
, j
),
5774 df_insn_rescan (insn
);
5778 rest_of_match_asm_constraints (void)
5781 rtx insn
, pat
, *p_sets
;
5784 if (!cfun
->has_asm_statement
)
5787 df_set_flags (DF_DEFER_INSN_RESCAN
);
5790 FOR_BB_INSNS (bb
, insn
)
5795 pat
= PATTERN (insn
);
5796 if (GET_CODE (pat
) == PARALLEL
)
5797 p_sets
= &XVECEXP (pat
, 0, 0), noutputs
= XVECLEN (pat
, 0);
5798 else if (GET_CODE (pat
) == SET
)
5799 p_sets
= &PATTERN (insn
), noutputs
= 1;
5803 if (GET_CODE (*p_sets
) == SET
5804 && GET_CODE (SET_SRC (*p_sets
)) == ASM_OPERANDS
)
5805 match_asm_constraints_1 (insn
, p_sets
, noutputs
);
5809 return TODO_df_finish
;
5812 struct tree_opt_pass pass_match_asm_constraints
=
5814 "asmcons", /* name */
5816 rest_of_match_asm_constraints
, /* execute */
5819 0, /* static_pass_number */
5821 0, /* properties_required */
5822 0, /* properties_provided */
5823 0, /* properties_destroyed */
5824 0, /* todo_flags_start */
5825 TODO_dump_func
, /* todo_flags_finish */
5830 #include "gt-function.h"