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
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 2, 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 COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 /* This file handles the generation of rtl code from tree structure
24 at the level of the function as a whole.
25 It creates the rtl expressions for parameters and auto variables
26 and has full responsibility for allocating stack slots.
28 `expand_function_start' is called at the beginning of a function,
29 before the function body is parsed, and `expand_function_end' is
30 called after parsing the body.
32 Call `assign_stack_local' to allocate a stack slot for a local variable.
33 This is usually done during the RTL generation for the function body,
34 but it can also be done in the reload pass when a pseudo-register does
35 not get a hard register. */
39 #include "coretypes.h"
50 #include "hard-reg-set.h"
51 #include "insn-config.h"
54 #include "basic-block.h"
59 #include "integrate.h"
60 #include "langhooks.h"
62 #include "cfglayout.h"
63 #include "tree-gimple.h"
65 #ifndef LOCAL_ALIGNMENT
66 #define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT
69 #ifndef STACK_ALIGNMENT_NEEDED
70 #define STACK_ALIGNMENT_NEEDED 1
73 #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
75 /* Some systems use __main in a way incompatible with its use in gcc, in these
76 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
77 give the same symbol without quotes for an alternative entry point. You
78 must define both, or neither. */
80 #define NAME__MAIN "__main"
83 /* Round a value to the lowest integer less than it that is a multiple of
84 the required alignment. Avoid using division in case the value is
85 negative. Assume the alignment is a power of two. */
86 #define FLOOR_ROUND(VALUE,ALIGN) ((VALUE) & ~((ALIGN) - 1))
88 /* Similar, but round to the next highest integer that meets the
90 #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
92 /* Nonzero if function being compiled doesn't contain any calls
93 (ignoring the prologue and epilogue). This is set prior to
94 local register allocation and is valid for the remaining
96 int current_function_is_leaf
;
98 /* Nonzero if function being compiled doesn't modify the stack pointer
99 (ignoring the prologue and epilogue). This is only valid after
100 life_analysis has run. */
101 int current_function_sp_is_unchanging
;
103 /* Nonzero if the function being compiled is a leaf function which only
104 uses leaf registers. This is valid after reload (specifically after
105 sched2) and is useful only if the port defines LEAF_REGISTERS. */
106 int current_function_uses_only_leaf_regs
;
108 /* Nonzero once virtual register instantiation has been done.
109 assign_stack_local uses frame_pointer_rtx when this is nonzero.
110 calls.c:emit_library_call_value_1 uses it to set up
111 post-instantiation libcalls. */
112 int virtuals_instantiated
;
114 /* Assign unique numbers to labels generated for profiling, debugging, etc. */
115 static GTY(()) int funcdef_no
;
117 /* These variables hold pointers to functions to create and destroy
118 target specific, per-function data structures. */
119 struct machine_function
* (*init_machine_status
) (void);
121 /* The currently compiled function. */
122 struct function
*cfun
= 0;
124 /* These arrays record the INSN_UIDs of the prologue and epilogue insns. */
125 static GTY(()) varray_type prologue
;
126 static GTY(()) varray_type epilogue
;
128 /* Array of INSN_UIDs to hold the INSN_UIDs for each sibcall epilogue
130 static GTY(()) varray_type sibcall_epilogue
;
132 /* In order to evaluate some expressions, such as function calls returning
133 structures in memory, we need to temporarily allocate stack locations.
134 We record each allocated temporary in the following structure.
136 Associated with each temporary slot is a nesting level. When we pop up
137 one level, all temporaries associated with the previous level are freed.
138 Normally, all temporaries are freed after the execution of the statement
139 in which they were created. However, if we are inside a ({...}) grouping,
140 the result may be in a temporary and hence must be preserved. If the
141 result could be in a temporary, we preserve it if we can determine which
142 one it is in. If we cannot determine which temporary may contain the
143 result, all temporaries are preserved. A temporary is preserved by
144 pretending it was allocated at the previous nesting level.
146 Automatic variables are also assigned temporary slots, at the nesting
147 level where they are defined. They are marked a "kept" so that
148 free_temp_slots will not free them. */
150 struct temp_slot
GTY(())
152 /* Points to next temporary slot. */
153 struct temp_slot
*next
;
154 /* Points to previous temporary slot. */
155 struct temp_slot
*prev
;
157 /* The rtx to used to reference the slot. */
159 /* The rtx used to represent the address if not the address of the
160 slot above. May be an EXPR_LIST if multiple addresses exist. */
162 /* The alignment (in bits) of the slot. */
164 /* The size, in units, of the slot. */
166 /* The type of the object in the slot, or zero if it doesn't correspond
167 to a type. We use this to determine whether a slot can be reused.
168 It can be reused if objects of the type of the new slot will always
169 conflict with objects of the type of the old slot. */
171 /* Nonzero if this temporary is currently in use. */
173 /* Nonzero if this temporary has its address taken. */
175 /* Nesting level at which this slot is being used. */
177 /* Nonzero if this should survive a call to free_temp_slots. */
179 /* The offset of the slot from the frame_pointer, including extra space
180 for alignment. This info is for combine_temp_slots. */
181 HOST_WIDE_INT base_offset
;
182 /* The size of the slot, including extra space for alignment. This
183 info is for combine_temp_slots. */
184 HOST_WIDE_INT full_size
;
187 /* Forward declarations. */
189 static rtx
assign_stack_local_1 (enum machine_mode
, HOST_WIDE_INT
, int,
191 static struct temp_slot
*find_temp_slot_from_address (rtx
);
192 static void instantiate_decls (tree
, int);
193 static void instantiate_decls_1 (tree
, int);
194 static void instantiate_decl (rtx
, HOST_WIDE_INT
, int);
195 static rtx
instantiate_new_reg (rtx
, HOST_WIDE_INT
*);
196 static int instantiate_virtual_regs_1 (rtx
*, rtx
, int);
197 static void pad_to_arg_alignment (struct args_size
*, int, struct args_size
*);
198 static void pad_below (struct args_size
*, enum machine_mode
, tree
);
199 static void reorder_blocks_1 (rtx
, tree
, varray_type
*);
200 static void reorder_fix_fragments (tree
);
201 static int all_blocks (tree
, tree
*);
202 static tree
*get_block_vector (tree
, int *);
203 extern tree
debug_find_var_in_block_tree (tree
, tree
);
204 /* We always define `record_insns' even if it's not used so that we
205 can always export `prologue_epilogue_contains'. */
206 static void record_insns (rtx
, varray_type
*) ATTRIBUTE_UNUSED
;
207 static int contains (rtx
, varray_type
);
209 static void emit_return_into_block (basic_block
, rtx
);
211 #if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX)
212 static rtx
keep_stack_depressed (rtx
);
214 static void prepare_function_start (tree
);
215 static void do_clobber_return_reg (rtx
, void *);
216 static void do_use_return_reg (rtx
, void *);
217 static void instantiate_virtual_regs_lossage (rtx
);
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 init_dummy_function_start ();
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
)
322 f
->x_avail_temp_slots
= NULL
;
323 f
->x_used_temp_slots
= NULL
;
324 f
->arg_offset_rtx
= NULL
;
325 f
->return_rtx
= NULL
;
326 f
->internal_arg_pointer
= NULL
;
327 f
->x_nonlocal_goto_handler_labels
= NULL
;
328 f
->x_return_label
= NULL
;
329 f
->x_naked_return_label
= NULL
;
330 f
->x_stack_slot_list
= NULL
;
331 f
->x_tail_recursion_reentry
= NULL
;
332 f
->x_arg_pointer_save_area
= NULL
;
333 f
->x_parm_birth_insn
= NULL
;
334 f
->original_arg_vector
= NULL
;
335 f
->original_decl_initial
= NULL
;
336 f
->epilogue_delay_list
= NULL
;
339 /* Allocate fixed slots in the stack frame of the current function. */
341 /* Return size needed for stack frame based on slots so far allocated in
343 This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY;
344 the caller may have to do that. */
347 get_func_frame_size (struct function
*f
)
349 #ifdef FRAME_GROWS_DOWNWARD
350 return -f
->x_frame_offset
;
352 return f
->x_frame_offset
;
356 /* Return size needed for stack frame based on slots so far allocated.
357 This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY;
358 the caller may have to do that. */
360 get_frame_size (void)
362 return get_func_frame_size (cfun
);
365 /* Allocate a stack slot of SIZE bytes and return a MEM rtx for it
366 with machine mode MODE.
368 ALIGN controls the amount of alignment for the address of the slot:
369 0 means according to MODE,
370 -1 means use BIGGEST_ALIGNMENT and round size to multiple of that,
371 -2 means use BITS_PER_UNIT,
372 positive specifies alignment boundary in bits.
374 We do not round to stack_boundary here.
376 FUNCTION specifies the function to allocate in. */
379 assign_stack_local_1 (enum machine_mode mode
, HOST_WIDE_INT size
, int align
,
380 struct function
*function
)
383 int bigend_correction
= 0;
384 unsigned int alignment
;
385 int frame_off
, frame_alignment
, frame_phase
;
392 alignment
= BIGGEST_ALIGNMENT
;
394 alignment
= GET_MODE_ALIGNMENT (mode
);
396 /* Allow the target to (possibly) increase the alignment of this
398 type
= lang_hooks
.types
.type_for_mode (mode
, 0);
400 alignment
= LOCAL_ALIGNMENT (type
, alignment
);
402 alignment
/= BITS_PER_UNIT
;
404 else if (align
== -1)
406 alignment
= BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
;
407 size
= CEIL_ROUND (size
, alignment
);
409 else if (align
== -2)
410 alignment
= 1; /* BITS_PER_UNIT / BITS_PER_UNIT */
412 alignment
= align
/ BITS_PER_UNIT
;
414 #ifdef FRAME_GROWS_DOWNWARD
415 function
->x_frame_offset
-= size
;
418 /* Ignore alignment we can't do with expected alignment of the boundary. */
419 if (alignment
* BITS_PER_UNIT
> PREFERRED_STACK_BOUNDARY
)
420 alignment
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
422 if (function
->stack_alignment_needed
< alignment
* BITS_PER_UNIT
)
423 function
->stack_alignment_needed
= alignment
* BITS_PER_UNIT
;
425 /* Calculate how many bytes the start of local variables is off from
427 frame_alignment
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
428 frame_off
= STARTING_FRAME_OFFSET
% frame_alignment
;
429 frame_phase
= frame_off
? frame_alignment
- frame_off
: 0;
431 /* Round the frame offset to the specified alignment. The default is
432 to always honor requests to align the stack but a port may choose to
433 do its own stack alignment by defining STACK_ALIGNMENT_NEEDED. */
434 if (STACK_ALIGNMENT_NEEDED
438 /* We must be careful here, since FRAME_OFFSET might be negative and
439 division with a negative dividend isn't as well defined as we might
440 like. So we instead assume that ALIGNMENT is a power of two and
441 use logical operations which are unambiguous. */
442 #ifdef FRAME_GROWS_DOWNWARD
443 function
->x_frame_offset
444 = (FLOOR_ROUND (function
->x_frame_offset
- frame_phase
,
445 (unsigned HOST_WIDE_INT
) alignment
)
448 function
->x_frame_offset
449 = (CEIL_ROUND (function
->x_frame_offset
- frame_phase
,
450 (unsigned HOST_WIDE_INT
) alignment
)
455 /* On a big-endian machine, if we are allocating more space than we will use,
456 use the least significant bytes of those that are allocated. */
457 if (BYTES_BIG_ENDIAN
&& mode
!= BLKmode
)
458 bigend_correction
= size
- GET_MODE_SIZE (mode
);
460 /* If we have already instantiated virtual registers, return the actual
461 address relative to the frame pointer. */
462 if (function
== cfun
&& virtuals_instantiated
)
463 addr
= plus_constant (frame_pointer_rtx
,
465 (frame_offset
+ bigend_correction
466 + STARTING_FRAME_OFFSET
, Pmode
));
468 addr
= plus_constant (virtual_stack_vars_rtx
,
470 (function
->x_frame_offset
+ bigend_correction
,
473 #ifndef FRAME_GROWS_DOWNWARD
474 function
->x_frame_offset
+= size
;
477 x
= gen_rtx_MEM (mode
, addr
);
479 function
->x_stack_slot_list
480 = gen_rtx_EXPR_LIST (VOIDmode
, x
, function
->x_stack_slot_list
);
485 /* Wrapper around assign_stack_local_1; assign a local stack slot for the
489 assign_stack_local (enum machine_mode mode
, HOST_WIDE_INT size
, int align
)
491 return assign_stack_local_1 (mode
, size
, align
, cfun
);
495 /* Removes temporary slot TEMP from LIST. */
498 cut_slot_from_list (struct temp_slot
*temp
, struct temp_slot
**list
)
501 temp
->next
->prev
= temp
->prev
;
503 temp
->prev
->next
= temp
->next
;
507 temp
->prev
= temp
->next
= NULL
;
510 /* Inserts temporary slot TEMP to LIST. */
513 insert_slot_to_list (struct temp_slot
*temp
, struct temp_slot
**list
)
517 (*list
)->prev
= temp
;
522 /* Returns the list of used temp slots at LEVEL. */
524 static struct temp_slot
**
525 temp_slots_at_level (int level
)
528 if (!used_temp_slots
)
529 VARRAY_GENERIC_PTR_INIT (used_temp_slots
, 3, "used_temp_slots");
531 while (level
>= (int) VARRAY_ACTIVE_SIZE (used_temp_slots
))
532 VARRAY_PUSH_GENERIC_PTR (used_temp_slots
, NULL
);
534 return (struct temp_slot
**) &VARRAY_GENERIC_PTR (used_temp_slots
, level
);
537 /* Returns the maximal temporary slot level. */
540 max_slot_level (void)
542 if (!used_temp_slots
)
545 return VARRAY_ACTIVE_SIZE (used_temp_slots
) - 1;
548 /* Moves temporary slot TEMP to LEVEL. */
551 move_slot_to_level (struct temp_slot
*temp
, int level
)
553 cut_slot_from_list (temp
, temp_slots_at_level (temp
->level
));
554 insert_slot_to_list (temp
, temp_slots_at_level (level
));
558 /* Make temporary slot TEMP available. */
561 make_slot_available (struct temp_slot
*temp
)
563 cut_slot_from_list (temp
, temp_slots_at_level (temp
->level
));
564 insert_slot_to_list (temp
, &avail_temp_slots
);
569 /* Allocate a temporary stack slot and record it for possible later
572 MODE is the machine mode to be given to the returned rtx.
574 SIZE is the size in units of the space required. We do no rounding here
575 since assign_stack_local will do any required rounding.
577 KEEP is 1 if this slot is to be retained after a call to
578 free_temp_slots. Automatic variables for a block are allocated
579 with this flag. KEEP values of 2 or 3 were needed respectively
580 for variables whose lifetime is controlled by CLEANUP_POINT_EXPRs
581 or for SAVE_EXPRs, but they are now unused and will abort.
583 TYPE is the type that will be used for the stack slot. */
586 assign_stack_temp_for_type (enum machine_mode mode
, HOST_WIDE_INT size
, int keep
,
590 struct temp_slot
*p
, *best_p
= 0, *selected
= NULL
, **pp
;
593 /* If SIZE is -1 it means that somebody tried to allocate a temporary
594 of a variable size. */
595 gcc_assert (size
!= -1);
597 /* These are now unused. */
598 gcc_assert (keep
<= 1);
601 align
= BIGGEST_ALIGNMENT
;
603 align
= GET_MODE_ALIGNMENT (mode
);
606 type
= lang_hooks
.types
.type_for_mode (mode
, 0);
609 align
= LOCAL_ALIGNMENT (type
, align
);
611 /* Try to find an available, already-allocated temporary of the proper
612 mode which meets the size and alignment requirements. Choose the
613 smallest one with the closest alignment. */
614 for (p
= avail_temp_slots
; p
; p
= p
->next
)
616 if (p
->align
>= align
&& p
->size
>= size
&& GET_MODE (p
->slot
) == mode
617 && objects_must_conflict_p (p
->type
, type
)
618 && (best_p
== 0 || best_p
->size
> p
->size
619 || (best_p
->size
== p
->size
&& best_p
->align
> p
->align
)))
621 if (p
->align
== align
&& p
->size
== size
)
624 cut_slot_from_list (selected
, &avail_temp_slots
);
632 /* Make our best, if any, the one to use. */
636 cut_slot_from_list (selected
, &avail_temp_slots
);
638 /* If there are enough aligned bytes left over, make them into a new
639 temp_slot so that the extra bytes don't get wasted. Do this only
640 for BLKmode slots, so that we can be sure of the alignment. */
641 if (GET_MODE (best_p
->slot
) == BLKmode
)
643 int alignment
= best_p
->align
/ BITS_PER_UNIT
;
644 HOST_WIDE_INT rounded_size
= CEIL_ROUND (size
, alignment
);
646 if (best_p
->size
- rounded_size
>= alignment
)
648 p
= ggc_alloc (sizeof (struct temp_slot
));
649 p
->in_use
= p
->addr_taken
= 0;
650 p
->size
= best_p
->size
- rounded_size
;
651 p
->base_offset
= best_p
->base_offset
+ rounded_size
;
652 p
->full_size
= best_p
->full_size
- rounded_size
;
653 p
->slot
= gen_rtx_MEM (BLKmode
,
654 plus_constant (XEXP (best_p
->slot
, 0),
656 p
->align
= best_p
->align
;
658 p
->type
= best_p
->type
;
659 insert_slot_to_list (p
, &avail_temp_slots
);
661 stack_slot_list
= gen_rtx_EXPR_LIST (VOIDmode
, p
->slot
,
664 best_p
->size
= rounded_size
;
665 best_p
->full_size
= rounded_size
;
670 /* If we still didn't find one, make a new temporary. */
673 HOST_WIDE_INT frame_offset_old
= frame_offset
;
675 p
= ggc_alloc (sizeof (struct temp_slot
));
677 /* We are passing an explicit alignment request to assign_stack_local.
678 One side effect of that is assign_stack_local will not round SIZE
679 to ensure the frame offset remains suitably aligned.
681 So for requests which depended on the rounding of SIZE, we go ahead
682 and round it now. We also make sure ALIGNMENT is at least
683 BIGGEST_ALIGNMENT. */
684 gcc_assert (mode
!= BLKmode
|| align
== BIGGEST_ALIGNMENT
);
685 p
->slot
= assign_stack_local (mode
,
687 ? CEIL_ROUND (size
, (int) align
/ BITS_PER_UNIT
)
693 /* The following slot size computation is necessary because we don't
694 know the actual size of the temporary slot until assign_stack_local
695 has performed all the frame alignment and size rounding for the
696 requested temporary. Note that extra space added for alignment
697 can be either above or below this stack slot depending on which
698 way the frame grows. We include the extra space if and only if it
699 is above this slot. */
700 #ifdef FRAME_GROWS_DOWNWARD
701 p
->size
= frame_offset_old
- frame_offset
;
706 /* Now define the fields used by combine_temp_slots. */
707 #ifdef FRAME_GROWS_DOWNWARD
708 p
->base_offset
= frame_offset
;
709 p
->full_size
= frame_offset_old
- frame_offset
;
711 p
->base_offset
= frame_offset_old
;
712 p
->full_size
= frame_offset
- frame_offset_old
;
723 p
->level
= temp_slot_level
;
726 pp
= temp_slots_at_level (p
->level
);
727 insert_slot_to_list (p
, pp
);
729 /* Create a new MEM rtx to avoid clobbering MEM flags of old slots. */
730 slot
= gen_rtx_MEM (mode
, XEXP (p
->slot
, 0));
731 stack_slot_list
= gen_rtx_EXPR_LIST (VOIDmode
, slot
, stack_slot_list
);
733 /* If we know the alias set for the memory that will be used, use
734 it. If there's no TYPE, then we don't know anything about the
735 alias set for the memory. */
736 set_mem_alias_set (slot
, type
? get_alias_set (type
) : 0);
737 set_mem_align (slot
, align
);
739 /* If a type is specified, set the relevant flags. */
742 MEM_VOLATILE_P (slot
) = TYPE_VOLATILE (type
);
743 MEM_SET_IN_STRUCT_P (slot
, AGGREGATE_TYPE_P (type
));
749 /* Allocate a temporary stack slot and record it for possible later
750 reuse. First three arguments are same as in preceding function. */
753 assign_stack_temp (enum machine_mode mode
, HOST_WIDE_INT size
, int keep
)
755 return assign_stack_temp_for_type (mode
, size
, keep
, NULL_TREE
);
758 /* Assign a temporary.
759 If TYPE_OR_DECL is a decl, then we are doing it on behalf of the decl
760 and so that should be used in error messages. In either case, we
761 allocate of the given type.
762 KEEP is as for assign_stack_temp.
763 MEMORY_REQUIRED is 1 if the result must be addressable stack memory;
764 it is 0 if a register is OK.
765 DONT_PROMOTE is 1 if we should not promote values in register
769 assign_temp (tree type_or_decl
, int keep
, int memory_required
,
770 int dont_promote ATTRIBUTE_UNUSED
)
773 enum machine_mode mode
;
778 if (DECL_P (type_or_decl
))
779 decl
= type_or_decl
, type
= TREE_TYPE (decl
);
781 decl
= NULL
, type
= type_or_decl
;
783 mode
= TYPE_MODE (type
);
785 unsignedp
= TYPE_UNSIGNED (type
);
788 if (mode
== BLKmode
|| memory_required
)
790 HOST_WIDE_INT size
= int_size_in_bytes (type
);
794 /* Zero sized arrays are GNU C extension. Set size to 1 to avoid
795 problems with allocating the stack space. */
799 /* Unfortunately, we don't yet know how to allocate variable-sized
800 temporaries. However, sometimes we have a fixed upper limit on
801 the size (which is stored in TYPE_ARRAY_MAX_SIZE) and can use that
802 instead. This is the case for Chill variable-sized strings. */
803 if (size
== -1 && TREE_CODE (type
) == ARRAY_TYPE
804 && TYPE_ARRAY_MAX_SIZE (type
) != NULL_TREE
805 && host_integerp (TYPE_ARRAY_MAX_SIZE (type
), 1))
806 size
= tree_low_cst (TYPE_ARRAY_MAX_SIZE (type
), 1);
808 /* If we still haven't been able to get a size, see if the language
809 can compute a maximum size. */
811 && (size_tree
= lang_hooks
.types
.max_size (type
)) != 0
812 && host_integerp (size_tree
, 1))
813 size
= tree_low_cst (size_tree
, 1);
815 /* The size of the temporary may be too large to fit into an integer. */
816 /* ??? Not sure this should happen except for user silliness, so limit
817 this to things that aren't compiler-generated temporaries. The
818 rest of the time we'll abort in assign_stack_temp_for_type. */
819 if (decl
&& size
== -1
820 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
)
822 error ("%Jsize of variable %qD is too large", decl
, decl
);
826 tmp
= assign_stack_temp_for_type (mode
, size
, keep
, type
);
832 mode
= promote_mode (type
, mode
, &unsignedp
, 0);
835 return gen_reg_rtx (mode
);
838 /* Combine temporary stack slots which are adjacent on the stack.
840 This allows for better use of already allocated stack space. This is only
841 done for BLKmode slots because we can be sure that we won't have alignment
842 problems in this case. */
845 combine_temp_slots (void)
847 struct temp_slot
*p
, *q
, *next
, *next_q
;
850 /* We can't combine slots, because the information about which slot
851 is in which alias set will be lost. */
852 if (flag_strict_aliasing
)
855 /* If there are a lot of temp slots, don't do anything unless
856 high levels of optimization. */
857 if (! flag_expensive_optimizations
)
858 for (p
= avail_temp_slots
, num_slots
= 0; p
; p
= p
->next
, num_slots
++)
859 if (num_slots
> 100 || (num_slots
> 10 && optimize
== 0))
862 for (p
= avail_temp_slots
; p
; p
= next
)
868 if (GET_MODE (p
->slot
) != BLKmode
)
871 for (q
= p
->next
; q
; q
= next_q
)
877 if (GET_MODE (q
->slot
) != BLKmode
)
880 if (p
->base_offset
+ p
->full_size
== q
->base_offset
)
882 /* Q comes after P; combine Q into P. */
884 p
->full_size
+= q
->full_size
;
887 else if (q
->base_offset
+ q
->full_size
== p
->base_offset
)
889 /* P comes after Q; combine P into Q. */
891 q
->full_size
+= p
->full_size
;
896 cut_slot_from_list (q
, &avail_temp_slots
);
899 /* Either delete P or advance past it. */
901 cut_slot_from_list (p
, &avail_temp_slots
);
905 /* Find the temp slot corresponding to the object at address X. */
907 static struct temp_slot
*
908 find_temp_slot_from_address (rtx x
)
914 for (i
= max_slot_level (); i
>= 0; i
--)
915 for (p
= *temp_slots_at_level (i
); p
; p
= p
->next
)
917 if (XEXP (p
->slot
, 0) == x
919 || (GET_CODE (x
) == PLUS
920 && XEXP (x
, 0) == virtual_stack_vars_rtx
921 && GET_CODE (XEXP (x
, 1)) == CONST_INT
922 && INTVAL (XEXP (x
, 1)) >= p
->base_offset
923 && INTVAL (XEXP (x
, 1)) < p
->base_offset
+ p
->full_size
))
926 else if (p
->address
!= 0 && GET_CODE (p
->address
) == EXPR_LIST
)
927 for (next
= p
->address
; next
; next
= XEXP (next
, 1))
928 if (XEXP (next
, 0) == x
)
932 /* If we have a sum involving a register, see if it points to a temp
934 if (GET_CODE (x
) == PLUS
&& REG_P (XEXP (x
, 0))
935 && (p
= find_temp_slot_from_address (XEXP (x
, 0))) != 0)
937 else if (GET_CODE (x
) == PLUS
&& REG_P (XEXP (x
, 1))
938 && (p
= find_temp_slot_from_address (XEXP (x
, 1))) != 0)
944 /* Indicate that NEW is an alternate way of referring to the temp slot
945 that previously was known by OLD. */
948 update_temp_slot_address (rtx old
, rtx
new)
952 if (rtx_equal_p (old
, new))
955 p
= find_temp_slot_from_address (old
);
957 /* If we didn't find one, see if both OLD is a PLUS. If so, and NEW
958 is a register, see if one operand of the PLUS is a temporary
959 location. If so, NEW points into it. Otherwise, if both OLD and
960 NEW are a PLUS and if there is a register in common between them.
961 If so, try a recursive call on those values. */
964 if (GET_CODE (old
) != PLUS
)
969 update_temp_slot_address (XEXP (old
, 0), new);
970 update_temp_slot_address (XEXP (old
, 1), new);
973 else if (GET_CODE (new) != PLUS
)
976 if (rtx_equal_p (XEXP (old
, 0), XEXP (new, 0)))
977 update_temp_slot_address (XEXP (old
, 1), XEXP (new, 1));
978 else if (rtx_equal_p (XEXP (old
, 1), XEXP (new, 0)))
979 update_temp_slot_address (XEXP (old
, 0), XEXP (new, 1));
980 else if (rtx_equal_p (XEXP (old
, 0), XEXP (new, 1)))
981 update_temp_slot_address (XEXP (old
, 1), XEXP (new, 0));
982 else if (rtx_equal_p (XEXP (old
, 1), XEXP (new, 1)))
983 update_temp_slot_address (XEXP (old
, 0), XEXP (new, 0));
988 /* Otherwise add an alias for the temp's address. */
989 else if (p
->address
== 0)
993 if (GET_CODE (p
->address
) != EXPR_LIST
)
994 p
->address
= gen_rtx_EXPR_LIST (VOIDmode
, p
->address
, NULL_RTX
);
996 p
->address
= gen_rtx_EXPR_LIST (VOIDmode
, new, p
->address
);
1000 /* If X could be a reference to a temporary slot, mark the fact that its
1001 address was taken. */
1004 mark_temp_addr_taken (rtx x
)
1006 struct temp_slot
*p
;
1011 /* If X is not in memory or is at a constant address, it cannot be in
1012 a temporary slot. */
1013 if (!MEM_P (x
) || CONSTANT_P (XEXP (x
, 0)))
1016 p
= find_temp_slot_from_address (XEXP (x
, 0));
1021 /* If X could be a reference to a temporary slot, mark that slot as
1022 belonging to the to one level higher than the current level. If X
1023 matched one of our slots, just mark that one. Otherwise, we can't
1024 easily predict which it is, so upgrade all of them. Kept slots
1025 need not be touched.
1027 This is called when an ({...}) construct occurs and a statement
1028 returns a value in memory. */
1031 preserve_temp_slots (rtx x
)
1033 struct temp_slot
*p
= 0, *next
;
1035 /* If there is no result, we still might have some objects whose address
1036 were taken, so we need to make sure they stay around. */
1039 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1044 move_slot_to_level (p
, temp_slot_level
- 1);
1050 /* If X is a register that is being used as a pointer, see if we have
1051 a temporary slot we know it points to. To be consistent with
1052 the code below, we really should preserve all non-kept slots
1053 if we can't find a match, but that seems to be much too costly. */
1054 if (REG_P (x
) && REG_POINTER (x
))
1055 p
= find_temp_slot_from_address (x
);
1057 /* If X is not in memory or is at a constant address, it cannot be in
1058 a temporary slot, but it can contain something whose address was
1060 if (p
== 0 && (!MEM_P (x
) || CONSTANT_P (XEXP (x
, 0))))
1062 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1067 move_slot_to_level (p
, temp_slot_level
- 1);
1073 /* First see if we can find a match. */
1075 p
= find_temp_slot_from_address (XEXP (x
, 0));
1079 /* Move everything at our level whose address was taken to our new
1080 level in case we used its address. */
1081 struct temp_slot
*q
;
1083 if (p
->level
== temp_slot_level
)
1085 for (q
= *temp_slots_at_level (temp_slot_level
); q
; q
= next
)
1089 if (p
!= q
&& q
->addr_taken
)
1090 move_slot_to_level (q
, temp_slot_level
- 1);
1093 move_slot_to_level (p
, temp_slot_level
- 1);
1099 /* Otherwise, preserve all non-kept slots at this level. */
1100 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1105 move_slot_to_level (p
, temp_slot_level
- 1);
1109 /* Free all temporaries used so far. This is normally called at the
1110 end of generating code for a statement. */
1113 free_temp_slots (void)
1115 struct temp_slot
*p
, *next
;
1117 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1122 make_slot_available (p
);
1125 combine_temp_slots ();
1128 /* Push deeper into the nesting level for stack temporaries. */
1131 push_temp_slots (void)
1136 /* Pop a temporary nesting level. All slots in use in the current level
1140 pop_temp_slots (void)
1142 struct temp_slot
*p
, *next
;
1144 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1147 make_slot_available (p
);
1150 combine_temp_slots ();
1155 /* Initialize temporary slots. */
1158 init_temp_slots (void)
1160 /* We have not allocated any temporaries yet. */
1161 avail_temp_slots
= 0;
1162 used_temp_slots
= 0;
1163 temp_slot_level
= 0;
1166 /* These routines are responsible for converting virtual register references
1167 to the actual hard register references once RTL generation is complete.
1169 The following four variables are used for communication between the
1170 routines. They contain the offsets of the virtual registers from their
1171 respective hard registers. */
1173 static int in_arg_offset
;
1174 static int var_offset
;
1175 static int dynamic_offset
;
1176 static int out_arg_offset
;
1177 static int cfa_offset
;
1179 /* In most machines, the stack pointer register is equivalent to the bottom
1182 #ifndef STACK_POINTER_OFFSET
1183 #define STACK_POINTER_OFFSET 0
1186 /* If not defined, pick an appropriate default for the offset of dynamically
1187 allocated memory depending on the value of ACCUMULATE_OUTGOING_ARGS,
1188 REG_PARM_STACK_SPACE, and OUTGOING_REG_PARM_STACK_SPACE. */
1190 #ifndef STACK_DYNAMIC_OFFSET
1192 /* The bottom of the stack points to the actual arguments. If
1193 REG_PARM_STACK_SPACE is defined, this includes the space for the register
1194 parameters. However, if OUTGOING_REG_PARM_STACK space is not defined,
1195 stack space for register parameters is not pushed by the caller, but
1196 rather part of the fixed stack areas and hence not included in
1197 `current_function_outgoing_args_size'. Nevertheless, we must allow
1198 for it when allocating stack dynamic objects. */
1200 #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE)
1201 #define STACK_DYNAMIC_OFFSET(FNDECL) \
1202 ((ACCUMULATE_OUTGOING_ARGS \
1203 ? (current_function_outgoing_args_size + REG_PARM_STACK_SPACE (FNDECL)) : 0)\
1204 + (STACK_POINTER_OFFSET)) \
1207 #define STACK_DYNAMIC_OFFSET(FNDECL) \
1208 ((ACCUMULATE_OUTGOING_ARGS ? current_function_outgoing_args_size : 0) \
1209 + (STACK_POINTER_OFFSET))
1213 /* On most machines, the CFA coincides with the first incoming parm. */
1215 #ifndef ARG_POINTER_CFA_OFFSET
1216 #define ARG_POINTER_CFA_OFFSET(FNDECL) FIRST_PARM_OFFSET (FNDECL)
1220 /* Pass through the INSNS of function FNDECL and convert virtual register
1221 references to hard register references. */
1224 instantiate_virtual_regs (void)
1228 /* Compute the offsets to use for this function. */
1229 in_arg_offset
= FIRST_PARM_OFFSET (current_function_decl
);
1230 var_offset
= STARTING_FRAME_OFFSET
;
1231 dynamic_offset
= STACK_DYNAMIC_OFFSET (current_function_decl
);
1232 out_arg_offset
= STACK_POINTER_OFFSET
;
1233 cfa_offset
= ARG_POINTER_CFA_OFFSET (current_function_decl
);
1235 /* Scan all variables and parameters of this function. For each that is
1236 in memory, instantiate all virtual registers if the result is a valid
1237 address. If not, we do it later. That will handle most uses of virtual
1238 regs on many machines. */
1239 instantiate_decls (current_function_decl
, 1);
1241 /* Initialize recognition, indicating that volatile is OK. */
1244 /* Scan through all the insns, instantiating every virtual register still
1246 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1247 if (GET_CODE (insn
) == INSN
|| GET_CODE (insn
) == JUMP_INSN
1248 || GET_CODE (insn
) == CALL_INSN
)
1250 instantiate_virtual_regs_1 (&PATTERN (insn
), insn
, 1);
1251 if (INSN_DELETED_P (insn
))
1253 instantiate_virtual_regs_1 (®_NOTES (insn
), NULL_RTX
, 0);
1254 /* Instantiate any virtual registers in CALL_INSN_FUNCTION_USAGE. */
1255 if (GET_CODE (insn
) == CALL_INSN
)
1256 instantiate_virtual_regs_1 (&CALL_INSN_FUNCTION_USAGE (insn
),
1259 /* Past this point all ASM statements should match. Verify that
1260 to avoid failures later in the compilation process. */
1261 if (asm_noperands (PATTERN (insn
)) >= 0
1262 && ! check_asm_operands (PATTERN (insn
)))
1263 instantiate_virtual_regs_lossage (insn
);
1266 /* Now instantiate the remaining register equivalences for debugging info.
1267 These will not be valid addresses. */
1268 instantiate_decls (current_function_decl
, 0);
1270 /* Indicate that, from now on, assign_stack_local should use
1271 frame_pointer_rtx. */
1272 virtuals_instantiated
= 1;
1275 /* Scan all decls in FNDECL (both variables and parameters) and instantiate
1276 all virtual registers in their DECL_RTL's.
1278 If VALID_ONLY, do this only if the resulting address is still valid.
1279 Otherwise, always do it. */
1282 instantiate_decls (tree fndecl
, int valid_only
)
1286 /* Process all parameters of the function. */
1287 for (decl
= DECL_ARGUMENTS (fndecl
); decl
; decl
= TREE_CHAIN (decl
))
1289 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (decl
));
1290 HOST_WIDE_INT size_rtl
;
1292 instantiate_decl (DECL_RTL (decl
), size
, valid_only
);
1294 /* If the parameter was promoted, then the incoming RTL mode may be
1295 larger than the declared type size. We must use the larger of
1297 size_rtl
= GET_MODE_SIZE (GET_MODE (DECL_INCOMING_RTL (decl
)));
1298 size
= MAX (size_rtl
, size
);
1299 instantiate_decl (DECL_INCOMING_RTL (decl
), size
, valid_only
);
1302 /* Now process all variables defined in the function or its subblocks. */
1303 instantiate_decls_1 (DECL_INITIAL (fndecl
), valid_only
);
1306 /* Subroutine of instantiate_decls: Process all decls in the given
1307 BLOCK node and all its subblocks. */
1310 instantiate_decls_1 (tree let
, int valid_only
)
1314 for (t
= BLOCK_VARS (let
); t
; t
= TREE_CHAIN (t
))
1315 if (DECL_RTL_SET_P (t
))
1316 instantiate_decl (DECL_RTL (t
),
1317 int_size_in_bytes (TREE_TYPE (t
)),
1320 /* Process all subblocks. */
1321 for (t
= BLOCK_SUBBLOCKS (let
); t
; t
= TREE_CHAIN (t
))
1322 instantiate_decls_1 (t
, valid_only
);
1325 /* Subroutine of the preceding procedures: Given RTL representing a
1326 decl and the size of the object, do any instantiation required.
1328 If VALID_ONLY is nonzero, it means that the RTL should only be
1329 changed if the new address is valid. */
1332 instantiate_decl (rtx x
, HOST_WIDE_INT size
, int valid_only
)
1334 enum machine_mode mode
;
1340 /* If this is a CONCAT, recurse for the pieces. */
1341 if (GET_CODE (x
) == CONCAT
)
1343 instantiate_decl (XEXP (x
, 0), size
/ 2, valid_only
);
1344 instantiate_decl (XEXP (x
, 1), size
/ 2, valid_only
);
1348 /* If this is not a MEM, no need to do anything. Similarly if the
1349 address is a constant or a register that is not a virtual register. */
1354 if (CONSTANT_P (addr
)
1356 && (REGNO (addr
) < FIRST_VIRTUAL_REGISTER
1357 || REGNO (addr
) > LAST_VIRTUAL_REGISTER
)))
1360 /* If we should only do this if the address is valid, copy the address.
1361 We need to do this so we can undo any changes that might make the
1362 address invalid. This copy is unfortunate, but probably can't be
1366 addr
= copy_rtx (addr
);
1368 instantiate_virtual_regs_1 (&addr
, NULL_RTX
, 0);
1370 if (valid_only
&& size
>= 0)
1372 unsigned HOST_WIDE_INT decl_size
= size
;
1374 /* Now verify that the resulting address is valid for every integer or
1375 floating-point mode up to and including SIZE bytes long. We do this
1376 since the object might be accessed in any mode and frame addresses
1379 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
1380 mode
!= VOIDmode
&& GET_MODE_SIZE (mode
) <= decl_size
;
1381 mode
= GET_MODE_WIDER_MODE (mode
))
1382 if (! memory_address_p (mode
, addr
))
1385 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_FLOAT
);
1386 mode
!= VOIDmode
&& GET_MODE_SIZE (mode
) <= decl_size
;
1387 mode
= GET_MODE_WIDER_MODE (mode
))
1388 if (! memory_address_p (mode
, addr
))
1392 /* Put back the address now that we have updated it and we either know
1393 it is valid or we don't care whether it is valid. */
1398 /* Given a piece of RTX and a pointer to a HOST_WIDE_INT, if the RTX
1399 is a virtual register, return the equivalent hard register and set the
1400 offset indirectly through the pointer. Otherwise, return 0. */
1403 instantiate_new_reg (rtx x
, HOST_WIDE_INT
*poffset
)
1406 HOST_WIDE_INT offset
;
1408 if (x
== virtual_incoming_args_rtx
)
1409 new = arg_pointer_rtx
, offset
= in_arg_offset
;
1410 else if (x
== virtual_stack_vars_rtx
)
1411 new = frame_pointer_rtx
, offset
= var_offset
;
1412 else if (x
== virtual_stack_dynamic_rtx
)
1413 new = stack_pointer_rtx
, offset
= dynamic_offset
;
1414 else if (x
== virtual_outgoing_args_rtx
)
1415 new = stack_pointer_rtx
, offset
= out_arg_offset
;
1416 else if (x
== virtual_cfa_rtx
)
1417 new = arg_pointer_rtx
, offset
= cfa_offset
;
1426 /* Called when instantiate_virtual_regs has failed to update the instruction.
1427 Usually this means that non-matching instruction has been emit, however for
1428 asm statements it may be the problem in the constraints. */
1430 instantiate_virtual_regs_lossage (rtx insn
)
1432 gcc_assert (asm_noperands (PATTERN (insn
)) >= 0);
1433 error_for_asm (insn
, "impossible constraint in %<asm%>");
1436 /* Given a pointer to a piece of rtx and an optional pointer to the
1437 containing object, instantiate any virtual registers present in it.
1439 If EXTRA_INSNS, we always do the replacement and generate
1440 any extra insns before OBJECT. If it zero, we do nothing if replacement
1443 Return 1 if we either had nothing to do or if we were able to do the
1444 needed replacement. Return 0 otherwise; we only return zero if
1445 EXTRA_INSNS is zero.
1447 We first try some simple transformations to avoid the creation of extra
1451 instantiate_virtual_regs_1 (rtx
*loc
, rtx object
, int extra_insns
)
1456 HOST_WIDE_INT offset
= 0;
1462 /* Re-start here to avoid recursion in common cases. */
1469 /* We may have detected and deleted invalid asm statements. */
1470 if (object
&& INSN_P (object
) && INSN_DELETED_P (object
))
1473 code
= GET_CODE (x
);
1475 /* Check for some special cases. */
1493 /* We are allowed to set the virtual registers. This means that
1494 the actual register should receive the source minus the
1495 appropriate offset. This is used, for example, in the handling
1496 of non-local gotos. */
1497 if ((new = instantiate_new_reg (SET_DEST (x
), &offset
)) != 0)
1499 rtx src
= SET_SRC (x
);
1501 /* We are setting the register, not using it, so the relevant
1502 offset is the negative of the offset to use were we using
1505 instantiate_virtual_regs_1 (&src
, NULL_RTX
, 0);
1507 /* The only valid sources here are PLUS or REG. Just do
1508 the simplest possible thing to handle them. */
1509 if (!REG_P (src
) && GET_CODE (src
) != PLUS
)
1511 instantiate_virtual_regs_lossage (object
);
1517 temp
= force_operand (src
, NULL_RTX
);
1520 temp
= force_operand (plus_constant (temp
, offset
), NULL_RTX
);
1524 emit_insn_before (seq
, object
);
1527 if (! validate_change (object
, &SET_SRC (x
), temp
, 0)
1529 instantiate_virtual_regs_lossage (object
);
1534 instantiate_virtual_regs_1 (&SET_DEST (x
), object
, extra_insns
);
1539 /* Handle special case of virtual register plus constant. */
1540 if (CONSTANT_P (XEXP (x
, 1)))
1542 rtx old
, new_offset
;
1544 /* Check for (plus (plus VIRT foo) (const_int)) first. */
1545 if (GET_CODE (XEXP (x
, 0)) == PLUS
)
1547 if ((new = instantiate_new_reg (XEXP (XEXP (x
, 0), 0), &offset
)))
1549 instantiate_virtual_regs_1 (&XEXP (XEXP (x
, 0), 1), object
,
1551 new = gen_rtx_PLUS (Pmode
, new, XEXP (XEXP (x
, 0), 1));
1560 #ifdef POINTERS_EXTEND_UNSIGNED
1561 /* If we have (plus (subreg (virtual-reg)) (const_int)), we know
1562 we can commute the PLUS and SUBREG because pointers into the
1563 frame are well-behaved. */
1564 else if (GET_CODE (XEXP (x
, 0)) == SUBREG
&& GET_MODE (x
) == ptr_mode
1565 && GET_CODE (XEXP (x
, 1)) == CONST_INT
1567 = instantiate_new_reg (SUBREG_REG (XEXP (x
, 0)),
1569 && validate_change (object
, loc
,
1570 plus_constant (gen_lowpart (ptr_mode
,
1573 + INTVAL (XEXP (x
, 1))),
1577 else if ((new = instantiate_new_reg (XEXP (x
, 0), &offset
)) == 0)
1579 /* We know the second operand is a constant. Unless the
1580 first operand is a REG (which has been already checked),
1581 it needs to be checked. */
1582 if (!REG_P (XEXP (x
, 0)))
1590 new_offset
= plus_constant (XEXP (x
, 1), offset
);
1592 /* If the new constant is zero, try to replace the sum with just
1594 if (new_offset
== const0_rtx
1595 && validate_change (object
, loc
, new, 0))
1598 /* Next try to replace the register and new offset.
1599 There are two changes to validate here and we can't assume that
1600 in the case of old offset equals new just changing the register
1601 will yield a valid insn. In the interests of a little efficiency,
1602 however, we only call validate change once (we don't queue up the
1603 changes and then call apply_change_group). */
1607 ? ! validate_change (object
, &XEXP (x
, 0), new, 0)
1608 : (XEXP (x
, 0) = new,
1609 ! validate_change (object
, &XEXP (x
, 1), new_offset
, 0)))
1617 /* Otherwise copy the new constant into a register and replace
1618 constant with that register. */
1619 temp
= gen_reg_rtx (Pmode
);
1621 if (validate_change (object
, &XEXP (x
, 1), temp
, 0))
1622 emit_insn_before (gen_move_insn (temp
, new_offset
), object
);
1625 /* If that didn't work, replace this expression with a
1626 register containing the sum. */
1629 new = gen_rtx_PLUS (Pmode
, new, new_offset
);
1632 temp
= force_operand (new, NULL_RTX
);
1636 emit_insn_before (seq
, object
);
1637 if (! validate_change (object
, loc
, temp
, 0)
1638 && ! validate_replace_rtx (x
, temp
, object
))
1640 instantiate_virtual_regs_lossage (object
);
1649 /* Fall through to generic two-operand expression case. */
1655 case DIV
: case UDIV
:
1656 case MOD
: case UMOD
:
1657 case AND
: case IOR
: case XOR
:
1658 case ROTATERT
: case ROTATE
:
1659 case ASHIFTRT
: case LSHIFTRT
: case ASHIFT
:
1661 case GE
: case GT
: case GEU
: case GTU
:
1662 case LE
: case LT
: case LEU
: case LTU
:
1663 if (XEXP (x
, 1) && ! CONSTANT_P (XEXP (x
, 1)))
1664 instantiate_virtual_regs_1 (&XEXP (x
, 1), object
, extra_insns
);
1669 /* Most cases of MEM that convert to valid addresses have already been
1670 handled by our scan of decls. The only special handling we
1671 need here is to make a copy of the rtx to ensure it isn't being
1672 shared if we have to change it to a pseudo.
1674 If the rtx is a simple reference to an address via a virtual register,
1675 it can potentially be shared. In such cases, first try to make it
1676 a valid address, which can also be shared. Otherwise, copy it and
1679 First check for common cases that need no processing. These are
1680 usually due to instantiation already being done on a previous instance
1684 if (CONSTANT_ADDRESS_P (temp
)
1685 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1686 || temp
== arg_pointer_rtx
1688 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
1689 || temp
== hard_frame_pointer_rtx
1691 || temp
== frame_pointer_rtx
)
1694 if (GET_CODE (temp
) == PLUS
1695 && CONSTANT_ADDRESS_P (XEXP (temp
, 1))
1696 && (XEXP (temp
, 0) == frame_pointer_rtx
1697 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
1698 || XEXP (temp
, 0) == hard_frame_pointer_rtx
1700 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1701 || XEXP (temp
, 0) == arg_pointer_rtx
1706 if (temp
== virtual_stack_vars_rtx
1707 || temp
== virtual_incoming_args_rtx
1708 || (GET_CODE (temp
) == PLUS
1709 && CONSTANT_ADDRESS_P (XEXP (temp
, 1))
1710 && (XEXP (temp
, 0) == virtual_stack_vars_rtx
1711 || XEXP (temp
, 0) == virtual_incoming_args_rtx
)))
1713 /* This MEM may be shared. If the substitution can be done without
1714 the need to generate new pseudos, we want to do it in place
1715 so all copies of the shared rtx benefit. The call below will
1716 only make substitutions if the resulting address is still
1719 Note that we cannot pass X as the object in the recursive call
1720 since the insn being processed may not allow all valid
1721 addresses. However, if we were not passed on object, we can
1722 only modify X without copying it if X will have a valid
1725 ??? Also note that this can still lose if OBJECT is an insn that
1726 has less restrictions on an address that some other insn.
1727 In that case, we will modify the shared address. This case
1728 doesn't seem very likely, though. One case where this could
1729 happen is in the case of a USE or CLOBBER reference, but we
1730 take care of that below. */
1732 if (instantiate_virtual_regs_1 (&XEXP (x
, 0),
1733 object
? object
: x
, 0))
1736 /* Otherwise make a copy and process that copy. We copy the entire
1737 RTL expression since it might be a PLUS which could also be
1739 *loc
= x
= copy_rtx (x
);
1742 /* Fall through to generic unary operation case. */
1745 case STRICT_LOW_PART
:
1747 case PRE_DEC
: case PRE_INC
: case POST_DEC
: case POST_INC
:
1748 case SIGN_EXTEND
: case ZERO_EXTEND
:
1749 case TRUNCATE
: case FLOAT_EXTEND
: case FLOAT_TRUNCATE
:
1750 case FLOAT
: case FIX
:
1751 case UNSIGNED_FIX
: case UNSIGNED_FLOAT
:
1756 case POPCOUNT
: case PARITY
:
1757 /* These case either have just one operand or we know that we need not
1758 check the rest of the operands. */
1764 /* If the operand is a MEM, see if the change is a valid MEM. If not,
1765 go ahead and make the invalid one, but do it to a copy. For a REG,
1766 just make the recursive call, since there's no chance of a problem. */
1768 if ((MEM_P (XEXP (x
, 0))
1769 && instantiate_virtual_regs_1 (&XEXP (XEXP (x
, 0), 0), XEXP (x
, 0),
1771 || (REG_P (XEXP (x
, 0))
1772 && instantiate_virtual_regs_1 (&XEXP (x
, 0), object
, 0)))
1775 XEXP (x
, 0) = copy_rtx (XEXP (x
, 0));
1780 /* Try to replace with a PLUS. If that doesn't work, compute the sum
1781 in front of this insn and substitute the temporary. */
1782 if ((new = instantiate_new_reg (x
, &offset
)) != 0)
1784 temp
= plus_constant (new, offset
);
1785 if (!validate_change (object
, loc
, temp
, 0))
1791 temp
= force_operand (temp
, NULL_RTX
);
1795 emit_insn_before (seq
, object
);
1796 if (! validate_change (object
, loc
, temp
, 0)
1797 && ! validate_replace_rtx (x
, temp
, object
))
1798 instantiate_virtual_regs_lossage (object
);
1808 /* Scan all subexpressions. */
1809 fmt
= GET_RTX_FORMAT (code
);
1810 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++, fmt
++)
1813 if (!instantiate_virtual_regs_1 (&XEXP (x
, i
), object
, extra_insns
))
1816 else if (*fmt
== 'E')
1817 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1818 if (! instantiate_virtual_regs_1 (&XVECEXP (x
, i
, j
), object
,
1825 /* Return 1 if EXP is an aggregate type (or a value with aggregate type).
1826 This means a type for which function calls must pass an address to the
1827 function or get an address back from the function.
1828 EXP may be a type node or an expression (whose type is tested). */
1831 aggregate_value_p (tree exp
, tree fntype
)
1833 int i
, regno
, nregs
;
1836 tree type
= (TYPE_P (exp
)) ? exp
: TREE_TYPE (exp
);
1839 switch (TREE_CODE (fntype
))
1842 fntype
= get_callee_fndecl (fntype
);
1843 fntype
= fntype
? TREE_TYPE (fntype
) : 0;
1846 fntype
= TREE_TYPE (fntype
);
1851 case IDENTIFIER_NODE
:
1855 /* We don't expect other rtl types here. */
1859 if (TREE_CODE (type
) == VOID_TYPE
)
1861 /* If the front end has decided that this needs to be passed by
1862 reference, do so. */
1863 if ((TREE_CODE (exp
) == PARM_DECL
|| TREE_CODE (exp
) == RESULT_DECL
)
1864 && DECL_BY_REFERENCE (exp
))
1866 if (targetm
.calls
.return_in_memory (type
, fntype
))
1868 /* Types that are TREE_ADDRESSABLE must be constructed in memory,
1869 and thus can't be returned in registers. */
1870 if (TREE_ADDRESSABLE (type
))
1872 if (flag_pcc_struct_return
&& AGGREGATE_TYPE_P (type
))
1874 /* Make sure we have suitable call-clobbered regs to return
1875 the value in; if not, we must return it in memory. */
1876 reg
= hard_function_value (type
, 0, 0);
1878 /* If we have something other than a REG (e.g. a PARALLEL), then assume
1883 regno
= REGNO (reg
);
1884 nregs
= hard_regno_nregs
[regno
][TYPE_MODE (type
)];
1885 for (i
= 0; i
< nregs
; i
++)
1886 if (! call_used_regs
[regno
+ i
])
1891 /* Return true if we should assign DECL a pseudo register; false if it
1892 should live on the local stack. */
1895 use_register_for_decl (tree decl
)
1897 /* Honor volatile. */
1898 if (TREE_SIDE_EFFECTS (decl
))
1901 /* Honor addressability. */
1902 if (TREE_ADDRESSABLE (decl
))
1905 /* Only register-like things go in registers. */
1906 if (DECL_MODE (decl
) == BLKmode
)
1909 /* If -ffloat-store specified, don't put explicit float variables
1911 /* ??? This should be checked after DECL_ARTIFICIAL, but tree-ssa
1912 propagates values across these stores, and it probably shouldn't. */
1913 if (flag_float_store
&& FLOAT_TYPE_P (TREE_TYPE (decl
)))
1916 /* If we're not interested in tracking debugging information for
1917 this decl, then we can certainly put it in a register. */
1918 if (DECL_IGNORED_P (decl
))
1921 return (optimize
|| DECL_REGISTER (decl
));
1924 /* Return true if TYPE should be passed by invisible reference. */
1927 pass_by_reference (CUMULATIVE_ARGS
*ca
, enum machine_mode mode
,
1928 tree type
, bool named_arg
)
1932 /* If this type contains non-trivial constructors, then it is
1933 forbidden for the middle-end to create any new copies. */
1934 if (TREE_ADDRESSABLE (type
))
1937 /* GCC post 3.4 passes *all* variable sized types by reference. */
1938 if (!TYPE_SIZE (type
) || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1942 return targetm
.calls
.pass_by_reference (ca
, mode
, type
, named_arg
);
1945 /* Return true if TYPE, which is passed by reference, should be callee
1946 copied instead of caller copied. */
1949 reference_callee_copied (CUMULATIVE_ARGS
*ca
, enum machine_mode mode
,
1950 tree type
, bool named_arg
)
1952 if (type
&& TREE_ADDRESSABLE (type
))
1954 return targetm
.calls
.callee_copies (ca
, mode
, type
, named_arg
);
1957 /* Structures to communicate between the subroutines of assign_parms.
1958 The first holds data persistent across all parameters, the second
1959 is cleared out for each parameter. */
1961 struct assign_parm_data_all
1963 CUMULATIVE_ARGS args_so_far
;
1964 struct args_size stack_args_size
;
1965 tree function_result_decl
;
1967 rtx conversion_insns
;
1968 HOST_WIDE_INT pretend_args_size
;
1969 HOST_WIDE_INT extra_pretend_bytes
;
1970 int reg_parm_stack_space
;
1973 struct assign_parm_data_one
1979 enum machine_mode nominal_mode
;
1980 enum machine_mode passed_mode
;
1981 enum machine_mode promoted_mode
;
1982 struct locate_and_pad_arg_data locate
;
1984 BOOL_BITFIELD named_arg
: 1;
1985 BOOL_BITFIELD passed_pointer
: 1;
1986 BOOL_BITFIELD on_stack
: 1;
1987 BOOL_BITFIELD loaded_in_reg
: 1;
1990 /* A subroutine of assign_parms. Initialize ALL. */
1993 assign_parms_initialize_all (struct assign_parm_data_all
*all
)
1997 memset (all
, 0, sizeof (*all
));
1999 fntype
= TREE_TYPE (current_function_decl
);
2001 #ifdef INIT_CUMULATIVE_INCOMING_ARGS
2002 INIT_CUMULATIVE_INCOMING_ARGS (all
->args_so_far
, fntype
, NULL_RTX
);
2004 INIT_CUMULATIVE_ARGS (all
->args_so_far
, fntype
, NULL_RTX
,
2005 current_function_decl
, -1);
2008 #ifdef REG_PARM_STACK_SPACE
2009 all
->reg_parm_stack_space
= REG_PARM_STACK_SPACE (current_function_decl
);
2013 /* If ARGS contains entries with complex types, split the entry into two
2014 entries of the component type. Return a new list of substitutions are
2015 needed, else the old list. */
2018 split_complex_args (tree args
)
2022 /* Before allocating memory, check for the common case of no complex. */
2023 for (p
= args
; p
; p
= TREE_CHAIN (p
))
2025 tree type
= TREE_TYPE (p
);
2026 if (TREE_CODE (type
) == COMPLEX_TYPE
2027 && targetm
.calls
.split_complex_arg (type
))
2033 args
= copy_list (args
);
2035 for (p
= args
; p
; p
= TREE_CHAIN (p
))
2037 tree type
= TREE_TYPE (p
);
2038 if (TREE_CODE (type
) == COMPLEX_TYPE
2039 && targetm
.calls
.split_complex_arg (type
))
2042 tree subtype
= TREE_TYPE (type
);
2043 bool addressable
= TREE_ADDRESSABLE (p
);
2045 /* Rewrite the PARM_DECL's type with its component. */
2046 TREE_TYPE (p
) = subtype
;
2047 DECL_ARG_TYPE (p
) = TREE_TYPE (DECL_ARG_TYPE (p
));
2048 DECL_MODE (p
) = VOIDmode
;
2049 DECL_SIZE (p
) = NULL
;
2050 DECL_SIZE_UNIT (p
) = NULL
;
2051 /* If this arg must go in memory, put it in a pseudo here.
2052 We can't allow it to go in memory as per normal parms,
2053 because the usual place might not have the imag part
2054 adjacent to the real part. */
2055 DECL_ARTIFICIAL (p
) = addressable
;
2056 DECL_IGNORED_P (p
) = addressable
;
2057 TREE_ADDRESSABLE (p
) = 0;
2060 /* Build a second synthetic decl. */
2061 decl
= build_decl (PARM_DECL
, NULL_TREE
, subtype
);
2062 DECL_ARG_TYPE (decl
) = DECL_ARG_TYPE (p
);
2063 DECL_ARTIFICIAL (decl
) = addressable
;
2064 DECL_IGNORED_P (decl
) = addressable
;
2065 layout_decl (decl
, 0);
2067 /* Splice it in; skip the new decl. */
2068 TREE_CHAIN (decl
) = TREE_CHAIN (p
);
2069 TREE_CHAIN (p
) = decl
;
2077 /* A subroutine of assign_parms. Adjust the parameter list to incorporate
2078 the hidden struct return argument, and (abi willing) complex args.
2079 Return the new parameter list. */
2082 assign_parms_augmented_arg_list (struct assign_parm_data_all
*all
)
2084 tree fndecl
= current_function_decl
;
2085 tree fntype
= TREE_TYPE (fndecl
);
2086 tree fnargs
= DECL_ARGUMENTS (fndecl
);
2088 /* If struct value address is treated as the first argument, make it so. */
2089 if (aggregate_value_p (DECL_RESULT (fndecl
), fndecl
)
2090 && ! current_function_returns_pcc_struct
2091 && targetm
.calls
.struct_value_rtx (TREE_TYPE (fndecl
), 1) == 0)
2093 tree type
= build_pointer_type (TREE_TYPE (fntype
));
2096 decl
= build_decl (PARM_DECL
, NULL_TREE
, type
);
2097 DECL_ARG_TYPE (decl
) = type
;
2098 DECL_ARTIFICIAL (decl
) = 1;
2099 DECL_IGNORED_P (decl
) = 1;
2101 TREE_CHAIN (decl
) = fnargs
;
2103 all
->function_result_decl
= decl
;
2106 all
->orig_fnargs
= fnargs
;
2108 /* If the target wants to split complex arguments into scalars, do so. */
2109 if (targetm
.calls
.split_complex_arg
)
2110 fnargs
= split_complex_args (fnargs
);
2115 /* A subroutine of assign_parms. Examine PARM and pull out type and mode
2116 data for the parameter. Incorporate ABI specifics such as pass-by-
2117 reference and type promotion. */
2120 assign_parm_find_data_types (struct assign_parm_data_all
*all
, tree parm
,
2121 struct assign_parm_data_one
*data
)
2123 tree nominal_type
, passed_type
;
2124 enum machine_mode nominal_mode
, passed_mode
, promoted_mode
;
2126 memset (data
, 0, sizeof (*data
));
2128 /* NAMED_ARG is a mis-nomer. We really mean 'non-varadic'. */
2129 if (!current_function_stdarg
)
2130 data
->named_arg
= 1; /* No varadic parms. */
2131 else if (TREE_CHAIN (parm
))
2132 data
->named_arg
= 1; /* Not the last non-varadic parm. */
2133 else if (targetm
.calls
.strict_argument_naming (&all
->args_so_far
))
2134 data
->named_arg
= 1; /* Only varadic ones are unnamed. */
2136 data
->named_arg
= 0; /* Treat as varadic. */
2138 nominal_type
= TREE_TYPE (parm
);
2139 passed_type
= DECL_ARG_TYPE (parm
);
2141 /* Look out for errors propagating this far. Also, if the parameter's
2142 type is void then its value doesn't matter. */
2143 if (TREE_TYPE (parm
) == error_mark_node
2144 /* This can happen after weird syntax errors
2145 or if an enum type is defined among the parms. */
2146 || TREE_CODE (parm
) != PARM_DECL
2147 || passed_type
== NULL
2148 || VOID_TYPE_P (nominal_type
))
2150 nominal_type
= passed_type
= void_type_node
;
2151 nominal_mode
= passed_mode
= promoted_mode
= VOIDmode
;
2155 /* Find mode of arg as it is passed, and mode of arg as it should be
2156 during execution of this function. */
2157 passed_mode
= TYPE_MODE (passed_type
);
2158 nominal_mode
= TYPE_MODE (nominal_type
);
2160 /* If the parm is to be passed as a transparent union, use the type of
2161 the first field for the tests below. We have already verified that
2162 the modes are the same. */
2163 if (DECL_TRANSPARENT_UNION (parm
)
2164 || (TREE_CODE (passed_type
) == UNION_TYPE
2165 && TYPE_TRANSPARENT_UNION (passed_type
)))
2166 passed_type
= TREE_TYPE (TYPE_FIELDS (passed_type
));
2168 /* See if this arg was passed by invisible reference. */
2169 if (pass_by_reference (&all
->args_so_far
, passed_mode
,
2170 passed_type
, data
->named_arg
))
2172 passed_type
= nominal_type
= build_pointer_type (passed_type
);
2173 data
->passed_pointer
= true;
2174 passed_mode
= nominal_mode
= Pmode
;
2177 /* Find mode as it is passed by the ABI. */
2178 promoted_mode
= passed_mode
;
2179 if (targetm
.calls
.promote_function_args (TREE_TYPE (current_function_decl
)))
2181 int unsignedp
= TYPE_UNSIGNED (passed_type
);
2182 promoted_mode
= promote_mode (passed_type
, promoted_mode
,
2187 data
->nominal_type
= nominal_type
;
2188 data
->passed_type
= passed_type
;
2189 data
->nominal_mode
= nominal_mode
;
2190 data
->passed_mode
= passed_mode
;
2191 data
->promoted_mode
= promoted_mode
;
2194 /* A subroutine of assign_parms. Invoke setup_incoming_varargs. */
2197 assign_parms_setup_varargs (struct assign_parm_data_all
*all
,
2198 struct assign_parm_data_one
*data
, bool no_rtl
)
2200 int varargs_pretend_bytes
= 0;
2202 targetm
.calls
.setup_incoming_varargs (&all
->args_so_far
,
2203 data
->promoted_mode
,
2205 &varargs_pretend_bytes
, no_rtl
);
2207 /* If the back-end has requested extra stack space, record how much is
2208 needed. Do not change pretend_args_size otherwise since it may be
2209 nonzero from an earlier partial argument. */
2210 if (varargs_pretend_bytes
> 0)
2211 all
->pretend_args_size
= varargs_pretend_bytes
;
2214 /* A subroutine of assign_parms. Set DATA->ENTRY_PARM corresponding to
2215 the incoming location of the current parameter. */
2218 assign_parm_find_entry_rtl (struct assign_parm_data_all
*all
,
2219 struct assign_parm_data_one
*data
)
2221 HOST_WIDE_INT pretend_bytes
= 0;
2225 if (data
->promoted_mode
== VOIDmode
)
2227 data
->entry_parm
= data
->stack_parm
= const0_rtx
;
2231 #ifdef FUNCTION_INCOMING_ARG
2232 entry_parm
= FUNCTION_INCOMING_ARG (all
->args_so_far
, data
->promoted_mode
,
2233 data
->passed_type
, data
->named_arg
);
2235 entry_parm
= FUNCTION_ARG (all
->args_so_far
, data
->promoted_mode
,
2236 data
->passed_type
, data
->named_arg
);
2239 if (entry_parm
== 0)
2240 data
->promoted_mode
= data
->passed_mode
;
2242 /* Determine parm's home in the stack, in case it arrives in the stack
2243 or we should pretend it did. Compute the stack position and rtx where
2244 the argument arrives and its size.
2246 There is one complexity here: If this was a parameter that would
2247 have been passed in registers, but wasn't only because it is
2248 __builtin_va_alist, we want locate_and_pad_parm to treat it as if
2249 it came in a register so that REG_PARM_STACK_SPACE isn't skipped.
2250 In this case, we call FUNCTION_ARG with NAMED set to 1 instead of 0
2251 as it was the previous time. */
2252 in_regs
= entry_parm
!= 0;
2253 #ifdef STACK_PARMS_IN_REG_PARM_AREA
2256 if (!in_regs
&& !data
->named_arg
)
2258 if (targetm
.calls
.pretend_outgoing_varargs_named (&all
->args_so_far
))
2261 #ifdef FUNCTION_INCOMING_ARG
2262 tem
= FUNCTION_INCOMING_ARG (all
->args_so_far
, data
->promoted_mode
,
2263 data
->passed_type
, true);
2265 tem
= FUNCTION_ARG (all
->args_so_far
, data
->promoted_mode
,
2266 data
->passed_type
, true);
2268 in_regs
= tem
!= NULL
;
2272 /* If this parameter was passed both in registers and in the stack, use
2273 the copy on the stack. */
2274 if (targetm
.calls
.must_pass_in_stack (data
->promoted_mode
,
2282 partial
= targetm
.calls
.arg_partial_bytes (&all
->args_so_far
,
2283 data
->promoted_mode
,
2286 data
->partial
= partial
;
2288 /* The caller might already have allocated stack space for the
2289 register parameters. */
2290 if (partial
!= 0 && all
->reg_parm_stack_space
== 0)
2292 /* Part of this argument is passed in registers and part
2293 is passed on the stack. Ask the prologue code to extend
2294 the stack part so that we can recreate the full value.
2296 PRETEND_BYTES is the size of the registers we need to store.
2297 CURRENT_FUNCTION_PRETEND_ARGS_SIZE is the amount of extra
2298 stack space that the prologue should allocate.
2300 Internally, gcc assumes that the argument pointer is aligned
2301 to STACK_BOUNDARY bits. This is used both for alignment
2302 optimizations (see init_emit) and to locate arguments that are
2303 aligned to more than PARM_BOUNDARY bits. We must preserve this
2304 invariant by rounding CURRENT_FUNCTION_PRETEND_ARGS_SIZE up to
2305 a stack boundary. */
2307 /* We assume at most one partial arg, and it must be the first
2308 argument on the stack. */
2309 gcc_assert (!all
->extra_pretend_bytes
&& !all
->pretend_args_size
);
2311 pretend_bytes
= partial
;
2312 all
->pretend_args_size
= CEIL_ROUND (pretend_bytes
, STACK_BYTES
);
2314 /* We want to align relative to the actual stack pointer, so
2315 don't include this in the stack size until later. */
2316 all
->extra_pretend_bytes
= all
->pretend_args_size
;
2320 locate_and_pad_parm (data
->promoted_mode
, data
->passed_type
, in_regs
,
2321 entry_parm
? data
->partial
: 0, current_function_decl
,
2322 &all
->stack_args_size
, &data
->locate
);
2324 /* Adjust offsets to include the pretend args. */
2325 pretend_bytes
= all
->extra_pretend_bytes
- pretend_bytes
;
2326 data
->locate
.slot_offset
.constant
+= pretend_bytes
;
2327 data
->locate
.offset
.constant
+= pretend_bytes
;
2329 data
->entry_parm
= entry_parm
;
2332 /* A subroutine of assign_parms. If there is actually space on the stack
2333 for this parm, count it in stack_args_size and return true. */
2336 assign_parm_is_stack_parm (struct assign_parm_data_all
*all
,
2337 struct assign_parm_data_one
*data
)
2339 /* Trivially true if we've no incoming register. */
2340 if (data
->entry_parm
== NULL
)
2342 /* Also true if we're partially in registers and partially not,
2343 since we've arranged to drop the entire argument on the stack. */
2344 else if (data
->partial
!= 0)
2346 /* Also true if the target says that it's passed in both registers
2347 and on the stack. */
2348 else if (GET_CODE (data
->entry_parm
) == PARALLEL
2349 && XEXP (XVECEXP (data
->entry_parm
, 0, 0), 0) == NULL_RTX
)
2351 /* Also true if the target says that there's stack allocated for
2352 all register parameters. */
2353 else if (all
->reg_parm_stack_space
> 0)
2355 /* Otherwise, no, this parameter has no ABI defined stack slot. */
2359 all
->stack_args_size
.constant
+= data
->locate
.size
.constant
;
2360 if (data
->locate
.size
.var
)
2361 ADD_PARM_SIZE (all
->stack_args_size
, data
->locate
.size
.var
);
2366 /* A subroutine of assign_parms. Given that this parameter is allocated
2367 stack space by the ABI, find it. */
2370 assign_parm_find_stack_rtl (tree parm
, struct assign_parm_data_one
*data
)
2372 rtx offset_rtx
, stack_parm
;
2373 unsigned int align
, boundary
;
2375 /* If we're passing this arg using a reg, make its stack home the
2376 aligned stack slot. */
2377 if (data
->entry_parm
)
2378 offset_rtx
= ARGS_SIZE_RTX (data
->locate
.slot_offset
);
2380 offset_rtx
= ARGS_SIZE_RTX (data
->locate
.offset
);
2382 stack_parm
= current_function_internal_arg_pointer
;
2383 if (offset_rtx
!= const0_rtx
)
2384 stack_parm
= gen_rtx_PLUS (Pmode
, stack_parm
, offset_rtx
);
2385 stack_parm
= gen_rtx_MEM (data
->promoted_mode
, stack_parm
);
2387 set_mem_attributes (stack_parm
, parm
, 1);
2389 boundary
= data
->locate
.boundary
;
2390 align
= BITS_PER_UNIT
;
2392 /* If we're padding upward, we know that the alignment of the slot
2393 is FUNCTION_ARG_BOUNDARY. If we're using slot_offset, we're
2394 intentionally forcing upward padding. Otherwise we have to come
2395 up with a guess at the alignment based on OFFSET_RTX. */
2396 if (data
->locate
.where_pad
!= downward
|| data
->entry_parm
)
2398 else if (GET_CODE (offset_rtx
) == CONST_INT
)
2400 align
= INTVAL (offset_rtx
) * BITS_PER_UNIT
| boundary
;
2401 align
= align
& -align
;
2403 set_mem_align (stack_parm
, align
);
2405 if (data
->entry_parm
)
2406 set_reg_attrs_for_parm (data
->entry_parm
, stack_parm
);
2408 data
->stack_parm
= stack_parm
;
2411 /* A subroutine of assign_parms. Adjust DATA->ENTRY_RTL such that it's
2412 always valid and contiguous. */
2415 assign_parm_adjust_entry_rtl (struct assign_parm_data_one
*data
)
2417 rtx entry_parm
= data
->entry_parm
;
2418 rtx stack_parm
= data
->stack_parm
;
2420 /* If this parm was passed part in regs and part in memory, pretend it
2421 arrived entirely in memory by pushing the register-part onto the stack.
2422 In the special case of a DImode or DFmode that is split, we could put
2423 it together in a pseudoreg directly, but for now that's not worth
2425 if (data
->partial
!= 0)
2427 /* Handle calls that pass values in multiple non-contiguous
2428 locations. The Irix 6 ABI has examples of this. */
2429 if (GET_CODE (entry_parm
) == PARALLEL
)
2430 emit_group_store (validize_mem (stack_parm
), entry_parm
,
2432 int_size_in_bytes (data
->passed_type
));
2435 gcc_assert (data
->partial
% UNITS_PER_WORD
== 0);
2436 move_block_from_reg (REGNO (entry_parm
), validize_mem (stack_parm
),
2437 data
->partial
/ UNITS_PER_WORD
);
2440 entry_parm
= stack_parm
;
2443 /* If we didn't decide this parm came in a register, by default it came
2445 else if (entry_parm
== NULL
)
2446 entry_parm
= stack_parm
;
2448 /* When an argument is passed in multiple locations, we can't make use
2449 of this information, but we can save some copying if the whole argument
2450 is passed in a single register. */
2451 else if (GET_CODE (entry_parm
) == PARALLEL
2452 && data
->nominal_mode
!= BLKmode
2453 && data
->passed_mode
!= BLKmode
)
2455 size_t i
, len
= XVECLEN (entry_parm
, 0);
2457 for (i
= 0; i
< len
; i
++)
2458 if (XEXP (XVECEXP (entry_parm
, 0, i
), 0) != NULL_RTX
2459 && REG_P (XEXP (XVECEXP (entry_parm
, 0, i
), 0))
2460 && (GET_MODE (XEXP (XVECEXP (entry_parm
, 0, i
), 0))
2461 == data
->passed_mode
)
2462 && INTVAL (XEXP (XVECEXP (entry_parm
, 0, i
), 1)) == 0)
2464 entry_parm
= XEXP (XVECEXP (entry_parm
, 0, i
), 0);
2469 data
->entry_parm
= entry_parm
;
2472 /* A subroutine of assign_parms. Adjust DATA->STACK_RTL such that it's
2473 always valid and properly aligned. */
2476 assign_parm_adjust_stack_rtl (struct assign_parm_data_one
*data
)
2478 rtx stack_parm
= data
->stack_parm
;
2480 /* If we can't trust the parm stack slot to be aligned enough for its
2481 ultimate type, don't use that slot after entry. We'll make another
2482 stack slot, if we need one. */
2484 && ((STRICT_ALIGNMENT
2485 && GET_MODE_ALIGNMENT (data
->nominal_mode
) > MEM_ALIGN (stack_parm
))
2486 || (data
->nominal_type
2487 && TYPE_ALIGN (data
->nominal_type
) > MEM_ALIGN (stack_parm
)
2488 && MEM_ALIGN (stack_parm
) < PREFERRED_STACK_BOUNDARY
)))
2491 /* If parm was passed in memory, and we need to convert it on entry,
2492 don't store it back in that same slot. */
2493 else if (data
->entry_parm
== stack_parm
2494 && data
->nominal_mode
!= BLKmode
2495 && data
->nominal_mode
!= data
->passed_mode
)
2498 data
->stack_parm
= stack_parm
;
2501 /* A subroutine of assign_parms. Return true if the current parameter
2502 should be stored as a BLKmode in the current frame. */
2505 assign_parm_setup_block_p (struct assign_parm_data_one
*data
)
2507 if (data
->nominal_mode
== BLKmode
)
2509 if (GET_CODE (data
->entry_parm
) == PARALLEL
)
2512 #ifdef BLOCK_REG_PADDING
2513 /* Only assign_parm_setup_block knows how to deal with register arguments
2514 that are padded at the least significant end. */
2515 if (REG_P (data
->entry_parm
)
2516 && GET_MODE_SIZE (data
->promoted_mode
) < UNITS_PER_WORD
2517 && (BLOCK_REG_PADDING (data
->passed_mode
, data
->passed_type
, 1)
2518 == (BYTES_BIG_ENDIAN
? upward
: downward
)))
2525 /* A subroutine of assign_parms. Arrange for the parameter to be
2526 present and valid in DATA->STACK_RTL. */
2529 assign_parm_setup_block (struct assign_parm_data_all
*all
,
2530 tree parm
, struct assign_parm_data_one
*data
)
2532 rtx entry_parm
= data
->entry_parm
;
2533 rtx stack_parm
= data
->stack_parm
;
2535 HOST_WIDE_INT size_stored
;
2536 rtx orig_entry_parm
= entry_parm
;
2538 if (GET_CODE (entry_parm
) == PARALLEL
)
2539 entry_parm
= emit_group_move_into_temps (entry_parm
);
2541 /* If we've a non-block object that's nevertheless passed in parts,
2542 reconstitute it in register operations rather than on the stack. */
2543 if (GET_CODE (entry_parm
) == PARALLEL
2544 && data
->nominal_mode
!= BLKmode
)
2546 rtx elt0
= XEXP (XVECEXP (orig_entry_parm
, 0, 0), 0);
2548 if ((XVECLEN (entry_parm
, 0) > 1
2549 || hard_regno_nregs
[REGNO (elt0
)][GET_MODE (elt0
)] > 1)
2550 && use_register_for_decl (parm
))
2552 rtx parmreg
= gen_reg_rtx (data
->nominal_mode
);
2554 push_to_sequence (all
->conversion_insns
);
2556 /* For values returned in multiple registers, handle possible
2557 incompatible calls to emit_group_store.
2559 For example, the following would be invalid, and would have to
2560 be fixed by the conditional below:
2562 emit_group_store ((reg:SF), (parallel:DF))
2563 emit_group_store ((reg:SI), (parallel:DI))
2565 An example of this are doubles in e500 v2:
2566 (parallel:DF (expr_list (reg:SI) (const_int 0))
2567 (expr_list (reg:SI) (const_int 4))). */
2568 if (data
->nominal_mode
!= data
->passed_mode
)
2570 rtx t
= gen_reg_rtx (GET_MODE (entry_parm
));
2571 emit_group_store (t
, entry_parm
, NULL_TREE
,
2572 GET_MODE_SIZE (GET_MODE (entry_parm
)));
2573 convert_move (parmreg
, t
, 0);
2576 emit_group_store (parmreg
, entry_parm
, data
->nominal_type
,
2577 int_size_in_bytes (data
->nominal_type
));
2579 all
->conversion_insns
= get_insns ();
2582 SET_DECL_RTL (parm
, parmreg
);
2587 size
= int_size_in_bytes (data
->passed_type
);
2588 size_stored
= CEIL_ROUND (size
, UNITS_PER_WORD
);
2589 if (stack_parm
== 0)
2591 DECL_ALIGN (parm
) = MAX (DECL_ALIGN (parm
), BITS_PER_WORD
);
2592 stack_parm
= assign_stack_local (BLKmode
, size_stored
,
2594 if (GET_MODE_SIZE (GET_MODE (entry_parm
)) == size
)
2595 PUT_MODE (stack_parm
, GET_MODE (entry_parm
));
2596 set_mem_attributes (stack_parm
, parm
, 1);
2599 /* If a BLKmode arrives in registers, copy it to a stack slot. Handle
2600 calls that pass values in multiple non-contiguous locations. */
2601 if (REG_P (entry_parm
) || GET_CODE (entry_parm
) == PARALLEL
)
2605 /* Note that we will be storing an integral number of words.
2606 So we have to be careful to ensure that we allocate an
2607 integral number of words. We do this above when we call
2608 assign_stack_local if space was not allocated in the argument
2609 list. If it was, this will not work if PARM_BOUNDARY is not
2610 a multiple of BITS_PER_WORD. It isn't clear how to fix this
2611 if it becomes a problem. Exception is when BLKmode arrives
2612 with arguments not conforming to word_mode. */
2614 if (data
->stack_parm
== 0)
2616 else if (GET_CODE (entry_parm
) == PARALLEL
)
2619 gcc_assert (!size
|| !(PARM_BOUNDARY
% BITS_PER_WORD
));
2621 mem
= validize_mem (stack_parm
);
2623 /* Handle values in multiple non-contiguous locations. */
2624 if (GET_CODE (entry_parm
) == PARALLEL
)
2626 push_to_sequence (all
->conversion_insns
);
2627 emit_group_store (mem
, entry_parm
, data
->passed_type
, size
);
2628 all
->conversion_insns
= get_insns ();
2635 /* If SIZE is that of a mode no bigger than a word, just use
2636 that mode's store operation. */
2637 else if (size
<= UNITS_PER_WORD
)
2639 enum machine_mode mode
2640 = mode_for_size (size
* BITS_PER_UNIT
, MODE_INT
, 0);
2643 #ifdef BLOCK_REG_PADDING
2644 && (size
== UNITS_PER_WORD
2645 || (BLOCK_REG_PADDING (mode
, data
->passed_type
, 1)
2646 != (BYTES_BIG_ENDIAN
? upward
: downward
)))
2650 rtx reg
= gen_rtx_REG (mode
, REGNO (entry_parm
));
2651 emit_move_insn (change_address (mem
, mode
, 0), reg
);
2654 /* Blocks smaller than a word on a BYTES_BIG_ENDIAN
2655 machine must be aligned to the left before storing
2656 to memory. Note that the previous test doesn't
2657 handle all cases (e.g. SIZE == 3). */
2658 else if (size
!= UNITS_PER_WORD
2659 #ifdef BLOCK_REG_PADDING
2660 && (BLOCK_REG_PADDING (mode
, data
->passed_type
, 1)
2668 int by
= (UNITS_PER_WORD
- size
) * BITS_PER_UNIT
;
2669 rtx reg
= gen_rtx_REG (word_mode
, REGNO (entry_parm
));
2671 x
= expand_shift (LSHIFT_EXPR
, word_mode
, reg
,
2672 build_int_cst (NULL_TREE
, by
),
2674 tem
= change_address (mem
, word_mode
, 0);
2675 emit_move_insn (tem
, x
);
2678 move_block_from_reg (REGNO (entry_parm
), mem
,
2679 size_stored
/ UNITS_PER_WORD
);
2682 move_block_from_reg (REGNO (entry_parm
), mem
,
2683 size_stored
/ UNITS_PER_WORD
);
2685 else if (data
->stack_parm
== 0)
2687 push_to_sequence (all
->conversion_insns
);
2688 emit_block_move (stack_parm
, data
->entry_parm
, GEN_INT (size
),
2690 all
->conversion_insns
= get_insns ();
2694 data
->stack_parm
= stack_parm
;
2695 SET_DECL_RTL (parm
, stack_parm
);
2698 /* A subroutine of assign_parms. Allocate a pseudo to hold the current
2699 parameter. Get it there. Perform all ABI specified conversions. */
2702 assign_parm_setup_reg (struct assign_parm_data_all
*all
, tree parm
,
2703 struct assign_parm_data_one
*data
)
2706 enum machine_mode promoted_nominal_mode
;
2707 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (parm
));
2708 bool did_conversion
= false;
2710 /* Store the parm in a pseudoregister during the function, but we may
2711 need to do it in a wider mode. */
2713 promoted_nominal_mode
2714 = promote_mode (data
->nominal_type
, data
->nominal_mode
, &unsignedp
, 0);
2716 parmreg
= gen_reg_rtx (promoted_nominal_mode
);
2718 if (!DECL_ARTIFICIAL (parm
))
2719 mark_user_reg (parmreg
);
2721 /* If this was an item that we received a pointer to,
2722 set DECL_RTL appropriately. */
2723 if (data
->passed_pointer
)
2725 rtx x
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data
->passed_type
)), parmreg
);
2726 set_mem_attributes (x
, parm
, 1);
2727 SET_DECL_RTL (parm
, x
);
2730 SET_DECL_RTL (parm
, parmreg
);
2732 /* Copy the value into the register. */
2733 if (data
->nominal_mode
!= data
->passed_mode
2734 || promoted_nominal_mode
!= data
->promoted_mode
)
2738 /* ENTRY_PARM has been converted to PROMOTED_MODE, its
2739 mode, by the caller. We now have to convert it to
2740 NOMINAL_MODE, if different. However, PARMREG may be in
2741 a different mode than NOMINAL_MODE if it is being stored
2744 If ENTRY_PARM is a hard register, it might be in a register
2745 not valid for operating in its mode (e.g., an odd-numbered
2746 register for a DFmode). In that case, moves are the only
2747 thing valid, so we can't do a convert from there. This
2748 occurs when the calling sequence allow such misaligned
2751 In addition, the conversion may involve a call, which could
2752 clobber parameters which haven't been copied to pseudo
2753 registers yet. Therefore, we must first copy the parm to
2754 a pseudo reg here, and save the conversion until after all
2755 parameters have been moved. */
2757 rtx tempreg
= gen_reg_rtx (GET_MODE (data
->entry_parm
));
2759 emit_move_insn (tempreg
, validize_mem (data
->entry_parm
));
2761 push_to_sequence (all
->conversion_insns
);
2762 tempreg
= convert_to_mode (data
->nominal_mode
, tempreg
, unsignedp
);
2764 if (GET_CODE (tempreg
) == SUBREG
2765 && GET_MODE (tempreg
) == data
->nominal_mode
2766 && REG_P (SUBREG_REG (tempreg
))
2767 && data
->nominal_mode
== data
->passed_mode
2768 && GET_MODE (SUBREG_REG (tempreg
)) == GET_MODE (data
->entry_parm
)
2769 && GET_MODE_SIZE (GET_MODE (tempreg
))
2770 < GET_MODE_SIZE (GET_MODE (data
->entry_parm
)))
2772 /* The argument is already sign/zero extended, so note it
2774 SUBREG_PROMOTED_VAR_P (tempreg
) = 1;
2775 SUBREG_PROMOTED_UNSIGNED_SET (tempreg
, unsignedp
);
2778 /* TREE_USED gets set erroneously during expand_assignment. */
2779 save_tree_used
= TREE_USED (parm
);
2780 expand_assignment (parm
, make_tree (data
->nominal_type
, tempreg
));
2781 TREE_USED (parm
) = save_tree_used
;
2782 all
->conversion_insns
= get_insns ();
2785 did_conversion
= true;
2788 emit_move_insn (parmreg
, validize_mem (data
->entry_parm
));
2790 /* If we were passed a pointer but the actual value can safely live
2791 in a register, put it in one. */
2792 if (data
->passed_pointer
2793 && TYPE_MODE (TREE_TYPE (parm
)) != BLKmode
2794 /* If by-reference argument was promoted, demote it. */
2795 && (TYPE_MODE (TREE_TYPE (parm
)) != GET_MODE (DECL_RTL (parm
))
2796 || use_register_for_decl (parm
)))
2798 /* We can't use nominal_mode, because it will have been set to
2799 Pmode above. We must use the actual mode of the parm. */
2800 parmreg
= gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm
)));
2801 mark_user_reg (parmreg
);
2803 if (GET_MODE (parmreg
) != GET_MODE (DECL_RTL (parm
)))
2805 rtx tempreg
= gen_reg_rtx (GET_MODE (DECL_RTL (parm
)));
2806 int unsigned_p
= TYPE_UNSIGNED (TREE_TYPE (parm
));
2808 push_to_sequence (all
->conversion_insns
);
2809 emit_move_insn (tempreg
, DECL_RTL (parm
));
2810 tempreg
= convert_to_mode (GET_MODE (parmreg
), tempreg
, unsigned_p
);
2811 emit_move_insn (parmreg
, tempreg
);
2812 all
->conversion_insns
= get_insns ();
2815 did_conversion
= true;
2818 emit_move_insn (parmreg
, DECL_RTL (parm
));
2820 SET_DECL_RTL (parm
, parmreg
);
2822 /* STACK_PARM is the pointer, not the parm, and PARMREG is
2824 data
->stack_parm
= NULL
;
2827 /* Mark the register as eliminable if we did no conversion and it was
2828 copied from memory at a fixed offset, and the arg pointer was not
2829 copied to a pseudo-reg. If the arg pointer is a pseudo reg or the
2830 offset formed an invalid address, such memory-equivalences as we
2831 make here would screw up life analysis for it. */
2832 if (data
->nominal_mode
== data
->passed_mode
2834 && data
->stack_parm
!= 0
2835 && MEM_P (data
->stack_parm
)
2836 && data
->locate
.offset
.var
== 0
2837 && reg_mentioned_p (virtual_incoming_args_rtx
,
2838 XEXP (data
->stack_parm
, 0)))
2840 rtx linsn
= get_last_insn ();
2843 /* Mark complex types separately. */
2844 if (GET_CODE (parmreg
) == CONCAT
)
2846 enum machine_mode submode
2847 = GET_MODE_INNER (GET_MODE (parmreg
));
2848 int regnor
= REGNO (XEXP (parmreg
, 0));
2849 int regnoi
= REGNO (XEXP (parmreg
, 1));
2850 rtx stackr
= adjust_address_nv (data
->stack_parm
, submode
, 0);
2851 rtx stacki
= adjust_address_nv (data
->stack_parm
, submode
,
2852 GET_MODE_SIZE (submode
));
2854 /* Scan backwards for the set of the real and
2856 for (sinsn
= linsn
; sinsn
!= 0;
2857 sinsn
= prev_nonnote_insn (sinsn
))
2859 set
= single_set (sinsn
);
2863 if (SET_DEST (set
) == regno_reg_rtx
[regnoi
])
2865 = gen_rtx_EXPR_LIST (REG_EQUIV
, stacki
,
2867 else if (SET_DEST (set
) == regno_reg_rtx
[regnor
])
2869 = gen_rtx_EXPR_LIST (REG_EQUIV
, stackr
,
2873 else if ((set
= single_set (linsn
)) != 0
2874 && SET_DEST (set
) == parmreg
)
2876 = gen_rtx_EXPR_LIST (REG_EQUIV
,
2877 data
->stack_parm
, REG_NOTES (linsn
));
2880 /* For pointer data type, suggest pointer register. */
2881 if (POINTER_TYPE_P (TREE_TYPE (parm
)))
2882 mark_reg_pointer (parmreg
,
2883 TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm
))));
2886 /* A subroutine of assign_parms. Allocate stack space to hold the current
2887 parameter. Get it there. Perform all ABI specified conversions. */
2890 assign_parm_setup_stack (struct assign_parm_data_all
*all
, tree parm
,
2891 struct assign_parm_data_one
*data
)
2893 /* Value must be stored in the stack slot STACK_PARM during function
2895 bool to_conversion
= false;
2897 if (data
->promoted_mode
!= data
->nominal_mode
)
2899 /* Conversion is required. */
2900 rtx tempreg
= gen_reg_rtx (GET_MODE (data
->entry_parm
));
2902 emit_move_insn (tempreg
, validize_mem (data
->entry_parm
));
2904 push_to_sequence (all
->conversion_insns
);
2905 to_conversion
= true;
2907 data
->entry_parm
= convert_to_mode (data
->nominal_mode
, tempreg
,
2908 TYPE_UNSIGNED (TREE_TYPE (parm
)));
2910 if (data
->stack_parm
)
2911 /* ??? This may need a big-endian conversion on sparc64. */
2913 = adjust_address (data
->stack_parm
, data
->nominal_mode
, 0);
2916 if (data
->entry_parm
!= data
->stack_parm
)
2920 if (data
->stack_parm
== 0)
2923 = assign_stack_local (GET_MODE (data
->entry_parm
),
2924 GET_MODE_SIZE (GET_MODE (data
->entry_parm
)),
2925 TYPE_ALIGN (data
->passed_type
));
2926 set_mem_attributes (data
->stack_parm
, parm
, 1);
2929 dest
= validize_mem (data
->stack_parm
);
2930 src
= validize_mem (data
->entry_parm
);
2934 /* Use a block move to handle potentially misaligned entry_parm. */
2936 push_to_sequence (all
->conversion_insns
);
2937 to_conversion
= true;
2939 emit_block_move (dest
, src
,
2940 GEN_INT (int_size_in_bytes (data
->passed_type
)),
2944 emit_move_insn (dest
, src
);
2949 all
->conversion_insns
= get_insns ();
2953 SET_DECL_RTL (parm
, data
->stack_parm
);
2956 /* A subroutine of assign_parms. If the ABI splits complex arguments, then
2957 undo the frobbing that we did in assign_parms_augmented_arg_list. */
2960 assign_parms_unsplit_complex (struct assign_parm_data_all
*all
, tree fnargs
)
2963 tree orig_fnargs
= all
->orig_fnargs
;
2965 for (parm
= orig_fnargs
; parm
; parm
= TREE_CHAIN (parm
))
2967 if (TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
2968 && targetm
.calls
.split_complex_arg (TREE_TYPE (parm
)))
2970 rtx tmp
, real
, imag
;
2971 enum machine_mode inner
= GET_MODE_INNER (DECL_MODE (parm
));
2973 real
= DECL_RTL (fnargs
);
2974 imag
= DECL_RTL (TREE_CHAIN (fnargs
));
2975 if (inner
!= GET_MODE (real
))
2977 real
= gen_lowpart_SUBREG (inner
, real
);
2978 imag
= gen_lowpart_SUBREG (inner
, imag
);
2981 if (TREE_ADDRESSABLE (parm
))
2984 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (parm
));
2986 /* split_complex_arg put the real and imag parts in
2987 pseudos. Move them to memory. */
2988 tmp
= assign_stack_local (DECL_MODE (parm
), size
,
2989 TYPE_ALIGN (TREE_TYPE (parm
)));
2990 set_mem_attributes (tmp
, parm
, 1);
2991 rmem
= adjust_address_nv (tmp
, inner
, 0);
2992 imem
= adjust_address_nv (tmp
, inner
, GET_MODE_SIZE (inner
));
2993 push_to_sequence (all
->conversion_insns
);
2994 emit_move_insn (rmem
, real
);
2995 emit_move_insn (imem
, imag
);
2996 all
->conversion_insns
= get_insns ();
3000 tmp
= gen_rtx_CONCAT (DECL_MODE (parm
), real
, imag
);
3001 SET_DECL_RTL (parm
, tmp
);
3003 real
= DECL_INCOMING_RTL (fnargs
);
3004 imag
= DECL_INCOMING_RTL (TREE_CHAIN (fnargs
));
3005 if (inner
!= GET_MODE (real
))
3007 real
= gen_lowpart_SUBREG (inner
, real
);
3008 imag
= gen_lowpart_SUBREG (inner
, imag
);
3010 tmp
= gen_rtx_CONCAT (DECL_MODE (parm
), real
, imag
);
3011 set_decl_incoming_rtl (parm
, tmp
);
3012 fnargs
= TREE_CHAIN (fnargs
);
3016 SET_DECL_RTL (parm
, DECL_RTL (fnargs
));
3017 set_decl_incoming_rtl (parm
, DECL_INCOMING_RTL (fnargs
));
3019 /* Set MEM_EXPR to the original decl, i.e. to PARM,
3020 instead of the copy of decl, i.e. FNARGS. */
3021 if (DECL_INCOMING_RTL (parm
) && MEM_P (DECL_INCOMING_RTL (parm
)))
3022 set_mem_expr (DECL_INCOMING_RTL (parm
), parm
);
3025 fnargs
= TREE_CHAIN (fnargs
);
3029 /* Assign RTL expressions to the function's parameters. This may involve
3030 copying them into registers and using those registers as the DECL_RTL. */
3033 assign_parms (tree fndecl
)
3035 struct assign_parm_data_all all
;
3037 rtx internal_arg_pointer
;
3039 /* If the reg that the virtual arg pointer will be translated into is
3040 not a fixed reg or is the stack pointer, make a copy of the virtual
3041 arg pointer, and address parms via the copy. The frame pointer is
3042 considered fixed even though it is not marked as such.
3044 The second time through, simply use ap to avoid generating rtx. */
3046 if ((ARG_POINTER_REGNUM
== STACK_POINTER_REGNUM
3047 || ! (fixed_regs
[ARG_POINTER_REGNUM
]
3048 || ARG_POINTER_REGNUM
== FRAME_POINTER_REGNUM
)))
3049 internal_arg_pointer
= copy_to_reg (virtual_incoming_args_rtx
);
3051 internal_arg_pointer
= virtual_incoming_args_rtx
;
3052 current_function_internal_arg_pointer
= internal_arg_pointer
;
3054 assign_parms_initialize_all (&all
);
3055 fnargs
= assign_parms_augmented_arg_list (&all
);
3057 for (parm
= fnargs
; parm
; parm
= TREE_CHAIN (parm
))
3059 struct assign_parm_data_one data
;
3061 /* Extract the type of PARM; adjust it according to ABI. */
3062 assign_parm_find_data_types (&all
, parm
, &data
);
3064 /* Early out for errors and void parameters. */
3065 if (data
.passed_mode
== VOIDmode
)
3067 SET_DECL_RTL (parm
, const0_rtx
);
3068 DECL_INCOMING_RTL (parm
) = DECL_RTL (parm
);
3072 if (current_function_stdarg
&& !TREE_CHAIN (parm
))
3073 assign_parms_setup_varargs (&all
, &data
, false);
3075 /* Find out where the parameter arrives in this function. */
3076 assign_parm_find_entry_rtl (&all
, &data
);
3078 /* Find out where stack space for this parameter might be. */
3079 if (assign_parm_is_stack_parm (&all
, &data
))
3081 assign_parm_find_stack_rtl (parm
, &data
);
3082 assign_parm_adjust_entry_rtl (&data
);
3085 /* Record permanently how this parm was passed. */
3086 set_decl_incoming_rtl (parm
, data
.entry_parm
);
3088 /* Update info on where next arg arrives in registers. */
3089 FUNCTION_ARG_ADVANCE (all
.args_so_far
, data
.promoted_mode
,
3090 data
.passed_type
, data
.named_arg
);
3092 assign_parm_adjust_stack_rtl (&data
);
3094 if (assign_parm_setup_block_p (&data
))
3095 assign_parm_setup_block (&all
, parm
, &data
);
3096 else if (data
.passed_pointer
|| use_register_for_decl (parm
))
3097 assign_parm_setup_reg (&all
, parm
, &data
);
3099 assign_parm_setup_stack (&all
, parm
, &data
);
3102 if (targetm
.calls
.split_complex_arg
&& fnargs
!= all
.orig_fnargs
)
3103 assign_parms_unsplit_complex (&all
, fnargs
);
3105 /* Output all parameter conversion instructions (possibly including calls)
3106 now that all parameters have been copied out of hard registers. */
3107 emit_insn (all
.conversion_insns
);
3109 /* If we are receiving a struct value address as the first argument, set up
3110 the RTL for the function result. As this might require code to convert
3111 the transmitted address to Pmode, we do this here to ensure that possible
3112 preliminary conversions of the address have been emitted already. */
3113 if (all
.function_result_decl
)
3115 tree result
= DECL_RESULT (current_function_decl
);
3116 rtx addr
= DECL_RTL (all
.function_result_decl
);
3119 if (DECL_BY_REFERENCE (result
))
3123 addr
= convert_memory_address (Pmode
, addr
);
3124 x
= gen_rtx_MEM (DECL_MODE (result
), addr
);
3125 set_mem_attributes (x
, result
, 1);
3127 SET_DECL_RTL (result
, x
);
3130 /* We have aligned all the args, so add space for the pretend args. */
3131 current_function_pretend_args_size
= all
.pretend_args_size
;
3132 all
.stack_args_size
.constant
+= all
.extra_pretend_bytes
;
3133 current_function_args_size
= all
.stack_args_size
.constant
;
3135 /* Adjust function incoming argument size for alignment and
3138 #ifdef REG_PARM_STACK_SPACE
3139 current_function_args_size
= MAX (current_function_args_size
,
3140 REG_PARM_STACK_SPACE (fndecl
));
3143 current_function_args_size
3144 = ((current_function_args_size
+ STACK_BYTES
- 1)
3145 / STACK_BYTES
) * STACK_BYTES
;
3147 #ifdef ARGS_GROW_DOWNWARD
3148 current_function_arg_offset_rtx
3149 = (all
.stack_args_size
.var
== 0 ? GEN_INT (-all
.stack_args_size
.constant
)
3150 : expand_expr (size_diffop (all
.stack_args_size
.var
,
3151 size_int (-all
.stack_args_size
.constant
)),
3152 NULL_RTX
, VOIDmode
, 0));
3154 current_function_arg_offset_rtx
= ARGS_SIZE_RTX (all
.stack_args_size
);
3157 /* See how many bytes, if any, of its args a function should try to pop
3160 current_function_pops_args
= RETURN_POPS_ARGS (fndecl
, TREE_TYPE (fndecl
),
3161 current_function_args_size
);
3163 /* For stdarg.h function, save info about
3164 regs and stack space used by the named args. */
3166 current_function_args_info
= all
.args_so_far
;
3168 /* Set the rtx used for the function return value. Put this in its
3169 own variable so any optimizers that need this information don't have
3170 to include tree.h. Do this here so it gets done when an inlined
3171 function gets output. */
3173 current_function_return_rtx
3174 = (DECL_RTL_SET_P (DECL_RESULT (fndecl
))
3175 ? DECL_RTL (DECL_RESULT (fndecl
)) : NULL_RTX
);
3177 /* If scalar return value was computed in a pseudo-reg, or was a named
3178 return value that got dumped to the stack, copy that to the hard
3180 if (DECL_RTL_SET_P (DECL_RESULT (fndecl
)))
3182 tree decl_result
= DECL_RESULT (fndecl
);
3183 rtx decl_rtl
= DECL_RTL (decl_result
);
3185 if (REG_P (decl_rtl
)
3186 ? REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
3187 : DECL_REGISTER (decl_result
))
3191 #ifdef FUNCTION_OUTGOING_VALUE
3192 real_decl_rtl
= FUNCTION_OUTGOING_VALUE (TREE_TYPE (decl_result
),
3195 real_decl_rtl
= FUNCTION_VALUE (TREE_TYPE (decl_result
),
3198 REG_FUNCTION_VALUE_P (real_decl_rtl
) = 1;
3199 /* The delay slot scheduler assumes that current_function_return_rtx
3200 holds the hard register containing the return value, not a
3201 temporary pseudo. */
3202 current_function_return_rtx
= real_decl_rtl
;
3207 /* A subroutine of gimplify_parameters, invoked via walk_tree.
3208 For all seen types, gimplify their sizes. */
3211 gimplify_parm_type (tree
*tp
, int *walk_subtrees
, void *data
)
3218 if (POINTER_TYPE_P (t
))
3220 else if (TYPE_SIZE (t
) && !TREE_CONSTANT (TYPE_SIZE (t
))
3221 && !TYPE_SIZES_GIMPLIFIED (t
))
3223 gimplify_type_sizes (t
, (tree
*) data
);
3231 /* Gimplify the parameter list for current_function_decl. This involves
3232 evaluating SAVE_EXPRs of variable sized parameters and generating code
3233 to implement callee-copies reference parameters. Returns a list of
3234 statements to add to the beginning of the function, or NULL if nothing
3238 gimplify_parameters (void)
3240 struct assign_parm_data_all all
;
3241 tree fnargs
, parm
, stmts
= NULL
;
3243 assign_parms_initialize_all (&all
);
3244 fnargs
= assign_parms_augmented_arg_list (&all
);
3246 for (parm
= fnargs
; parm
; parm
= TREE_CHAIN (parm
))
3248 struct assign_parm_data_one data
;
3250 /* Extract the type of PARM; adjust it according to ABI. */
3251 assign_parm_find_data_types (&all
, parm
, &data
);
3253 /* Early out for errors and void parameters. */
3254 if (data
.passed_mode
== VOIDmode
|| DECL_SIZE (parm
) == NULL
)
3257 /* Update info on where next arg arrives in registers. */
3258 FUNCTION_ARG_ADVANCE (all
.args_so_far
, data
.promoted_mode
,
3259 data
.passed_type
, data
.named_arg
);
3261 /* ??? Once upon a time variable_size stuffed parameter list
3262 SAVE_EXPRs (amongst others) onto a pending sizes list. This
3263 turned out to be less than manageable in the gimple world.
3264 Now we have to hunt them down ourselves. */
3265 walk_tree_without_duplicates (&data
.passed_type
,
3266 gimplify_parm_type
, &stmts
);
3268 if (!TREE_CONSTANT (DECL_SIZE (parm
)))
3270 gimplify_one_sizepos (&DECL_SIZE (parm
), &stmts
);
3271 gimplify_one_sizepos (&DECL_SIZE_UNIT (parm
), &stmts
);
3274 if (data
.passed_pointer
)
3276 tree type
= TREE_TYPE (data
.passed_type
);
3277 if (reference_callee_copied (&all
.args_so_far
, TYPE_MODE (type
),
3278 type
, data
.named_arg
))
3282 /* For constant sized objects, this is trivial; for
3283 variable-sized objects, we have to play games. */
3284 if (TREE_CONSTANT (DECL_SIZE (parm
)))
3286 local
= create_tmp_var (type
, get_name (parm
));
3287 DECL_IGNORED_P (local
) = 0;
3291 tree ptr_type
, addr
, args
;
3293 ptr_type
= build_pointer_type (type
);
3294 addr
= create_tmp_var (ptr_type
, get_name (parm
));
3295 DECL_IGNORED_P (addr
) = 0;
3296 local
= build_fold_indirect_ref (addr
);
3298 args
= tree_cons (NULL
, DECL_SIZE_UNIT (parm
), NULL
);
3299 t
= built_in_decls
[BUILT_IN_ALLOCA
];
3300 t
= build_function_call_expr (t
, args
);
3301 t
= fold_convert (ptr_type
, t
);
3302 t
= build2 (MODIFY_EXPR
, void_type_node
, addr
, t
);
3303 gimplify_and_add (t
, &stmts
);
3306 t
= build2 (MODIFY_EXPR
, void_type_node
, local
, parm
);
3307 gimplify_and_add (t
, &stmts
);
3309 DECL_VALUE_EXPR (parm
) = local
;
3317 /* Indicate whether REGNO is an incoming argument to the current function
3318 that was promoted to a wider mode. If so, return the RTX for the
3319 register (to get its mode). PMODE and PUNSIGNEDP are set to the mode
3320 that REGNO is promoted from and whether the promotion was signed or
3324 promoted_input_arg (unsigned int regno
, enum machine_mode
*pmode
, int *punsignedp
)
3328 for (arg
= DECL_ARGUMENTS (current_function_decl
); arg
;
3329 arg
= TREE_CHAIN (arg
))
3330 if (REG_P (DECL_INCOMING_RTL (arg
))
3331 && REGNO (DECL_INCOMING_RTL (arg
)) == regno
3332 && TYPE_MODE (DECL_ARG_TYPE (arg
)) == TYPE_MODE (TREE_TYPE (arg
)))
3334 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (arg
));
3335 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (arg
));
3337 mode
= promote_mode (TREE_TYPE (arg
), mode
, &unsignedp
, 1);
3338 if (mode
== GET_MODE (DECL_INCOMING_RTL (arg
))
3339 && mode
!= DECL_MODE (arg
))
3341 *pmode
= DECL_MODE (arg
);
3342 *punsignedp
= unsignedp
;
3343 return DECL_INCOMING_RTL (arg
);
3351 /* Compute the size and offset from the start of the stacked arguments for a
3352 parm passed in mode PASSED_MODE and with type TYPE.
3354 INITIAL_OFFSET_PTR points to the current offset into the stacked
3357 The starting offset and size for this parm are returned in
3358 LOCATE->OFFSET and LOCATE->SIZE, respectively. When IN_REGS is
3359 nonzero, the offset is that of stack slot, which is returned in
3360 LOCATE->SLOT_OFFSET. LOCATE->ALIGNMENT_PAD is the amount of
3361 padding required from the initial offset ptr to the stack slot.
3363 IN_REGS is nonzero if the argument will be passed in registers. It will
3364 never be set if REG_PARM_STACK_SPACE is not defined.
3366 FNDECL is the function in which the argument was defined.
3368 There are two types of rounding that are done. The first, controlled by
3369 FUNCTION_ARG_BOUNDARY, forces the offset from the start of the argument
3370 list to be aligned to the specific boundary (in bits). This rounding
3371 affects the initial and starting offsets, but not the argument size.
3373 The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY,
3374 optionally rounds the size of the parm to PARM_BOUNDARY. The
3375 initial offset is not affected by this rounding, while the size always
3376 is and the starting offset may be. */
3378 /* LOCATE->OFFSET will be negative for ARGS_GROW_DOWNWARD case;
3379 INITIAL_OFFSET_PTR is positive because locate_and_pad_parm's
3380 callers pass in the total size of args so far as
3381 INITIAL_OFFSET_PTR. LOCATE->SIZE is always positive. */
3384 locate_and_pad_parm (enum machine_mode passed_mode
, tree type
, int in_regs
,
3385 int partial
, tree fndecl ATTRIBUTE_UNUSED
,
3386 struct args_size
*initial_offset_ptr
,
3387 struct locate_and_pad_arg_data
*locate
)
3390 enum direction where_pad
;
3392 int reg_parm_stack_space
= 0;
3393 int part_size_in_regs
;
3395 #ifdef REG_PARM_STACK_SPACE
3396 reg_parm_stack_space
= REG_PARM_STACK_SPACE (fndecl
);
3398 /* If we have found a stack parm before we reach the end of the
3399 area reserved for registers, skip that area. */
3402 if (reg_parm_stack_space
> 0)
3404 if (initial_offset_ptr
->var
)
3406 initial_offset_ptr
->var
3407 = size_binop (MAX_EXPR
, ARGS_SIZE_TREE (*initial_offset_ptr
),
3408 ssize_int (reg_parm_stack_space
));
3409 initial_offset_ptr
->constant
= 0;
3411 else if (initial_offset_ptr
->constant
< reg_parm_stack_space
)
3412 initial_offset_ptr
->constant
= reg_parm_stack_space
;
3415 #endif /* REG_PARM_STACK_SPACE */
3417 part_size_in_regs
= (reg_parm_stack_space
== 0 ? partial
: 0);
3420 = type
? size_in_bytes (type
) : size_int (GET_MODE_SIZE (passed_mode
));
3421 where_pad
= FUNCTION_ARG_PADDING (passed_mode
, type
);
3422 boundary
= FUNCTION_ARG_BOUNDARY (passed_mode
, type
);
3423 locate
->where_pad
= where_pad
;
3424 locate
->boundary
= boundary
;
3426 #ifdef ARGS_GROW_DOWNWARD
3427 locate
->slot_offset
.constant
= -initial_offset_ptr
->constant
;
3428 if (initial_offset_ptr
->var
)
3429 locate
->slot_offset
.var
= size_binop (MINUS_EXPR
, ssize_int (0),
3430 initial_offset_ptr
->var
);
3434 if (where_pad
!= none
3435 && (!host_integerp (sizetree
, 1)
3436 || (tree_low_cst (sizetree
, 1) * BITS_PER_UNIT
) % PARM_BOUNDARY
))
3437 s2
= round_up (s2
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
3438 SUB_PARM_SIZE (locate
->slot_offset
, s2
);
3441 locate
->slot_offset
.constant
+= part_size_in_regs
;
3444 #ifdef REG_PARM_STACK_SPACE
3445 || REG_PARM_STACK_SPACE (fndecl
) > 0
3448 pad_to_arg_alignment (&locate
->slot_offset
, boundary
,
3449 &locate
->alignment_pad
);
3451 locate
->size
.constant
= (-initial_offset_ptr
->constant
3452 - locate
->slot_offset
.constant
);
3453 if (initial_offset_ptr
->var
)
3454 locate
->size
.var
= size_binop (MINUS_EXPR
,
3455 size_binop (MINUS_EXPR
,
3457 initial_offset_ptr
->var
),
3458 locate
->slot_offset
.var
);
3460 /* Pad_below needs the pre-rounded size to know how much to pad
3462 locate
->offset
= locate
->slot_offset
;
3463 if (where_pad
== downward
)
3464 pad_below (&locate
->offset
, passed_mode
, sizetree
);
3466 #else /* !ARGS_GROW_DOWNWARD */
3468 #ifdef REG_PARM_STACK_SPACE
3469 || REG_PARM_STACK_SPACE (fndecl
) > 0
3472 pad_to_arg_alignment (initial_offset_ptr
, boundary
,
3473 &locate
->alignment_pad
);
3474 locate
->slot_offset
= *initial_offset_ptr
;
3476 #ifdef PUSH_ROUNDING
3477 if (passed_mode
!= BLKmode
)
3478 sizetree
= size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree
)));
3481 /* Pad_below needs the pre-rounded size to know how much to pad below
3482 so this must be done before rounding up. */
3483 locate
->offset
= locate
->slot_offset
;
3484 if (where_pad
== downward
)
3485 pad_below (&locate
->offset
, passed_mode
, sizetree
);
3487 if (where_pad
!= none
3488 && (!host_integerp (sizetree
, 1)
3489 || (tree_low_cst (sizetree
, 1) * BITS_PER_UNIT
) % PARM_BOUNDARY
))
3490 sizetree
= round_up (sizetree
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
3492 ADD_PARM_SIZE (locate
->size
, sizetree
);
3494 locate
->size
.constant
-= part_size_in_regs
;
3495 #endif /* ARGS_GROW_DOWNWARD */
3498 /* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY.
3499 BOUNDARY is measured in bits, but must be a multiple of a storage unit. */
3502 pad_to_arg_alignment (struct args_size
*offset_ptr
, int boundary
,
3503 struct args_size
*alignment_pad
)
3505 tree save_var
= NULL_TREE
;
3506 HOST_WIDE_INT save_constant
= 0;
3507 int boundary_in_bytes
= boundary
/ BITS_PER_UNIT
;
3508 HOST_WIDE_INT sp_offset
= STACK_POINTER_OFFSET
;
3510 #ifdef SPARC_STACK_BOUNDARY_HACK
3511 /* The sparc port has a bug. It sometimes claims a STACK_BOUNDARY
3512 higher than the real alignment of %sp. However, when it does this,
3513 the alignment of %sp+STACK_POINTER_OFFSET will be STACK_BOUNDARY.
3514 This is a temporary hack while the sparc port is fixed. */
3515 if (SPARC_STACK_BOUNDARY_HACK
)
3519 if (boundary
> PARM_BOUNDARY
&& boundary
> STACK_BOUNDARY
)
3521 save_var
= offset_ptr
->var
;
3522 save_constant
= offset_ptr
->constant
;
3525 alignment_pad
->var
= NULL_TREE
;
3526 alignment_pad
->constant
= 0;
3528 if (boundary
> BITS_PER_UNIT
)
3530 if (offset_ptr
->var
)
3532 tree sp_offset_tree
= ssize_int (sp_offset
);
3533 tree offset
= size_binop (PLUS_EXPR
,
3534 ARGS_SIZE_TREE (*offset_ptr
),
3536 #ifdef ARGS_GROW_DOWNWARD
3537 tree rounded
= round_down (offset
, boundary
/ BITS_PER_UNIT
);
3539 tree rounded
= round_up (offset
, boundary
/ BITS_PER_UNIT
);
3542 offset_ptr
->var
= size_binop (MINUS_EXPR
, rounded
, sp_offset_tree
);
3543 /* ARGS_SIZE_TREE includes constant term. */
3544 offset_ptr
->constant
= 0;
3545 if (boundary
> PARM_BOUNDARY
&& boundary
> STACK_BOUNDARY
)
3546 alignment_pad
->var
= size_binop (MINUS_EXPR
, offset_ptr
->var
,
3551 offset_ptr
->constant
= -sp_offset
+
3552 #ifdef ARGS_GROW_DOWNWARD
3553 FLOOR_ROUND (offset_ptr
->constant
+ sp_offset
, boundary_in_bytes
);
3555 CEIL_ROUND (offset_ptr
->constant
+ sp_offset
, boundary_in_bytes
);
3557 if (boundary
> PARM_BOUNDARY
&& boundary
> STACK_BOUNDARY
)
3558 alignment_pad
->constant
= offset_ptr
->constant
- save_constant
;
3564 pad_below (struct args_size
*offset_ptr
, enum machine_mode passed_mode
, tree sizetree
)
3566 if (passed_mode
!= BLKmode
)
3568 if (GET_MODE_BITSIZE (passed_mode
) % PARM_BOUNDARY
)
3569 offset_ptr
->constant
3570 += (((GET_MODE_BITSIZE (passed_mode
) + PARM_BOUNDARY
- 1)
3571 / PARM_BOUNDARY
* PARM_BOUNDARY
/ BITS_PER_UNIT
)
3572 - GET_MODE_SIZE (passed_mode
));
3576 if (TREE_CODE (sizetree
) != INTEGER_CST
3577 || (TREE_INT_CST_LOW (sizetree
) * BITS_PER_UNIT
) % PARM_BOUNDARY
)
3579 /* Round the size up to multiple of PARM_BOUNDARY bits. */
3580 tree s2
= round_up (sizetree
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
3582 ADD_PARM_SIZE (*offset_ptr
, s2
);
3583 SUB_PARM_SIZE (*offset_ptr
, sizetree
);
3588 /* Walk the tree of blocks describing the binding levels within a function
3589 and warn about variables the might be killed by setjmp or vfork.
3590 This is done after calling flow_analysis and before global_alloc
3591 clobbers the pseudo-regs to hard regs. */
3594 setjmp_vars_warning (tree block
)
3598 for (decl
= BLOCK_VARS (block
); decl
; decl
= TREE_CHAIN (decl
))
3600 if (TREE_CODE (decl
) == VAR_DECL
3601 && DECL_RTL_SET_P (decl
)
3602 && REG_P (DECL_RTL (decl
))
3603 && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl
))))
3604 warning ("%Jvariable %qD might be clobbered by %<longjmp%>"
3609 for (sub
= BLOCK_SUBBLOCKS (block
); sub
; sub
= TREE_CHAIN (sub
))
3610 setjmp_vars_warning (sub
);
3613 /* Do the appropriate part of setjmp_vars_warning
3614 but for arguments instead of local variables. */
3617 setjmp_args_warning (void)
3620 for (decl
= DECL_ARGUMENTS (current_function_decl
);
3621 decl
; decl
= TREE_CHAIN (decl
))
3622 if (DECL_RTL (decl
) != 0
3623 && REG_P (DECL_RTL (decl
))
3624 && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl
))))
3625 warning ("%Jargument %qD might be clobbered by %<longjmp%> or %<vfork%>",
3630 /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
3631 and create duplicate blocks. */
3632 /* ??? Need an option to either create block fragments or to create
3633 abstract origin duplicates of a source block. It really depends
3634 on what optimization has been performed. */
3637 reorder_blocks (void)
3639 tree block
= DECL_INITIAL (current_function_decl
);
3640 varray_type block_stack
;
3642 if (block
== NULL_TREE
)
3645 VARRAY_TREE_INIT (block_stack
, 10, "block_stack");
3647 /* Reset the TREE_ASM_WRITTEN bit for all blocks. */
3648 clear_block_marks (block
);
3650 /* Prune the old trees away, so that they don't get in the way. */
3651 BLOCK_SUBBLOCKS (block
) = NULL_TREE
;
3652 BLOCK_CHAIN (block
) = NULL_TREE
;
3654 /* Recreate the block tree from the note nesting. */
3655 reorder_blocks_1 (get_insns (), block
, &block_stack
);
3656 BLOCK_SUBBLOCKS (block
) = blocks_nreverse (BLOCK_SUBBLOCKS (block
));
3658 /* Remove deleted blocks from the block fragment chains. */
3659 reorder_fix_fragments (block
);
3662 /* Helper function for reorder_blocks. Reset TREE_ASM_WRITTEN. */
3665 clear_block_marks (tree block
)
3669 TREE_ASM_WRITTEN (block
) = 0;
3670 clear_block_marks (BLOCK_SUBBLOCKS (block
));
3671 block
= BLOCK_CHAIN (block
);
3676 reorder_blocks_1 (rtx insns
, tree current_block
, varray_type
*p_block_stack
)
3680 for (insn
= insns
; insn
; insn
= NEXT_INSN (insn
))
3684 if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_BEG
)
3686 tree block
= NOTE_BLOCK (insn
);
3688 /* If we have seen this block before, that means it now
3689 spans multiple address regions. Create a new fragment. */
3690 if (TREE_ASM_WRITTEN (block
))
3692 tree new_block
= copy_node (block
);
3695 origin
= (BLOCK_FRAGMENT_ORIGIN (block
)
3696 ? BLOCK_FRAGMENT_ORIGIN (block
)
3698 BLOCK_FRAGMENT_ORIGIN (new_block
) = origin
;
3699 BLOCK_FRAGMENT_CHAIN (new_block
)
3700 = BLOCK_FRAGMENT_CHAIN (origin
);
3701 BLOCK_FRAGMENT_CHAIN (origin
) = new_block
;
3703 NOTE_BLOCK (insn
) = new_block
;
3707 BLOCK_SUBBLOCKS (block
) = 0;
3708 TREE_ASM_WRITTEN (block
) = 1;
3709 /* When there's only one block for the entire function,
3710 current_block == block and we mustn't do this, it
3711 will cause infinite recursion. */
3712 if (block
!= current_block
)
3714 BLOCK_SUPERCONTEXT (block
) = current_block
;
3715 BLOCK_CHAIN (block
) = BLOCK_SUBBLOCKS (current_block
);
3716 BLOCK_SUBBLOCKS (current_block
) = block
;
3717 current_block
= block
;
3719 VARRAY_PUSH_TREE (*p_block_stack
, block
);
3721 else if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_END
)
3723 NOTE_BLOCK (insn
) = VARRAY_TOP_TREE (*p_block_stack
);
3724 VARRAY_POP (*p_block_stack
);
3725 BLOCK_SUBBLOCKS (current_block
)
3726 = blocks_nreverse (BLOCK_SUBBLOCKS (current_block
));
3727 current_block
= BLOCK_SUPERCONTEXT (current_block
);
3733 /* Rationalize BLOCK_FRAGMENT_ORIGIN. If an origin block no longer
3734 appears in the block tree, select one of the fragments to become
3735 the new origin block. */
3738 reorder_fix_fragments (tree block
)
3742 tree dup_origin
= BLOCK_FRAGMENT_ORIGIN (block
);
3743 tree new_origin
= NULL_TREE
;
3747 if (! TREE_ASM_WRITTEN (dup_origin
))
3749 new_origin
= BLOCK_FRAGMENT_CHAIN (dup_origin
);
3751 /* Find the first of the remaining fragments. There must
3752 be at least one -- the current block. */
3753 while (! TREE_ASM_WRITTEN (new_origin
))
3754 new_origin
= BLOCK_FRAGMENT_CHAIN (new_origin
);
3755 BLOCK_FRAGMENT_ORIGIN (new_origin
) = NULL_TREE
;
3758 else if (! dup_origin
)
3761 /* Re-root the rest of the fragments to the new origin. In the
3762 case that DUP_ORIGIN was null, that means BLOCK was the origin
3763 of a chain of fragments and we want to remove those fragments
3764 that didn't make it to the output. */
3767 tree
*pp
= &BLOCK_FRAGMENT_CHAIN (new_origin
);
3772 if (TREE_ASM_WRITTEN (chain
))
3774 BLOCK_FRAGMENT_ORIGIN (chain
) = new_origin
;
3776 pp
= &BLOCK_FRAGMENT_CHAIN (chain
);
3778 chain
= BLOCK_FRAGMENT_CHAIN (chain
);
3783 reorder_fix_fragments (BLOCK_SUBBLOCKS (block
));
3784 block
= BLOCK_CHAIN (block
);
3788 /* Reverse the order of elements in the chain T of blocks,
3789 and return the new head of the chain (old last element). */
3792 blocks_nreverse (tree t
)
3794 tree prev
= 0, decl
, next
;
3795 for (decl
= t
; decl
; decl
= next
)
3797 next
= BLOCK_CHAIN (decl
);
3798 BLOCK_CHAIN (decl
) = prev
;
3804 /* Count the subblocks of the list starting with BLOCK. If VECTOR is
3805 non-NULL, list them all into VECTOR, in a depth-first preorder
3806 traversal of the block tree. Also clear TREE_ASM_WRITTEN in all
3810 all_blocks (tree block
, tree
*vector
)
3816 TREE_ASM_WRITTEN (block
) = 0;
3818 /* Record this block. */
3820 vector
[n_blocks
] = block
;
3824 /* Record the subblocks, and their subblocks... */
3825 n_blocks
+= all_blocks (BLOCK_SUBBLOCKS (block
),
3826 vector
? vector
+ n_blocks
: 0);
3827 block
= BLOCK_CHAIN (block
);
3833 /* Return a vector containing all the blocks rooted at BLOCK. The
3834 number of elements in the vector is stored in N_BLOCKS_P. The
3835 vector is dynamically allocated; it is the caller's responsibility
3836 to call `free' on the pointer returned. */
3839 get_block_vector (tree block
, int *n_blocks_p
)
3843 *n_blocks_p
= all_blocks (block
, NULL
);
3844 block_vector
= xmalloc (*n_blocks_p
* sizeof (tree
));
3845 all_blocks (block
, block_vector
);
3847 return block_vector
;
3850 static GTY(()) int next_block_index
= 2;
3852 /* Set BLOCK_NUMBER for all the blocks in FN. */
3855 number_blocks (tree fn
)
3861 /* For SDB and XCOFF debugging output, we start numbering the blocks
3862 from 1 within each function, rather than keeping a running
3864 #if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
3865 if (write_symbols
== SDB_DEBUG
|| write_symbols
== XCOFF_DEBUG
)
3866 next_block_index
= 1;
3869 block_vector
= get_block_vector (DECL_INITIAL (fn
), &n_blocks
);
3871 /* The top-level BLOCK isn't numbered at all. */
3872 for (i
= 1; i
< n_blocks
; ++i
)
3873 /* We number the blocks from two. */
3874 BLOCK_NUMBER (block_vector
[i
]) = next_block_index
++;
3876 free (block_vector
);
3881 /* If VAR is present in a subblock of BLOCK, return the subblock. */
3884 debug_find_var_in_block_tree (tree var
, tree block
)
3888 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
3892 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= TREE_CHAIN (t
))
3894 tree ret
= debug_find_var_in_block_tree (var
, t
);
3902 /* Allocate a function structure for FNDECL and set its contents
3906 allocate_struct_function (tree fndecl
)
3909 tree fntype
= fndecl
? TREE_TYPE (fndecl
) : NULL_TREE
;
3911 cfun
= ggc_alloc_cleared (sizeof (struct function
));
3912 cfun
->cfg
= ggc_alloc_cleared (sizeof (struct control_flow_graph
));
3916 cfun
->stack_alignment_needed
= STACK_BOUNDARY
;
3917 cfun
->preferred_stack_boundary
= STACK_BOUNDARY
;
3919 current_function_funcdef_no
= funcdef_no
++;
3921 cfun
->function_frequency
= FUNCTION_FREQUENCY_NORMAL
;
3923 init_eh_for_function ();
3925 lang_hooks
.function
.init (cfun
);
3926 if (init_machine_status
)
3927 cfun
->machine
= (*init_machine_status
) ();
3932 DECL_STRUCT_FUNCTION (fndecl
) = cfun
;
3933 cfun
->decl
= fndecl
;
3935 result
= DECL_RESULT (fndecl
);
3936 if (aggregate_value_p (result
, fndecl
))
3938 #ifdef PCC_STATIC_STRUCT_RETURN
3939 current_function_returns_pcc_struct
= 1;
3941 current_function_returns_struct
= 1;
3944 current_function_returns_pointer
= POINTER_TYPE_P (TREE_TYPE (result
));
3946 current_function_stdarg
3948 && TYPE_ARG_TYPES (fntype
) != 0
3949 && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype
)))
3950 != void_type_node
));
3952 /* Assume all registers in stdarg functions need to be saved. */
3953 cfun
->va_list_gpr_size
= VA_LIST_MAX_GPR_SIZE
;
3954 cfun
->va_list_fpr_size
= VA_LIST_MAX_FPR_SIZE
;
3957 /* Reset cfun, and other non-struct-function variables to defaults as
3958 appropriate for emitting rtl at the start of a function. */
3961 prepare_function_start (tree fndecl
)
3963 if (fndecl
&& DECL_STRUCT_FUNCTION (fndecl
))
3964 cfun
= DECL_STRUCT_FUNCTION (fndecl
);
3966 allocate_struct_function (fndecl
);
3968 init_varasm_status (cfun
);
3971 cse_not_expected
= ! optimize
;
3973 /* Caller save not needed yet. */
3974 caller_save_needed
= 0;
3976 /* We haven't done register allocation yet. */
3979 /* Indicate that we have not instantiated virtual registers yet. */
3980 virtuals_instantiated
= 0;
3982 /* Indicate that we want CONCATs now. */
3983 generating_concat_p
= 1;
3985 /* Indicate we have no need of a frame pointer yet. */
3986 frame_pointer_needed
= 0;
3989 /* Initialize the rtl expansion mechanism so that we can do simple things
3990 like generate sequences. This is used to provide a context during global
3991 initialization of some passes. */
3993 init_dummy_function_start (void)
3995 prepare_function_start (NULL
);
3998 /* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node)
3999 and initialize static variables for generating RTL for the statements
4003 init_function_start (tree subr
)
4005 prepare_function_start (subr
);
4007 /* Prevent ever trying to delete the first instruction of a
4008 function. Also tell final how to output a linenum before the
4009 function prologue. Note linenums could be missing, e.g. when
4010 compiling a Java .class file. */
4011 if (! DECL_IS_BUILTIN (subr
))
4012 emit_line_note (DECL_SOURCE_LOCATION (subr
));
4014 /* Make sure first insn is a note even if we don't want linenums.
4015 This makes sure the first insn will never be deleted.
4016 Also, final expects a note to appear there. */
4017 emit_note (NOTE_INSN_DELETED
);
4019 /* Warn if this value is an aggregate type,
4020 regardless of which calling convention we are using for it. */
4021 if (warn_aggregate_return
4022 && AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr
))))
4023 warning ("function returns an aggregate");
4026 /* Make sure all values used by the optimization passes have sane
4029 init_function_for_compilation (void)
4033 /* No prologue/epilogue insns yet. */
4034 VARRAY_GROW (prologue
, 0);
4035 VARRAY_GROW (epilogue
, 0);
4036 VARRAY_GROW (sibcall_epilogue
, 0);
4039 /* Expand a call to __main at the beginning of a possible main function. */
4041 #if defined(INIT_SECTION_ASM_OP) && !defined(INVOKE__main)
4042 #undef HAS_INIT_SECTION
4043 #define HAS_INIT_SECTION
4047 expand_main_function (void)
4049 #ifdef FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN
4050 if (FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN
)
4052 int align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
4056 /* Forcibly align the stack. */
4057 #ifdef STACK_GROWS_DOWNWARD
4058 tmp
= expand_simple_binop (Pmode
, AND
, stack_pointer_rtx
, GEN_INT(-align
),
4059 stack_pointer_rtx
, 1, OPTAB_WIDEN
);
4061 tmp
= expand_simple_binop (Pmode
, PLUS
, stack_pointer_rtx
,
4062 GEN_INT (align
- 1), NULL_RTX
, 1, OPTAB_WIDEN
);
4063 tmp
= expand_simple_binop (Pmode
, AND
, tmp
, GEN_INT (-align
),
4064 stack_pointer_rtx
, 1, OPTAB_WIDEN
);
4066 if (tmp
!= stack_pointer_rtx
)
4067 emit_move_insn (stack_pointer_rtx
, tmp
);
4069 /* Enlist allocate_dynamic_stack_space to pick up the pieces. */
4070 tmp
= force_reg (Pmode
, const0_rtx
);
4071 allocate_dynamic_stack_space (tmp
, NULL_RTX
, BIGGEST_ALIGNMENT
);
4075 for (tmp
= get_last_insn (); tmp
; tmp
= PREV_INSN (tmp
))
4076 if (NOTE_P (tmp
) && NOTE_LINE_NUMBER (tmp
) == NOTE_INSN_FUNCTION_BEG
)
4079 emit_insn_before (seq
, tmp
);
4085 #ifndef HAS_INIT_SECTION
4086 emit_library_call (init_one_libfunc (NAME__MAIN
), LCT_NORMAL
, VOIDmode
, 0);
4090 /* Start the RTL for a new function, and set variables used for
4092 SUBR is the FUNCTION_DECL node.
4093 PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with
4094 the function's parameters, which must be run at any return statement. */
4097 expand_function_start (tree subr
)
4099 /* Make sure volatile mem refs aren't considered
4100 valid operands of arithmetic insns. */
4101 init_recog_no_volatile ();
4103 current_function_profile
4105 && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr
));
4107 current_function_limit_stack
4108 = (stack_limit_rtx
!= NULL_RTX
&& ! DECL_NO_LIMIT_STACK (subr
));
4110 /* Make the label for return statements to jump to. Do not special
4111 case machines with special return instructions -- they will be
4112 handled later during jump, ifcvt, or epilogue creation. */
4113 return_label
= gen_label_rtx ();
4115 /* Initialize rtx used to return the value. */
4116 /* Do this before assign_parms so that we copy the struct value address
4117 before any library calls that assign parms might generate. */
4119 /* Decide whether to return the value in memory or in a register. */
4120 if (aggregate_value_p (DECL_RESULT (subr
), subr
))
4122 /* Returning something that won't go in a register. */
4123 rtx value_address
= 0;
4125 #ifdef PCC_STATIC_STRUCT_RETURN
4126 if (current_function_returns_pcc_struct
)
4128 int size
= int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr
)));
4129 value_address
= assemble_static_space (size
);
4134 rtx sv
= targetm
.calls
.struct_value_rtx (TREE_TYPE (subr
), 1);
4135 /* Expect to be passed the address of a place to store the value.
4136 If it is passed as an argument, assign_parms will take care of
4140 value_address
= gen_reg_rtx (Pmode
);
4141 emit_move_insn (value_address
, sv
);
4146 rtx x
= value_address
;
4147 if (!DECL_BY_REFERENCE (DECL_RESULT (subr
)))
4149 x
= gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr
)), x
);
4150 set_mem_attributes (x
, DECL_RESULT (subr
), 1);
4152 SET_DECL_RTL (DECL_RESULT (subr
), x
);
4155 else if (DECL_MODE (DECL_RESULT (subr
)) == VOIDmode
)
4156 /* If return mode is void, this decl rtl should not be used. */
4157 SET_DECL_RTL (DECL_RESULT (subr
), NULL_RTX
);
4160 /* Compute the return values into a pseudo reg, which we will copy
4161 into the true return register after the cleanups are done. */
4162 tree return_type
= TREE_TYPE (DECL_RESULT (subr
));
4163 if (TYPE_MODE (return_type
) != BLKmode
4164 && targetm
.calls
.return_in_msb (return_type
))
4165 /* expand_function_end will insert the appropriate padding in
4166 this case. Use the return value's natural (unpadded) mode
4167 within the function proper. */
4168 SET_DECL_RTL (DECL_RESULT (subr
),
4169 gen_reg_rtx (TYPE_MODE (return_type
)));
4172 /* In order to figure out what mode to use for the pseudo, we
4173 figure out what the mode of the eventual return register will
4174 actually be, and use that. */
4175 rtx hard_reg
= hard_function_value (return_type
, subr
, 1);
4177 /* Structures that are returned in registers are not
4178 aggregate_value_p, so we may see a PARALLEL or a REG. */
4179 if (REG_P (hard_reg
))
4180 SET_DECL_RTL (DECL_RESULT (subr
),
4181 gen_reg_rtx (GET_MODE (hard_reg
)));
4184 gcc_assert (GET_CODE (hard_reg
) == PARALLEL
);
4185 SET_DECL_RTL (DECL_RESULT (subr
), gen_group_rtx (hard_reg
));
4189 /* Set DECL_REGISTER flag so that expand_function_end will copy the
4190 result to the real return register(s). */
4191 DECL_REGISTER (DECL_RESULT (subr
)) = 1;
4194 /* Initialize rtx for parameters and local variables.
4195 In some cases this requires emitting insns. */
4196 assign_parms (subr
);
4198 /* If function gets a static chain arg, store it. */
4199 if (cfun
->static_chain_decl
)
4201 tree parm
= cfun
->static_chain_decl
;
4202 rtx local
= gen_reg_rtx (Pmode
);
4204 set_decl_incoming_rtl (parm
, static_chain_incoming_rtx
);
4205 SET_DECL_RTL (parm
, local
);
4206 mark_reg_pointer (local
, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm
))));
4208 emit_move_insn (local
, static_chain_incoming_rtx
);
4211 /* If the function receives a non-local goto, then store the
4212 bits we need to restore the frame pointer. */
4213 if (cfun
->nonlocal_goto_save_area
)
4218 /* ??? We need to do this save early. Unfortunately here is
4219 before the frame variable gets declared. Help out... */
4220 expand_var (TREE_OPERAND (cfun
->nonlocal_goto_save_area
, 0));
4222 t_save
= build4 (ARRAY_REF
, ptr_type_node
,
4223 cfun
->nonlocal_goto_save_area
,
4224 integer_zero_node
, NULL_TREE
, NULL_TREE
);
4225 r_save
= expand_expr (t_save
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
4226 r_save
= convert_memory_address (Pmode
, r_save
);
4228 emit_move_insn (r_save
, virtual_stack_vars_rtx
);
4229 update_nonlocal_goto_save_area ();
4232 /* The following was moved from init_function_start.
4233 The move is supposed to make sdb output more accurate. */
4234 /* Indicate the beginning of the function body,
4235 as opposed to parm setup. */
4236 emit_note (NOTE_INSN_FUNCTION_BEG
);
4238 if (!NOTE_P (get_last_insn ()))
4239 emit_note (NOTE_INSN_DELETED
);
4240 parm_birth_insn
= get_last_insn ();
4242 if (current_function_profile
)
4245 PROFILE_HOOK (current_function_funcdef_no
);
4249 /* After the display initializations is where the tail-recursion label
4250 should go, if we end up needing one. Ensure we have a NOTE here
4251 since some things (like trampolines) get placed before this. */
4252 tail_recursion_reentry
= emit_note (NOTE_INSN_DELETED
);
4254 /* Make sure there is a line number after the function entry setup code. */
4255 force_next_line_note ();
4258 /* Undo the effects of init_dummy_function_start. */
4260 expand_dummy_function_end (void)
4262 /* End any sequences that failed to be closed due to syntax errors. */
4263 while (in_sequence_p ())
4266 /* Outside function body, can't compute type's actual size
4267 until next function's body starts. */
4269 free_after_parsing (cfun
);
4270 free_after_compilation (cfun
);
4274 /* Call DOIT for each hard register used as a return value from
4275 the current function. */
4278 diddle_return_value (void (*doit
) (rtx
, void *), void *arg
)
4280 rtx outgoing
= current_function_return_rtx
;
4285 if (REG_P (outgoing
))
4286 (*doit
) (outgoing
, arg
);
4287 else if (GET_CODE (outgoing
) == PARALLEL
)
4291 for (i
= 0; i
< XVECLEN (outgoing
, 0); i
++)
4293 rtx x
= XEXP (XVECEXP (outgoing
, 0, i
), 0);
4295 if (REG_P (x
) && REGNO (x
) < FIRST_PSEUDO_REGISTER
)
4302 do_clobber_return_reg (rtx reg
, void *arg ATTRIBUTE_UNUSED
)
4304 emit_insn (gen_rtx_CLOBBER (VOIDmode
, reg
));
4308 clobber_return_register (void)
4310 diddle_return_value (do_clobber_return_reg
, NULL
);
4312 /* In case we do use pseudo to return value, clobber it too. */
4313 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl
)))
4315 tree decl_result
= DECL_RESULT (current_function_decl
);
4316 rtx decl_rtl
= DECL_RTL (decl_result
);
4317 if (REG_P (decl_rtl
) && REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
)
4319 do_clobber_return_reg (decl_rtl
, NULL
);
4325 do_use_return_reg (rtx reg
, void *arg ATTRIBUTE_UNUSED
)
4327 emit_insn (gen_rtx_USE (VOIDmode
, reg
));
4331 use_return_register (void)
4333 diddle_return_value (do_use_return_reg
, NULL
);
4336 /* Possibly warn about unused parameters. */
4338 do_warn_unused_parameter (tree fn
)
4342 for (decl
= DECL_ARGUMENTS (fn
);
4343 decl
; decl
= TREE_CHAIN (decl
))
4344 if (!TREE_USED (decl
) && TREE_CODE (decl
) == PARM_DECL
4345 && DECL_NAME (decl
) && !DECL_ARTIFICIAL (decl
))
4346 warning ("%Junused parameter %qD", decl
, decl
);
4349 static GTY(()) rtx initial_trampoline
;
4351 /* Generate RTL for the end of the current function. */
4354 expand_function_end (void)
4358 /* If arg_pointer_save_area was referenced only from a nested
4359 function, we will not have initialized it yet. Do that now. */
4360 if (arg_pointer_save_area
&& ! cfun
->arg_pointer_save_area_init
)
4361 get_arg_pointer_save_area (cfun
);
4363 /* If we are doing stack checking and this function makes calls,
4364 do a stack probe at the start of the function to ensure we have enough
4365 space for another stack frame. */
4366 if (flag_stack_check
&& ! STACK_CHECK_BUILTIN
)
4370 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
4374 probe_stack_range (STACK_CHECK_PROTECT
,
4375 GEN_INT (STACK_CHECK_MAX_FRAME_SIZE
));
4378 emit_insn_before (seq
, tail_recursion_reentry
);
4383 /* Possibly warn about unused parameters.
4384 When frontend does unit-at-a-time, the warning is already
4385 issued at finalization time. */
4386 if (warn_unused_parameter
4387 && !lang_hooks
.callgraph
.expand_function
)
4388 do_warn_unused_parameter (current_function_decl
);
4390 /* End any sequences that failed to be closed due to syntax errors. */
4391 while (in_sequence_p ())
4394 clear_pending_stack_adjust ();
4395 do_pending_stack_adjust ();
4397 /* @@@ This is a kludge. We want to ensure that instructions that
4398 may trap are not moved into the epilogue by scheduling, because
4399 we don't always emit unwind information for the epilogue.
4400 However, not all machine descriptions define a blockage insn, so
4401 emit an ASM_INPUT to act as one. */
4402 if (flag_non_call_exceptions
)
4403 emit_insn (gen_rtx_ASM_INPUT (VOIDmode
, ""));
4405 /* Mark the end of the function body.
4406 If control reaches this insn, the function can drop through
4407 without returning a value. */
4408 emit_note (NOTE_INSN_FUNCTION_END
);
4410 /* Must mark the last line number note in the function, so that the test
4411 coverage code can avoid counting the last line twice. This just tells
4412 the code to ignore the immediately following line note, since there
4413 already exists a copy of this note somewhere above. This line number
4414 note is still needed for debugging though, so we can't delete it. */
4415 if (flag_test_coverage
)
4416 emit_note (NOTE_INSN_REPEATED_LINE_NUMBER
);
4418 /* Output a linenumber for the end of the function.
4419 SDB depends on this. */
4420 force_next_line_note ();
4421 emit_line_note (input_location
);
4423 /* Before the return label (if any), clobber the return
4424 registers so that they are not propagated live to the rest of
4425 the function. This can only happen with functions that drop
4426 through; if there had been a return statement, there would
4427 have either been a return rtx, or a jump to the return label.
4429 We delay actual code generation after the current_function_value_rtx
4431 clobber_after
= get_last_insn ();
4433 /* Output the label for the actual return from the function. */
4434 emit_label (return_label
);
4436 /* Let except.c know where it should emit the call to unregister
4437 the function context for sjlj exceptions. */
4438 if (flag_exceptions
&& USING_SJLJ_EXCEPTIONS
)
4439 sjlj_emit_function_exit_after (get_last_insn ());
4441 /* If scalar return value was computed in a pseudo-reg, or was a named
4442 return value that got dumped to the stack, copy that to the hard
4444 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl
)))
4446 tree decl_result
= DECL_RESULT (current_function_decl
);
4447 rtx decl_rtl
= DECL_RTL (decl_result
);
4449 if (REG_P (decl_rtl
)
4450 ? REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
4451 : DECL_REGISTER (decl_result
))
4453 rtx real_decl_rtl
= current_function_return_rtx
;
4455 /* This should be set in assign_parms. */
4456 gcc_assert (REG_FUNCTION_VALUE_P (real_decl_rtl
));
4458 /* If this is a BLKmode structure being returned in registers,
4459 then use the mode computed in expand_return. Note that if
4460 decl_rtl is memory, then its mode may have been changed,
4461 but that current_function_return_rtx has not. */
4462 if (GET_MODE (real_decl_rtl
) == BLKmode
)
4463 PUT_MODE (real_decl_rtl
, GET_MODE (decl_rtl
));
4465 /* If a non-BLKmode return value should be padded at the least
4466 significant end of the register, shift it left by the appropriate
4467 amount. BLKmode results are handled using the group load/store
4469 if (TYPE_MODE (TREE_TYPE (decl_result
)) != BLKmode
4470 && targetm
.calls
.return_in_msb (TREE_TYPE (decl_result
)))
4472 emit_move_insn (gen_rtx_REG (GET_MODE (decl_rtl
),
4473 REGNO (real_decl_rtl
)),
4475 shift_return_value (GET_MODE (decl_rtl
), true, real_decl_rtl
);
4477 /* If a named return value dumped decl_return to memory, then
4478 we may need to re-do the PROMOTE_MODE signed/unsigned
4480 else if (GET_MODE (real_decl_rtl
) != GET_MODE (decl_rtl
))
4482 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (decl_result
));
4484 if (targetm
.calls
.promote_function_return (TREE_TYPE (current_function_decl
)))
4485 promote_mode (TREE_TYPE (decl_result
), GET_MODE (decl_rtl
),
4488 convert_move (real_decl_rtl
, decl_rtl
, unsignedp
);
4490 else if (GET_CODE (real_decl_rtl
) == PARALLEL
)
4492 /* If expand_function_start has created a PARALLEL for decl_rtl,
4493 move the result to the real return registers. Otherwise, do
4494 a group load from decl_rtl for a named return. */
4495 if (GET_CODE (decl_rtl
) == PARALLEL
)
4496 emit_group_move (real_decl_rtl
, decl_rtl
);
4498 emit_group_load (real_decl_rtl
, decl_rtl
,
4499 TREE_TYPE (decl_result
),
4500 int_size_in_bytes (TREE_TYPE (decl_result
)));
4503 emit_move_insn (real_decl_rtl
, decl_rtl
);
4507 /* If returning a structure, arrange to return the address of the value
4508 in a place where debuggers expect to find it.
4510 If returning a structure PCC style,
4511 the caller also depends on this value.
4512 And current_function_returns_pcc_struct is not necessarily set. */
4513 if (current_function_returns_struct
4514 || current_function_returns_pcc_struct
)
4516 rtx value_address
= DECL_RTL (DECL_RESULT (current_function_decl
));
4517 tree type
= TREE_TYPE (DECL_RESULT (current_function_decl
));
4520 if (DECL_BY_REFERENCE (DECL_RESULT (current_function_decl
)))
4521 type
= TREE_TYPE (type
);
4523 value_address
= XEXP (value_address
, 0);
4525 #ifdef FUNCTION_OUTGOING_VALUE
4526 outgoing
= FUNCTION_OUTGOING_VALUE (build_pointer_type (type
),
4527 current_function_decl
);
4529 outgoing
= FUNCTION_VALUE (build_pointer_type (type
),
4530 current_function_decl
);
4533 /* Mark this as a function return value so integrate will delete the
4534 assignment and USE below when inlining this function. */
4535 REG_FUNCTION_VALUE_P (outgoing
) = 1;
4537 /* The address may be ptr_mode and OUTGOING may be Pmode. */
4538 value_address
= convert_memory_address (GET_MODE (outgoing
),
4541 emit_move_insn (outgoing
, value_address
);
4543 /* Show return register used to hold result (in this case the address
4545 current_function_return_rtx
= outgoing
;
4548 /* If this is an implementation of throw, do what's necessary to
4549 communicate between __builtin_eh_return and the epilogue. */
4550 expand_eh_return ();
4552 /* Emit the actual code to clobber return register. */
4557 clobber_return_register ();
4558 expand_naked_return ();
4562 emit_insn_after (seq
, clobber_after
);
4565 /* Output the label for the naked return from the function. */
4566 emit_label (naked_return_label
);
4568 /* If we had calls to alloca, and this machine needs
4569 an accurate stack pointer to exit the function,
4570 insert some code to save and restore the stack pointer. */
4571 if (! EXIT_IGNORE_STACK
4572 && current_function_calls_alloca
)
4576 emit_stack_save (SAVE_FUNCTION
, &tem
, parm_birth_insn
);
4577 emit_stack_restore (SAVE_FUNCTION
, tem
, NULL_RTX
);
4580 /* ??? This should no longer be necessary since stupid is no longer with
4581 us, but there are some parts of the compiler (eg reload_combine, and
4582 sh mach_dep_reorg) that still try and compute their own lifetime info
4583 instead of using the general framework. */
4584 use_return_register ();
4588 get_arg_pointer_save_area (struct function
*f
)
4590 rtx ret
= f
->x_arg_pointer_save_area
;
4594 ret
= assign_stack_local_1 (Pmode
, GET_MODE_SIZE (Pmode
), 0, f
);
4595 f
->x_arg_pointer_save_area
= ret
;
4598 if (f
== cfun
&& ! f
->arg_pointer_save_area_init
)
4602 /* Save the arg pointer at the beginning of the function. The
4603 generated stack slot may not be a valid memory address, so we
4604 have to check it and fix it if necessary. */
4606 emit_move_insn (validize_mem (ret
), virtual_incoming_args_rtx
);
4610 push_topmost_sequence ();
4611 emit_insn_after (seq
, entry_of_function ());
4612 pop_topmost_sequence ();
4618 /* Extend a vector that records the INSN_UIDs of INSNS
4619 (a list of one or more insns). */
4622 record_insns (rtx insns
, varray_type
*vecp
)
4629 while (tmp
!= NULL_RTX
)
4632 tmp
= NEXT_INSN (tmp
);
4635 i
= VARRAY_SIZE (*vecp
);
4636 VARRAY_GROW (*vecp
, i
+ len
);
4638 while (tmp
!= NULL_RTX
)
4640 VARRAY_INT (*vecp
, i
) = INSN_UID (tmp
);
4642 tmp
= NEXT_INSN (tmp
);
4646 /* Set the locator of the insn chain starting at INSN to LOC. */
4648 set_insn_locators (rtx insn
, int loc
)
4650 while (insn
!= NULL_RTX
)
4653 INSN_LOCATOR (insn
) = loc
;
4654 insn
= NEXT_INSN (insn
);
4658 /* Determine how many INSN_UIDs in VEC are part of INSN. Because we can
4659 be running after reorg, SEQUENCE rtl is possible. */
4662 contains (rtx insn
, varray_type vec
)
4666 if (NONJUMP_INSN_P (insn
)
4667 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
4670 for (i
= XVECLEN (PATTERN (insn
), 0) - 1; i
>= 0; i
--)
4671 for (j
= VARRAY_SIZE (vec
) - 1; j
>= 0; --j
)
4672 if (INSN_UID (XVECEXP (PATTERN (insn
), 0, i
)) == VARRAY_INT (vec
, j
))
4678 for (j
= VARRAY_SIZE (vec
) - 1; j
>= 0; --j
)
4679 if (INSN_UID (insn
) == VARRAY_INT (vec
, j
))
4686 prologue_epilogue_contains (rtx insn
)
4688 if (contains (insn
, prologue
))
4690 if (contains (insn
, epilogue
))
4696 sibcall_epilogue_contains (rtx insn
)
4698 if (sibcall_epilogue
)
4699 return contains (insn
, sibcall_epilogue
);
4704 /* Insert gen_return at the end of block BB. This also means updating
4705 block_for_insn appropriately. */
4708 emit_return_into_block (basic_block bb
, rtx line_note
)
4710 emit_jump_insn_after (gen_return (), BB_END (bb
));
4712 emit_note_copy_after (line_note
, PREV_INSN (BB_END (bb
)));
4714 #endif /* HAVE_return */
4716 #if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX)
4718 /* These functions convert the epilogue into a variant that does not modify the
4719 stack pointer. This is used in cases where a function returns an object
4720 whose size is not known until it is computed. The called function leaves the
4721 object on the stack, leaves the stack depressed, and returns a pointer to
4724 What we need to do is track all modifications and references to the stack
4725 pointer, deleting the modifications and changing the references to point to
4726 the location the stack pointer would have pointed to had the modifications
4729 These functions need to be portable so we need to make as few assumptions
4730 about the epilogue as we can. However, the epilogue basically contains
4731 three things: instructions to reset the stack pointer, instructions to
4732 reload registers, possibly including the frame pointer, and an
4733 instruction to return to the caller.
4735 If we can't be sure of what a relevant epilogue insn is doing, we abort.
4736 We also make no attempt to validate the insns we make since if they are
4737 invalid, we probably can't do anything valid. The intent is that these
4738 routines get "smarter" as more and more machines start to use them and
4739 they try operating on different epilogues.
4741 We use the following structure to track what the part of the epilogue that
4742 we've already processed has done. We keep two copies of the SP equivalence,
4743 one for use during the insn we are processing and one for use in the next
4744 insn. The difference is because one part of a PARALLEL may adjust SP
4745 and the other may use it. */
4749 rtx sp_equiv_reg
; /* REG that SP is set from, perhaps SP. */
4750 HOST_WIDE_INT sp_offset
; /* Offset from SP_EQUIV_REG of present SP. */
4751 rtx new_sp_equiv_reg
; /* REG to be used at end of insn. */
4752 HOST_WIDE_INT new_sp_offset
; /* Offset to be used at end of insn. */
4753 rtx equiv_reg_src
; /* If nonzero, the value that SP_EQUIV_REG
4754 should be set to once we no longer need
4756 rtx const_equiv
[FIRST_PSEUDO_REGISTER
]; /* Any known constant equivalences
4760 static void handle_epilogue_set (rtx
, struct epi_info
*);
4761 static void update_epilogue_consts (rtx
, rtx
, void *);
4762 static void emit_equiv_load (struct epi_info
*);
4764 /* Modify INSN, a list of one or more insns that is part of the epilogue, to
4765 no modifications to the stack pointer. Return the new list of insns. */
4768 keep_stack_depressed (rtx insns
)
4771 struct epi_info info
;
4774 /* If the epilogue is just a single instruction, it must be OK as is. */
4775 if (NEXT_INSN (insns
) == NULL_RTX
)
4778 /* Otherwise, start a sequence, initialize the information we have, and
4779 process all the insns we were given. */
4782 info
.sp_equiv_reg
= stack_pointer_rtx
;
4784 info
.equiv_reg_src
= 0;
4786 for (j
= 0; j
< FIRST_PSEUDO_REGISTER
; j
++)
4787 info
.const_equiv
[j
] = 0;
4791 while (insn
!= NULL_RTX
)
4793 next
= NEXT_INSN (insn
);
4802 /* If this insn references the register that SP is equivalent to and
4803 we have a pending load to that register, we must force out the load
4804 first and then indicate we no longer know what SP's equivalent is. */
4805 if (info
.equiv_reg_src
!= 0
4806 && reg_referenced_p (info
.sp_equiv_reg
, PATTERN (insn
)))
4808 emit_equiv_load (&info
);
4809 info
.sp_equiv_reg
= 0;
4812 info
.new_sp_equiv_reg
= info
.sp_equiv_reg
;
4813 info
.new_sp_offset
= info
.sp_offset
;
4815 /* If this is a (RETURN) and the return address is on the stack,
4816 update the address and change to an indirect jump. */
4817 if (GET_CODE (PATTERN (insn
)) == RETURN
4818 || (GET_CODE (PATTERN (insn
)) == PARALLEL
4819 && GET_CODE (XVECEXP (PATTERN (insn
), 0, 0)) == RETURN
))
4821 rtx retaddr
= INCOMING_RETURN_ADDR_RTX
;
4823 HOST_WIDE_INT offset
= 0;
4824 rtx jump_insn
, jump_set
;
4826 /* If the return address is in a register, we can emit the insn
4827 unchanged. Otherwise, it must be a MEM and we see what the
4828 base register and offset are. In any case, we have to emit any
4829 pending load to the equivalent reg of SP, if any. */
4830 if (REG_P (retaddr
))
4832 emit_equiv_load (&info
);
4840 gcc_assert (MEM_P (retaddr
));
4842 ret_ptr
= XEXP (retaddr
, 0);
4844 if (REG_P (ret_ptr
))
4846 base
= gen_rtx_REG (Pmode
, REGNO (ret_ptr
));
4851 gcc_assert (GET_CODE (ret_ptr
) == PLUS
4852 && REG_P (XEXP (ret_ptr
, 0))
4853 && GET_CODE (XEXP (ret_ptr
, 1)) == CONST_INT
);
4854 base
= gen_rtx_REG (Pmode
, REGNO (XEXP (ret_ptr
, 0)));
4855 offset
= INTVAL (XEXP (ret_ptr
, 1));
4859 /* If the base of the location containing the return pointer
4860 is SP, we must update it with the replacement address. Otherwise,
4861 just build the necessary MEM. */
4862 retaddr
= plus_constant (base
, offset
);
4863 if (base
== stack_pointer_rtx
)
4864 retaddr
= simplify_replace_rtx (retaddr
, stack_pointer_rtx
,
4865 plus_constant (info
.sp_equiv_reg
,
4868 retaddr
= gen_rtx_MEM (Pmode
, retaddr
);
4870 /* If there is a pending load to the equivalent register for SP
4871 and we reference that register, we must load our address into
4872 a scratch register and then do that load. */
4873 if (info
.equiv_reg_src
4874 && reg_overlap_mentioned_p (info
.equiv_reg_src
, retaddr
))
4879 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
4880 if (HARD_REGNO_MODE_OK (regno
, Pmode
)
4881 && !fixed_regs
[regno
]
4882 && TEST_HARD_REG_BIT (regs_invalidated_by_call
, regno
)
4883 && !REGNO_REG_SET_P (EXIT_BLOCK_PTR
->global_live_at_start
,
4885 && !refers_to_regno_p (regno
,
4886 regno
+ hard_regno_nregs
[regno
]
4888 info
.equiv_reg_src
, NULL
)
4889 && info
.const_equiv
[regno
] == 0)
4892 gcc_assert (regno
< FIRST_PSEUDO_REGISTER
);
4894 reg
= gen_rtx_REG (Pmode
, regno
);
4895 emit_move_insn (reg
, retaddr
);
4899 emit_equiv_load (&info
);
4900 jump_insn
= emit_jump_insn (gen_indirect_jump (retaddr
));
4902 /* Show the SET in the above insn is a RETURN. */
4903 jump_set
= single_set (jump_insn
);
4904 gcc_assert (jump_set
);
4905 SET_IS_RETURN_P (jump_set
) = 1;
4908 /* If SP is not mentioned in the pattern and its equivalent register, if
4909 any, is not modified, just emit it. Otherwise, if neither is set,
4910 replace the reference to SP and emit the insn. If none of those are
4911 true, handle each SET individually. */
4912 else if (!reg_mentioned_p (stack_pointer_rtx
, PATTERN (insn
))
4913 && (info
.sp_equiv_reg
== stack_pointer_rtx
4914 || !reg_set_p (info
.sp_equiv_reg
, insn
)))
4916 else if (! reg_set_p (stack_pointer_rtx
, insn
)
4917 && (info
.sp_equiv_reg
== stack_pointer_rtx
4918 || !reg_set_p (info
.sp_equiv_reg
, insn
)))
4922 changed
= validate_replace_rtx (stack_pointer_rtx
,
4923 plus_constant (info
.sp_equiv_reg
,
4926 gcc_assert (changed
);
4930 else if (GET_CODE (PATTERN (insn
)) == SET
)
4931 handle_epilogue_set (PATTERN (insn
), &info
);
4932 else if (GET_CODE (PATTERN (insn
)) == PARALLEL
)
4934 for (j
= 0; j
< XVECLEN (PATTERN (insn
), 0); j
++)
4935 if (GET_CODE (XVECEXP (PATTERN (insn
), 0, j
)) == SET
)
4936 handle_epilogue_set (XVECEXP (PATTERN (insn
), 0, j
), &info
);
4941 info
.sp_equiv_reg
= info
.new_sp_equiv_reg
;
4942 info
.sp_offset
= info
.new_sp_offset
;
4944 /* Now update any constants this insn sets. */
4945 note_stores (PATTERN (insn
), update_epilogue_consts
, &info
);
4949 insns
= get_insns ();
4954 /* SET is a SET from an insn in the epilogue. P is a pointer to the epi_info
4955 structure that contains information about what we've seen so far. We
4956 process this SET by either updating that data or by emitting one or
4960 handle_epilogue_set (rtx set
, struct epi_info
*p
)
4962 /* First handle the case where we are setting SP. Record what it is being
4963 set from. If unknown, abort. */
4964 if (reg_set_p (stack_pointer_rtx
, set
))
4966 gcc_assert (SET_DEST (set
) == stack_pointer_rtx
);
4968 if (GET_CODE (SET_SRC (set
)) == PLUS
)
4970 p
->new_sp_equiv_reg
= XEXP (SET_SRC (set
), 0);
4971 if (GET_CODE (XEXP (SET_SRC (set
), 1)) == CONST_INT
)
4972 p
->new_sp_offset
= INTVAL (XEXP (SET_SRC (set
), 1));
4975 gcc_assert (REG_P (XEXP (SET_SRC (set
), 1))
4976 && (REGNO (XEXP (SET_SRC (set
), 1))
4977 < FIRST_PSEUDO_REGISTER
)
4978 && p
->const_equiv
[REGNO (XEXP (SET_SRC (set
), 1))]);
4980 = INTVAL (p
->const_equiv
[REGNO (XEXP (SET_SRC (set
), 1))]);
4984 p
->new_sp_equiv_reg
= SET_SRC (set
), p
->new_sp_offset
= 0;
4986 /* If we are adjusting SP, we adjust from the old data. */
4987 if (p
->new_sp_equiv_reg
== stack_pointer_rtx
)
4989 p
->new_sp_equiv_reg
= p
->sp_equiv_reg
;
4990 p
->new_sp_offset
+= p
->sp_offset
;
4993 gcc_assert (p
->new_sp_equiv_reg
&& REG_P (p
->new_sp_equiv_reg
));
4998 /* Next handle the case where we are setting SP's equivalent register.
4999 If we already have a value to set it to, abort. We could update, but
5000 there seems little point in handling that case. Note that we have
5001 to allow for the case where we are setting the register set in
5002 the previous part of a PARALLEL inside a single insn. But use the
5003 old offset for any updates within this insn. We must allow for the case
5004 where the register is being set in a different (usually wider) mode than
5006 else if (p
->new_sp_equiv_reg
!= 0 && reg_set_p (p
->new_sp_equiv_reg
, set
))
5008 gcc_assert (!p
->equiv_reg_src
5009 && REG_P (p
->new_sp_equiv_reg
)
5010 && REG_P (SET_DEST (set
))
5011 && (GET_MODE_BITSIZE (GET_MODE (SET_DEST (set
)))
5013 && REGNO (p
->new_sp_equiv_reg
) == REGNO (SET_DEST (set
)));
5015 = simplify_replace_rtx (SET_SRC (set
), stack_pointer_rtx
,
5016 plus_constant (p
->sp_equiv_reg
,
5020 /* Otherwise, replace any references to SP in the insn to its new value
5021 and emit the insn. */
5024 SET_SRC (set
) = simplify_replace_rtx (SET_SRC (set
), stack_pointer_rtx
,
5025 plus_constant (p
->sp_equiv_reg
,
5027 SET_DEST (set
) = simplify_replace_rtx (SET_DEST (set
), stack_pointer_rtx
,
5028 plus_constant (p
->sp_equiv_reg
,
5034 /* Update the tracking information for registers set to constants. */
5037 update_epilogue_consts (rtx dest
, rtx x
, void *data
)
5039 struct epi_info
*p
= (struct epi_info
*) data
;
5042 if (!REG_P (dest
) || REGNO (dest
) >= FIRST_PSEUDO_REGISTER
)
5045 /* If we are either clobbering a register or doing a partial set,
5046 show we don't know the value. */
5047 else if (GET_CODE (x
) == CLOBBER
|| ! rtx_equal_p (dest
, SET_DEST (x
)))
5048 p
->const_equiv
[REGNO (dest
)] = 0;
5050 /* If we are setting it to a constant, record that constant. */
5051 else if (GET_CODE (SET_SRC (x
)) == CONST_INT
)
5052 p
->const_equiv
[REGNO (dest
)] = SET_SRC (x
);
5054 /* If this is a binary operation between a register we have been tracking
5055 and a constant, see if we can compute a new constant value. */
5056 else if (ARITHMETIC_P (SET_SRC (x
))
5057 && REG_P (XEXP (SET_SRC (x
), 0))
5058 && REGNO (XEXP (SET_SRC (x
), 0)) < FIRST_PSEUDO_REGISTER
5059 && p
->const_equiv
[REGNO (XEXP (SET_SRC (x
), 0))] != 0
5060 && GET_CODE (XEXP (SET_SRC (x
), 1)) == CONST_INT
5061 && 0 != (new = simplify_binary_operation
5062 (GET_CODE (SET_SRC (x
)), GET_MODE (dest
),
5063 p
->const_equiv
[REGNO (XEXP (SET_SRC (x
), 0))],
5064 XEXP (SET_SRC (x
), 1)))
5065 && GET_CODE (new) == CONST_INT
)
5066 p
->const_equiv
[REGNO (dest
)] = new;
5068 /* Otherwise, we can't do anything with this value. */
5070 p
->const_equiv
[REGNO (dest
)] = 0;
5073 /* Emit an insn to do the load shown in p->equiv_reg_src, if needed. */
5076 emit_equiv_load (struct epi_info
*p
)
5078 if (p
->equiv_reg_src
!= 0)
5080 rtx dest
= p
->sp_equiv_reg
;
5082 if (GET_MODE (p
->equiv_reg_src
) != GET_MODE (dest
))
5083 dest
= gen_rtx_REG (GET_MODE (p
->equiv_reg_src
),
5084 REGNO (p
->sp_equiv_reg
));
5086 emit_move_insn (dest
, p
->equiv_reg_src
);
5087 p
->equiv_reg_src
= 0;
5092 /* Generate the prologue and epilogue RTL if the machine supports it. Thread
5093 this into place with notes indicating where the prologue ends and where
5094 the epilogue begins. Update the basic block information when possible. */
5097 thread_prologue_and_epilogue_insns (rtx f ATTRIBUTE_UNUSED
)
5101 #if defined (HAVE_sibcall_epilogue) || defined (HAVE_epilogue) || defined (HAVE_return) || defined (HAVE_prologue)
5104 #ifdef HAVE_prologue
5105 rtx prologue_end
= NULL_RTX
;
5107 #if defined (HAVE_epilogue) || defined(HAVE_return)
5108 rtx epilogue_end
= NULL_RTX
;
5112 #ifdef HAVE_prologue
5116 seq
= gen_prologue ();
5119 /* Retain a map of the prologue insns. */
5120 record_insns (seq
, &prologue
);
5121 prologue_end
= emit_note (NOTE_INSN_PROLOGUE_END
);
5125 set_insn_locators (seq
, prologue_locator
);
5127 /* Can't deal with multiple successors of the entry block
5128 at the moment. Function should always have at least one
5130 gcc_assert (single_succ_p (ENTRY_BLOCK_PTR
));
5132 insert_insn_on_edge (seq
, single_succ_edge (ENTRY_BLOCK_PTR
));
5137 /* If the exit block has no non-fake predecessors, we don't need
5139 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
5140 if ((e
->flags
& EDGE_FAKE
) == 0)
5146 if (optimize
&& HAVE_return
)
5148 /* If we're allowed to generate a simple return instruction,
5149 then by definition we don't need a full epilogue. Examine
5150 the block that falls through to EXIT. If it does not
5151 contain any code, examine its predecessors and try to
5152 emit (conditional) return instructions. */
5157 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
5158 if (e
->flags
& EDGE_FALLTHRU
)
5164 /* Verify that there are no active instructions in the last block. */
5165 label
= BB_END (last
);
5166 while (label
&& !LABEL_P (label
))
5168 if (active_insn_p (label
))
5170 label
= PREV_INSN (label
);
5173 if (BB_HEAD (last
) == label
&& LABEL_P (label
))
5176 rtx epilogue_line_note
= NULL_RTX
;
5178 /* Locate the line number associated with the closing brace,
5179 if we can find one. */
5180 for (seq
= get_last_insn ();
5181 seq
&& ! active_insn_p (seq
);
5182 seq
= PREV_INSN (seq
))
5183 if (NOTE_P (seq
) && NOTE_LINE_NUMBER (seq
) > 0)
5185 epilogue_line_note
= seq
;
5189 for (ei2
= ei_start (last
->preds
); (e
= ei_safe_edge (ei2
)); )
5191 basic_block bb
= e
->src
;
5194 if (bb
== ENTRY_BLOCK_PTR
)
5201 if (!JUMP_P (jump
) || JUMP_LABEL (jump
) != label
)
5207 /* If we have an unconditional jump, we can replace that
5208 with a simple return instruction. */
5209 if (simplejump_p (jump
))
5211 emit_return_into_block (bb
, epilogue_line_note
);
5215 /* If we have a conditional jump, we can try to replace
5216 that with a conditional return instruction. */
5217 else if (condjump_p (jump
))
5219 if (! redirect_jump (jump
, 0, 0))
5225 /* If this block has only one successor, it both jumps
5226 and falls through to the fallthru block, so we can't
5228 if (single_succ_p (bb
))
5240 /* Fix up the CFG for the successful change we just made. */
5241 redirect_edge_succ (e
, EXIT_BLOCK_PTR
);
5244 /* Emit a return insn for the exit fallthru block. Whether
5245 this is still reachable will be determined later. */
5247 emit_barrier_after (BB_END (last
));
5248 emit_return_into_block (last
, epilogue_line_note
);
5249 epilogue_end
= BB_END (last
);
5250 single_succ_edge (last
)->flags
&= ~EDGE_FALLTHRU
;
5255 /* Find the edge that falls through to EXIT. Other edges may exist
5256 due to RETURN instructions, but those don't need epilogues.
5257 There really shouldn't be a mixture -- either all should have
5258 been converted or none, however... */
5260 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
5261 if (e
->flags
& EDGE_FALLTHRU
)
5266 #ifdef HAVE_epilogue
5270 epilogue_end
= emit_note (NOTE_INSN_EPILOGUE_BEG
);
5272 seq
= gen_epilogue ();
5274 #ifdef INCOMING_RETURN_ADDR_RTX
5275 /* If this function returns with the stack depressed and we can support
5276 it, massage the epilogue to actually do that. */
5277 if (TREE_CODE (TREE_TYPE (current_function_decl
)) == FUNCTION_TYPE
5278 && TYPE_RETURNS_STACK_DEPRESSED (TREE_TYPE (current_function_decl
)))
5279 seq
= keep_stack_depressed (seq
);
5282 emit_jump_insn (seq
);
5284 /* Retain a map of the epilogue insns. */
5285 record_insns (seq
, &epilogue
);
5286 set_insn_locators (seq
, epilogue_locator
);
5291 insert_insn_on_edge (seq
, e
);
5299 if (! next_active_insn (BB_END (e
->src
)))
5301 /* We have a fall-through edge to the exit block, the source is not
5302 at the end of the function, and there will be an assembler epilogue
5303 at the end of the function.
5304 We can't use force_nonfallthru here, because that would try to
5305 use return. Inserting a jump 'by hand' is extremely messy, so
5306 we take advantage of cfg_layout_finalize using
5307 fixup_fallthru_exit_predecessor. */
5308 cfg_layout_initialize (0);
5309 FOR_EACH_BB (cur_bb
)
5310 if (cur_bb
->index
>= 0 && cur_bb
->next_bb
->index
>= 0)
5311 cur_bb
->rbi
->next
= cur_bb
->next_bb
;
5312 cfg_layout_finalize ();
5317 commit_edge_insertions ();
5319 #ifdef HAVE_sibcall_epilogue
5320 /* Emit sibling epilogues before any sibling call sites. */
5321 for (ei
= ei_start (EXIT_BLOCK_PTR
->preds
); (e
= ei_safe_edge (ei
)); )
5323 basic_block bb
= e
->src
;
5324 rtx insn
= BB_END (bb
);
5327 || ! SIBLING_CALL_P (insn
))
5334 emit_insn (gen_sibcall_epilogue ());
5338 /* Retain a map of the epilogue insns. Used in life analysis to
5339 avoid getting rid of sibcall epilogue insns. Do this before we
5340 actually emit the sequence. */
5341 record_insns (seq
, &sibcall_epilogue
);
5342 set_insn_locators (seq
, epilogue_locator
);
5344 emit_insn_before (seq
, insn
);
5349 #ifdef HAVE_prologue
5350 /* This is probably all useless now that we use locators. */
5355 /* GDB handles `break f' by setting a breakpoint on the first
5356 line note after the prologue. Which means (1) that if
5357 there are line number notes before where we inserted the
5358 prologue we should move them, and (2) we should generate a
5359 note before the end of the first basic block, if there isn't
5362 ??? This behavior is completely broken when dealing with
5363 multiple entry functions. We simply place the note always
5364 into first basic block and let alternate entry points
5368 for (insn
= prologue_end
; insn
; insn
= prev
)
5370 prev
= PREV_INSN (insn
);
5371 if (NOTE_P (insn
) && NOTE_LINE_NUMBER (insn
) > 0)
5373 /* Note that we cannot reorder the first insn in the
5374 chain, since rest_of_compilation relies on that
5375 remaining constant. */
5378 reorder_insns (insn
, insn
, prologue_end
);
5382 /* Find the last line number note in the first block. */
5383 for (insn
= BB_END (ENTRY_BLOCK_PTR
->next_bb
);
5384 insn
!= prologue_end
&& insn
;
5385 insn
= PREV_INSN (insn
))
5386 if (NOTE_P (insn
) && NOTE_LINE_NUMBER (insn
) > 0)
5389 /* If we didn't find one, make a copy of the first line number
5393 for (insn
= next_active_insn (prologue_end
);
5395 insn
= PREV_INSN (insn
))
5396 if (NOTE_P (insn
) && NOTE_LINE_NUMBER (insn
) > 0)
5398 emit_note_copy_after (insn
, prologue_end
);
5404 #ifdef HAVE_epilogue
5409 /* Similarly, move any line notes that appear after the epilogue.
5410 There is no need, however, to be quite so anal about the existence
5411 of such a note. Also move the NOTE_INSN_FUNCTION_END and (possibly)
5412 NOTE_INSN_FUNCTION_BEG notes, as those can be relevant for debug
5414 for (insn
= epilogue_end
; insn
; insn
= next
)
5416 next
= NEXT_INSN (insn
);
5418 && (NOTE_LINE_NUMBER (insn
) > 0
5419 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_FUNCTION_BEG
5420 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_FUNCTION_END
))
5421 reorder_insns (insn
, insn
, PREV_INSN (epilogue_end
));
5427 /* Reposition the prologue-end and epilogue-begin notes after instruction
5428 scheduling and delayed branch scheduling. */
5431 reposition_prologue_and_epilogue_notes (rtx f ATTRIBUTE_UNUSED
)
5433 #if defined (HAVE_prologue) || defined (HAVE_epilogue)
5434 rtx insn
, last
, note
;
5437 if ((len
= VARRAY_SIZE (prologue
)) > 0)
5441 /* Scan from the beginning until we reach the last prologue insn.
5442 We apparently can't depend on basic_block_{head,end} after
5444 for (insn
= f
; insn
; insn
= NEXT_INSN (insn
))
5448 if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_PROLOGUE_END
)
5451 else if (contains (insn
, prologue
))
5461 /* Find the prologue-end note if we haven't already, and
5462 move it to just after the last prologue insn. */
5465 for (note
= last
; (note
= NEXT_INSN (note
));)
5467 && NOTE_LINE_NUMBER (note
) == NOTE_INSN_PROLOGUE_END
)
5471 /* Avoid placing note between CODE_LABEL and BASIC_BLOCK note. */
5473 last
= NEXT_INSN (last
);
5474 reorder_insns (note
, note
, last
);
5478 if ((len
= VARRAY_SIZE (epilogue
)) > 0)
5482 /* Scan from the end until we reach the first epilogue insn.
5483 We apparently can't depend on basic_block_{head,end} after
5485 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
5489 if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_EPILOGUE_BEG
)
5492 else if (contains (insn
, epilogue
))
5502 /* Find the epilogue-begin note if we haven't already, and
5503 move it to just before the first epilogue insn. */
5506 for (note
= insn
; (note
= PREV_INSN (note
));)
5508 && NOTE_LINE_NUMBER (note
) == NOTE_INSN_EPILOGUE_BEG
)
5512 if (PREV_INSN (last
) != note
)
5513 reorder_insns (note
, note
, PREV_INSN (last
));
5516 #endif /* HAVE_prologue or HAVE_epilogue */
5519 /* Called once, at initialization, to initialize function.c. */
5522 init_function_once (void)
5524 VARRAY_INT_INIT (prologue
, 0, "prologue");
5525 VARRAY_INT_INIT (epilogue
, 0, "epilogue");
5526 VARRAY_INT_INIT (sibcall_epilogue
, 0, "sibcall_epilogue");
5529 /* Resets insn_block_boundaries array. */
5532 reset_block_changes (void)
5534 VARRAY_TREE_INIT (cfun
->ib_boundaries_block
, 100, "ib_boundaries_block");
5535 VARRAY_PUSH_TREE (cfun
->ib_boundaries_block
, NULL_TREE
);
5538 /* Record the boundary for BLOCK. */
5540 record_block_change (tree block
)
5548 last_block
= VARRAY_TOP_TREE (cfun
->ib_boundaries_block
);
5549 VARRAY_POP (cfun
->ib_boundaries_block
);
5551 for (i
= VARRAY_ACTIVE_SIZE (cfun
->ib_boundaries_block
); i
< n
; i
++)
5552 VARRAY_PUSH_TREE (cfun
->ib_boundaries_block
, last_block
);
5554 VARRAY_PUSH_TREE (cfun
->ib_boundaries_block
, block
);
5557 /* Finishes record of boundaries. */
5558 void finalize_block_changes (void)
5560 record_block_change (DECL_INITIAL (current_function_decl
));
5563 /* For INSN return the BLOCK it belongs to. */
5565 check_block_change (rtx insn
, tree
*block
)
5567 unsigned uid
= INSN_UID (insn
);
5569 if (uid
>= VARRAY_ACTIVE_SIZE (cfun
->ib_boundaries_block
))
5572 *block
= VARRAY_TREE (cfun
->ib_boundaries_block
, uid
);
5575 /* Releases the ib_boundaries_block records. */
5577 free_block_changes (void)
5579 cfun
->ib_boundaries_block
= NULL
;
5582 /* Returns the name of the current function. */
5584 current_function_name (void)
5586 return lang_hooks
.decl_printable_name (cfun
->decl
, 2);
5589 #include "gt-function.h"