1 /* Expands front end tree to back end RTL for GCC.
2 Copyright (C) 1987, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* This file handles the generation of rtl code from tree structure
23 at the level of the function as a whole.
24 It creates the rtl expressions for parameters and auto variables
25 and has full responsibility for allocating stack slots.
27 `expand_function_start' is called at the beginning of a function,
28 before the function body is parsed, and `expand_function_end' is
29 called after parsing the body.
31 Call `assign_stack_local' to allocate a stack slot for a local variable.
32 This is usually done during the RTL generation for the function body,
33 but it can also be done in the reload pass when a pseudo-register does
34 not get a hard register. */
38 #include "coretypes.h"
49 #include "hard-reg-set.h"
50 #include "insn-config.h"
53 #include "basic-block.h"
58 #include "integrate.h"
59 #include "langhooks.h"
61 #include "cfglayout.h"
62 #include "tree-gimple.h"
63 #include "tree-pass.h"
69 /* So we can assign to cfun in this file. */
72 #ifndef LOCAL_ALIGNMENT
73 #define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT
76 #ifndef STACK_ALIGNMENT_NEEDED
77 #define STACK_ALIGNMENT_NEEDED 1
80 #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
82 /* Some systems use __main in a way incompatible with its use in gcc, in these
83 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
84 give the same symbol without quotes for an alternative entry point. You
85 must define both, or neither. */
87 #define NAME__MAIN "__main"
90 /* Round a value to the lowest integer less than it that is a multiple of
91 the required alignment. Avoid using division in case the value is
92 negative. Assume the alignment is a power of two. */
93 #define FLOOR_ROUND(VALUE,ALIGN) ((VALUE) & ~((ALIGN) - 1))
95 /* Similar, but round to the next highest integer that meets the
97 #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
99 /* Nonzero if function being compiled doesn't contain any calls
100 (ignoring the prologue and epilogue). This is set prior to
101 local register allocation and is valid for the remaining
103 int current_function_is_leaf
;
105 /* Nonzero if function being compiled doesn't modify the stack pointer
106 (ignoring the prologue and epilogue). This is only valid after
107 pass_stack_ptr_mod has run. */
108 int current_function_sp_is_unchanging
;
110 /* Nonzero if the function being compiled is a leaf function which only
111 uses leaf registers. This is valid after reload (specifically after
112 sched2) and is useful only if the port defines LEAF_REGISTERS. */
113 int current_function_uses_only_leaf_regs
;
115 /* Nonzero once virtual register instantiation has been done.
116 assign_stack_local uses frame_pointer_rtx when this is nonzero.
117 calls.c:emit_library_call_value_1 uses it to set up
118 post-instantiation libcalls. */
119 int virtuals_instantiated
;
121 /* Assign unique numbers to labels generated for profiling, debugging, etc. */
122 static GTY(()) int funcdef_no
;
124 /* These variables hold pointers to functions to create and destroy
125 target specific, per-function data structures. */
126 struct machine_function
* (*init_machine_status
) (void);
128 /* The currently compiled function. */
129 struct function
*cfun
= 0;
131 /* These arrays record the INSN_UIDs of the prologue and epilogue insns. */
132 static VEC(int,heap
) *prologue
;
133 static VEC(int,heap
) *epilogue
;
135 /* Array of INSN_UIDs to hold the INSN_UIDs for each sibcall epilogue
137 static VEC(int,heap
) *sibcall_epilogue
;
139 /* In order to evaluate some expressions, such as function calls returning
140 structures in memory, we need to temporarily allocate stack locations.
141 We record each allocated temporary in the following structure.
143 Associated with each temporary slot is a nesting level. When we pop up
144 one level, all temporaries associated with the previous level are freed.
145 Normally, all temporaries are freed after the execution of the statement
146 in which they were created. However, if we are inside a ({...}) grouping,
147 the result may be in a temporary and hence must be preserved. If the
148 result could be in a temporary, we preserve it if we can determine which
149 one it is in. If we cannot determine which temporary may contain the
150 result, all temporaries are preserved. A temporary is preserved by
151 pretending it was allocated at the previous nesting level.
153 Automatic variables are also assigned temporary slots, at the nesting
154 level where they are defined. They are marked a "kept" so that
155 free_temp_slots will not free them. */
157 struct temp_slot
GTY(())
159 /* Points to next temporary slot. */
160 struct temp_slot
*next
;
161 /* Points to previous temporary slot. */
162 struct temp_slot
*prev
;
164 /* The rtx to used to reference the slot. */
166 /* The rtx used to represent the address if not the address of the
167 slot above. May be an EXPR_LIST if multiple addresses exist. */
169 /* The alignment (in bits) of the slot. */
171 /* The size, in units, of the slot. */
173 /* The type of the object in the slot, or zero if it doesn't correspond
174 to a type. We use this to determine whether a slot can be reused.
175 It can be reused if objects of the type of the new slot will always
176 conflict with objects of the type of the old slot. */
178 /* Nonzero if this temporary is currently in use. */
180 /* Nonzero if this temporary has its address taken. */
182 /* Nesting level at which this slot is being used. */
184 /* Nonzero if this should survive a call to free_temp_slots. */
186 /* The offset of the slot from the frame_pointer, including extra space
187 for alignment. This info is for combine_temp_slots. */
188 HOST_WIDE_INT base_offset
;
189 /* The size of the slot, including extra space for alignment. This
190 info is for combine_temp_slots. */
191 HOST_WIDE_INT full_size
;
194 /* Forward declarations. */
196 static struct temp_slot
*find_temp_slot_from_address (rtx
);
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
, VEC(tree
,heap
) **);
200 static int all_blocks (tree
, tree
*);
201 static tree
*get_block_vector (tree
, int *);
202 extern tree
debug_find_var_in_block_tree (tree
, tree
);
203 /* We always define `record_insns' even if it's not used so that we
204 can always export `prologue_epilogue_contains'. */
205 static void record_insns (rtx
, VEC(int,heap
) **) ATTRIBUTE_UNUSED
;
206 static int contains (const_rtx
, VEC(int,heap
) **);
208 static void emit_return_into_block (basic_block
);
210 static void prepare_function_start (void);
211 static void do_clobber_return_reg (rtx
, void *);
212 static void do_use_return_reg (rtx
, void *);
213 static void set_insn_locators (rtx
, int) ATTRIBUTE_UNUSED
;
215 /* Pointer to chain of `struct function' for containing functions. */
216 struct function
*outer_function_chain
;
218 /* Given a function decl for a containing function,
219 return the `struct function' for it. */
222 find_function_data (tree decl
)
226 for (p
= outer_function_chain
; p
; p
= p
->outer
)
233 /* Save the current context for compilation of a nested function.
234 This is called from language-specific code. */
237 push_function_context (void)
240 allocate_struct_function (NULL
, false);
242 cfun
->outer
= outer_function_chain
;
243 outer_function_chain
= cfun
;
247 /* Restore the last saved context, at the end of a nested function.
248 This function is called from language-specific code. */
251 pop_function_context (void)
253 struct function
*p
= outer_function_chain
;
256 outer_function_chain
= p
->outer
;
257 current_function_decl
= p
->decl
;
259 /* Reset variables that have known state during rtx generation. */
260 virtuals_instantiated
= 0;
261 generating_concat_p
= 1;
264 /* Clear out all parts of the state in F that can safely be discarded
265 after the function has been parsed, but not compiled, to let
266 garbage collection reclaim the memory. */
269 free_after_parsing (struct function
*f
)
274 /* Clear out all parts of the state in F that can safely be discarded
275 after the function has been compiled, to let garbage collection
276 reclaim the memory. */
279 free_after_compilation (struct function
*f
)
281 VEC_free (int, heap
, prologue
);
282 VEC_free (int, heap
, epilogue
);
283 VEC_free (int, heap
, sibcall_epilogue
);
284 if (crtl
->emit
.regno_pointer_align
)
285 free (crtl
->emit
.regno_pointer_align
);
287 memset (crtl
, 0, sizeof (struct rtl_data
));
292 regno_reg_rtx
= NULL
;
295 /* Return size needed for stack frame based on slots so far allocated.
296 This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY;
297 the caller may have to do that. */
300 get_frame_size (void)
302 if (FRAME_GROWS_DOWNWARD
)
303 return -frame_offset
;
308 /* Issue an error message and return TRUE if frame OFFSET overflows in
309 the signed target pointer arithmetics for function FUNC. Otherwise
313 frame_offset_overflow (HOST_WIDE_INT offset
, tree func
)
315 unsigned HOST_WIDE_INT size
= FRAME_GROWS_DOWNWARD
? -offset
: offset
;
317 if (size
> ((unsigned HOST_WIDE_INT
) 1 << (GET_MODE_BITSIZE (Pmode
) - 1))
318 /* Leave room for the fixed part of the frame. */
319 - 64 * UNITS_PER_WORD
)
321 error ("%Jtotal size of local objects too large", func
);
328 /* Allocate a stack slot of SIZE bytes and return a MEM rtx for it
329 with machine mode MODE.
331 ALIGN controls the amount of alignment for the address of the slot:
332 0 means according to MODE,
333 -1 means use BIGGEST_ALIGNMENT and round size to multiple of that,
334 -2 means use BITS_PER_UNIT,
335 positive specifies alignment boundary in bits.
337 We do not round to stack_boundary here. */
340 assign_stack_local (enum machine_mode mode
, HOST_WIDE_INT size
, int align
)
343 int bigend_correction
= 0;
344 unsigned int alignment
;
345 int frame_off
, frame_alignment
, frame_phase
;
352 alignment
= BIGGEST_ALIGNMENT
;
354 alignment
= GET_MODE_ALIGNMENT (mode
);
356 /* Allow the target to (possibly) increase the alignment of this
358 type
= lang_hooks
.types
.type_for_mode (mode
, 0);
360 alignment
= LOCAL_ALIGNMENT (type
, alignment
);
362 alignment
/= BITS_PER_UNIT
;
364 else if (align
== -1)
366 alignment
= BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
;
367 size
= CEIL_ROUND (size
, alignment
);
369 else if (align
== -2)
370 alignment
= 1; /* BITS_PER_UNIT / BITS_PER_UNIT */
372 alignment
= align
/ BITS_PER_UNIT
;
374 if (FRAME_GROWS_DOWNWARD
)
375 frame_offset
-= size
;
377 /* Ignore alignment we can't do with expected alignment of the boundary. */
378 if (alignment
* BITS_PER_UNIT
> PREFERRED_STACK_BOUNDARY
)
379 alignment
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
381 if (crtl
->stack_alignment_needed
< alignment
* BITS_PER_UNIT
)
382 crtl
->stack_alignment_needed
= alignment
* BITS_PER_UNIT
;
384 /* Calculate how many bytes the start of local variables is off from
386 frame_alignment
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
387 frame_off
= STARTING_FRAME_OFFSET
% frame_alignment
;
388 frame_phase
= frame_off
? frame_alignment
- frame_off
: 0;
390 /* Round the frame offset to the specified alignment. The default is
391 to always honor requests to align the stack but a port may choose to
392 do its own stack alignment by defining STACK_ALIGNMENT_NEEDED. */
393 if (STACK_ALIGNMENT_NEEDED
397 /* We must be careful here, since FRAME_OFFSET might be negative and
398 division with a negative dividend isn't as well defined as we might
399 like. So we instead assume that ALIGNMENT is a power of two and
400 use logical operations which are unambiguous. */
401 if (FRAME_GROWS_DOWNWARD
)
403 = (FLOOR_ROUND (frame_offset
- frame_phase
,
404 (unsigned HOST_WIDE_INT
) alignment
)
408 = (CEIL_ROUND (frame_offset
- frame_phase
,
409 (unsigned HOST_WIDE_INT
) alignment
)
413 /* On a big-endian machine, if we are allocating more space than we will use,
414 use the least significant bytes of those that are allocated. */
415 if (BYTES_BIG_ENDIAN
&& mode
!= BLKmode
&& GET_MODE_SIZE (mode
) < size
)
416 bigend_correction
= size
- GET_MODE_SIZE (mode
);
418 /* If we have already instantiated virtual registers, return the actual
419 address relative to the frame pointer. */
420 if (virtuals_instantiated
)
421 addr
= plus_constant (frame_pointer_rtx
,
423 (frame_offset
+ bigend_correction
424 + STARTING_FRAME_OFFSET
, Pmode
));
426 addr
= plus_constant (virtual_stack_vars_rtx
,
428 (frame_offset
+ bigend_correction
,
431 if (!FRAME_GROWS_DOWNWARD
)
432 frame_offset
+= size
;
434 x
= gen_rtx_MEM (mode
, addr
);
435 MEM_NOTRAP_P (x
) = 1;
438 = gen_rtx_EXPR_LIST (VOIDmode
, x
, stack_slot_list
);
440 if (frame_offset_overflow (frame_offset
, current_function_decl
))
446 /* Removes temporary slot TEMP from LIST. */
449 cut_slot_from_list (struct temp_slot
*temp
, struct temp_slot
**list
)
452 temp
->next
->prev
= temp
->prev
;
454 temp
->prev
->next
= temp
->next
;
458 temp
->prev
= temp
->next
= NULL
;
461 /* Inserts temporary slot TEMP to LIST. */
464 insert_slot_to_list (struct temp_slot
*temp
, struct temp_slot
**list
)
468 (*list
)->prev
= temp
;
473 /* Returns the list of used temp slots at LEVEL. */
475 static struct temp_slot
**
476 temp_slots_at_level (int level
)
478 if (level
>= (int) VEC_length (temp_slot_p
, used_temp_slots
))
479 VEC_safe_grow_cleared (temp_slot_p
, gc
, used_temp_slots
, level
+ 1);
481 return &(VEC_address (temp_slot_p
, used_temp_slots
)[level
]);
484 /* Returns the maximal temporary slot level. */
487 max_slot_level (void)
489 if (!used_temp_slots
)
492 return VEC_length (temp_slot_p
, used_temp_slots
) - 1;
495 /* Moves temporary slot TEMP to LEVEL. */
498 move_slot_to_level (struct temp_slot
*temp
, int level
)
500 cut_slot_from_list (temp
, temp_slots_at_level (temp
->level
));
501 insert_slot_to_list (temp
, temp_slots_at_level (level
));
505 /* Make temporary slot TEMP available. */
508 make_slot_available (struct temp_slot
*temp
)
510 cut_slot_from_list (temp
, temp_slots_at_level (temp
->level
));
511 insert_slot_to_list (temp
, &avail_temp_slots
);
516 /* Allocate a temporary stack slot and record it for possible later
519 MODE is the machine mode to be given to the returned rtx.
521 SIZE is the size in units of the space required. We do no rounding here
522 since assign_stack_local will do any required rounding.
524 KEEP is 1 if this slot is to be retained after a call to
525 free_temp_slots. Automatic variables for a block are allocated
526 with this flag. KEEP values of 2 or 3 were needed respectively
527 for variables whose lifetime is controlled by CLEANUP_POINT_EXPRs
528 or for SAVE_EXPRs, but they are now unused.
530 TYPE is the type that will be used for the stack slot. */
533 assign_stack_temp_for_type (enum machine_mode mode
, HOST_WIDE_INT size
,
537 struct temp_slot
*p
, *best_p
= 0, *selected
= NULL
, **pp
;
540 /* If SIZE is -1 it means that somebody tried to allocate a temporary
541 of a variable size. */
542 gcc_assert (size
!= -1);
544 /* These are now unused. */
545 gcc_assert (keep
<= 1);
548 align
= BIGGEST_ALIGNMENT
;
550 align
= GET_MODE_ALIGNMENT (mode
);
553 type
= lang_hooks
.types
.type_for_mode (mode
, 0);
556 align
= LOCAL_ALIGNMENT (type
, align
);
558 /* Try to find an available, already-allocated temporary of the proper
559 mode which meets the size and alignment requirements. Choose the
560 smallest one with the closest alignment.
562 If assign_stack_temp is called outside of the tree->rtl expansion,
563 we cannot reuse the stack slots (that may still refer to
564 VIRTUAL_STACK_VARS_REGNUM). */
565 if (!virtuals_instantiated
)
567 for (p
= avail_temp_slots
; p
; p
= p
->next
)
569 if (p
->align
>= align
&& p
->size
>= size
570 && GET_MODE (p
->slot
) == mode
571 && objects_must_conflict_p (p
->type
, type
)
572 && (best_p
== 0 || best_p
->size
> p
->size
573 || (best_p
->size
== p
->size
&& best_p
->align
> p
->align
)))
575 if (p
->align
== align
&& p
->size
== size
)
578 cut_slot_from_list (selected
, &avail_temp_slots
);
587 /* Make our best, if any, the one to use. */
591 cut_slot_from_list (selected
, &avail_temp_slots
);
593 /* If there are enough aligned bytes left over, make them into a new
594 temp_slot so that the extra bytes don't get wasted. Do this only
595 for BLKmode slots, so that we can be sure of the alignment. */
596 if (GET_MODE (best_p
->slot
) == BLKmode
)
598 int alignment
= best_p
->align
/ BITS_PER_UNIT
;
599 HOST_WIDE_INT rounded_size
= CEIL_ROUND (size
, alignment
);
601 if (best_p
->size
- rounded_size
>= alignment
)
603 p
= ggc_alloc (sizeof (struct temp_slot
));
604 p
->in_use
= p
->addr_taken
= 0;
605 p
->size
= best_p
->size
- rounded_size
;
606 p
->base_offset
= best_p
->base_offset
+ rounded_size
;
607 p
->full_size
= best_p
->full_size
- rounded_size
;
608 p
->slot
= adjust_address_nv (best_p
->slot
, BLKmode
, rounded_size
);
609 p
->align
= best_p
->align
;
611 p
->type
= best_p
->type
;
612 insert_slot_to_list (p
, &avail_temp_slots
);
614 stack_slot_list
= gen_rtx_EXPR_LIST (VOIDmode
, p
->slot
,
617 best_p
->size
= rounded_size
;
618 best_p
->full_size
= rounded_size
;
623 /* If we still didn't find one, make a new temporary. */
626 HOST_WIDE_INT frame_offset_old
= frame_offset
;
628 p
= ggc_alloc (sizeof (struct temp_slot
));
630 /* We are passing an explicit alignment request to assign_stack_local.
631 One side effect of that is assign_stack_local will not round SIZE
632 to ensure the frame offset remains suitably aligned.
634 So for requests which depended on the rounding of SIZE, we go ahead
635 and round it now. We also make sure ALIGNMENT is at least
636 BIGGEST_ALIGNMENT. */
637 gcc_assert (mode
!= BLKmode
|| align
== BIGGEST_ALIGNMENT
);
638 p
->slot
= assign_stack_local (mode
,
640 ? CEIL_ROUND (size
, (int) align
/ BITS_PER_UNIT
)
646 /* The following slot size computation is necessary because we don't
647 know the actual size of the temporary slot until assign_stack_local
648 has performed all the frame alignment and size rounding for the
649 requested temporary. Note that extra space added for alignment
650 can be either above or below this stack slot depending on which
651 way the frame grows. We include the extra space if and only if it
652 is above this slot. */
653 if (FRAME_GROWS_DOWNWARD
)
654 p
->size
= frame_offset_old
- frame_offset
;
658 /* Now define the fields used by combine_temp_slots. */
659 if (FRAME_GROWS_DOWNWARD
)
661 p
->base_offset
= frame_offset
;
662 p
->full_size
= frame_offset_old
- frame_offset
;
666 p
->base_offset
= frame_offset_old
;
667 p
->full_size
= frame_offset
- frame_offset_old
;
678 p
->level
= temp_slot_level
;
681 pp
= temp_slots_at_level (p
->level
);
682 insert_slot_to_list (p
, pp
);
684 /* Create a new MEM rtx to avoid clobbering MEM flags of old slots. */
685 slot
= gen_rtx_MEM (mode
, XEXP (p
->slot
, 0));
686 stack_slot_list
= gen_rtx_EXPR_LIST (VOIDmode
, slot
, stack_slot_list
);
688 /* If we know the alias set for the memory that will be used, use
689 it. If there's no TYPE, then we don't know anything about the
690 alias set for the memory. */
691 set_mem_alias_set (slot
, type
? get_alias_set (type
) : 0);
692 set_mem_align (slot
, align
);
694 /* If a type is specified, set the relevant flags. */
697 MEM_VOLATILE_P (slot
) = TYPE_VOLATILE (type
);
698 MEM_SET_IN_STRUCT_P (slot
, (AGGREGATE_TYPE_P (type
)
699 || TREE_CODE (type
) == COMPLEX_TYPE
));
701 MEM_NOTRAP_P (slot
) = 1;
706 /* Allocate a temporary stack slot and record it for possible later
707 reuse. First three arguments are same as in preceding function. */
710 assign_stack_temp (enum machine_mode mode
, HOST_WIDE_INT size
, int keep
)
712 return assign_stack_temp_for_type (mode
, size
, keep
, NULL_TREE
);
715 /* Assign a temporary.
716 If TYPE_OR_DECL is a decl, then we are doing it on behalf of the decl
717 and so that should be used in error messages. In either case, we
718 allocate of the given type.
719 KEEP is as for assign_stack_temp.
720 MEMORY_REQUIRED is 1 if the result must be addressable stack memory;
721 it is 0 if a register is OK.
722 DONT_PROMOTE is 1 if we should not promote values in register
726 assign_temp (tree type_or_decl
, int keep
, int memory_required
,
727 int dont_promote ATTRIBUTE_UNUSED
)
730 enum machine_mode mode
;
735 if (DECL_P (type_or_decl
))
736 decl
= type_or_decl
, type
= TREE_TYPE (decl
);
738 decl
= NULL
, type
= type_or_decl
;
740 mode
= TYPE_MODE (type
);
742 unsignedp
= TYPE_UNSIGNED (type
);
745 if (mode
== BLKmode
|| memory_required
)
747 HOST_WIDE_INT size
= int_size_in_bytes (type
);
750 /* Zero sized arrays are GNU C extension. Set size to 1 to avoid
751 problems with allocating the stack space. */
755 /* Unfortunately, we don't yet know how to allocate variable-sized
756 temporaries. However, sometimes we can find a fixed upper limit on
757 the size, so try that instead. */
759 size
= max_int_size_in_bytes (type
);
761 /* The size of the temporary may be too large to fit into an integer. */
762 /* ??? Not sure this should happen except for user silliness, so limit
763 this to things that aren't compiler-generated temporaries. The
764 rest of the time we'll die in assign_stack_temp_for_type. */
765 if (decl
&& size
== -1
766 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
)
768 error ("size of variable %q+D is too large", decl
);
772 tmp
= assign_stack_temp_for_type (mode
, size
, keep
, type
);
778 mode
= promote_mode (type
, mode
, &unsignedp
, 0);
781 return gen_reg_rtx (mode
);
784 /* Combine temporary stack slots which are adjacent on the stack.
786 This allows for better use of already allocated stack space. This is only
787 done for BLKmode slots because we can be sure that we won't have alignment
788 problems in this case. */
791 combine_temp_slots (void)
793 struct temp_slot
*p
, *q
, *next
, *next_q
;
796 /* We can't combine slots, because the information about which slot
797 is in which alias set will be lost. */
798 if (flag_strict_aliasing
)
801 /* If there are a lot of temp slots, don't do anything unless
802 high levels of optimization. */
803 if (! flag_expensive_optimizations
)
804 for (p
= avail_temp_slots
, num_slots
= 0; p
; p
= p
->next
, num_slots
++)
805 if (num_slots
> 100 || (num_slots
> 10 && optimize
== 0))
808 for (p
= avail_temp_slots
; p
; p
= next
)
814 if (GET_MODE (p
->slot
) != BLKmode
)
817 for (q
= p
->next
; q
; q
= next_q
)
823 if (GET_MODE (q
->slot
) != BLKmode
)
826 if (p
->base_offset
+ p
->full_size
== q
->base_offset
)
828 /* Q comes after P; combine Q into P. */
830 p
->full_size
+= q
->full_size
;
833 else if (q
->base_offset
+ q
->full_size
== p
->base_offset
)
835 /* P comes after Q; combine P into Q. */
837 q
->full_size
+= p
->full_size
;
842 cut_slot_from_list (q
, &avail_temp_slots
);
845 /* Either delete P or advance past it. */
847 cut_slot_from_list (p
, &avail_temp_slots
);
851 /* Find the temp slot corresponding to the object at address X. */
853 static struct temp_slot
*
854 find_temp_slot_from_address (rtx x
)
860 for (i
= max_slot_level (); i
>= 0; i
--)
861 for (p
= *temp_slots_at_level (i
); p
; p
= p
->next
)
863 if (XEXP (p
->slot
, 0) == x
865 || (GET_CODE (x
) == PLUS
866 && XEXP (x
, 0) == virtual_stack_vars_rtx
867 && GET_CODE (XEXP (x
, 1)) == CONST_INT
868 && INTVAL (XEXP (x
, 1)) >= p
->base_offset
869 && INTVAL (XEXP (x
, 1)) < p
->base_offset
+ p
->full_size
))
872 else if (p
->address
!= 0 && GET_CODE (p
->address
) == EXPR_LIST
)
873 for (next
= p
->address
; next
; next
= XEXP (next
, 1))
874 if (XEXP (next
, 0) == x
)
878 /* If we have a sum involving a register, see if it points to a temp
880 if (GET_CODE (x
) == PLUS
&& REG_P (XEXP (x
, 0))
881 && (p
= find_temp_slot_from_address (XEXP (x
, 0))) != 0)
883 else if (GET_CODE (x
) == PLUS
&& REG_P (XEXP (x
, 1))
884 && (p
= find_temp_slot_from_address (XEXP (x
, 1))) != 0)
890 /* Indicate that NEW is an alternate way of referring to the temp slot
891 that previously was known by OLD. */
894 update_temp_slot_address (rtx old
, rtx
new)
898 if (rtx_equal_p (old
, new))
901 p
= find_temp_slot_from_address (old
);
903 /* If we didn't find one, see if both OLD is a PLUS. If so, and NEW
904 is a register, see if one operand of the PLUS is a temporary
905 location. If so, NEW points into it. Otherwise, if both OLD and
906 NEW are a PLUS and if there is a register in common between them.
907 If so, try a recursive call on those values. */
910 if (GET_CODE (old
) != PLUS
)
915 update_temp_slot_address (XEXP (old
, 0), new);
916 update_temp_slot_address (XEXP (old
, 1), new);
919 else if (GET_CODE (new) != PLUS
)
922 if (rtx_equal_p (XEXP (old
, 0), XEXP (new, 0)))
923 update_temp_slot_address (XEXP (old
, 1), XEXP (new, 1));
924 else if (rtx_equal_p (XEXP (old
, 1), XEXP (new, 0)))
925 update_temp_slot_address (XEXP (old
, 0), XEXP (new, 1));
926 else if (rtx_equal_p (XEXP (old
, 0), XEXP (new, 1)))
927 update_temp_slot_address (XEXP (old
, 1), XEXP (new, 0));
928 else if (rtx_equal_p (XEXP (old
, 1), XEXP (new, 1)))
929 update_temp_slot_address (XEXP (old
, 0), XEXP (new, 0));
934 /* Otherwise add an alias for the temp's address. */
935 else if (p
->address
== 0)
939 if (GET_CODE (p
->address
) != EXPR_LIST
)
940 p
->address
= gen_rtx_EXPR_LIST (VOIDmode
, p
->address
, NULL_RTX
);
942 p
->address
= gen_rtx_EXPR_LIST (VOIDmode
, new, p
->address
);
946 /* If X could be a reference to a temporary slot, mark the fact that its
947 address was taken. */
950 mark_temp_addr_taken (rtx x
)
957 /* If X is not in memory or is at a constant address, it cannot be in
959 if (!MEM_P (x
) || CONSTANT_P (XEXP (x
, 0)))
962 p
= find_temp_slot_from_address (XEXP (x
, 0));
967 /* If X could be a reference to a temporary slot, mark that slot as
968 belonging to the to one level higher than the current level. If X
969 matched one of our slots, just mark that one. Otherwise, we can't
970 easily predict which it is, so upgrade all of them. Kept slots
973 This is called when an ({...}) construct occurs and a statement
974 returns a value in memory. */
977 preserve_temp_slots (rtx x
)
979 struct temp_slot
*p
= 0, *next
;
981 /* If there is no result, we still might have some objects whose address
982 were taken, so we need to make sure they stay around. */
985 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
990 move_slot_to_level (p
, temp_slot_level
- 1);
996 /* If X is a register that is being used as a pointer, see if we have
997 a temporary slot we know it points to. To be consistent with
998 the code below, we really should preserve all non-kept slots
999 if we can't find a match, but that seems to be much too costly. */
1000 if (REG_P (x
) && REG_POINTER (x
))
1001 p
= find_temp_slot_from_address (x
);
1003 /* If X is not in memory or is at a constant address, it cannot be in
1004 a temporary slot, but it can contain something whose address was
1006 if (p
== 0 && (!MEM_P (x
) || CONSTANT_P (XEXP (x
, 0))))
1008 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1013 move_slot_to_level (p
, temp_slot_level
- 1);
1019 /* First see if we can find a match. */
1021 p
= find_temp_slot_from_address (XEXP (x
, 0));
1025 /* Move everything at our level whose address was taken to our new
1026 level in case we used its address. */
1027 struct temp_slot
*q
;
1029 if (p
->level
== temp_slot_level
)
1031 for (q
= *temp_slots_at_level (temp_slot_level
); q
; q
= next
)
1035 if (p
!= q
&& q
->addr_taken
)
1036 move_slot_to_level (q
, temp_slot_level
- 1);
1039 move_slot_to_level (p
, temp_slot_level
- 1);
1045 /* Otherwise, preserve all non-kept slots at this level. */
1046 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1051 move_slot_to_level (p
, temp_slot_level
- 1);
1055 /* Free all temporaries used so far. This is normally called at the
1056 end of generating code for a statement. */
1059 free_temp_slots (void)
1061 struct temp_slot
*p
, *next
;
1063 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1068 make_slot_available (p
);
1071 combine_temp_slots ();
1074 /* Push deeper into the nesting level for stack temporaries. */
1077 push_temp_slots (void)
1082 /* Pop a temporary nesting level. All slots in use in the current level
1086 pop_temp_slots (void)
1088 struct temp_slot
*p
, *next
;
1090 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1093 make_slot_available (p
);
1096 combine_temp_slots ();
1101 /* Initialize temporary slots. */
1104 init_temp_slots (void)
1106 /* We have not allocated any temporaries yet. */
1107 avail_temp_slots
= 0;
1108 used_temp_slots
= 0;
1109 temp_slot_level
= 0;
1112 /* These routines are responsible for converting virtual register references
1113 to the actual hard register references once RTL generation is complete.
1115 The following four variables are used for communication between the
1116 routines. They contain the offsets of the virtual registers from their
1117 respective hard registers. */
1119 static int in_arg_offset
;
1120 static int var_offset
;
1121 static int dynamic_offset
;
1122 static int out_arg_offset
;
1123 static int cfa_offset
;
1125 /* In most machines, the stack pointer register is equivalent to the bottom
1128 #ifndef STACK_POINTER_OFFSET
1129 #define STACK_POINTER_OFFSET 0
1132 /* If not defined, pick an appropriate default for the offset of dynamically
1133 allocated memory depending on the value of ACCUMULATE_OUTGOING_ARGS,
1134 REG_PARM_STACK_SPACE, and OUTGOING_REG_PARM_STACK_SPACE. */
1136 #ifndef STACK_DYNAMIC_OFFSET
1138 /* The bottom of the stack points to the actual arguments. If
1139 REG_PARM_STACK_SPACE is defined, this includes the space for the register
1140 parameters. However, if OUTGOING_REG_PARM_STACK space is not defined,
1141 stack space for register parameters is not pushed by the caller, but
1142 rather part of the fixed stack areas and hence not included in
1143 `crtl->outgoing_args_size'. Nevertheless, we must allow
1144 for it when allocating stack dynamic objects. */
1146 #if defined(REG_PARM_STACK_SPACE)
1147 #define STACK_DYNAMIC_OFFSET(FNDECL) \
1148 ((ACCUMULATE_OUTGOING_ARGS \
1149 ? (crtl->outgoing_args_size \
1150 + (OUTGOING_REG_PARM_STACK_SPACE ? 0 : REG_PARM_STACK_SPACE (FNDECL))) \
1151 : 0) + (STACK_POINTER_OFFSET))
1153 #define STACK_DYNAMIC_OFFSET(FNDECL) \
1154 ((ACCUMULATE_OUTGOING_ARGS ? crtl->outgoing_args_size : 0) \
1155 + (STACK_POINTER_OFFSET))
1160 /* Given a piece of RTX and a pointer to a HOST_WIDE_INT, if the RTX
1161 is a virtual register, return the equivalent hard register and set the
1162 offset indirectly through the pointer. Otherwise, return 0. */
1165 instantiate_new_reg (rtx x
, HOST_WIDE_INT
*poffset
)
1168 HOST_WIDE_INT offset
;
1170 if (x
== virtual_incoming_args_rtx
)
1171 new = arg_pointer_rtx
, offset
= in_arg_offset
;
1172 else if (x
== virtual_stack_vars_rtx
)
1173 new = frame_pointer_rtx
, offset
= var_offset
;
1174 else if (x
== virtual_stack_dynamic_rtx
)
1175 new = stack_pointer_rtx
, offset
= dynamic_offset
;
1176 else if (x
== virtual_outgoing_args_rtx
)
1177 new = stack_pointer_rtx
, offset
= out_arg_offset
;
1178 else if (x
== virtual_cfa_rtx
)
1180 #ifdef FRAME_POINTER_CFA_OFFSET
1181 new = frame_pointer_rtx
;
1183 new = arg_pointer_rtx
;
1185 offset
= cfa_offset
;
1194 /* A subroutine of instantiate_virtual_regs, called via for_each_rtx.
1195 Instantiate any virtual registers present inside of *LOC. The expression
1196 is simplified, as much as possible, but is not to be considered "valid"
1197 in any sense implied by the target. If any change is made, set CHANGED
1201 instantiate_virtual_regs_in_rtx (rtx
*loc
, void *data
)
1203 HOST_WIDE_INT offset
;
1204 bool *changed
= (bool *) data
;
1211 switch (GET_CODE (x
))
1214 new = instantiate_new_reg (x
, &offset
);
1217 *loc
= plus_constant (new, offset
);
1224 new = instantiate_new_reg (XEXP (x
, 0), &offset
);
1227 new = plus_constant (new, offset
);
1228 *loc
= simplify_gen_binary (PLUS
, GET_MODE (x
), new, XEXP (x
, 1));
1234 /* FIXME -- from old code */
1235 /* If we have (plus (subreg (virtual-reg)) (const_int)), we know
1236 we can commute the PLUS and SUBREG because pointers into the
1237 frame are well-behaved. */
1247 /* A subroutine of instantiate_virtual_regs_in_insn. Return true if X
1248 matches the predicate for insn CODE operand OPERAND. */
1251 safe_insn_predicate (int code
, int operand
, rtx x
)
1253 const struct insn_operand_data
*op_data
;
1258 op_data
= &insn_data
[code
].operand
[operand
];
1259 if (op_data
->predicate
== NULL
)
1262 return op_data
->predicate (x
, op_data
->mode
);
1265 /* A subroutine of instantiate_virtual_regs. Instantiate any virtual
1266 registers present inside of insn. The result will be a valid insn. */
1269 instantiate_virtual_regs_in_insn (rtx insn
)
1271 HOST_WIDE_INT offset
;
1273 bool any_change
= false;
1274 rtx set
, new, x
, seq
;
1276 /* There are some special cases to be handled first. */
1277 set
= single_set (insn
);
1280 /* We're allowed to assign to a virtual register. This is interpreted
1281 to mean that the underlying register gets assigned the inverse
1282 transformation. This is used, for example, in the handling of
1284 new = instantiate_new_reg (SET_DEST (set
), &offset
);
1289 for_each_rtx (&SET_SRC (set
), instantiate_virtual_regs_in_rtx
, NULL
);
1290 x
= simplify_gen_binary (PLUS
, GET_MODE (new), SET_SRC (set
),
1292 x
= force_operand (x
, new);
1294 emit_move_insn (new, x
);
1299 emit_insn_before (seq
, insn
);
1304 /* Handle a straight copy from a virtual register by generating a
1305 new add insn. The difference between this and falling through
1306 to the generic case is avoiding a new pseudo and eliminating a
1307 move insn in the initial rtl stream. */
1308 new = instantiate_new_reg (SET_SRC (set
), &offset
);
1309 if (new && offset
!= 0
1310 && REG_P (SET_DEST (set
))
1311 && REGNO (SET_DEST (set
)) > LAST_VIRTUAL_REGISTER
)
1315 x
= expand_simple_binop (GET_MODE (SET_DEST (set
)), PLUS
,
1316 new, GEN_INT (offset
), SET_DEST (set
),
1317 1, OPTAB_LIB_WIDEN
);
1318 if (x
!= SET_DEST (set
))
1319 emit_move_insn (SET_DEST (set
), x
);
1324 emit_insn_before (seq
, insn
);
1329 extract_insn (insn
);
1330 insn_code
= INSN_CODE (insn
);
1332 /* Handle a plus involving a virtual register by determining if the
1333 operands remain valid if they're modified in place. */
1334 if (GET_CODE (SET_SRC (set
)) == PLUS
1335 && recog_data
.n_operands
>= 3
1336 && recog_data
.operand_loc
[1] == &XEXP (SET_SRC (set
), 0)
1337 && recog_data
.operand_loc
[2] == &XEXP (SET_SRC (set
), 1)
1338 && GET_CODE (recog_data
.operand
[2]) == CONST_INT
1339 && (new = instantiate_new_reg (recog_data
.operand
[1], &offset
)))
1341 offset
+= INTVAL (recog_data
.operand
[2]);
1343 /* If the sum is zero, then replace with a plain move. */
1345 && REG_P (SET_DEST (set
))
1346 && REGNO (SET_DEST (set
)) > LAST_VIRTUAL_REGISTER
)
1349 emit_move_insn (SET_DEST (set
), new);
1353 emit_insn_before (seq
, insn
);
1358 x
= gen_int_mode (offset
, recog_data
.operand_mode
[2]);
1360 /* Using validate_change and apply_change_group here leaves
1361 recog_data in an invalid state. Since we know exactly what
1362 we want to check, do those two by hand. */
1363 if (safe_insn_predicate (insn_code
, 1, new)
1364 && safe_insn_predicate (insn_code
, 2, x
))
1366 *recog_data
.operand_loc
[1] = recog_data
.operand
[1] = new;
1367 *recog_data
.operand_loc
[2] = recog_data
.operand
[2] = x
;
1370 /* Fall through into the regular operand fixup loop in
1371 order to take care of operands other than 1 and 2. */
1377 extract_insn (insn
);
1378 insn_code
= INSN_CODE (insn
);
1381 /* In the general case, we expect virtual registers to appear only in
1382 operands, and then only as either bare registers or inside memories. */
1383 for (i
= 0; i
< recog_data
.n_operands
; ++i
)
1385 x
= recog_data
.operand
[i
];
1386 switch (GET_CODE (x
))
1390 rtx addr
= XEXP (x
, 0);
1391 bool changed
= false;
1393 for_each_rtx (&addr
, instantiate_virtual_regs_in_rtx
, &changed
);
1398 x
= replace_equiv_address (x
, addr
);
1399 /* It may happen that the address with the virtual reg
1400 was valid (e.g. based on the virtual stack reg, which might
1401 be acceptable to the predicates with all offsets), whereas
1402 the address now isn't anymore, for instance when the address
1403 is still offsetted, but the base reg isn't virtual-stack-reg
1404 anymore. Below we would do a force_reg on the whole operand,
1405 but this insn might actually only accept memory. Hence,
1406 before doing that last resort, try to reload the address into
1407 a register, so this operand stays a MEM. */
1408 if (!safe_insn_predicate (insn_code
, i
, x
))
1410 addr
= force_reg (GET_MODE (addr
), addr
);
1411 x
= replace_equiv_address (x
, addr
);
1416 emit_insn_before (seq
, insn
);
1421 new = instantiate_new_reg (x
, &offset
);
1430 /* Careful, special mode predicates may have stuff in
1431 insn_data[insn_code].operand[i].mode that isn't useful
1432 to us for computing a new value. */
1433 /* ??? Recognize address_operand and/or "p" constraints
1434 to see if (plus new offset) is a valid before we put
1435 this through expand_simple_binop. */
1436 x
= expand_simple_binop (GET_MODE (x
), PLUS
, new,
1437 GEN_INT (offset
), NULL_RTX
,
1438 1, OPTAB_LIB_WIDEN
);
1441 emit_insn_before (seq
, insn
);
1446 new = instantiate_new_reg (SUBREG_REG (x
), &offset
);
1452 new = expand_simple_binop (GET_MODE (new), PLUS
, new,
1453 GEN_INT (offset
), NULL_RTX
,
1454 1, OPTAB_LIB_WIDEN
);
1457 emit_insn_before (seq
, insn
);
1459 x
= simplify_gen_subreg (recog_data
.operand_mode
[i
], new,
1460 GET_MODE (new), SUBREG_BYTE (x
));
1467 /* At this point, X contains the new value for the operand.
1468 Validate the new value vs the insn predicate. Note that
1469 asm insns will have insn_code -1 here. */
1470 if (!safe_insn_predicate (insn_code
, i
, x
))
1473 x
= force_reg (insn_data
[insn_code
].operand
[i
].mode
, x
);
1477 emit_insn_before (seq
, insn
);
1480 *recog_data
.operand_loc
[i
] = recog_data
.operand
[i
] = x
;
1486 /* Propagate operand changes into the duplicates. */
1487 for (i
= 0; i
< recog_data
.n_dups
; ++i
)
1488 *recog_data
.dup_loc
[i
]
1489 = copy_rtx (recog_data
.operand
[(unsigned)recog_data
.dup_num
[i
]]);
1491 /* Force re-recognition of the instruction for validation. */
1492 INSN_CODE (insn
) = -1;
1495 if (asm_noperands (PATTERN (insn
)) >= 0)
1497 if (!check_asm_operands (PATTERN (insn
)))
1499 error_for_asm (insn
, "impossible constraint in %<asm%>");
1505 if (recog_memoized (insn
) < 0)
1506 fatal_insn_not_found (insn
);
1510 /* Subroutine of instantiate_decls. Given RTL representing a decl,
1511 do any instantiation required. */
1514 instantiate_decl_rtl (rtx x
)
1521 /* If this is a CONCAT, recurse for the pieces. */
1522 if (GET_CODE (x
) == CONCAT
)
1524 instantiate_decl_rtl (XEXP (x
, 0));
1525 instantiate_decl_rtl (XEXP (x
, 1));
1529 /* If this is not a MEM, no need to do anything. Similarly if the
1530 address is a constant or a register that is not a virtual register. */
1535 if (CONSTANT_P (addr
)
1537 && (REGNO (addr
) < FIRST_VIRTUAL_REGISTER
1538 || REGNO (addr
) > LAST_VIRTUAL_REGISTER
)))
1541 for_each_rtx (&XEXP (x
, 0), instantiate_virtual_regs_in_rtx
, NULL
);
1544 /* Helper for instantiate_decls called via walk_tree: Process all decls
1545 in the given DECL_VALUE_EXPR. */
1548 instantiate_expr (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
1551 if (! EXPR_P (t
) && ! GIMPLE_STMT_P (t
))
1554 if (DECL_P (t
) && DECL_RTL_SET_P (t
))
1555 instantiate_decl_rtl (DECL_RTL (t
));
1560 /* Subroutine of instantiate_decls: Process all decls in the given
1561 BLOCK node and all its subblocks. */
1564 instantiate_decls_1 (tree let
)
1568 for (t
= BLOCK_VARS (let
); t
; t
= TREE_CHAIN (t
))
1570 if (DECL_RTL_SET_P (t
))
1571 instantiate_decl_rtl (DECL_RTL (t
));
1572 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (t
))
1574 tree v
= DECL_VALUE_EXPR (t
);
1575 walk_tree (&v
, instantiate_expr
, NULL
, NULL
);
1579 /* Process all subblocks. */
1580 for (t
= BLOCK_SUBBLOCKS (let
); t
; t
= BLOCK_CHAIN (t
))
1581 instantiate_decls_1 (t
);
1584 /* Scan all decls in FNDECL (both variables and parameters) and instantiate
1585 all virtual registers in their DECL_RTL's. */
1588 instantiate_decls (tree fndecl
)
1592 /* Process all parameters of the function. */
1593 for (decl
= DECL_ARGUMENTS (fndecl
); decl
; decl
= TREE_CHAIN (decl
))
1595 instantiate_decl_rtl (DECL_RTL (decl
));
1596 instantiate_decl_rtl (DECL_INCOMING_RTL (decl
));
1597 if (DECL_HAS_VALUE_EXPR_P (decl
))
1599 tree v
= DECL_VALUE_EXPR (decl
);
1600 walk_tree (&v
, instantiate_expr
, NULL
, NULL
);
1604 /* Now process all variables defined in the function or its subblocks. */
1605 instantiate_decls_1 (DECL_INITIAL (fndecl
));
1608 /* Pass through the INSNS of function FNDECL and convert virtual register
1609 references to hard register references. */
1612 instantiate_virtual_regs (void)
1616 /* Compute the offsets to use for this function. */
1617 in_arg_offset
= FIRST_PARM_OFFSET (current_function_decl
);
1618 var_offset
= STARTING_FRAME_OFFSET
;
1619 dynamic_offset
= STACK_DYNAMIC_OFFSET (current_function_decl
);
1620 out_arg_offset
= STACK_POINTER_OFFSET
;
1621 #ifdef FRAME_POINTER_CFA_OFFSET
1622 cfa_offset
= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
1624 cfa_offset
= ARG_POINTER_CFA_OFFSET (current_function_decl
);
1627 /* Initialize recognition, indicating that volatile is OK. */
1630 /* Scan through all the insns, instantiating every virtual register still
1632 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1635 /* These patterns in the instruction stream can never be recognized.
1636 Fortunately, they shouldn't contain virtual registers either. */
1637 if (GET_CODE (PATTERN (insn
)) == USE
1638 || GET_CODE (PATTERN (insn
)) == CLOBBER
1639 || GET_CODE (PATTERN (insn
)) == ADDR_VEC
1640 || GET_CODE (PATTERN (insn
)) == ADDR_DIFF_VEC
1641 || GET_CODE (PATTERN (insn
)) == ASM_INPUT
)
1644 instantiate_virtual_regs_in_insn (insn
);
1646 if (INSN_DELETED_P (insn
))
1649 for_each_rtx (®_NOTES (insn
), instantiate_virtual_regs_in_rtx
, NULL
);
1651 /* Instantiate any virtual registers in CALL_INSN_FUNCTION_USAGE. */
1652 if (GET_CODE (insn
) == CALL_INSN
)
1653 for_each_rtx (&CALL_INSN_FUNCTION_USAGE (insn
),
1654 instantiate_virtual_regs_in_rtx
, NULL
);
1657 /* Instantiate the virtual registers in the DECLs for debugging purposes. */
1658 instantiate_decls (current_function_decl
);
1660 targetm
.instantiate_decls ();
1662 /* Indicate that, from now on, assign_stack_local should use
1663 frame_pointer_rtx. */
1664 virtuals_instantiated
= 1;
1668 struct rtl_opt_pass pass_instantiate_virtual_regs
=
1674 instantiate_virtual_regs
, /* execute */
1677 0, /* static_pass_number */
1679 0, /* properties_required */
1680 0, /* properties_provided */
1681 0, /* properties_destroyed */
1682 0, /* todo_flags_start */
1683 TODO_dump_func
/* todo_flags_finish */
1688 /* Return 1 if EXP is an aggregate type (or a value with aggregate type).
1689 This means a type for which function calls must pass an address to the
1690 function or get an address back from the function.
1691 EXP may be a type node or an expression (whose type is tested). */
1694 aggregate_value_p (const_tree exp
, const_tree fntype
)
1696 int i
, regno
, nregs
;
1699 const_tree type
= (TYPE_P (exp
)) ? exp
: TREE_TYPE (exp
);
1701 /* DECL node associated with FNTYPE when relevant, which we might need to
1702 check for by-invisible-reference returns, typically for CALL_EXPR input
1704 const_tree fndecl
= NULL_TREE
;
1707 switch (TREE_CODE (fntype
))
1710 fndecl
= get_callee_fndecl (fntype
);
1711 fntype
= fndecl
? TREE_TYPE (fndecl
) : 0;
1715 fntype
= TREE_TYPE (fndecl
);
1720 case IDENTIFIER_NODE
:
1724 /* We don't expect other rtl types here. */
1728 if (TREE_CODE (type
) == VOID_TYPE
)
1731 /* If the front end has decided that this needs to be passed by
1732 reference, do so. */
1733 if ((TREE_CODE (exp
) == PARM_DECL
|| TREE_CODE (exp
) == RESULT_DECL
)
1734 && DECL_BY_REFERENCE (exp
))
1737 /* If the EXPression is a CALL_EXPR, honor DECL_BY_REFERENCE set on the
1738 called function RESULT_DECL, meaning the function returns in memory by
1739 invisible reference. This check lets front-ends not set TREE_ADDRESSABLE
1740 on the function type, which used to be the way to request such a return
1741 mechanism but might now be causing troubles at gimplification time if
1742 temporaries with the function type need to be created. */
1743 if (TREE_CODE (exp
) == CALL_EXPR
&& fndecl
&& DECL_RESULT (fndecl
)
1744 && DECL_BY_REFERENCE (DECL_RESULT (fndecl
)))
1747 if (targetm
.calls
.return_in_memory (type
, fntype
))
1749 /* Types that are TREE_ADDRESSABLE must be constructed in memory,
1750 and thus can't be returned in registers. */
1751 if (TREE_ADDRESSABLE (type
))
1753 if (flag_pcc_struct_return
&& AGGREGATE_TYPE_P (type
))
1755 /* Make sure we have suitable call-clobbered regs to return
1756 the value in; if not, we must return it in memory. */
1757 reg
= hard_function_value (type
, 0, fntype
, 0);
1759 /* If we have something other than a REG (e.g. a PARALLEL), then assume
1764 regno
= REGNO (reg
);
1765 nregs
= hard_regno_nregs
[regno
][TYPE_MODE (type
)];
1766 for (i
= 0; i
< nregs
; i
++)
1767 if (! call_used_regs
[regno
+ i
])
1772 /* Return true if we should assign DECL a pseudo register; false if it
1773 should live on the local stack. */
1776 use_register_for_decl (const_tree decl
)
1778 /* Honor volatile. */
1779 if (TREE_SIDE_EFFECTS (decl
))
1782 /* Honor addressability. */
1783 if (TREE_ADDRESSABLE (decl
))
1786 /* Only register-like things go in registers. */
1787 if (DECL_MODE (decl
) == BLKmode
)
1790 /* If -ffloat-store specified, don't put explicit float variables
1792 /* ??? This should be checked after DECL_ARTIFICIAL, but tree-ssa
1793 propagates values across these stores, and it probably shouldn't. */
1794 if (flag_float_store
&& FLOAT_TYPE_P (TREE_TYPE (decl
)))
1797 /* If we're not interested in tracking debugging information for
1798 this decl, then we can certainly put it in a register. */
1799 if (DECL_IGNORED_P (decl
))
1802 return (optimize
|| DECL_REGISTER (decl
));
1805 /* Return true if TYPE should be passed by invisible reference. */
1808 pass_by_reference (CUMULATIVE_ARGS
*ca
, enum machine_mode mode
,
1809 tree type
, bool named_arg
)
1813 /* If this type contains non-trivial constructors, then it is
1814 forbidden for the middle-end to create any new copies. */
1815 if (TREE_ADDRESSABLE (type
))
1818 /* GCC post 3.4 passes *all* variable sized types by reference. */
1819 if (!TYPE_SIZE (type
) || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1823 return targetm
.calls
.pass_by_reference (ca
, mode
, type
, named_arg
);
1826 /* Return true if TYPE, which is passed by reference, should be callee
1827 copied instead of caller copied. */
1830 reference_callee_copied (CUMULATIVE_ARGS
*ca
, enum machine_mode mode
,
1831 tree type
, bool named_arg
)
1833 if (type
&& TREE_ADDRESSABLE (type
))
1835 return targetm
.calls
.callee_copies (ca
, mode
, type
, named_arg
);
1838 /* Structures to communicate between the subroutines of assign_parms.
1839 The first holds data persistent across all parameters, the second
1840 is cleared out for each parameter. */
1842 struct assign_parm_data_all
1844 CUMULATIVE_ARGS args_so_far
;
1845 struct args_size stack_args_size
;
1846 tree function_result_decl
;
1848 rtx first_conversion_insn
;
1849 rtx last_conversion_insn
;
1850 HOST_WIDE_INT pretend_args_size
;
1851 HOST_WIDE_INT extra_pretend_bytes
;
1852 int reg_parm_stack_space
;
1855 struct assign_parm_data_one
1861 enum machine_mode nominal_mode
;
1862 enum machine_mode passed_mode
;
1863 enum machine_mode promoted_mode
;
1864 struct locate_and_pad_arg_data locate
;
1866 BOOL_BITFIELD named_arg
: 1;
1867 BOOL_BITFIELD passed_pointer
: 1;
1868 BOOL_BITFIELD on_stack
: 1;
1869 BOOL_BITFIELD loaded_in_reg
: 1;
1872 /* A subroutine of assign_parms. Initialize ALL. */
1875 assign_parms_initialize_all (struct assign_parm_data_all
*all
)
1879 memset (all
, 0, sizeof (*all
));
1881 fntype
= TREE_TYPE (current_function_decl
);
1883 #ifdef INIT_CUMULATIVE_INCOMING_ARGS
1884 INIT_CUMULATIVE_INCOMING_ARGS (all
->args_so_far
, fntype
, NULL_RTX
);
1886 INIT_CUMULATIVE_ARGS (all
->args_so_far
, fntype
, NULL_RTX
,
1887 current_function_decl
, -1);
1890 #ifdef REG_PARM_STACK_SPACE
1891 all
->reg_parm_stack_space
= REG_PARM_STACK_SPACE (current_function_decl
);
1895 /* If ARGS contains entries with complex types, split the entry into two
1896 entries of the component type. Return a new list of substitutions are
1897 needed, else the old list. */
1900 split_complex_args (tree args
)
1904 /* Before allocating memory, check for the common case of no complex. */
1905 for (p
= args
; p
; p
= TREE_CHAIN (p
))
1907 tree type
= TREE_TYPE (p
);
1908 if (TREE_CODE (type
) == COMPLEX_TYPE
1909 && targetm
.calls
.split_complex_arg (type
))
1915 args
= copy_list (args
);
1917 for (p
= args
; p
; p
= TREE_CHAIN (p
))
1919 tree type
= TREE_TYPE (p
);
1920 if (TREE_CODE (type
) == COMPLEX_TYPE
1921 && targetm
.calls
.split_complex_arg (type
))
1924 tree subtype
= TREE_TYPE (type
);
1925 bool addressable
= TREE_ADDRESSABLE (p
);
1927 /* Rewrite the PARM_DECL's type with its component. */
1928 TREE_TYPE (p
) = subtype
;
1929 DECL_ARG_TYPE (p
) = TREE_TYPE (DECL_ARG_TYPE (p
));
1930 DECL_MODE (p
) = VOIDmode
;
1931 DECL_SIZE (p
) = NULL
;
1932 DECL_SIZE_UNIT (p
) = NULL
;
1933 /* If this arg must go in memory, put it in a pseudo here.
1934 We can't allow it to go in memory as per normal parms,
1935 because the usual place might not have the imag part
1936 adjacent to the real part. */
1937 DECL_ARTIFICIAL (p
) = addressable
;
1938 DECL_IGNORED_P (p
) = addressable
;
1939 TREE_ADDRESSABLE (p
) = 0;
1942 /* Build a second synthetic decl. */
1943 decl
= build_decl (PARM_DECL
, NULL_TREE
, subtype
);
1944 DECL_ARG_TYPE (decl
) = DECL_ARG_TYPE (p
);
1945 DECL_ARTIFICIAL (decl
) = addressable
;
1946 DECL_IGNORED_P (decl
) = addressable
;
1947 layout_decl (decl
, 0);
1949 /* Splice it in; skip the new decl. */
1950 TREE_CHAIN (decl
) = TREE_CHAIN (p
);
1951 TREE_CHAIN (p
) = decl
;
1959 /* A subroutine of assign_parms. Adjust the parameter list to incorporate
1960 the hidden struct return argument, and (abi willing) complex args.
1961 Return the new parameter list. */
1964 assign_parms_augmented_arg_list (struct assign_parm_data_all
*all
)
1966 tree fndecl
= current_function_decl
;
1967 tree fntype
= TREE_TYPE (fndecl
);
1968 tree fnargs
= DECL_ARGUMENTS (fndecl
);
1970 /* If struct value address is treated as the first argument, make it so. */
1971 if (aggregate_value_p (DECL_RESULT (fndecl
), fndecl
)
1972 && ! current_function_returns_pcc_struct
1973 && targetm
.calls
.struct_value_rtx (TREE_TYPE (fndecl
), 1) == 0)
1975 tree type
= build_pointer_type (TREE_TYPE (fntype
));
1978 decl
= build_decl (PARM_DECL
, NULL_TREE
, type
);
1979 DECL_ARG_TYPE (decl
) = type
;
1980 DECL_ARTIFICIAL (decl
) = 1;
1981 DECL_IGNORED_P (decl
) = 1;
1983 TREE_CHAIN (decl
) = fnargs
;
1985 all
->function_result_decl
= decl
;
1988 all
->orig_fnargs
= fnargs
;
1990 /* If the target wants to split complex arguments into scalars, do so. */
1991 if (targetm
.calls
.split_complex_arg
)
1992 fnargs
= split_complex_args (fnargs
);
1997 /* A subroutine of assign_parms. Examine PARM and pull out type and mode
1998 data for the parameter. Incorporate ABI specifics such as pass-by-
1999 reference and type promotion. */
2002 assign_parm_find_data_types (struct assign_parm_data_all
*all
, tree parm
,
2003 struct assign_parm_data_one
*data
)
2005 tree nominal_type
, passed_type
;
2006 enum machine_mode nominal_mode
, passed_mode
, promoted_mode
;
2008 memset (data
, 0, sizeof (*data
));
2010 /* NAMED_ARG is a mis-nomer. We really mean 'non-varadic'. */
2011 if (!current_function_stdarg
)
2012 data
->named_arg
= 1; /* No varadic parms. */
2013 else if (TREE_CHAIN (parm
))
2014 data
->named_arg
= 1; /* Not the last non-varadic parm. */
2015 else if (targetm
.calls
.strict_argument_naming (&all
->args_so_far
))
2016 data
->named_arg
= 1; /* Only varadic ones are unnamed. */
2018 data
->named_arg
= 0; /* Treat as varadic. */
2020 nominal_type
= TREE_TYPE (parm
);
2021 passed_type
= DECL_ARG_TYPE (parm
);
2023 /* Look out for errors propagating this far. Also, if the parameter's
2024 type is void then its value doesn't matter. */
2025 if (TREE_TYPE (parm
) == error_mark_node
2026 /* This can happen after weird syntax errors
2027 or if an enum type is defined among the parms. */
2028 || TREE_CODE (parm
) != PARM_DECL
2029 || passed_type
== NULL
2030 || VOID_TYPE_P (nominal_type
))
2032 nominal_type
= passed_type
= void_type_node
;
2033 nominal_mode
= passed_mode
= promoted_mode
= VOIDmode
;
2037 /* Find mode of arg as it is passed, and mode of arg as it should be
2038 during execution of this function. */
2039 passed_mode
= TYPE_MODE (passed_type
);
2040 nominal_mode
= TYPE_MODE (nominal_type
);
2042 /* If the parm is to be passed as a transparent union, use the type of
2043 the first field for the tests below. We have already verified that
2044 the modes are the same. */
2045 if (TREE_CODE (passed_type
) == UNION_TYPE
2046 && TYPE_TRANSPARENT_UNION (passed_type
))
2047 passed_type
= TREE_TYPE (TYPE_FIELDS (passed_type
));
2049 /* See if this arg was passed by invisible reference. */
2050 if (pass_by_reference (&all
->args_so_far
, passed_mode
,
2051 passed_type
, data
->named_arg
))
2053 passed_type
= nominal_type
= build_pointer_type (passed_type
);
2054 data
->passed_pointer
= true;
2055 passed_mode
= nominal_mode
= Pmode
;
2058 /* Find mode as it is passed by the ABI. */
2059 promoted_mode
= passed_mode
;
2060 if (targetm
.calls
.promote_function_args (TREE_TYPE (current_function_decl
)))
2062 int unsignedp
= TYPE_UNSIGNED (passed_type
);
2063 promoted_mode
= promote_mode (passed_type
, promoted_mode
,
2068 data
->nominal_type
= nominal_type
;
2069 data
->passed_type
= passed_type
;
2070 data
->nominal_mode
= nominal_mode
;
2071 data
->passed_mode
= passed_mode
;
2072 data
->promoted_mode
= promoted_mode
;
2075 /* A subroutine of assign_parms. Invoke setup_incoming_varargs. */
2078 assign_parms_setup_varargs (struct assign_parm_data_all
*all
,
2079 struct assign_parm_data_one
*data
, bool no_rtl
)
2081 int varargs_pretend_bytes
= 0;
2083 targetm
.calls
.setup_incoming_varargs (&all
->args_so_far
,
2084 data
->promoted_mode
,
2086 &varargs_pretend_bytes
, no_rtl
);
2088 /* If the back-end has requested extra stack space, record how much is
2089 needed. Do not change pretend_args_size otherwise since it may be
2090 nonzero from an earlier partial argument. */
2091 if (varargs_pretend_bytes
> 0)
2092 all
->pretend_args_size
= varargs_pretend_bytes
;
2095 /* A subroutine of assign_parms. Set DATA->ENTRY_PARM corresponding to
2096 the incoming location of the current parameter. */
2099 assign_parm_find_entry_rtl (struct assign_parm_data_all
*all
,
2100 struct assign_parm_data_one
*data
)
2102 HOST_WIDE_INT pretend_bytes
= 0;
2106 if (data
->promoted_mode
== VOIDmode
)
2108 data
->entry_parm
= data
->stack_parm
= const0_rtx
;
2112 #ifdef FUNCTION_INCOMING_ARG
2113 entry_parm
= FUNCTION_INCOMING_ARG (all
->args_so_far
, data
->promoted_mode
,
2114 data
->passed_type
, data
->named_arg
);
2116 entry_parm
= FUNCTION_ARG (all
->args_so_far
, data
->promoted_mode
,
2117 data
->passed_type
, data
->named_arg
);
2120 if (entry_parm
== 0)
2121 data
->promoted_mode
= data
->passed_mode
;
2123 /* Determine parm's home in the stack, in case it arrives in the stack
2124 or we should pretend it did. Compute the stack position and rtx where
2125 the argument arrives and its size.
2127 There is one complexity here: If this was a parameter that would
2128 have been passed in registers, but wasn't only because it is
2129 __builtin_va_alist, we want locate_and_pad_parm to treat it as if
2130 it came in a register so that REG_PARM_STACK_SPACE isn't skipped.
2131 In this case, we call FUNCTION_ARG with NAMED set to 1 instead of 0
2132 as it was the previous time. */
2133 in_regs
= entry_parm
!= 0;
2134 #ifdef STACK_PARMS_IN_REG_PARM_AREA
2137 if (!in_regs
&& !data
->named_arg
)
2139 if (targetm
.calls
.pretend_outgoing_varargs_named (&all
->args_so_far
))
2142 #ifdef FUNCTION_INCOMING_ARG
2143 tem
= FUNCTION_INCOMING_ARG (all
->args_so_far
, data
->promoted_mode
,
2144 data
->passed_type
, true);
2146 tem
= FUNCTION_ARG (all
->args_so_far
, data
->promoted_mode
,
2147 data
->passed_type
, true);
2149 in_regs
= tem
!= NULL
;
2153 /* If this parameter was passed both in registers and in the stack, use
2154 the copy on the stack. */
2155 if (targetm
.calls
.must_pass_in_stack (data
->promoted_mode
,
2163 partial
= targetm
.calls
.arg_partial_bytes (&all
->args_so_far
,
2164 data
->promoted_mode
,
2167 data
->partial
= partial
;
2169 /* The caller might already have allocated stack space for the
2170 register parameters. */
2171 if (partial
!= 0 && all
->reg_parm_stack_space
== 0)
2173 /* Part of this argument is passed in registers and part
2174 is passed on the stack. Ask the prologue code to extend
2175 the stack part so that we can recreate the full value.
2177 PRETEND_BYTES is the size of the registers we need to store.
2178 CURRENT_FUNCTION_PRETEND_ARGS_SIZE is the amount of extra
2179 stack space that the prologue should allocate.
2181 Internally, gcc assumes that the argument pointer is aligned
2182 to STACK_BOUNDARY bits. This is used both for alignment
2183 optimizations (see init_emit) and to locate arguments that are
2184 aligned to more than PARM_BOUNDARY bits. We must preserve this
2185 invariant by rounding CURRENT_FUNCTION_PRETEND_ARGS_SIZE up to
2186 a stack boundary. */
2188 /* We assume at most one partial arg, and it must be the first
2189 argument on the stack. */
2190 gcc_assert (!all
->extra_pretend_bytes
&& !all
->pretend_args_size
);
2192 pretend_bytes
= partial
;
2193 all
->pretend_args_size
= CEIL_ROUND (pretend_bytes
, STACK_BYTES
);
2195 /* We want to align relative to the actual stack pointer, so
2196 don't include this in the stack size until later. */
2197 all
->extra_pretend_bytes
= all
->pretend_args_size
;
2201 locate_and_pad_parm (data
->promoted_mode
, data
->passed_type
, in_regs
,
2202 entry_parm
? data
->partial
: 0, current_function_decl
,
2203 &all
->stack_args_size
, &data
->locate
);
2205 /* Adjust offsets to include the pretend args. */
2206 pretend_bytes
= all
->extra_pretend_bytes
- pretend_bytes
;
2207 data
->locate
.slot_offset
.constant
+= pretend_bytes
;
2208 data
->locate
.offset
.constant
+= pretend_bytes
;
2210 data
->entry_parm
= entry_parm
;
2213 /* A subroutine of assign_parms. If there is actually space on the stack
2214 for this parm, count it in stack_args_size and return true. */
2217 assign_parm_is_stack_parm (struct assign_parm_data_all
*all
,
2218 struct assign_parm_data_one
*data
)
2220 /* Trivially true if we've no incoming register. */
2221 if (data
->entry_parm
== NULL
)
2223 /* Also true if we're partially in registers and partially not,
2224 since we've arranged to drop the entire argument on the stack. */
2225 else if (data
->partial
!= 0)
2227 /* Also true if the target says that it's passed in both registers
2228 and on the stack. */
2229 else if (GET_CODE (data
->entry_parm
) == PARALLEL
2230 && XEXP (XVECEXP (data
->entry_parm
, 0, 0), 0) == NULL_RTX
)
2232 /* Also true if the target says that there's stack allocated for
2233 all register parameters. */
2234 else if (all
->reg_parm_stack_space
> 0)
2236 /* Otherwise, no, this parameter has no ABI defined stack slot. */
2240 all
->stack_args_size
.constant
+= data
->locate
.size
.constant
;
2241 if (data
->locate
.size
.var
)
2242 ADD_PARM_SIZE (all
->stack_args_size
, data
->locate
.size
.var
);
2247 /* A subroutine of assign_parms. Given that this parameter is allocated
2248 stack space by the ABI, find it. */
2251 assign_parm_find_stack_rtl (tree parm
, struct assign_parm_data_one
*data
)
2253 rtx offset_rtx
, stack_parm
;
2254 unsigned int align
, boundary
;
2256 /* If we're passing this arg using a reg, make its stack home the
2257 aligned stack slot. */
2258 if (data
->entry_parm
)
2259 offset_rtx
= ARGS_SIZE_RTX (data
->locate
.slot_offset
);
2261 offset_rtx
= ARGS_SIZE_RTX (data
->locate
.offset
);
2263 stack_parm
= crtl
->args
.internal_arg_pointer
;
2264 if (offset_rtx
!= const0_rtx
)
2265 stack_parm
= gen_rtx_PLUS (Pmode
, stack_parm
, offset_rtx
);
2266 stack_parm
= gen_rtx_MEM (data
->promoted_mode
, stack_parm
);
2268 set_mem_attributes (stack_parm
, parm
, 1);
2270 boundary
= data
->locate
.boundary
;
2271 align
= BITS_PER_UNIT
;
2273 /* If we're padding upward, we know that the alignment of the slot
2274 is FUNCTION_ARG_BOUNDARY. If we're using slot_offset, we're
2275 intentionally forcing upward padding. Otherwise we have to come
2276 up with a guess at the alignment based on OFFSET_RTX. */
2277 if (data
->locate
.where_pad
!= downward
|| data
->entry_parm
)
2279 else if (GET_CODE (offset_rtx
) == CONST_INT
)
2281 align
= INTVAL (offset_rtx
) * BITS_PER_UNIT
| boundary
;
2282 align
= align
& -align
;
2284 set_mem_align (stack_parm
, align
);
2286 if (data
->entry_parm
)
2287 set_reg_attrs_for_parm (data
->entry_parm
, stack_parm
);
2289 data
->stack_parm
= stack_parm
;
2292 /* A subroutine of assign_parms. Adjust DATA->ENTRY_RTL such that it's
2293 always valid and contiguous. */
2296 assign_parm_adjust_entry_rtl (struct assign_parm_data_one
*data
)
2298 rtx entry_parm
= data
->entry_parm
;
2299 rtx stack_parm
= data
->stack_parm
;
2301 /* If this parm was passed part in regs and part in memory, pretend it
2302 arrived entirely in memory by pushing the register-part onto the stack.
2303 In the special case of a DImode or DFmode that is split, we could put
2304 it together in a pseudoreg directly, but for now that's not worth
2306 if (data
->partial
!= 0)
2308 /* Handle calls that pass values in multiple non-contiguous
2309 locations. The Irix 6 ABI has examples of this. */
2310 if (GET_CODE (entry_parm
) == PARALLEL
)
2311 emit_group_store (validize_mem (stack_parm
), entry_parm
,
2313 int_size_in_bytes (data
->passed_type
));
2316 gcc_assert (data
->partial
% UNITS_PER_WORD
== 0);
2317 move_block_from_reg (REGNO (entry_parm
), validize_mem (stack_parm
),
2318 data
->partial
/ UNITS_PER_WORD
);
2321 entry_parm
= stack_parm
;
2324 /* If we didn't decide this parm came in a register, by default it came
2326 else if (entry_parm
== NULL
)
2327 entry_parm
= stack_parm
;
2329 /* When an argument is passed in multiple locations, we can't make use
2330 of this information, but we can save some copying if the whole argument
2331 is passed in a single register. */
2332 else if (GET_CODE (entry_parm
) == PARALLEL
2333 && data
->nominal_mode
!= BLKmode
2334 && data
->passed_mode
!= BLKmode
)
2336 size_t i
, len
= XVECLEN (entry_parm
, 0);
2338 for (i
= 0; i
< len
; i
++)
2339 if (XEXP (XVECEXP (entry_parm
, 0, i
), 0) != NULL_RTX
2340 && REG_P (XEXP (XVECEXP (entry_parm
, 0, i
), 0))
2341 && (GET_MODE (XEXP (XVECEXP (entry_parm
, 0, i
), 0))
2342 == data
->passed_mode
)
2343 && INTVAL (XEXP (XVECEXP (entry_parm
, 0, i
), 1)) == 0)
2345 entry_parm
= XEXP (XVECEXP (entry_parm
, 0, i
), 0);
2350 data
->entry_parm
= entry_parm
;
2353 /* A subroutine of assign_parms. Adjust DATA->STACK_RTL such that it's
2354 always valid and properly aligned. */
2357 assign_parm_adjust_stack_rtl (struct assign_parm_data_one
*data
)
2359 rtx stack_parm
= data
->stack_parm
;
2361 /* If we can't trust the parm stack slot to be aligned enough for its
2362 ultimate type, don't use that slot after entry. We'll make another
2363 stack slot, if we need one. */
2365 && ((STRICT_ALIGNMENT
2366 && GET_MODE_ALIGNMENT (data
->nominal_mode
) > MEM_ALIGN (stack_parm
))
2367 || (data
->nominal_type
2368 && TYPE_ALIGN (data
->nominal_type
) > MEM_ALIGN (stack_parm
)
2369 && MEM_ALIGN (stack_parm
) < PREFERRED_STACK_BOUNDARY
)))
2372 /* If parm was passed in memory, and we need to convert it on entry,
2373 don't store it back in that same slot. */
2374 else if (data
->entry_parm
== stack_parm
2375 && data
->nominal_mode
!= BLKmode
2376 && data
->nominal_mode
!= data
->passed_mode
)
2379 /* If stack protection is in effect for this function, don't leave any
2380 pointers in their passed stack slots. */
2381 else if (crtl
->stack_protect_guard
2382 && (flag_stack_protect
== 2
2383 || data
->passed_pointer
2384 || POINTER_TYPE_P (data
->nominal_type
)))
2387 data
->stack_parm
= stack_parm
;
2390 /* A subroutine of assign_parms. Return true if the current parameter
2391 should be stored as a BLKmode in the current frame. */
2394 assign_parm_setup_block_p (struct assign_parm_data_one
*data
)
2396 if (data
->nominal_mode
== BLKmode
)
2398 if (GET_CODE (data
->entry_parm
) == PARALLEL
)
2401 #ifdef BLOCK_REG_PADDING
2402 /* Only assign_parm_setup_block knows how to deal with register arguments
2403 that are padded at the least significant end. */
2404 if (REG_P (data
->entry_parm
)
2405 && GET_MODE_SIZE (data
->promoted_mode
) < UNITS_PER_WORD
2406 && (BLOCK_REG_PADDING (data
->passed_mode
, data
->passed_type
, 1)
2407 == (BYTES_BIG_ENDIAN
? upward
: downward
)))
2414 /* A subroutine of assign_parms. Arrange for the parameter to be
2415 present and valid in DATA->STACK_RTL. */
2418 assign_parm_setup_block (struct assign_parm_data_all
*all
,
2419 tree parm
, struct assign_parm_data_one
*data
)
2421 rtx entry_parm
= data
->entry_parm
;
2422 rtx stack_parm
= data
->stack_parm
;
2424 HOST_WIDE_INT size_stored
;
2425 rtx orig_entry_parm
= entry_parm
;
2427 if (GET_CODE (entry_parm
) == PARALLEL
)
2428 entry_parm
= emit_group_move_into_temps (entry_parm
);
2430 /* If we've a non-block object that's nevertheless passed in parts,
2431 reconstitute it in register operations rather than on the stack. */
2432 if (GET_CODE (entry_parm
) == PARALLEL
2433 && data
->nominal_mode
!= BLKmode
)
2435 rtx elt0
= XEXP (XVECEXP (orig_entry_parm
, 0, 0), 0);
2437 if ((XVECLEN (entry_parm
, 0) > 1
2438 || hard_regno_nregs
[REGNO (elt0
)][GET_MODE (elt0
)] > 1)
2439 && use_register_for_decl (parm
))
2441 rtx parmreg
= gen_reg_rtx (data
->nominal_mode
);
2443 push_to_sequence2 (all
->first_conversion_insn
,
2444 all
->last_conversion_insn
);
2446 /* For values returned in multiple registers, handle possible
2447 incompatible calls to emit_group_store.
2449 For example, the following would be invalid, and would have to
2450 be fixed by the conditional below:
2452 emit_group_store ((reg:SF), (parallel:DF))
2453 emit_group_store ((reg:SI), (parallel:DI))
2455 An example of this are doubles in e500 v2:
2456 (parallel:DF (expr_list (reg:SI) (const_int 0))
2457 (expr_list (reg:SI) (const_int 4))). */
2458 if (data
->nominal_mode
!= data
->passed_mode
)
2460 rtx t
= gen_reg_rtx (GET_MODE (entry_parm
));
2461 emit_group_store (t
, entry_parm
, NULL_TREE
,
2462 GET_MODE_SIZE (GET_MODE (entry_parm
)));
2463 convert_move (parmreg
, t
, 0);
2466 emit_group_store (parmreg
, entry_parm
, data
->nominal_type
,
2467 int_size_in_bytes (data
->nominal_type
));
2469 all
->first_conversion_insn
= get_insns ();
2470 all
->last_conversion_insn
= get_last_insn ();
2473 SET_DECL_RTL (parm
, parmreg
);
2478 size
= int_size_in_bytes (data
->passed_type
);
2479 size_stored
= CEIL_ROUND (size
, UNITS_PER_WORD
);
2480 if (stack_parm
== 0)
2482 DECL_ALIGN (parm
) = MAX (DECL_ALIGN (parm
), BITS_PER_WORD
);
2483 stack_parm
= assign_stack_local (BLKmode
, size_stored
,
2485 if (GET_MODE_SIZE (GET_MODE (entry_parm
)) == size
)
2486 PUT_MODE (stack_parm
, GET_MODE (entry_parm
));
2487 set_mem_attributes (stack_parm
, parm
, 1);
2490 /* If a BLKmode arrives in registers, copy it to a stack slot. Handle
2491 calls that pass values in multiple non-contiguous locations. */
2492 if (REG_P (entry_parm
) || GET_CODE (entry_parm
) == PARALLEL
)
2496 /* Note that we will be storing an integral number of words.
2497 So we have to be careful to ensure that we allocate an
2498 integral number of words. We do this above when we call
2499 assign_stack_local if space was not allocated in the argument
2500 list. If it was, this will not work if PARM_BOUNDARY is not
2501 a multiple of BITS_PER_WORD. It isn't clear how to fix this
2502 if it becomes a problem. Exception is when BLKmode arrives
2503 with arguments not conforming to word_mode. */
2505 if (data
->stack_parm
== 0)
2507 else if (GET_CODE (entry_parm
) == PARALLEL
)
2510 gcc_assert (!size
|| !(PARM_BOUNDARY
% BITS_PER_WORD
));
2512 mem
= validize_mem (stack_parm
);
2514 /* Handle values in multiple non-contiguous locations. */
2515 if (GET_CODE (entry_parm
) == PARALLEL
)
2517 push_to_sequence2 (all
->first_conversion_insn
,
2518 all
->last_conversion_insn
);
2519 emit_group_store (mem
, entry_parm
, data
->passed_type
, size
);
2520 all
->first_conversion_insn
= get_insns ();
2521 all
->last_conversion_insn
= get_last_insn ();
2528 /* If SIZE is that of a mode no bigger than a word, just use
2529 that mode's store operation. */
2530 else if (size
<= UNITS_PER_WORD
)
2532 enum machine_mode mode
2533 = mode_for_size (size
* BITS_PER_UNIT
, MODE_INT
, 0);
2536 #ifdef BLOCK_REG_PADDING
2537 && (size
== UNITS_PER_WORD
2538 || (BLOCK_REG_PADDING (mode
, data
->passed_type
, 1)
2539 != (BYTES_BIG_ENDIAN
? upward
: downward
)))
2545 /* We are really truncating a word_mode value containing
2546 SIZE bytes into a value of mode MODE. If such an
2547 operation requires no actual instructions, we can refer
2548 to the value directly in mode MODE, otherwise we must
2549 start with the register in word_mode and explicitly
2551 if (TRULY_NOOP_TRUNCATION (size
* BITS_PER_UNIT
, BITS_PER_WORD
))
2552 reg
= gen_rtx_REG (mode
, REGNO (entry_parm
));
2555 reg
= gen_rtx_REG (word_mode
, REGNO (entry_parm
));
2556 reg
= convert_to_mode (mode
, copy_to_reg (reg
), 1);
2558 emit_move_insn (change_address (mem
, mode
, 0), reg
);
2561 /* Blocks smaller than a word on a BYTES_BIG_ENDIAN
2562 machine must be aligned to the left before storing
2563 to memory. Note that the previous test doesn't
2564 handle all cases (e.g. SIZE == 3). */
2565 else if (size
!= UNITS_PER_WORD
2566 #ifdef BLOCK_REG_PADDING
2567 && (BLOCK_REG_PADDING (mode
, data
->passed_type
, 1)
2575 int by
= (UNITS_PER_WORD
- size
) * BITS_PER_UNIT
;
2576 rtx reg
= gen_rtx_REG (word_mode
, REGNO (entry_parm
));
2578 x
= expand_shift (LSHIFT_EXPR
, word_mode
, reg
,
2579 build_int_cst (NULL_TREE
, by
),
2581 tem
= change_address (mem
, word_mode
, 0);
2582 emit_move_insn (tem
, x
);
2585 move_block_from_reg (REGNO (entry_parm
), mem
,
2586 size_stored
/ UNITS_PER_WORD
);
2589 move_block_from_reg (REGNO (entry_parm
), mem
,
2590 size_stored
/ UNITS_PER_WORD
);
2592 else if (data
->stack_parm
== 0)
2594 push_to_sequence2 (all
->first_conversion_insn
, all
->last_conversion_insn
);
2595 emit_block_move (stack_parm
, data
->entry_parm
, GEN_INT (size
),
2597 all
->first_conversion_insn
= get_insns ();
2598 all
->last_conversion_insn
= get_last_insn ();
2602 data
->stack_parm
= stack_parm
;
2603 SET_DECL_RTL (parm
, stack_parm
);
2606 /* A subroutine of assign_parms. Allocate a pseudo to hold the current
2607 parameter. Get it there. Perform all ABI specified conversions. */
2610 assign_parm_setup_reg (struct assign_parm_data_all
*all
, tree parm
,
2611 struct assign_parm_data_one
*data
)
2614 enum machine_mode promoted_nominal_mode
;
2615 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (parm
));
2616 bool did_conversion
= false;
2618 /* Store the parm in a pseudoregister during the function, but we may
2619 need to do it in a wider mode. */
2621 /* This is not really promoting for a call. However we need to be
2622 consistent with assign_parm_find_data_types and expand_expr_real_1. */
2623 promoted_nominal_mode
2624 = promote_mode (data
->nominal_type
, data
->nominal_mode
, &unsignedp
, 1);
2626 parmreg
= gen_reg_rtx (promoted_nominal_mode
);
2628 if (!DECL_ARTIFICIAL (parm
))
2629 mark_user_reg (parmreg
);
2631 /* If this was an item that we received a pointer to,
2632 set DECL_RTL appropriately. */
2633 if (data
->passed_pointer
)
2635 rtx x
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data
->passed_type
)), parmreg
);
2636 set_mem_attributes (x
, parm
, 1);
2637 SET_DECL_RTL (parm
, x
);
2640 SET_DECL_RTL (parm
, parmreg
);
2642 /* Copy the value into the register. */
2643 if (data
->nominal_mode
!= data
->passed_mode
2644 || promoted_nominal_mode
!= data
->promoted_mode
)
2648 /* ENTRY_PARM has been converted to PROMOTED_MODE, its
2649 mode, by the caller. We now have to convert it to
2650 NOMINAL_MODE, if different. However, PARMREG may be in
2651 a different mode than NOMINAL_MODE if it is being stored
2654 If ENTRY_PARM is a hard register, it might be in a register
2655 not valid for operating in its mode (e.g., an odd-numbered
2656 register for a DFmode). In that case, moves are the only
2657 thing valid, so we can't do a convert from there. This
2658 occurs when the calling sequence allow such misaligned
2661 In addition, the conversion may involve a call, which could
2662 clobber parameters which haven't been copied to pseudo
2663 registers yet. Therefore, we must first copy the parm to
2664 a pseudo reg here, and save the conversion until after all
2665 parameters have been moved. */
2667 rtx tempreg
= gen_reg_rtx (GET_MODE (data
->entry_parm
));
2669 emit_move_insn (tempreg
, validize_mem (data
->entry_parm
));
2671 push_to_sequence2 (all
->first_conversion_insn
, all
->last_conversion_insn
);
2672 tempreg
= convert_to_mode (data
->nominal_mode
, tempreg
, unsignedp
);
2674 if (GET_CODE (tempreg
) == SUBREG
2675 && GET_MODE (tempreg
) == data
->nominal_mode
2676 && REG_P (SUBREG_REG (tempreg
))
2677 && data
->nominal_mode
== data
->passed_mode
2678 && GET_MODE (SUBREG_REG (tempreg
)) == GET_MODE (data
->entry_parm
)
2679 && GET_MODE_SIZE (GET_MODE (tempreg
))
2680 < GET_MODE_SIZE (GET_MODE (data
->entry_parm
)))
2682 /* The argument is already sign/zero extended, so note it
2684 SUBREG_PROMOTED_VAR_P (tempreg
) = 1;
2685 SUBREG_PROMOTED_UNSIGNED_SET (tempreg
, unsignedp
);
2688 /* TREE_USED gets set erroneously during expand_assignment. */
2689 save_tree_used
= TREE_USED (parm
);
2690 expand_assignment (parm
, make_tree (data
->nominal_type
, tempreg
), false);
2691 TREE_USED (parm
) = save_tree_used
;
2692 all
->first_conversion_insn
= get_insns ();
2693 all
->last_conversion_insn
= get_last_insn ();
2696 did_conversion
= true;
2699 emit_move_insn (parmreg
, validize_mem (data
->entry_parm
));
2701 /* If we were passed a pointer but the actual value can safely live
2702 in a register, put it in one. */
2703 if (data
->passed_pointer
2704 && TYPE_MODE (TREE_TYPE (parm
)) != BLKmode
2705 /* If by-reference argument was promoted, demote it. */
2706 && (TYPE_MODE (TREE_TYPE (parm
)) != GET_MODE (DECL_RTL (parm
))
2707 || use_register_for_decl (parm
)))
2709 /* We can't use nominal_mode, because it will have been set to
2710 Pmode above. We must use the actual mode of the parm. */
2711 parmreg
= gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm
)));
2712 mark_user_reg (parmreg
);
2714 if (GET_MODE (parmreg
) != GET_MODE (DECL_RTL (parm
)))
2716 rtx tempreg
= gen_reg_rtx (GET_MODE (DECL_RTL (parm
)));
2717 int unsigned_p
= TYPE_UNSIGNED (TREE_TYPE (parm
));
2719 push_to_sequence2 (all
->first_conversion_insn
,
2720 all
->last_conversion_insn
);
2721 emit_move_insn (tempreg
, DECL_RTL (parm
));
2722 tempreg
= convert_to_mode (GET_MODE (parmreg
), tempreg
, unsigned_p
);
2723 emit_move_insn (parmreg
, tempreg
);
2724 all
->first_conversion_insn
= get_insns ();
2725 all
->last_conversion_insn
= get_last_insn ();
2728 did_conversion
= true;
2731 emit_move_insn (parmreg
, DECL_RTL (parm
));
2733 SET_DECL_RTL (parm
, parmreg
);
2735 /* STACK_PARM is the pointer, not the parm, and PARMREG is
2737 data
->stack_parm
= NULL
;
2740 /* Mark the register as eliminable if we did no conversion and it was
2741 copied from memory at a fixed offset, and the arg pointer was not
2742 copied to a pseudo-reg. If the arg pointer is a pseudo reg or the
2743 offset formed an invalid address, such memory-equivalences as we
2744 make here would screw up life analysis for it. */
2745 if (data
->nominal_mode
== data
->passed_mode
2747 && data
->stack_parm
!= 0
2748 && MEM_P (data
->stack_parm
)
2749 && data
->locate
.offset
.var
== 0
2750 && reg_mentioned_p (virtual_incoming_args_rtx
,
2751 XEXP (data
->stack_parm
, 0)))
2753 rtx linsn
= get_last_insn ();
2756 /* Mark complex types separately. */
2757 if (GET_CODE (parmreg
) == CONCAT
)
2759 enum machine_mode submode
2760 = GET_MODE_INNER (GET_MODE (parmreg
));
2761 int regnor
= REGNO (XEXP (parmreg
, 0));
2762 int regnoi
= REGNO (XEXP (parmreg
, 1));
2763 rtx stackr
= adjust_address_nv (data
->stack_parm
, submode
, 0);
2764 rtx stacki
= adjust_address_nv (data
->stack_parm
, submode
,
2765 GET_MODE_SIZE (submode
));
2767 /* Scan backwards for the set of the real and
2769 for (sinsn
= linsn
; sinsn
!= 0;
2770 sinsn
= prev_nonnote_insn (sinsn
))
2772 set
= single_set (sinsn
);
2776 if (SET_DEST (set
) == regno_reg_rtx
[regnoi
])
2777 set_unique_reg_note (sinsn
, REG_EQUIV
, stacki
);
2778 else if (SET_DEST (set
) == regno_reg_rtx
[regnor
])
2779 set_unique_reg_note (sinsn
, REG_EQUIV
, stackr
);
2782 else if ((set
= single_set (linsn
)) != 0
2783 && SET_DEST (set
) == parmreg
)
2784 set_unique_reg_note (linsn
, REG_EQUIV
, data
->stack_parm
);
2787 /* For pointer data type, suggest pointer register. */
2788 if (POINTER_TYPE_P (TREE_TYPE (parm
)))
2789 mark_reg_pointer (parmreg
,
2790 TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm
))));
2793 /* A subroutine of assign_parms. Allocate stack space to hold the current
2794 parameter. Get it there. Perform all ABI specified conversions. */
2797 assign_parm_setup_stack (struct assign_parm_data_all
*all
, tree parm
,
2798 struct assign_parm_data_one
*data
)
2800 /* Value must be stored in the stack slot STACK_PARM during function
2802 bool to_conversion
= false;
2804 if (data
->promoted_mode
!= data
->nominal_mode
)
2806 /* Conversion is required. */
2807 rtx tempreg
= gen_reg_rtx (GET_MODE (data
->entry_parm
));
2809 emit_move_insn (tempreg
, validize_mem (data
->entry_parm
));
2811 push_to_sequence2 (all
->first_conversion_insn
, all
->last_conversion_insn
);
2812 to_conversion
= true;
2814 data
->entry_parm
= convert_to_mode (data
->nominal_mode
, tempreg
,
2815 TYPE_UNSIGNED (TREE_TYPE (parm
)));
2817 if (data
->stack_parm
)
2818 /* ??? This may need a big-endian conversion on sparc64. */
2820 = adjust_address (data
->stack_parm
, data
->nominal_mode
, 0);
2823 if (data
->entry_parm
!= data
->stack_parm
)
2827 if (data
->stack_parm
== 0)
2830 = assign_stack_local (GET_MODE (data
->entry_parm
),
2831 GET_MODE_SIZE (GET_MODE (data
->entry_parm
)),
2832 TYPE_ALIGN (data
->passed_type
));
2833 set_mem_attributes (data
->stack_parm
, parm
, 1);
2836 dest
= validize_mem (data
->stack_parm
);
2837 src
= validize_mem (data
->entry_parm
);
2841 /* Use a block move to handle potentially misaligned entry_parm. */
2843 push_to_sequence2 (all
->first_conversion_insn
,
2844 all
->last_conversion_insn
);
2845 to_conversion
= true;
2847 emit_block_move (dest
, src
,
2848 GEN_INT (int_size_in_bytes (data
->passed_type
)),
2852 emit_move_insn (dest
, src
);
2857 all
->first_conversion_insn
= get_insns ();
2858 all
->last_conversion_insn
= get_last_insn ();
2862 SET_DECL_RTL (parm
, data
->stack_parm
);
2865 /* A subroutine of assign_parms. If the ABI splits complex arguments, then
2866 undo the frobbing that we did in assign_parms_augmented_arg_list. */
2869 assign_parms_unsplit_complex (struct assign_parm_data_all
*all
, tree fnargs
)
2872 tree orig_fnargs
= all
->orig_fnargs
;
2874 for (parm
= orig_fnargs
; parm
; parm
= TREE_CHAIN (parm
))
2876 if (TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
2877 && targetm
.calls
.split_complex_arg (TREE_TYPE (parm
)))
2879 rtx tmp
, real
, imag
;
2880 enum machine_mode inner
= GET_MODE_INNER (DECL_MODE (parm
));
2882 real
= DECL_RTL (fnargs
);
2883 imag
= DECL_RTL (TREE_CHAIN (fnargs
));
2884 if (inner
!= GET_MODE (real
))
2886 real
= gen_lowpart_SUBREG (inner
, real
);
2887 imag
= gen_lowpart_SUBREG (inner
, imag
);
2890 if (TREE_ADDRESSABLE (parm
))
2893 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (parm
));
2895 /* split_complex_arg put the real and imag parts in
2896 pseudos. Move them to memory. */
2897 tmp
= assign_stack_local (DECL_MODE (parm
), size
,
2898 TYPE_ALIGN (TREE_TYPE (parm
)));
2899 set_mem_attributes (tmp
, parm
, 1);
2900 rmem
= adjust_address_nv (tmp
, inner
, 0);
2901 imem
= adjust_address_nv (tmp
, inner
, GET_MODE_SIZE (inner
));
2902 push_to_sequence2 (all
->first_conversion_insn
,
2903 all
->last_conversion_insn
);
2904 emit_move_insn (rmem
, real
);
2905 emit_move_insn (imem
, imag
);
2906 all
->first_conversion_insn
= get_insns ();
2907 all
->last_conversion_insn
= get_last_insn ();
2911 tmp
= gen_rtx_CONCAT (DECL_MODE (parm
), real
, imag
);
2912 SET_DECL_RTL (parm
, tmp
);
2914 real
= DECL_INCOMING_RTL (fnargs
);
2915 imag
= DECL_INCOMING_RTL (TREE_CHAIN (fnargs
));
2916 if (inner
!= GET_MODE (real
))
2918 real
= gen_lowpart_SUBREG (inner
, real
);
2919 imag
= gen_lowpart_SUBREG (inner
, imag
);
2921 tmp
= gen_rtx_CONCAT (DECL_MODE (parm
), real
, imag
);
2922 set_decl_incoming_rtl (parm
, tmp
, false);
2923 fnargs
= TREE_CHAIN (fnargs
);
2927 SET_DECL_RTL (parm
, DECL_RTL (fnargs
));
2928 set_decl_incoming_rtl (parm
, DECL_INCOMING_RTL (fnargs
), false);
2930 /* Set MEM_EXPR to the original decl, i.e. to PARM,
2931 instead of the copy of decl, i.e. FNARGS. */
2932 if (DECL_INCOMING_RTL (parm
) && MEM_P (DECL_INCOMING_RTL (parm
)))
2933 set_mem_expr (DECL_INCOMING_RTL (parm
), parm
);
2936 fnargs
= TREE_CHAIN (fnargs
);
2940 /* Assign RTL expressions to the function's parameters. This may involve
2941 copying them into registers and using those registers as the DECL_RTL. */
2944 assign_parms (tree fndecl
)
2946 struct assign_parm_data_all all
;
2949 crtl
->args
.internal_arg_pointer
2950 = targetm
.calls
.internal_arg_pointer ();
2952 assign_parms_initialize_all (&all
);
2953 fnargs
= assign_parms_augmented_arg_list (&all
);
2955 for (parm
= fnargs
; parm
; parm
= TREE_CHAIN (parm
))
2957 struct assign_parm_data_one data
;
2959 /* Extract the type of PARM; adjust it according to ABI. */
2960 assign_parm_find_data_types (&all
, parm
, &data
);
2962 /* Early out for errors and void parameters. */
2963 if (data
.passed_mode
== VOIDmode
)
2965 SET_DECL_RTL (parm
, const0_rtx
);
2966 DECL_INCOMING_RTL (parm
) = DECL_RTL (parm
);
2970 if (current_function_stdarg
&& !TREE_CHAIN (parm
))
2971 assign_parms_setup_varargs (&all
, &data
, false);
2973 /* Find out where the parameter arrives in this function. */
2974 assign_parm_find_entry_rtl (&all
, &data
);
2976 /* Find out where stack space for this parameter might be. */
2977 if (assign_parm_is_stack_parm (&all
, &data
))
2979 assign_parm_find_stack_rtl (parm
, &data
);
2980 assign_parm_adjust_entry_rtl (&data
);
2983 /* Record permanently how this parm was passed. */
2984 set_decl_incoming_rtl (parm
, data
.entry_parm
, data
.passed_pointer
);
2986 /* Update info on where next arg arrives in registers. */
2987 FUNCTION_ARG_ADVANCE (all
.args_so_far
, data
.promoted_mode
,
2988 data
.passed_type
, data
.named_arg
);
2990 assign_parm_adjust_stack_rtl (&data
);
2992 if (assign_parm_setup_block_p (&data
))
2993 assign_parm_setup_block (&all
, parm
, &data
);
2994 else if (data
.passed_pointer
|| use_register_for_decl (parm
))
2995 assign_parm_setup_reg (&all
, parm
, &data
);
2997 assign_parm_setup_stack (&all
, parm
, &data
);
3000 if (targetm
.calls
.split_complex_arg
&& fnargs
!= all
.orig_fnargs
)
3001 assign_parms_unsplit_complex (&all
, fnargs
);
3003 /* Output all parameter conversion instructions (possibly including calls)
3004 now that all parameters have been copied out of hard registers. */
3005 emit_insn (all
.first_conversion_insn
);
3007 /* If we are receiving a struct value address as the first argument, set up
3008 the RTL for the function result. As this might require code to convert
3009 the transmitted address to Pmode, we do this here to ensure that possible
3010 preliminary conversions of the address have been emitted already. */
3011 if (all
.function_result_decl
)
3013 tree result
= DECL_RESULT (current_function_decl
);
3014 rtx addr
= DECL_RTL (all
.function_result_decl
);
3017 if (DECL_BY_REFERENCE (result
))
3021 addr
= convert_memory_address (Pmode
, addr
);
3022 x
= gen_rtx_MEM (DECL_MODE (result
), addr
);
3023 set_mem_attributes (x
, result
, 1);
3025 SET_DECL_RTL (result
, x
);
3028 /* We have aligned all the args, so add space for the pretend args. */
3029 crtl
->args
.pretend_args_size
= all
.pretend_args_size
;
3030 all
.stack_args_size
.constant
+= all
.extra_pretend_bytes
;
3031 crtl
->args
.size
= all
.stack_args_size
.constant
;
3033 /* Adjust function incoming argument size for alignment and
3036 #ifdef REG_PARM_STACK_SPACE
3037 crtl
->args
.size
= MAX (crtl
->args
.size
,
3038 REG_PARM_STACK_SPACE (fndecl
));
3041 crtl
->args
.size
= CEIL_ROUND (crtl
->args
.size
,
3042 PARM_BOUNDARY
/ BITS_PER_UNIT
);
3044 #ifdef ARGS_GROW_DOWNWARD
3045 crtl
->args
.arg_offset_rtx
3046 = (all
.stack_args_size
.var
== 0 ? GEN_INT (-all
.stack_args_size
.constant
)
3047 : expand_expr (size_diffop (all
.stack_args_size
.var
,
3048 size_int (-all
.stack_args_size
.constant
)),
3049 NULL_RTX
, VOIDmode
, 0));
3051 crtl
->args
.arg_offset_rtx
= ARGS_SIZE_RTX (all
.stack_args_size
);
3054 /* See how many bytes, if any, of its args a function should try to pop
3057 crtl
->args
.pops_args
= RETURN_POPS_ARGS (fndecl
, TREE_TYPE (fndecl
),
3060 /* For stdarg.h function, save info about
3061 regs and stack space used by the named args. */
3063 crtl
->args
.info
= all
.args_so_far
;
3065 /* Set the rtx used for the function return value. Put this in its
3066 own variable so any optimizers that need this information don't have
3067 to include tree.h. Do this here so it gets done when an inlined
3068 function gets output. */
3071 = (DECL_RTL_SET_P (DECL_RESULT (fndecl
))
3072 ? DECL_RTL (DECL_RESULT (fndecl
)) : NULL_RTX
);
3074 /* If scalar return value was computed in a pseudo-reg, or was a named
3075 return value that got dumped to the stack, copy that to the hard
3077 if (DECL_RTL_SET_P (DECL_RESULT (fndecl
)))
3079 tree decl_result
= DECL_RESULT (fndecl
);
3080 rtx decl_rtl
= DECL_RTL (decl_result
);
3082 if (REG_P (decl_rtl
)
3083 ? REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
3084 : DECL_REGISTER (decl_result
))
3088 real_decl_rtl
= targetm
.calls
.function_value (TREE_TYPE (decl_result
),
3090 REG_FUNCTION_VALUE_P (real_decl_rtl
) = 1;
3091 /* The delay slot scheduler assumes that crtl->return_rtx
3092 holds the hard register containing the return value, not a
3093 temporary pseudo. */
3094 crtl
->return_rtx
= real_decl_rtl
;
3099 /* A subroutine of gimplify_parameters, invoked via walk_tree.
3100 For all seen types, gimplify their sizes. */
3103 gimplify_parm_type (tree
*tp
, int *walk_subtrees
, void *data
)
3110 if (POINTER_TYPE_P (t
))
3112 else if (TYPE_SIZE (t
) && !TREE_CONSTANT (TYPE_SIZE (t
))
3113 && !TYPE_SIZES_GIMPLIFIED (t
))
3115 gimplify_type_sizes (t
, (tree
*) data
);
3123 /* Gimplify the parameter list for current_function_decl. This involves
3124 evaluating SAVE_EXPRs of variable sized parameters and generating code
3125 to implement callee-copies reference parameters. Returns a list of
3126 statements to add to the beginning of the function, or NULL if nothing
3130 gimplify_parameters (void)
3132 struct assign_parm_data_all all
;
3133 tree fnargs
, parm
, stmts
= NULL
;
3135 assign_parms_initialize_all (&all
);
3136 fnargs
= assign_parms_augmented_arg_list (&all
);
3138 for (parm
= fnargs
; parm
; parm
= TREE_CHAIN (parm
))
3140 struct assign_parm_data_one data
;
3142 /* Extract the type of PARM; adjust it according to ABI. */
3143 assign_parm_find_data_types (&all
, parm
, &data
);
3145 /* Early out for errors and void parameters. */
3146 if (data
.passed_mode
== VOIDmode
|| DECL_SIZE (parm
) == NULL
)
3149 /* Update info on where next arg arrives in registers. */
3150 FUNCTION_ARG_ADVANCE (all
.args_so_far
, data
.promoted_mode
,
3151 data
.passed_type
, data
.named_arg
);
3153 /* ??? Once upon a time variable_size stuffed parameter list
3154 SAVE_EXPRs (amongst others) onto a pending sizes list. This
3155 turned out to be less than manageable in the gimple world.
3156 Now we have to hunt them down ourselves. */
3157 walk_tree_without_duplicates (&data
.passed_type
,
3158 gimplify_parm_type
, &stmts
);
3160 if (!TREE_CONSTANT (DECL_SIZE (parm
)))
3162 gimplify_one_sizepos (&DECL_SIZE (parm
), &stmts
);
3163 gimplify_one_sizepos (&DECL_SIZE_UNIT (parm
), &stmts
);
3166 if (data
.passed_pointer
)
3168 tree type
= TREE_TYPE (data
.passed_type
);
3169 if (reference_callee_copied (&all
.args_so_far
, TYPE_MODE (type
),
3170 type
, data
.named_arg
))
3174 /* For constant sized objects, this is trivial; for
3175 variable-sized objects, we have to play games. */
3176 if (TREE_CONSTANT (DECL_SIZE (parm
)))
3178 local
= create_tmp_var (type
, get_name (parm
));
3179 DECL_IGNORED_P (local
) = 0;
3183 tree ptr_type
, addr
;
3185 ptr_type
= build_pointer_type (type
);
3186 addr
= create_tmp_var (ptr_type
, get_name (parm
));
3187 DECL_IGNORED_P (addr
) = 0;
3188 local
= build_fold_indirect_ref (addr
);
3190 t
= built_in_decls
[BUILT_IN_ALLOCA
];
3191 t
= build_call_expr (t
, 1, DECL_SIZE_UNIT (parm
));
3192 t
= fold_convert (ptr_type
, t
);
3193 t
= build_gimple_modify_stmt (addr
, t
);
3194 gimplify_and_add (t
, &stmts
);
3197 t
= build_gimple_modify_stmt (local
, parm
);
3198 gimplify_and_add (t
, &stmts
);
3200 SET_DECL_VALUE_EXPR (parm
, local
);
3201 DECL_HAS_VALUE_EXPR_P (parm
) = 1;
3209 /* Compute the size and offset from the start of the stacked arguments for a
3210 parm passed in mode PASSED_MODE and with type TYPE.
3212 INITIAL_OFFSET_PTR points to the current offset into the stacked
3215 The starting offset and size for this parm are returned in
3216 LOCATE->OFFSET and LOCATE->SIZE, respectively. When IN_REGS is
3217 nonzero, the offset is that of stack slot, which is returned in
3218 LOCATE->SLOT_OFFSET. LOCATE->ALIGNMENT_PAD is the amount of
3219 padding required from the initial offset ptr to the stack slot.
3221 IN_REGS is nonzero if the argument will be passed in registers. It will
3222 never be set if REG_PARM_STACK_SPACE is not defined.
3224 FNDECL is the function in which the argument was defined.
3226 There are two types of rounding that are done. The first, controlled by
3227 FUNCTION_ARG_BOUNDARY, forces the offset from the start of the argument
3228 list to be aligned to the specific boundary (in bits). This rounding
3229 affects the initial and starting offsets, but not the argument size.
3231 The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY,
3232 optionally rounds the size of the parm to PARM_BOUNDARY. The
3233 initial offset is not affected by this rounding, while the size always
3234 is and the starting offset may be. */
3236 /* LOCATE->OFFSET will be negative for ARGS_GROW_DOWNWARD case;
3237 INITIAL_OFFSET_PTR is positive because locate_and_pad_parm's
3238 callers pass in the total size of args so far as
3239 INITIAL_OFFSET_PTR. LOCATE->SIZE is always positive. */
3242 locate_and_pad_parm (enum machine_mode passed_mode
, tree type
, int in_regs
,
3243 int partial
, tree fndecl ATTRIBUTE_UNUSED
,
3244 struct args_size
*initial_offset_ptr
,
3245 struct locate_and_pad_arg_data
*locate
)
3248 enum direction where_pad
;
3249 unsigned int boundary
;
3250 int reg_parm_stack_space
= 0;
3251 int part_size_in_regs
;
3253 #ifdef REG_PARM_STACK_SPACE
3254 reg_parm_stack_space
= REG_PARM_STACK_SPACE (fndecl
);
3256 /* If we have found a stack parm before we reach the end of the
3257 area reserved for registers, skip that area. */
3260 if (reg_parm_stack_space
> 0)
3262 if (initial_offset_ptr
->var
)
3264 initial_offset_ptr
->var
3265 = size_binop (MAX_EXPR
, ARGS_SIZE_TREE (*initial_offset_ptr
),
3266 ssize_int (reg_parm_stack_space
));
3267 initial_offset_ptr
->constant
= 0;
3269 else if (initial_offset_ptr
->constant
< reg_parm_stack_space
)
3270 initial_offset_ptr
->constant
= reg_parm_stack_space
;
3273 #endif /* REG_PARM_STACK_SPACE */
3275 part_size_in_regs
= (reg_parm_stack_space
== 0 ? partial
: 0);
3278 = type
? size_in_bytes (type
) : size_int (GET_MODE_SIZE (passed_mode
));
3279 where_pad
= FUNCTION_ARG_PADDING (passed_mode
, type
);
3280 boundary
= FUNCTION_ARG_BOUNDARY (passed_mode
, type
);
3281 locate
->where_pad
= where_pad
;
3282 locate
->boundary
= boundary
;
3284 /* Remember if the outgoing parameter requires extra alignment on the
3285 calling function side. */
3286 if (boundary
> PREFERRED_STACK_BOUNDARY
)
3287 boundary
= PREFERRED_STACK_BOUNDARY
;
3288 if (crtl
->stack_alignment_needed
< boundary
)
3289 crtl
->stack_alignment_needed
= boundary
;
3291 #ifdef ARGS_GROW_DOWNWARD
3292 locate
->slot_offset
.constant
= -initial_offset_ptr
->constant
;
3293 if (initial_offset_ptr
->var
)
3294 locate
->slot_offset
.var
= size_binop (MINUS_EXPR
, ssize_int (0),
3295 initial_offset_ptr
->var
);
3299 if (where_pad
!= none
3300 && (!host_integerp (sizetree
, 1)
3301 || (tree_low_cst (sizetree
, 1) * BITS_PER_UNIT
) % PARM_BOUNDARY
))
3302 s2
= round_up (s2
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
3303 SUB_PARM_SIZE (locate
->slot_offset
, s2
);
3306 locate
->slot_offset
.constant
+= part_size_in_regs
;
3309 #ifdef REG_PARM_STACK_SPACE
3310 || REG_PARM_STACK_SPACE (fndecl
) > 0
3313 pad_to_arg_alignment (&locate
->slot_offset
, boundary
,
3314 &locate
->alignment_pad
);
3316 locate
->size
.constant
= (-initial_offset_ptr
->constant
3317 - locate
->slot_offset
.constant
);
3318 if (initial_offset_ptr
->var
)
3319 locate
->size
.var
= size_binop (MINUS_EXPR
,
3320 size_binop (MINUS_EXPR
,
3322 initial_offset_ptr
->var
),
3323 locate
->slot_offset
.var
);
3325 /* Pad_below needs the pre-rounded size to know how much to pad
3327 locate
->offset
= locate
->slot_offset
;
3328 if (where_pad
== downward
)
3329 pad_below (&locate
->offset
, passed_mode
, sizetree
);
3331 #else /* !ARGS_GROW_DOWNWARD */
3333 #ifdef REG_PARM_STACK_SPACE
3334 || REG_PARM_STACK_SPACE (fndecl
) > 0
3337 pad_to_arg_alignment (initial_offset_ptr
, boundary
,
3338 &locate
->alignment_pad
);
3339 locate
->slot_offset
= *initial_offset_ptr
;
3341 #ifdef PUSH_ROUNDING
3342 if (passed_mode
!= BLKmode
)
3343 sizetree
= size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree
)));
3346 /* Pad_below needs the pre-rounded size to know how much to pad below
3347 so this must be done before rounding up. */
3348 locate
->offset
= locate
->slot_offset
;
3349 if (where_pad
== downward
)
3350 pad_below (&locate
->offset
, passed_mode
, sizetree
);
3352 if (where_pad
!= none
3353 && (!host_integerp (sizetree
, 1)
3354 || (tree_low_cst (sizetree
, 1) * BITS_PER_UNIT
) % PARM_BOUNDARY
))
3355 sizetree
= round_up (sizetree
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
3357 ADD_PARM_SIZE (locate
->size
, sizetree
);
3359 locate
->size
.constant
-= part_size_in_regs
;
3360 #endif /* ARGS_GROW_DOWNWARD */
3363 /* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY.
3364 BOUNDARY is measured in bits, but must be a multiple of a storage unit. */
3367 pad_to_arg_alignment (struct args_size
*offset_ptr
, int boundary
,
3368 struct args_size
*alignment_pad
)
3370 tree save_var
= NULL_TREE
;
3371 HOST_WIDE_INT save_constant
= 0;
3372 int boundary_in_bytes
= boundary
/ BITS_PER_UNIT
;
3373 HOST_WIDE_INT sp_offset
= STACK_POINTER_OFFSET
;
3375 #ifdef SPARC_STACK_BOUNDARY_HACK
3376 /* ??? The SPARC port may claim a STACK_BOUNDARY higher than
3377 the real alignment of %sp. However, when it does this, the
3378 alignment of %sp+STACK_POINTER_OFFSET is STACK_BOUNDARY. */
3379 if (SPARC_STACK_BOUNDARY_HACK
)
3383 if (boundary
> PARM_BOUNDARY
)
3385 save_var
= offset_ptr
->var
;
3386 save_constant
= offset_ptr
->constant
;
3389 alignment_pad
->var
= NULL_TREE
;
3390 alignment_pad
->constant
= 0;
3392 if (boundary
> BITS_PER_UNIT
)
3394 if (offset_ptr
->var
)
3396 tree sp_offset_tree
= ssize_int (sp_offset
);
3397 tree offset
= size_binop (PLUS_EXPR
,
3398 ARGS_SIZE_TREE (*offset_ptr
),
3400 #ifdef ARGS_GROW_DOWNWARD
3401 tree rounded
= round_down (offset
, boundary
/ BITS_PER_UNIT
);
3403 tree rounded
= round_up (offset
, boundary
/ BITS_PER_UNIT
);
3406 offset_ptr
->var
= size_binop (MINUS_EXPR
, rounded
, sp_offset_tree
);
3407 /* ARGS_SIZE_TREE includes constant term. */
3408 offset_ptr
->constant
= 0;
3409 if (boundary
> PARM_BOUNDARY
)
3410 alignment_pad
->var
= size_binop (MINUS_EXPR
, offset_ptr
->var
,
3415 offset_ptr
->constant
= -sp_offset
+
3416 #ifdef ARGS_GROW_DOWNWARD
3417 FLOOR_ROUND (offset_ptr
->constant
+ sp_offset
, boundary_in_bytes
);
3419 CEIL_ROUND (offset_ptr
->constant
+ sp_offset
, boundary_in_bytes
);
3421 if (boundary
> PARM_BOUNDARY
)
3422 alignment_pad
->constant
= offset_ptr
->constant
- save_constant
;
3428 pad_below (struct args_size
*offset_ptr
, enum machine_mode passed_mode
, tree sizetree
)
3430 if (passed_mode
!= BLKmode
)
3432 if (GET_MODE_BITSIZE (passed_mode
) % PARM_BOUNDARY
)
3433 offset_ptr
->constant
3434 += (((GET_MODE_BITSIZE (passed_mode
) + PARM_BOUNDARY
- 1)
3435 / PARM_BOUNDARY
* PARM_BOUNDARY
/ BITS_PER_UNIT
)
3436 - GET_MODE_SIZE (passed_mode
));
3440 if (TREE_CODE (sizetree
) != INTEGER_CST
3441 || (TREE_INT_CST_LOW (sizetree
) * BITS_PER_UNIT
) % PARM_BOUNDARY
)
3443 /* Round the size up to multiple of PARM_BOUNDARY bits. */
3444 tree s2
= round_up (sizetree
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
3446 ADD_PARM_SIZE (*offset_ptr
, s2
);
3447 SUB_PARM_SIZE (*offset_ptr
, sizetree
);
3453 /* True if register REGNO was alive at a place where `setjmp' was
3454 called and was set more than once or is an argument. Such regs may
3455 be clobbered by `longjmp'. */
3458 regno_clobbered_at_setjmp (bitmap setjmp_crosses
, int regno
)
3460 /* There appear to be cases where some local vars never reach the
3461 backend but have bogus regnos. */
3462 if (regno
>= max_reg_num ())
3465 return ((REG_N_SETS (regno
) > 1
3466 || REGNO_REG_SET_P (df_get_live_out (ENTRY_BLOCK_PTR
), regno
))
3467 && REGNO_REG_SET_P (setjmp_crosses
, regno
));
3470 /* Walk the tree of blocks describing the binding levels within a
3471 function and warn about variables the might be killed by setjmp or
3472 vfork. This is done after calling flow_analysis before register
3473 allocation since that will clobber the pseudo-regs to hard
3477 setjmp_vars_warning (bitmap setjmp_crosses
, tree block
)
3481 for (decl
= BLOCK_VARS (block
); decl
; decl
= TREE_CHAIN (decl
))
3483 if (TREE_CODE (decl
) == VAR_DECL
3484 && DECL_RTL_SET_P (decl
)
3485 && REG_P (DECL_RTL (decl
))
3486 && regno_clobbered_at_setjmp (setjmp_crosses
, REGNO (DECL_RTL (decl
))))
3487 warning (OPT_Wclobbered
, "variable %q+D might be clobbered by"
3488 " %<longjmp%> or %<vfork%>", decl
);
3491 for (sub
= BLOCK_SUBBLOCKS (block
); sub
; sub
= BLOCK_CHAIN (sub
))
3492 setjmp_vars_warning (setjmp_crosses
, sub
);
3495 /* Do the appropriate part of setjmp_vars_warning
3496 but for arguments instead of local variables. */
3499 setjmp_args_warning (bitmap setjmp_crosses
)
3502 for (decl
= DECL_ARGUMENTS (current_function_decl
);
3503 decl
; decl
= TREE_CHAIN (decl
))
3504 if (DECL_RTL (decl
) != 0
3505 && REG_P (DECL_RTL (decl
))
3506 && regno_clobbered_at_setjmp (setjmp_crosses
, REGNO (DECL_RTL (decl
))))
3507 warning (OPT_Wclobbered
,
3508 "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>",
3512 /* Generate warning messages for variables live across setjmp. */
3515 generate_setjmp_warnings (void)
3517 bitmap setjmp_crosses
= regstat_get_setjmp_crosses ();
3519 if (n_basic_blocks
== NUM_FIXED_BLOCKS
3520 || bitmap_empty_p (setjmp_crosses
))
3523 setjmp_vars_warning (setjmp_crosses
, DECL_INITIAL (current_function_decl
));
3524 setjmp_args_warning (setjmp_crosses
);
3528 /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
3529 and create duplicate blocks. */
3530 /* ??? Need an option to either create block fragments or to create
3531 abstract origin duplicates of a source block. It really depends
3532 on what optimization has been performed. */
3535 reorder_blocks (void)
3537 tree block
= DECL_INITIAL (current_function_decl
);
3538 VEC(tree
,heap
) *block_stack
;
3540 if (block
== NULL_TREE
)
3543 block_stack
= VEC_alloc (tree
, heap
, 10);
3545 /* Reset the TREE_ASM_WRITTEN bit for all blocks. */
3546 clear_block_marks (block
);
3548 /* Prune the old trees away, so that they don't get in the way. */
3549 BLOCK_SUBBLOCKS (block
) = NULL_TREE
;
3550 BLOCK_CHAIN (block
) = NULL_TREE
;
3552 /* Recreate the block tree from the note nesting. */
3553 reorder_blocks_1 (get_insns (), block
, &block_stack
);
3554 BLOCK_SUBBLOCKS (block
) = blocks_nreverse (BLOCK_SUBBLOCKS (block
));
3556 VEC_free (tree
, heap
, block_stack
);
3559 /* Helper function for reorder_blocks. Reset TREE_ASM_WRITTEN. */
3562 clear_block_marks (tree block
)
3566 TREE_ASM_WRITTEN (block
) = 0;
3567 clear_block_marks (BLOCK_SUBBLOCKS (block
));
3568 block
= BLOCK_CHAIN (block
);
3573 reorder_blocks_1 (rtx insns
, tree current_block
, VEC(tree
,heap
) **p_block_stack
)
3577 for (insn
= insns
; insn
; insn
= NEXT_INSN (insn
))
3581 if (NOTE_KIND (insn
) == NOTE_INSN_BLOCK_BEG
)
3583 tree block
= NOTE_BLOCK (insn
);
3586 origin
= (BLOCK_FRAGMENT_ORIGIN (block
)
3587 ? BLOCK_FRAGMENT_ORIGIN (block
)
3590 /* If we have seen this block before, that means it now
3591 spans multiple address regions. Create a new fragment. */
3592 if (TREE_ASM_WRITTEN (block
))
3594 tree new_block
= copy_node (block
);
3596 BLOCK_FRAGMENT_ORIGIN (new_block
) = origin
;
3597 BLOCK_FRAGMENT_CHAIN (new_block
)
3598 = BLOCK_FRAGMENT_CHAIN (origin
);
3599 BLOCK_FRAGMENT_CHAIN (origin
) = new_block
;
3601 NOTE_BLOCK (insn
) = new_block
;
3605 BLOCK_SUBBLOCKS (block
) = 0;
3606 TREE_ASM_WRITTEN (block
) = 1;
3607 /* When there's only one block for the entire function,
3608 current_block == block and we mustn't do this, it
3609 will cause infinite recursion. */
3610 if (block
!= current_block
)
3612 if (block
!= origin
)
3613 gcc_assert (BLOCK_SUPERCONTEXT (origin
) == current_block
);
3615 BLOCK_SUPERCONTEXT (block
) = current_block
;
3616 BLOCK_CHAIN (block
) = BLOCK_SUBBLOCKS (current_block
);
3617 BLOCK_SUBBLOCKS (current_block
) = block
;
3618 current_block
= origin
;
3620 VEC_safe_push (tree
, heap
, *p_block_stack
, block
);
3622 else if (NOTE_KIND (insn
) == NOTE_INSN_BLOCK_END
)
3624 NOTE_BLOCK (insn
) = VEC_pop (tree
, *p_block_stack
);
3625 BLOCK_SUBBLOCKS (current_block
)
3626 = blocks_nreverse (BLOCK_SUBBLOCKS (current_block
));
3627 current_block
= BLOCK_SUPERCONTEXT (current_block
);
3633 /* Reverse the order of elements in the chain T of blocks,
3634 and return the new head of the chain (old last element). */
3637 blocks_nreverse (tree t
)
3639 tree prev
= 0, decl
, next
;
3640 for (decl
= t
; decl
; decl
= next
)
3642 next
= BLOCK_CHAIN (decl
);
3643 BLOCK_CHAIN (decl
) = prev
;
3649 /* Count the subblocks of the list starting with BLOCK. If VECTOR is
3650 non-NULL, list them all into VECTOR, in a depth-first preorder
3651 traversal of the block tree. Also clear TREE_ASM_WRITTEN in all
3655 all_blocks (tree block
, tree
*vector
)
3661 TREE_ASM_WRITTEN (block
) = 0;
3663 /* Record this block. */
3665 vector
[n_blocks
] = block
;
3669 /* Record the subblocks, and their subblocks... */
3670 n_blocks
+= all_blocks (BLOCK_SUBBLOCKS (block
),
3671 vector
? vector
+ n_blocks
: 0);
3672 block
= BLOCK_CHAIN (block
);
3678 /* Return a vector containing all the blocks rooted at BLOCK. The
3679 number of elements in the vector is stored in N_BLOCKS_P. The
3680 vector is dynamically allocated; it is the caller's responsibility
3681 to call `free' on the pointer returned. */
3684 get_block_vector (tree block
, int *n_blocks_p
)
3688 *n_blocks_p
= all_blocks (block
, NULL
);
3689 block_vector
= XNEWVEC (tree
, *n_blocks_p
);
3690 all_blocks (block
, block_vector
);
3692 return block_vector
;
3695 static GTY(()) int next_block_index
= 2;
3697 /* Set BLOCK_NUMBER for all the blocks in FN. */
3700 number_blocks (tree fn
)
3706 /* For SDB and XCOFF debugging output, we start numbering the blocks
3707 from 1 within each function, rather than keeping a running
3709 #if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
3710 if (write_symbols
== SDB_DEBUG
|| write_symbols
== XCOFF_DEBUG
)
3711 next_block_index
= 1;
3714 block_vector
= get_block_vector (DECL_INITIAL (fn
), &n_blocks
);
3716 /* The top-level BLOCK isn't numbered at all. */
3717 for (i
= 1; i
< n_blocks
; ++i
)
3718 /* We number the blocks from two. */
3719 BLOCK_NUMBER (block_vector
[i
]) = next_block_index
++;
3721 free (block_vector
);
3726 /* If VAR is present in a subblock of BLOCK, return the subblock. */
3729 debug_find_var_in_block_tree (tree var
, tree block
)
3733 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
3737 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= TREE_CHAIN (t
))
3739 tree ret
= debug_find_var_in_block_tree (var
, t
);
3747 /* Keep track of whether we're in a dummy function context. If we are,
3748 we don't want to invoke the set_current_function hook, because we'll
3749 get into trouble if the hook calls target_reinit () recursively or
3750 when the initial initialization is not yet complete. */
3752 static bool in_dummy_function
;
3754 /* Invoke the target hook when setting cfun. */
3757 invoke_set_current_function_hook (tree fndecl
)
3759 if (!in_dummy_function
)
3760 targetm
.set_current_function (fndecl
);
3763 /* cfun should never be set directly; use this function. */
3766 set_cfun (struct function
*new_cfun
)
3768 if (cfun
!= new_cfun
)
3771 invoke_set_current_function_hook (new_cfun
? new_cfun
->decl
: NULL_TREE
);
3775 /* Keep track of the cfun stack. */
3777 typedef struct function
*function_p
;
3779 DEF_VEC_P(function_p
);
3780 DEF_VEC_ALLOC_P(function_p
,heap
);
3782 /* Initialized with NOGC, making this poisonous to the garbage collector. */
3784 static VEC(function_p
,heap
) *cfun_stack
;
3786 /* We save the value of in_system_header here when pushing the first
3787 function on the cfun stack, and we restore it from here when
3788 popping the last function. */
3790 static bool saved_in_system_header
;
3792 /* Push the current cfun onto the stack, and set cfun to new_cfun. */
3795 push_cfun (struct function
*new_cfun
)
3798 saved_in_system_header
= in_system_header
;
3799 VEC_safe_push (function_p
, heap
, cfun_stack
, cfun
);
3801 in_system_header
= DECL_IN_SYSTEM_HEADER (new_cfun
->decl
);
3802 set_cfun (new_cfun
);
3805 /* Pop cfun from the stack. */
3810 struct function
*new_cfun
= VEC_pop (function_p
, cfun_stack
);
3811 in_system_header
= ((new_cfun
== NULL
) ? saved_in_system_header
3812 : DECL_IN_SYSTEM_HEADER (new_cfun
->decl
));
3813 set_cfun (new_cfun
);
3816 /* Return value of funcdef and increase it. */
3818 get_next_funcdef_no (void)
3820 return funcdef_no
++;
3823 /* Allocate a function structure for FNDECL and set its contents
3824 to the defaults. Set cfun to the newly-allocated object.
3825 Some of the helper functions invoked during initialization assume
3826 that cfun has already been set. Therefore, assign the new object
3827 directly into cfun and invoke the back end hook explicitly at the
3828 very end, rather than initializing a temporary and calling set_cfun
3831 ABSTRACT_P is true if this is a function that will never be seen by
3832 the middle-end. Such functions are front-end concepts (like C++
3833 function templates) that do not correspond directly to functions
3834 placed in object files. */
3837 allocate_struct_function (tree fndecl
, bool abstract_p
)
3840 tree fntype
= fndecl
? TREE_TYPE (fndecl
) : NULL_TREE
;
3842 cfun
= ggc_alloc_cleared (sizeof (struct function
));
3844 current_function_funcdef_no
= get_next_funcdef_no ();
3846 cfun
->function_frequency
= FUNCTION_FREQUENCY_NORMAL
;
3848 init_eh_for_function ();
3850 if (init_machine_status
)
3851 cfun
->machine
= (*init_machine_status
) ();
3855 DECL_STRUCT_FUNCTION (fndecl
) = cfun
;
3856 cfun
->decl
= fndecl
;
3858 result
= DECL_RESULT (fndecl
);
3859 if (!abstract_p
&& aggregate_value_p (result
, fndecl
))
3861 #ifdef PCC_STATIC_STRUCT_RETURN
3862 current_function_returns_pcc_struct
= 1;
3864 current_function_returns_struct
= 1;
3867 current_function_stdarg
3869 && TYPE_ARG_TYPES (fntype
) != 0
3870 && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype
)))
3871 != void_type_node
));
3873 /* Assume all registers in stdarg functions need to be saved. */
3874 cfun
->va_list_gpr_size
= VA_LIST_MAX_GPR_SIZE
;
3875 cfun
->va_list_fpr_size
= VA_LIST_MAX_FPR_SIZE
;
3878 invoke_set_current_function_hook (fndecl
);
3881 /* This is like allocate_struct_function, but pushes a new cfun for FNDECL
3882 instead of just setting it. */
3885 push_struct_function (tree fndecl
)
3888 saved_in_system_header
= in_system_header
;
3889 VEC_safe_push (function_p
, heap
, cfun_stack
, cfun
);
3891 in_system_header
= DECL_IN_SYSTEM_HEADER (fndecl
);
3892 allocate_struct_function (fndecl
, false);
3895 /* Reset cfun, and other non-struct-function variables to defaults as
3896 appropriate for emitting rtl at the start of a function. */
3899 prepare_function_start (void)
3901 gcc_assert (!crtl
->emit
.x_last_insn
);
3903 init_varasm_status ();
3906 cse_not_expected
= ! optimize
;
3908 /* Caller save not needed yet. */
3909 caller_save_needed
= 0;
3911 /* We haven't done register allocation yet. */
3914 /* Indicate that we have not instantiated virtual registers yet. */
3915 virtuals_instantiated
= 0;
3917 /* Indicate that we want CONCATs now. */
3918 generating_concat_p
= 1;
3920 /* Indicate we have no need of a frame pointer yet. */
3921 frame_pointer_needed
= 0;
3924 /* Initialize the rtl expansion mechanism so that we can do simple things
3925 like generate sequences. This is used to provide a context during global
3926 initialization of some passes. You must call expand_dummy_function_end
3927 to exit this context. */
3930 init_dummy_function_start (void)
3932 gcc_assert (!in_dummy_function
);
3933 in_dummy_function
= true;
3934 push_struct_function (NULL_TREE
);
3935 prepare_function_start ();
3938 /* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node)
3939 and initialize static variables for generating RTL for the statements
3943 init_function_start (tree subr
)
3945 if (subr
&& DECL_STRUCT_FUNCTION (subr
))
3946 set_cfun (DECL_STRUCT_FUNCTION (subr
));
3948 allocate_struct_function (subr
, false);
3949 prepare_function_start ();
3951 /* Warn if this value is an aggregate type,
3952 regardless of which calling convention we are using for it. */
3953 if (AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr
))))
3954 warning (OPT_Waggregate_return
, "function returns an aggregate");
3957 /* Make sure all values used by the optimization passes have sane
3960 init_function_for_compilation (void)
3964 /* No prologue/epilogue insns yet. Make sure that these vectors are
3966 gcc_assert (VEC_length (int, prologue
) == 0);
3967 gcc_assert (VEC_length (int, epilogue
) == 0);
3968 gcc_assert (VEC_length (int, sibcall_epilogue
) == 0);
3972 struct rtl_opt_pass pass_init_function
=
3978 init_function_for_compilation
, /* execute */
3981 0, /* static_pass_number */
3983 0, /* properties_required */
3984 0, /* properties_provided */
3985 0, /* properties_destroyed */
3986 0, /* todo_flags_start */
3987 0 /* todo_flags_finish */
3993 expand_main_function (void)
3995 #if (defined(INVOKE__main) \
3996 || (!defined(HAS_INIT_SECTION) \
3997 && !defined(INIT_SECTION_ASM_OP) \
3998 && !defined(INIT_ARRAY_SECTION_ASM_OP)))
3999 emit_library_call (init_one_libfunc (NAME__MAIN
), LCT_NORMAL
, VOIDmode
, 0);
4003 /* Expand code to initialize the stack_protect_guard. This is invoked at
4004 the beginning of a function to be protected. */
4006 #ifndef HAVE_stack_protect_set
4007 # define HAVE_stack_protect_set 0
4008 # define gen_stack_protect_set(x,y) (gcc_unreachable (), NULL_RTX)
4012 stack_protect_prologue (void)
4014 tree guard_decl
= targetm
.stack_protect_guard ();
4017 /* Avoid expand_expr here, because we don't want guard_decl pulled
4018 into registers unless absolutely necessary. And we know that
4019 crtl->stack_protect_guard is a local stack slot, so this skips
4021 x
= validize_mem (DECL_RTL (crtl
->stack_protect_guard
));
4022 y
= validize_mem (DECL_RTL (guard_decl
));
4024 /* Allow the target to copy from Y to X without leaking Y into a
4026 if (HAVE_stack_protect_set
)
4028 rtx insn
= gen_stack_protect_set (x
, y
);
4036 /* Otherwise do a straight move. */
4037 emit_move_insn (x
, y
);
4040 /* Expand code to verify the stack_protect_guard. This is invoked at
4041 the end of a function to be protected. */
4043 #ifndef HAVE_stack_protect_test
4044 # define HAVE_stack_protect_test 0
4045 # define gen_stack_protect_test(x, y, z) (gcc_unreachable (), NULL_RTX)
4049 stack_protect_epilogue (void)
4051 tree guard_decl
= targetm
.stack_protect_guard ();
4052 rtx label
= gen_label_rtx ();
4055 /* Avoid expand_expr here, because we don't want guard_decl pulled
4056 into registers unless absolutely necessary. And we know that
4057 crtl->stack_protect_guard is a local stack slot, so this skips
4059 x
= validize_mem (DECL_RTL (crtl
->stack_protect_guard
));
4060 y
= validize_mem (DECL_RTL (guard_decl
));
4062 /* Allow the target to compare Y with X without leaking either into
4064 switch (HAVE_stack_protect_test
!= 0)
4067 tmp
= gen_stack_protect_test (x
, y
, label
);
4076 emit_cmp_and_jump_insns (x
, y
, EQ
, NULL_RTX
, ptr_mode
, 1, label
);
4080 /* The noreturn predictor has been moved to the tree level. The rtl-level
4081 predictors estimate this branch about 20%, which isn't enough to get
4082 things moved out of line. Since this is the only extant case of adding
4083 a noreturn function at the rtl level, it doesn't seem worth doing ought
4084 except adding the prediction by hand. */
4085 tmp
= get_last_insn ();
4087 predict_insn_def (tmp
, PRED_NORETURN
, TAKEN
);
4089 expand_expr_stmt (targetm
.stack_protect_fail ());
4093 /* Start the RTL for a new function, and set variables used for
4095 SUBR is the FUNCTION_DECL node.
4096 PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with
4097 the function's parameters, which must be run at any return statement. */
4100 expand_function_start (tree subr
)
4102 /* Make sure volatile mem refs aren't considered
4103 valid operands of arithmetic insns. */
4104 init_recog_no_volatile ();
4106 current_function_profile
4108 && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr
));
4110 current_function_limit_stack
4111 = (stack_limit_rtx
!= NULL_RTX
&& ! DECL_NO_LIMIT_STACK (subr
));
4113 /* Make the label for return statements to jump to. Do not special
4114 case machines with special return instructions -- they will be
4115 handled later during jump, ifcvt, or epilogue creation. */
4116 return_label
= gen_label_rtx ();
4118 /* Initialize rtx used to return the value. */
4119 /* Do this before assign_parms so that we copy the struct value address
4120 before any library calls that assign parms might generate. */
4122 /* Decide whether to return the value in memory or in a register. */
4123 if (aggregate_value_p (DECL_RESULT (subr
), subr
))
4125 /* Returning something that won't go in a register. */
4126 rtx value_address
= 0;
4128 #ifdef PCC_STATIC_STRUCT_RETURN
4129 if (current_function_returns_pcc_struct
)
4131 int size
= int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr
)));
4132 value_address
= assemble_static_space (size
);
4137 rtx sv
= targetm
.calls
.struct_value_rtx (TREE_TYPE (subr
), 2);
4138 /* Expect to be passed the address of a place to store the value.
4139 If it is passed as an argument, assign_parms will take care of
4143 value_address
= gen_reg_rtx (Pmode
);
4144 emit_move_insn (value_address
, sv
);
4149 rtx x
= value_address
;
4150 if (!DECL_BY_REFERENCE (DECL_RESULT (subr
)))
4152 x
= gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr
)), x
);
4153 set_mem_attributes (x
, DECL_RESULT (subr
), 1);
4155 SET_DECL_RTL (DECL_RESULT (subr
), x
);
4158 else if (DECL_MODE (DECL_RESULT (subr
)) == VOIDmode
)
4159 /* If return mode is void, this decl rtl should not be used. */
4160 SET_DECL_RTL (DECL_RESULT (subr
), NULL_RTX
);
4163 /* Compute the return values into a pseudo reg, which we will copy
4164 into the true return register after the cleanups are done. */
4165 tree return_type
= TREE_TYPE (DECL_RESULT (subr
));
4166 if (TYPE_MODE (return_type
) != BLKmode
4167 && targetm
.calls
.return_in_msb (return_type
))
4168 /* expand_function_end will insert the appropriate padding in
4169 this case. Use the return value's natural (unpadded) mode
4170 within the function proper. */
4171 SET_DECL_RTL (DECL_RESULT (subr
),
4172 gen_reg_rtx (TYPE_MODE (return_type
)));
4175 /* In order to figure out what mode to use for the pseudo, we
4176 figure out what the mode of the eventual return register will
4177 actually be, and use that. */
4178 rtx hard_reg
= hard_function_value (return_type
, subr
, 0, 1);
4180 /* Structures that are returned in registers are not
4181 aggregate_value_p, so we may see a PARALLEL or a REG. */
4182 if (REG_P (hard_reg
))
4183 SET_DECL_RTL (DECL_RESULT (subr
),
4184 gen_reg_rtx (GET_MODE (hard_reg
)));
4187 gcc_assert (GET_CODE (hard_reg
) == PARALLEL
);
4188 SET_DECL_RTL (DECL_RESULT (subr
), gen_group_rtx (hard_reg
));
4192 /* Set DECL_REGISTER flag so that expand_function_end will copy the
4193 result to the real return register(s). */
4194 DECL_REGISTER (DECL_RESULT (subr
)) = 1;
4197 /* Initialize rtx for parameters and local variables.
4198 In some cases this requires emitting insns. */
4199 assign_parms (subr
);
4201 /* If function gets a static chain arg, store it. */
4202 if (cfun
->static_chain_decl
)
4204 tree parm
= cfun
->static_chain_decl
;
4205 rtx local
= gen_reg_rtx (Pmode
);
4207 set_decl_incoming_rtl (parm
, static_chain_incoming_rtx
, false);
4208 SET_DECL_RTL (parm
, local
);
4209 mark_reg_pointer (local
, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm
))));
4211 emit_move_insn (local
, static_chain_incoming_rtx
);
4214 /* If the function receives a non-local goto, then store the
4215 bits we need to restore the frame pointer. */
4216 if (cfun
->nonlocal_goto_save_area
)
4221 /* ??? We need to do this save early. Unfortunately here is
4222 before the frame variable gets declared. Help out... */
4223 tree var
= TREE_OPERAND (cfun
->nonlocal_goto_save_area
, 0);
4224 if (!DECL_RTL_SET_P (var
))
4227 t_save
= build4 (ARRAY_REF
, ptr_type_node
,
4228 cfun
->nonlocal_goto_save_area
,
4229 integer_zero_node
, NULL_TREE
, NULL_TREE
);
4230 r_save
= expand_expr (t_save
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
4231 r_save
= convert_memory_address (Pmode
, r_save
);
4233 emit_move_insn (r_save
, virtual_stack_vars_rtx
);
4234 update_nonlocal_goto_save_area ();
4237 /* The following was moved from init_function_start.
4238 The move is supposed to make sdb output more accurate. */
4239 /* Indicate the beginning of the function body,
4240 as opposed to parm setup. */
4241 emit_note (NOTE_INSN_FUNCTION_BEG
);
4243 gcc_assert (NOTE_P (get_last_insn ()));
4245 parm_birth_insn
= get_last_insn ();
4247 if (current_function_profile
)
4250 PROFILE_HOOK (current_function_funcdef_no
);
4254 /* After the display initializations is where the stack checking
4256 if(flag_stack_check
)
4257 stack_check_probe_note
= emit_note (NOTE_INSN_DELETED
);
4259 /* Make sure there is a line number after the function entry setup code. */
4260 force_next_line_note ();
4263 /* Undo the effects of init_dummy_function_start. */
4265 expand_dummy_function_end (void)
4267 gcc_assert (in_dummy_function
);
4269 /* End any sequences that failed to be closed due to syntax errors. */
4270 while (in_sequence_p ())
4273 /* Outside function body, can't compute type's actual size
4274 until next function's body starts. */
4276 free_after_parsing (cfun
);
4277 free_after_compilation (cfun
);
4279 in_dummy_function
= false;
4282 /* Call DOIT for each hard register used as a return value from
4283 the current function. */
4286 diddle_return_value (void (*doit
) (rtx
, void *), void *arg
)
4288 rtx outgoing
= crtl
->return_rtx
;
4293 if (REG_P (outgoing
))
4294 (*doit
) (outgoing
, arg
);
4295 else if (GET_CODE (outgoing
) == PARALLEL
)
4299 for (i
= 0; i
< XVECLEN (outgoing
, 0); i
++)
4301 rtx x
= XEXP (XVECEXP (outgoing
, 0, i
), 0);
4303 if (REG_P (x
) && REGNO (x
) < FIRST_PSEUDO_REGISTER
)
4310 do_clobber_return_reg (rtx reg
, void *arg ATTRIBUTE_UNUSED
)
4312 emit_insn (gen_rtx_CLOBBER (VOIDmode
, reg
));
4316 clobber_return_register (void)
4318 diddle_return_value (do_clobber_return_reg
, NULL
);
4320 /* In case we do use pseudo to return value, clobber it too. */
4321 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl
)))
4323 tree decl_result
= DECL_RESULT (current_function_decl
);
4324 rtx decl_rtl
= DECL_RTL (decl_result
);
4325 if (REG_P (decl_rtl
) && REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
)
4327 do_clobber_return_reg (decl_rtl
, NULL
);
4333 do_use_return_reg (rtx reg
, void *arg ATTRIBUTE_UNUSED
)
4335 emit_insn (gen_rtx_USE (VOIDmode
, reg
));
4339 use_return_register (void)
4341 diddle_return_value (do_use_return_reg
, NULL
);
4344 /* Possibly warn about unused parameters. */
4346 do_warn_unused_parameter (tree fn
)
4350 for (decl
= DECL_ARGUMENTS (fn
);
4351 decl
; decl
= TREE_CHAIN (decl
))
4352 if (!TREE_USED (decl
) && TREE_CODE (decl
) == PARM_DECL
4353 && DECL_NAME (decl
) && !DECL_ARTIFICIAL (decl
)
4354 && !TREE_NO_WARNING (decl
))
4355 warning (OPT_Wunused_parameter
, "unused parameter %q+D", decl
);
4358 static GTY(()) rtx initial_trampoline
;
4360 /* Generate RTL for the end of the current function. */
4363 expand_function_end (void)
4367 /* If arg_pointer_save_area was referenced only from a nested
4368 function, we will not have initialized it yet. Do that now. */
4369 if (arg_pointer_save_area
&& ! cfun
->arg_pointer_save_area_init
)
4370 get_arg_pointer_save_area ();
4372 /* If we are doing stack checking and this function makes calls,
4373 do a stack probe at the start of the function to ensure we have enough
4374 space for another stack frame. */
4375 if (flag_stack_check
&& ! STACK_CHECK_BUILTIN
)
4379 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
4383 probe_stack_range (STACK_CHECK_PROTECT
,
4384 GEN_INT (STACK_CHECK_MAX_FRAME_SIZE
));
4387 emit_insn_before (seq
, stack_check_probe_note
);
4392 /* End any sequences that failed to be closed due to syntax errors. */
4393 while (in_sequence_p ())
4396 clear_pending_stack_adjust ();
4397 do_pending_stack_adjust ();
4399 /* Output a linenumber for the end of the function.
4400 SDB depends on this. */
4401 force_next_line_note ();
4402 set_curr_insn_source_location (input_location
);
4404 /* Before the return label (if any), clobber the return
4405 registers so that they are not propagated live to the rest of
4406 the function. This can only happen with functions that drop
4407 through; if there had been a return statement, there would
4408 have either been a return rtx, or a jump to the return label.
4410 We delay actual code generation after the current_function_value_rtx
4412 clobber_after
= get_last_insn ();
4414 /* Output the label for the actual return from the function. */
4415 emit_label (return_label
);
4417 if (USING_SJLJ_EXCEPTIONS
)
4419 /* Let except.c know where it should emit the call to unregister
4420 the function context for sjlj exceptions. */
4421 if (flag_exceptions
)
4422 sjlj_emit_function_exit_after (get_last_insn ());
4426 /* We want to ensure that instructions that may trap are not
4427 moved into the epilogue by scheduling, because we don't
4428 always emit unwind information for the epilogue. */
4429 if (flag_non_call_exceptions
)
4430 emit_insn (gen_blockage ());
4433 /* If this is an implementation of throw, do what's necessary to
4434 communicate between __builtin_eh_return and the epilogue. */
4435 expand_eh_return ();
4437 /* If scalar return value was computed in a pseudo-reg, or was a named
4438 return value that got dumped to the stack, copy that to the hard
4440 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl
)))
4442 tree decl_result
= DECL_RESULT (current_function_decl
);
4443 rtx decl_rtl
= DECL_RTL (decl_result
);
4445 if (REG_P (decl_rtl
)
4446 ? REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
4447 : DECL_REGISTER (decl_result
))
4449 rtx real_decl_rtl
= crtl
->return_rtx
;
4451 /* This should be set in assign_parms. */
4452 gcc_assert (REG_FUNCTION_VALUE_P (real_decl_rtl
));
4454 /* If this is a BLKmode structure being returned in registers,
4455 then use the mode computed in expand_return. Note that if
4456 decl_rtl is memory, then its mode may have been changed,
4457 but that crtl->return_rtx has not. */
4458 if (GET_MODE (real_decl_rtl
) == BLKmode
)
4459 PUT_MODE (real_decl_rtl
, GET_MODE (decl_rtl
));
4461 /* If a non-BLKmode return value should be padded at the least
4462 significant end of the register, shift it left by the appropriate
4463 amount. BLKmode results are handled using the group load/store
4465 if (TYPE_MODE (TREE_TYPE (decl_result
)) != BLKmode
4466 && targetm
.calls
.return_in_msb (TREE_TYPE (decl_result
)))
4468 emit_move_insn (gen_rtx_REG (GET_MODE (decl_rtl
),
4469 REGNO (real_decl_rtl
)),
4471 shift_return_value (GET_MODE (decl_rtl
), true, real_decl_rtl
);
4473 /* If a named return value dumped decl_return to memory, then
4474 we may need to re-do the PROMOTE_MODE signed/unsigned
4476 else if (GET_MODE (real_decl_rtl
) != GET_MODE (decl_rtl
))
4478 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (decl_result
));
4480 if (targetm
.calls
.promote_function_return (TREE_TYPE (current_function_decl
)))
4481 promote_mode (TREE_TYPE (decl_result
), GET_MODE (decl_rtl
),
4484 convert_move (real_decl_rtl
, decl_rtl
, unsignedp
);
4486 else if (GET_CODE (real_decl_rtl
) == PARALLEL
)
4488 /* If expand_function_start has created a PARALLEL for decl_rtl,
4489 move the result to the real return registers. Otherwise, do
4490 a group load from decl_rtl for a named return. */
4491 if (GET_CODE (decl_rtl
) == PARALLEL
)
4492 emit_group_move (real_decl_rtl
, decl_rtl
);
4494 emit_group_load (real_decl_rtl
, decl_rtl
,
4495 TREE_TYPE (decl_result
),
4496 int_size_in_bytes (TREE_TYPE (decl_result
)));
4498 /* In the case of complex integer modes smaller than a word, we'll
4499 need to generate some non-trivial bitfield insertions. Do that
4500 on a pseudo and not the hard register. */
4501 else if (GET_CODE (decl_rtl
) == CONCAT
4502 && GET_MODE_CLASS (GET_MODE (decl_rtl
)) == MODE_COMPLEX_INT
4503 && GET_MODE_BITSIZE (GET_MODE (decl_rtl
)) <= BITS_PER_WORD
)
4505 int old_generating_concat_p
;
4508 old_generating_concat_p
= generating_concat_p
;
4509 generating_concat_p
= 0;
4510 tmp
= gen_reg_rtx (GET_MODE (decl_rtl
));
4511 generating_concat_p
= old_generating_concat_p
;
4513 emit_move_insn (tmp
, decl_rtl
);
4514 emit_move_insn (real_decl_rtl
, tmp
);
4517 emit_move_insn (real_decl_rtl
, decl_rtl
);
4521 /* If returning a structure, arrange to return the address of the value
4522 in a place where debuggers expect to find it.
4524 If returning a structure PCC style,
4525 the caller also depends on this value.
4526 And current_function_returns_pcc_struct is not necessarily set. */
4527 if (current_function_returns_struct
4528 || current_function_returns_pcc_struct
)
4530 rtx value_address
= DECL_RTL (DECL_RESULT (current_function_decl
));
4531 tree type
= TREE_TYPE (DECL_RESULT (current_function_decl
));
4534 if (DECL_BY_REFERENCE (DECL_RESULT (current_function_decl
)))
4535 type
= TREE_TYPE (type
);
4537 value_address
= XEXP (value_address
, 0);
4539 outgoing
= targetm
.calls
.function_value (build_pointer_type (type
),
4540 current_function_decl
, true);
4542 /* Mark this as a function return value so integrate will delete the
4543 assignment and USE below when inlining this function. */
4544 REG_FUNCTION_VALUE_P (outgoing
) = 1;
4546 /* The address may be ptr_mode and OUTGOING may be Pmode. */
4547 value_address
= convert_memory_address (GET_MODE (outgoing
),
4550 emit_move_insn (outgoing
, value_address
);
4552 /* Show return register used to hold result (in this case the address
4554 crtl
->return_rtx
= outgoing
;
4557 /* Emit the actual code to clobber return register. */
4562 clobber_return_register ();
4563 expand_naked_return ();
4567 emit_insn_after (seq
, clobber_after
);
4570 /* Output the label for the naked return from the function. */
4571 emit_label (naked_return_label
);
4573 /* @@@ This is a kludge. We want to ensure that instructions that
4574 may trap are not moved into the epilogue by scheduling, because
4575 we don't always emit unwind information for the epilogue. */
4576 if (! USING_SJLJ_EXCEPTIONS
&& flag_non_call_exceptions
)
4577 emit_insn (gen_blockage ());
4579 /* If stack protection is enabled for this function, check the guard. */
4580 if (crtl
->stack_protect_guard
)
4581 stack_protect_epilogue ();
4583 /* If we had calls to alloca, and this machine needs
4584 an accurate stack pointer to exit the function,
4585 insert some code to save and restore the stack pointer. */
4586 if (! EXIT_IGNORE_STACK
4587 && current_function_calls_alloca
)
4591 emit_stack_save (SAVE_FUNCTION
, &tem
, parm_birth_insn
);
4592 emit_stack_restore (SAVE_FUNCTION
, tem
, NULL_RTX
);
4595 /* ??? This should no longer be necessary since stupid is no longer with
4596 us, but there are some parts of the compiler (eg reload_combine, and
4597 sh mach_dep_reorg) that still try and compute their own lifetime info
4598 instead of using the general framework. */
4599 use_return_register ();
4603 get_arg_pointer_save_area (void)
4605 rtx ret
= arg_pointer_save_area
;
4609 ret
= assign_stack_local (Pmode
, GET_MODE_SIZE (Pmode
), 0);
4610 arg_pointer_save_area
= ret
;
4613 if (! cfun
->arg_pointer_save_area_init
)
4617 /* Save the arg pointer at the beginning of the function. The
4618 generated stack slot may not be a valid memory address, so we
4619 have to check it and fix it if necessary. */
4621 emit_move_insn (validize_mem (ret
), virtual_incoming_args_rtx
);
4625 push_topmost_sequence ();
4626 emit_insn_after (seq
, entry_of_function ());
4627 pop_topmost_sequence ();
4633 /* Extend a vector that records the INSN_UIDs of INSNS
4634 (a list of one or more insns). */
4637 record_insns (rtx insns
, VEC(int,heap
) **vecp
)
4641 for (tmp
= insns
; tmp
!= NULL_RTX
; tmp
= NEXT_INSN (tmp
))
4642 VEC_safe_push (int, heap
, *vecp
, INSN_UID (tmp
));
4645 /* Set the locator of the insn chain starting at INSN to LOC. */
4647 set_insn_locators (rtx insn
, int loc
)
4649 while (insn
!= NULL_RTX
)
4652 INSN_LOCATOR (insn
) = loc
;
4653 insn
= NEXT_INSN (insn
);
4657 /* Determine how many INSN_UIDs in VEC are part of INSN. Because we can
4658 be running after reorg, SEQUENCE rtl is possible. */
4661 contains (const_rtx insn
, VEC(int,heap
) **vec
)
4665 if (NONJUMP_INSN_P (insn
)
4666 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
4669 for (i
= XVECLEN (PATTERN (insn
), 0) - 1; i
>= 0; i
--)
4670 for (j
= VEC_length (int, *vec
) - 1; j
>= 0; --j
)
4671 if (INSN_UID (XVECEXP (PATTERN (insn
), 0, i
))
4672 == VEC_index (int, *vec
, j
))
4678 for (j
= VEC_length (int, *vec
) - 1; j
>= 0; --j
)
4679 if (INSN_UID (insn
) == VEC_index (int, *vec
, j
))
4686 prologue_epilogue_contains (const_rtx insn
)
4688 if (contains (insn
, &prologue
))
4690 if (contains (insn
, &epilogue
))
4696 sibcall_epilogue_contains (const_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
)
4710 emit_jump_insn_after (gen_return (), BB_END (bb
));
4712 #endif /* HAVE_return */
4714 /* Generate the prologue and epilogue RTL if the machine supports it. Thread
4715 this into place with notes indicating where the prologue ends and where
4716 the epilogue begins. Update the basic block information when possible. */
4719 thread_prologue_and_epilogue_insns (void)
4723 #if defined (HAVE_sibcall_epilogue) || defined (HAVE_epilogue) || defined (HAVE_return) || defined (HAVE_prologue)
4726 #if defined (HAVE_epilogue) || defined(HAVE_return)
4727 rtx epilogue_end
= NULL_RTX
;
4731 #ifdef HAVE_prologue
4735 seq
= gen_prologue ();
4738 /* Insert an explicit USE for the frame pointer
4739 if the profiling is on and the frame pointer is required. */
4740 if (current_function_profile
&& frame_pointer_needed
)
4741 emit_insn (gen_rtx_USE (VOIDmode
, hard_frame_pointer_rtx
));
4743 /* Retain a map of the prologue insns. */
4744 record_insns (seq
, &prologue
);
4745 emit_note (NOTE_INSN_PROLOGUE_END
);
4747 #ifndef PROFILE_BEFORE_PROLOGUE
4748 /* Ensure that instructions are not moved into the prologue when
4749 profiling is on. The call to the profiling routine can be
4750 emitted within the live range of a call-clobbered register. */
4751 if (current_function_profile
)
4752 emit_insn (gen_blockage ());
4757 set_insn_locators (seq
, prologue_locator
);
4759 /* Can't deal with multiple successors of the entry block
4760 at the moment. Function should always have at least one
4762 gcc_assert (single_succ_p (ENTRY_BLOCK_PTR
));
4764 insert_insn_on_edge (seq
, single_succ_edge (ENTRY_BLOCK_PTR
));
4769 /* If the exit block has no non-fake predecessors, we don't need
4771 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
4772 if ((e
->flags
& EDGE_FAKE
) == 0)
4778 if (optimize
&& HAVE_return
)
4780 /* If we're allowed to generate a simple return instruction,
4781 then by definition we don't need a full epilogue. Examine
4782 the block that falls through to EXIT. If it does not
4783 contain any code, examine its predecessors and try to
4784 emit (conditional) return instructions. */
4789 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
4790 if (e
->flags
& EDGE_FALLTHRU
)
4796 /* Verify that there are no active instructions in the last block. */
4797 label
= BB_END (last
);
4798 while (label
&& !LABEL_P (label
))
4800 if (active_insn_p (label
))
4802 label
= PREV_INSN (label
);
4805 if (BB_HEAD (last
) == label
&& LABEL_P (label
))
4809 for (ei2
= ei_start (last
->preds
); (e
= ei_safe_edge (ei2
)); )
4811 basic_block bb
= e
->src
;
4814 if (bb
== ENTRY_BLOCK_PTR
)
4821 if (!JUMP_P (jump
) || JUMP_LABEL (jump
) != label
)
4827 /* If we have an unconditional jump, we can replace that
4828 with a simple return instruction. */
4829 if (simplejump_p (jump
))
4831 emit_return_into_block (bb
);
4835 /* If we have a conditional jump, we can try to replace
4836 that with a conditional return instruction. */
4837 else if (condjump_p (jump
))
4839 if (! redirect_jump (jump
, 0, 0))
4845 /* If this block has only one successor, it both jumps
4846 and falls through to the fallthru block, so we can't
4848 if (single_succ_p (bb
))
4860 /* Fix up the CFG for the successful change we just made. */
4861 redirect_edge_succ (e
, EXIT_BLOCK_PTR
);
4864 /* Emit a return insn for the exit fallthru block. Whether
4865 this is still reachable will be determined later. */
4867 emit_barrier_after (BB_END (last
));
4868 emit_return_into_block (last
);
4869 epilogue_end
= BB_END (last
);
4870 single_succ_edge (last
)->flags
&= ~EDGE_FALLTHRU
;
4875 /* Find the edge that falls through to EXIT. Other edges may exist
4876 due to RETURN instructions, but those don't need epilogues.
4877 There really shouldn't be a mixture -- either all should have
4878 been converted or none, however... */
4880 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
4881 if (e
->flags
& EDGE_FALLTHRU
)
4886 #ifdef HAVE_epilogue
4890 epilogue_end
= emit_note (NOTE_INSN_EPILOGUE_BEG
);
4891 seq
= gen_epilogue ();
4892 emit_jump_insn (seq
);
4894 /* Retain a map of the epilogue insns. */
4895 record_insns (seq
, &epilogue
);
4896 set_insn_locators (seq
, epilogue_locator
);
4901 insert_insn_on_edge (seq
, e
);
4909 if (! next_active_insn (BB_END (e
->src
)))
4911 /* We have a fall-through edge to the exit block, the source is not
4912 at the end of the function, and there will be an assembler epilogue
4913 at the end of the function.
4914 We can't use force_nonfallthru here, because that would try to
4915 use return. Inserting a jump 'by hand' is extremely messy, so
4916 we take advantage of cfg_layout_finalize using
4917 fixup_fallthru_exit_predecessor. */
4918 cfg_layout_initialize (0);
4919 FOR_EACH_BB (cur_bb
)
4920 if (cur_bb
->index
>= NUM_FIXED_BLOCKS
4921 && cur_bb
->next_bb
->index
>= NUM_FIXED_BLOCKS
)
4922 cur_bb
->aux
= cur_bb
->next_bb
;
4923 cfg_layout_finalize ();
4929 commit_edge_insertions ();
4931 /* The epilogue insns we inserted may cause the exit edge to no longer
4933 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
4935 if (((e
->flags
& EDGE_FALLTHRU
) != 0)
4936 && returnjump_p (BB_END (e
->src
)))
4937 e
->flags
&= ~EDGE_FALLTHRU
;
4941 #ifdef HAVE_sibcall_epilogue
4942 /* Emit sibling epilogues before any sibling call sites. */
4943 for (ei
= ei_start (EXIT_BLOCK_PTR
->preds
); (e
= ei_safe_edge (ei
)); )
4945 basic_block bb
= e
->src
;
4946 rtx insn
= BB_END (bb
);
4949 || ! SIBLING_CALL_P (insn
))
4956 emit_insn (gen_sibcall_epilogue ());
4960 /* Retain a map of the epilogue insns. Used in life analysis to
4961 avoid getting rid of sibcall epilogue insns. Do this before we
4962 actually emit the sequence. */
4963 record_insns (seq
, &sibcall_epilogue
);
4964 set_insn_locators (seq
, epilogue_locator
);
4966 emit_insn_before (seq
, insn
);
4971 #ifdef HAVE_epilogue
4976 /* Similarly, move any line notes that appear after the epilogue.
4977 There is no need, however, to be quite so anal about the existence
4978 of such a note. Also possibly move
4979 NOTE_INSN_FUNCTION_BEG notes, as those can be relevant for debug
4981 for (insn
= epilogue_end
; insn
; insn
= next
)
4983 next
= NEXT_INSN (insn
);
4985 && (NOTE_KIND (insn
) == NOTE_INSN_FUNCTION_BEG
))
4986 reorder_insns (insn
, insn
, PREV_INSN (epilogue_end
));
4991 /* Threading the prologue and epilogue changes the artificial refs
4992 in the entry and exit blocks. */
4993 epilogue_completed
= 1;
4994 df_update_entry_exit_and_calls ();
4997 /* Reposition the prologue-end and epilogue-begin notes after instruction
4998 scheduling and delayed branch scheduling. */
5001 reposition_prologue_and_epilogue_notes (void)
5003 #if defined (HAVE_prologue) || defined (HAVE_epilogue)
5004 rtx insn
, last
, note
;
5007 if ((len
= VEC_length (int, prologue
)) > 0)
5011 /* Scan from the beginning until we reach the last prologue insn.
5012 We apparently can't depend on basic_block_{head,end} after
5014 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
5018 if (NOTE_KIND (insn
) == NOTE_INSN_PROLOGUE_END
)
5021 else if (contains (insn
, &prologue
))
5031 /* Find the prologue-end note if we haven't already, and
5032 move it to just after the last prologue insn. */
5035 for (note
= last
; (note
= NEXT_INSN (note
));)
5037 && NOTE_KIND (note
) == NOTE_INSN_PROLOGUE_END
)
5041 /* Avoid placing note between CODE_LABEL and BASIC_BLOCK note. */
5043 last
= NEXT_INSN (last
);
5044 reorder_insns (note
, note
, last
);
5048 if ((len
= VEC_length (int, epilogue
)) > 0)
5052 /* Scan from the end until we reach the first epilogue insn.
5053 We apparently can't depend on basic_block_{head,end} after
5055 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
5059 if (NOTE_KIND (insn
) == NOTE_INSN_EPILOGUE_BEG
)
5062 else if (contains (insn
, &epilogue
))
5072 /* Find the epilogue-begin note if we haven't already, and
5073 move it to just before the first epilogue insn. */
5076 for (note
= insn
; (note
= PREV_INSN (note
));)
5078 && NOTE_KIND (note
) == NOTE_INSN_EPILOGUE_BEG
)
5082 if (PREV_INSN (last
) != note
)
5083 reorder_insns (note
, note
, PREV_INSN (last
));
5086 #endif /* HAVE_prologue or HAVE_epilogue */
5089 /* Returns the name of the current function. */
5091 current_function_name (void)
5093 return lang_hooks
.decl_printable_name (cfun
->decl
, 2);
5096 /* Returns the raw (mangled) name of the current function. */
5098 current_function_assembler_name (void)
5100 return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (cfun
->decl
));
5105 rest_of_handle_check_leaf_regs (void)
5107 #ifdef LEAF_REGISTERS
5108 current_function_uses_only_leaf_regs
5109 = optimize
> 0 && only_leaf_regs_used () && leaf_function_p ();
5114 /* Insert a TYPE into the used types hash table of CFUN. */
5116 used_types_insert_helper (tree type
, struct function
*func
)
5118 if (type
!= NULL
&& func
!= NULL
)
5122 if (func
->used_types_hash
== NULL
)
5123 func
->used_types_hash
= htab_create_ggc (37, htab_hash_pointer
,
5124 htab_eq_pointer
, NULL
);
5125 slot
= htab_find_slot (func
->used_types_hash
, type
, INSERT
);
5131 /* Given a type, insert it into the used hash table in cfun. */
5133 used_types_insert (tree t
)
5135 while (POINTER_TYPE_P (t
) || TREE_CODE (t
) == ARRAY_TYPE
)
5137 t
= TYPE_MAIN_VARIANT (t
);
5138 if (debug_info_level
> DINFO_LEVEL_NONE
)
5139 used_types_insert_helper (t
, cfun
);
5142 struct rtl_opt_pass pass_leaf_regs
=
5148 rest_of_handle_check_leaf_regs
, /* execute */
5151 0, /* static_pass_number */
5153 0, /* properties_required */
5154 0, /* properties_provided */
5155 0, /* properties_destroyed */
5156 0, /* todo_flags_start */
5157 0 /* todo_flags_finish */
5162 rest_of_handle_thread_prologue_and_epilogue (void)
5165 cleanup_cfg (CLEANUP_EXPENSIVE
);
5166 /* On some machines, the prologue and epilogue code, or parts thereof,
5167 can be represented as RTL. Doing so lets us schedule insns between
5168 it and the rest of the code and also allows delayed branch
5169 scheduling to operate in the epilogue. */
5171 thread_prologue_and_epilogue_insns ();
5175 struct rtl_opt_pass pass_thread_prologue_and_epilogue
=
5179 "pro_and_epilogue", /* name */
5181 rest_of_handle_thread_prologue_and_epilogue
, /* execute */
5184 0, /* static_pass_number */
5185 TV_THREAD_PROLOGUE_AND_EPILOGUE
, /* tv_id */
5186 0, /* properties_required */
5187 0, /* properties_provided */
5188 0, /* properties_destroyed */
5189 TODO_verify_flow
, /* todo_flags_start */
5192 TODO_df_finish
| TODO_verify_rtl_sharing
|
5193 TODO_ggc_collect
/* todo_flags_finish */
5198 /* This mini-pass fixes fall-out from SSA in asm statements that have
5199 in-out constraints. Say you start with
5202 asm ("": "+mr" (inout));
5205 which is transformed very early to use explicit output and match operands:
5208 asm ("": "=mr" (inout) : "0" (inout));
5211 Or, after SSA and copyprop,
5213 asm ("": "=mr" (inout_2) : "0" (inout_1));
5216 Clearly inout_2 and inout_1 can't be coalesced easily anymore, as
5217 they represent two separate values, so they will get different pseudo
5218 registers during expansion. Then, since the two operands need to match
5219 per the constraints, but use different pseudo registers, reload can
5220 only register a reload for these operands. But reloads can only be
5221 satisfied by hardregs, not by memory, so we need a register for this
5222 reload, just because we are presented with non-matching operands.
5223 So, even though we allow memory for this operand, no memory can be
5224 used for it, just because the two operands don't match. This can
5225 cause reload failures on register-starved targets.
5227 So it's a symptom of reload not being able to use memory for reloads
5228 or, alternatively it's also a symptom of both operands not coming into
5229 reload as matching (in which case the pseudo could go to memory just
5230 fine, as the alternative allows it, and no reload would be necessary).
5231 We fix the latter problem here, by transforming
5233 asm ("": "=mr" (inout_2) : "0" (inout_1));
5238 asm ("": "=mr" (inout_2) : "0" (inout_2)); */
5241 match_asm_constraints_1 (rtx insn
, rtx
*p_sets
, int noutputs
)
5244 bool changed
= false;
5245 rtx op
= SET_SRC (p_sets
[0]);
5246 int ninputs
= ASM_OPERANDS_INPUT_LENGTH (op
);
5247 rtvec inputs
= ASM_OPERANDS_INPUT_VEC (op
);
5248 bool *output_matched
= alloca (noutputs
* sizeof (bool));
5250 memset (output_matched
, 0, noutputs
* sizeof (bool));
5251 for (i
= 0; i
< ninputs
; i
++)
5253 rtx input
, output
, insns
;
5254 const char *constraint
= ASM_OPERANDS_INPUT_CONSTRAINT (op
, i
);
5258 match
= strtoul (constraint
, &end
, 10);
5259 if (end
== constraint
)
5262 gcc_assert (match
< noutputs
);
5263 output
= SET_DEST (p_sets
[match
]);
5264 input
= RTVEC_ELT (inputs
, i
);
5265 /* Only do the transformation for pseudos. */
5266 if (! REG_P (output
)
5267 || rtx_equal_p (output
, input
)
5268 || (GET_MODE (input
) != VOIDmode
5269 && GET_MODE (input
) != GET_MODE (output
)))
5272 /* We can't do anything if the output is also used as input,
5273 as we're going to overwrite it. */
5274 for (j
= 0; j
< ninputs
; j
++)
5275 if (reg_overlap_mentioned_p (output
, RTVEC_ELT (inputs
, j
)))
5280 /* Avoid changing the same input several times. For
5281 asm ("" : "=mr" (out1), "=mr" (out2) : "0" (in), "1" (in));
5282 only change in once (to out1), rather than changing it
5283 first to out1 and afterwards to out2. */
5286 for (j
= 0; j
< noutputs
; j
++)
5287 if (output_matched
[j
] && input
== SET_DEST (p_sets
[j
]))
5292 output_matched
[match
] = true;
5295 emit_move_insn (output
, input
);
5296 insns
= get_insns ();
5298 emit_insn_before (insns
, insn
);
5300 /* Now replace all mentions of the input with output. We can't
5301 just replace the occurence in inputs[i], as the register might
5302 also be used in some other input (or even in an address of an
5303 output), which would mean possibly increasing the number of
5304 inputs by one (namely 'output' in addition), which might pose
5305 a too complicated problem for reload to solve. E.g. this situation:
5307 asm ("" : "=r" (output), "=m" (input) : "0" (input))
5309 Here 'input' is used in two occurrences as input (once for the
5310 input operand, once for the address in the second output operand).
5311 If we would replace only the occurence of the input operand (to
5312 make the matching) we would be left with this:
5315 asm ("" : "=r" (output), "=m" (input) : "0" (output))
5317 Now we suddenly have two different input values (containing the same
5318 value, but different pseudos) where we formerly had only one.
5319 With more complicated asms this might lead to reload failures
5320 which wouldn't have happen without this pass. So, iterate over
5321 all operands and replace all occurrences of the register used. */
5322 for (j
= 0; j
< noutputs
; j
++)
5323 if (!rtx_equal_p (SET_DEST (p_sets
[j
]), input
)
5324 && reg_overlap_mentioned_p (input
, SET_DEST (p_sets
[j
])))
5325 SET_DEST (p_sets
[j
]) = replace_rtx (SET_DEST (p_sets
[j
]),
5327 for (j
= 0; j
< ninputs
; j
++)
5328 if (reg_overlap_mentioned_p (input
, RTVEC_ELT (inputs
, j
)))
5329 RTVEC_ELT (inputs
, j
) = replace_rtx (RTVEC_ELT (inputs
, j
),
5336 df_insn_rescan (insn
);
5340 rest_of_match_asm_constraints (void)
5343 rtx insn
, pat
, *p_sets
;
5346 if (!cfun
->has_asm_statement
)
5349 df_set_flags (DF_DEFER_INSN_RESCAN
);
5352 FOR_BB_INSNS (bb
, insn
)
5357 pat
= PATTERN (insn
);
5358 if (GET_CODE (pat
) == PARALLEL
)
5359 p_sets
= &XVECEXP (pat
, 0, 0), noutputs
= XVECLEN (pat
, 0);
5360 else if (GET_CODE (pat
) == SET
)
5361 p_sets
= &PATTERN (insn
), noutputs
= 1;
5365 if (GET_CODE (*p_sets
) == SET
5366 && GET_CODE (SET_SRC (*p_sets
)) == ASM_OPERANDS
)
5367 match_asm_constraints_1 (insn
, p_sets
, noutputs
);
5371 return TODO_df_finish
;
5374 struct rtl_opt_pass pass_match_asm_constraints
=
5378 "asmcons", /* name */
5380 rest_of_match_asm_constraints
, /* execute */
5383 0, /* static_pass_number */
5385 0, /* properties_required */
5386 0, /* properties_provided */
5387 0, /* properties_destroyed */
5388 0, /* todo_flags_start */
5389 TODO_dump_func
/* todo_flags_finish */
5394 #include "gt-function.h"