1 /* Expands front end tree to back end RTL for GCC.
2 Copyright (C) 1987-2015 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* This file handles the generation of rtl code from tree structure
21 at the level of the function as a whole.
22 It creates the rtl expressions for parameters and auto variables
23 and has full responsibility for allocating stack slots.
25 `expand_function_start' is called at the beginning of a function,
26 before the function body is parsed, and `expand_function_end' is
27 called after parsing the body.
29 Call `assign_stack_local' to allocate a stack slot for a local variable.
30 This is usually done during the RTL generation for the function body,
31 but it can also be done in the reload pass when a pseudo-register does
32 not get a hard register. */
36 #include "coretypes.h"
38 #include "rtl-error.h"
43 #include "fold-const.h"
44 #include "stor-layout.h"
46 #include "stringpool.h"
49 #include "hard-reg-set.h"
52 #include "insn-config.h"
60 #include "insn-codes.h"
67 #include "langhooks.h"
69 #include "common/common-target.h"
70 #include "gimple-expr.h"
72 #include "tree-pass.h"
74 #include "dominance.h"
79 #include "cfgcleanup.h"
80 #include "cfgexpand.h"
81 #include "basic-block.h"
84 #include "bb-reorder.h"
85 #include "shrink-wrap.h"
88 #include "tree-chkp.h"
91 /* So we can assign to cfun in this file. */
94 #ifndef STACK_ALIGNMENT_NEEDED
95 #define STACK_ALIGNMENT_NEEDED 1
98 #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
100 /* Round a value to the lowest integer less than it that is a multiple of
101 the required alignment. Avoid using division in case the value is
102 negative. Assume the alignment is a power of two. */
103 #define FLOOR_ROUND(VALUE,ALIGN) ((VALUE) & ~((ALIGN) - 1))
105 /* Similar, but round to the next highest integer that meets the
107 #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
109 /* Nonzero once virtual register instantiation has been done.
110 assign_stack_local uses frame_pointer_rtx when this is nonzero.
111 calls.c:emit_library_call_value_1 uses it to set up
112 post-instantiation libcalls. */
113 int virtuals_instantiated
;
115 /* Assign unique numbers to labels generated for profiling, debugging, etc. */
116 static GTY(()) int funcdef_no
;
118 /* These variables hold pointers to functions to create and destroy
119 target specific, per-function data structures. */
120 struct machine_function
* (*init_machine_status
) (void);
122 /* The currently compiled function. */
123 struct function
*cfun
= 0;
125 /* These hashes record the prologue and epilogue insns. */
127 struct insn_cache_hasher
: ggc_cache_hasher
<rtx
>
129 static hashval_t
hash (rtx x
) { return htab_hash_pointer (x
); }
130 static bool equal (rtx a
, rtx b
) { return a
== b
; }
134 hash_table
<insn_cache_hasher
> *prologue_insn_hash
;
136 hash_table
<insn_cache_hasher
> *epilogue_insn_hash
;
139 hash_table
<used_type_hasher
> *types_used_by_vars_hash
= NULL
;
140 vec
<tree
, va_gc
> *types_used_by_cur_var_decl
;
142 /* Forward declarations. */
144 static struct temp_slot
*find_temp_slot_from_address (rtx
);
145 static void pad_to_arg_alignment (struct args_size
*, int, struct args_size
*);
146 static void pad_below (struct args_size
*, machine_mode
, tree
);
147 static void reorder_blocks_1 (rtx_insn
*, tree
, vec
<tree
> *);
148 static int all_blocks (tree
, tree
*);
149 static tree
*get_block_vector (tree
, int *);
150 extern tree
debug_find_var_in_block_tree (tree
, tree
);
151 /* We always define `record_insns' even if it's not used so that we
152 can always export `prologue_epilogue_contains'. */
153 static void record_insns (rtx_insn
*, rtx
, hash_table
<insn_cache_hasher
> **)
155 static bool contains (const_rtx
, hash_table
<insn_cache_hasher
> *);
156 static void prepare_function_start (void);
157 static void do_clobber_return_reg (rtx
, void *);
158 static void do_use_return_reg (rtx
, void *);
160 /* Stack of nested functions. */
161 /* Keep track of the cfun stack. */
163 typedef struct function
*function_p
;
165 static vec
<function_p
> function_context_stack
;
167 /* Save the current context for compilation of a nested function.
168 This is called from language-specific code. */
171 push_function_context (void)
174 allocate_struct_function (NULL
, false);
176 function_context_stack
.safe_push (cfun
);
180 /* Restore the last saved context, at the end of a nested function.
181 This function is called from language-specific code. */
184 pop_function_context (void)
186 struct function
*p
= function_context_stack
.pop ();
188 current_function_decl
= p
->decl
;
190 /* Reset variables that have known state during rtx generation. */
191 virtuals_instantiated
= 0;
192 generating_concat_p
= 1;
195 /* Clear out all parts of the state in F that can safely be discarded
196 after the function has been parsed, but not compiled, to let
197 garbage collection reclaim the memory. */
200 free_after_parsing (struct function
*f
)
205 /* Clear out all parts of the state in F that can safely be discarded
206 after the function has been compiled, to let garbage collection
207 reclaim the memory. */
210 free_after_compilation (struct function
*f
)
212 prologue_insn_hash
= NULL
;
213 epilogue_insn_hash
= NULL
;
215 free (crtl
->emit
.regno_pointer_align
);
217 memset (crtl
, 0, sizeof (struct rtl_data
));
222 regno_reg_rtx
= NULL
;
225 /* Return size needed for stack frame based on slots so far allocated.
226 This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY;
227 the caller may have to do that. */
230 get_frame_size (void)
232 if (FRAME_GROWS_DOWNWARD
)
233 return -frame_offset
;
238 /* Issue an error message and return TRUE if frame OFFSET overflows in
239 the signed target pointer arithmetics for function FUNC. Otherwise
243 frame_offset_overflow (HOST_WIDE_INT offset
, tree func
)
245 unsigned HOST_WIDE_INT size
= FRAME_GROWS_DOWNWARD
? -offset
: offset
;
247 if (size
> ((unsigned HOST_WIDE_INT
) 1 << (GET_MODE_BITSIZE (Pmode
) - 1))
248 /* Leave room for the fixed part of the frame. */
249 - 64 * UNITS_PER_WORD
)
251 error_at (DECL_SOURCE_LOCATION (func
),
252 "total size of local objects too large");
259 /* Return stack slot alignment in bits for TYPE and MODE. */
262 get_stack_local_alignment (tree type
, machine_mode mode
)
264 unsigned int alignment
;
267 alignment
= BIGGEST_ALIGNMENT
;
269 alignment
= GET_MODE_ALIGNMENT (mode
);
271 /* Allow the frond-end to (possibly) increase the alignment of this
274 type
= lang_hooks
.types
.type_for_mode (mode
, 0);
276 return STACK_SLOT_ALIGNMENT (type
, mode
, alignment
);
279 /* Determine whether it is possible to fit a stack slot of size SIZE and
280 alignment ALIGNMENT into an area in the stack frame that starts at
281 frame offset START and has a length of LENGTH. If so, store the frame
282 offset to be used for the stack slot in *POFFSET and return true;
283 return false otherwise. This function will extend the frame size when
284 given a start/length pair that lies at the end of the frame. */
287 try_fit_stack_local (HOST_WIDE_INT start
, HOST_WIDE_INT length
,
288 HOST_WIDE_INT size
, unsigned int alignment
,
289 HOST_WIDE_INT
*poffset
)
291 HOST_WIDE_INT this_frame_offset
;
292 int frame_off
, frame_alignment
, frame_phase
;
294 /* Calculate how many bytes the start of local variables is off from
296 frame_alignment
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
297 frame_off
= STARTING_FRAME_OFFSET
% frame_alignment
;
298 frame_phase
= frame_off
? frame_alignment
- frame_off
: 0;
300 /* Round the frame offset to the specified alignment. */
302 /* We must be careful here, since FRAME_OFFSET might be negative and
303 division with a negative dividend isn't as well defined as we might
304 like. So we instead assume that ALIGNMENT is a power of two and
305 use logical operations which are unambiguous. */
306 if (FRAME_GROWS_DOWNWARD
)
308 = (FLOOR_ROUND (start
+ length
- size
- frame_phase
,
309 (unsigned HOST_WIDE_INT
) alignment
)
313 = (CEIL_ROUND (start
- frame_phase
,
314 (unsigned HOST_WIDE_INT
) alignment
)
317 /* See if it fits. If this space is at the edge of the frame,
318 consider extending the frame to make it fit. Our caller relies on
319 this when allocating a new slot. */
320 if (frame_offset
== start
&& this_frame_offset
< frame_offset
)
321 frame_offset
= this_frame_offset
;
322 else if (this_frame_offset
< start
)
324 else if (start
+ length
== frame_offset
325 && this_frame_offset
+ size
> start
+ length
)
326 frame_offset
= this_frame_offset
+ size
;
327 else if (this_frame_offset
+ size
> start
+ length
)
330 *poffset
= this_frame_offset
;
334 /* Create a new frame_space structure describing free space in the stack
335 frame beginning at START and ending at END, and chain it into the
336 function's frame_space_list. */
339 add_frame_space (HOST_WIDE_INT start
, HOST_WIDE_INT end
)
341 struct frame_space
*space
= ggc_alloc
<frame_space
> ();
342 space
->next
= crtl
->frame_space_list
;
343 crtl
->frame_space_list
= space
;
344 space
->start
= start
;
345 space
->length
= end
- start
;
348 /* Allocate a stack slot of SIZE bytes and return a MEM rtx for it
349 with machine mode MODE.
351 ALIGN controls the amount of alignment for the address of the slot:
352 0 means according to MODE,
353 -1 means use BIGGEST_ALIGNMENT and round size to multiple of that,
354 -2 means use BITS_PER_UNIT,
355 positive specifies alignment boundary in bits.
357 KIND has ASLK_REDUCE_ALIGN bit set if it is OK to reduce
358 alignment and ASLK_RECORD_PAD bit set if we should remember
359 extra space we allocated for alignment purposes. When we are
360 called from assign_stack_temp_for_type, it is not set so we don't
361 track the same stack slot in two independent lists.
363 We do not round to stack_boundary here. */
366 assign_stack_local_1 (machine_mode mode
, HOST_WIDE_INT size
,
370 int bigend_correction
= 0;
371 HOST_WIDE_INT slot_offset
= 0, old_frame_offset
;
372 unsigned int alignment
, alignment_in_bits
;
376 alignment
= get_stack_local_alignment (NULL
, mode
);
377 alignment
/= BITS_PER_UNIT
;
379 else if (align
== -1)
381 alignment
= BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
;
382 size
= CEIL_ROUND (size
, alignment
);
384 else if (align
== -2)
385 alignment
= 1; /* BITS_PER_UNIT / BITS_PER_UNIT */
387 alignment
= align
/ BITS_PER_UNIT
;
389 alignment_in_bits
= alignment
* BITS_PER_UNIT
;
391 /* Ignore alignment if it exceeds MAX_SUPPORTED_STACK_ALIGNMENT. */
392 if (alignment_in_bits
> MAX_SUPPORTED_STACK_ALIGNMENT
)
394 alignment_in_bits
= MAX_SUPPORTED_STACK_ALIGNMENT
;
395 alignment
= alignment_in_bits
/ BITS_PER_UNIT
;
398 if (SUPPORTS_STACK_ALIGNMENT
)
400 if (crtl
->stack_alignment_estimated
< alignment_in_bits
)
402 if (!crtl
->stack_realign_processed
)
403 crtl
->stack_alignment_estimated
= alignment_in_bits
;
406 /* If stack is realigned and stack alignment value
407 hasn't been finalized, it is OK not to increase
408 stack_alignment_estimated. The bigger alignment
409 requirement is recorded in stack_alignment_needed
411 gcc_assert (!crtl
->stack_realign_finalized
);
412 if (!crtl
->stack_realign_needed
)
414 /* It is OK to reduce the alignment as long as the
415 requested size is 0 or the estimated stack
416 alignment >= mode alignment. */
417 gcc_assert ((kind
& ASLK_REDUCE_ALIGN
)
419 || (crtl
->stack_alignment_estimated
420 >= GET_MODE_ALIGNMENT (mode
)));
421 alignment_in_bits
= crtl
->stack_alignment_estimated
;
422 alignment
= alignment_in_bits
/ BITS_PER_UNIT
;
428 if (crtl
->stack_alignment_needed
< alignment_in_bits
)
429 crtl
->stack_alignment_needed
= alignment_in_bits
;
430 if (crtl
->max_used_stack_slot_alignment
< alignment_in_bits
)
431 crtl
->max_used_stack_slot_alignment
= alignment_in_bits
;
433 if (mode
!= BLKmode
|| size
!= 0)
435 if (kind
& ASLK_RECORD_PAD
)
437 struct frame_space
**psp
;
439 for (psp
= &crtl
->frame_space_list
; *psp
; psp
= &(*psp
)->next
)
441 struct frame_space
*space
= *psp
;
442 if (!try_fit_stack_local (space
->start
, space
->length
, size
,
443 alignment
, &slot_offset
))
446 if (slot_offset
> space
->start
)
447 add_frame_space (space
->start
, slot_offset
);
448 if (slot_offset
+ size
< space
->start
+ space
->length
)
449 add_frame_space (slot_offset
+ size
,
450 space
->start
+ space
->length
);
455 else if (!STACK_ALIGNMENT_NEEDED
)
457 slot_offset
= frame_offset
;
461 old_frame_offset
= frame_offset
;
463 if (FRAME_GROWS_DOWNWARD
)
465 frame_offset
-= size
;
466 try_fit_stack_local (frame_offset
, size
, size
, alignment
, &slot_offset
);
468 if (kind
& ASLK_RECORD_PAD
)
470 if (slot_offset
> frame_offset
)
471 add_frame_space (frame_offset
, slot_offset
);
472 if (slot_offset
+ size
< old_frame_offset
)
473 add_frame_space (slot_offset
+ size
, old_frame_offset
);
478 frame_offset
+= size
;
479 try_fit_stack_local (old_frame_offset
, size
, size
, alignment
, &slot_offset
);
481 if (kind
& ASLK_RECORD_PAD
)
483 if (slot_offset
> old_frame_offset
)
484 add_frame_space (old_frame_offset
, slot_offset
);
485 if (slot_offset
+ size
< frame_offset
)
486 add_frame_space (slot_offset
+ size
, frame_offset
);
491 /* On a big-endian machine, if we are allocating more space than we will use,
492 use the least significant bytes of those that are allocated. */
493 if (BYTES_BIG_ENDIAN
&& mode
!= BLKmode
&& GET_MODE_SIZE (mode
) < size
)
494 bigend_correction
= size
- GET_MODE_SIZE (mode
);
496 /* If we have already instantiated virtual registers, return the actual
497 address relative to the frame pointer. */
498 if (virtuals_instantiated
)
499 addr
= plus_constant (Pmode
, frame_pointer_rtx
,
501 (slot_offset
+ bigend_correction
502 + STARTING_FRAME_OFFSET
, Pmode
));
504 addr
= plus_constant (Pmode
, virtual_stack_vars_rtx
,
506 (slot_offset
+ bigend_correction
,
509 x
= gen_rtx_MEM (mode
, addr
);
510 set_mem_align (x
, alignment_in_bits
);
511 MEM_NOTRAP_P (x
) = 1;
514 = gen_rtx_EXPR_LIST (VOIDmode
, x
, stack_slot_list
);
516 if (frame_offset_overflow (frame_offset
, current_function_decl
))
522 /* Wrap up assign_stack_local_1 with last parameter as false. */
525 assign_stack_local (machine_mode mode
, HOST_WIDE_INT size
, int align
)
527 return assign_stack_local_1 (mode
, size
, align
, ASLK_RECORD_PAD
);
530 /* In order to evaluate some expressions, such as function calls returning
531 structures in memory, we need to temporarily allocate stack locations.
532 We record each allocated temporary in the following structure.
534 Associated with each temporary slot is a nesting level. When we pop up
535 one level, all temporaries associated with the previous level are freed.
536 Normally, all temporaries are freed after the execution of the statement
537 in which they were created. However, if we are inside a ({...}) grouping,
538 the result may be in a temporary and hence must be preserved. If the
539 result could be in a temporary, we preserve it if we can determine which
540 one it is in. If we cannot determine which temporary may contain the
541 result, all temporaries are preserved. A temporary is preserved by
542 pretending it was allocated at the previous nesting level. */
544 struct GTY(()) temp_slot
{
545 /* Points to next temporary slot. */
546 struct temp_slot
*next
;
547 /* Points to previous temporary slot. */
548 struct temp_slot
*prev
;
549 /* The rtx to used to reference the slot. */
551 /* The size, in units, of the slot. */
553 /* The type of the object in the slot, or zero if it doesn't correspond
554 to a type. We use this to determine whether a slot can be reused.
555 It can be reused if objects of the type of the new slot will always
556 conflict with objects of the type of the old slot. */
558 /* The alignment (in bits) of the slot. */
560 /* Nonzero if this temporary is currently in use. */
562 /* Nesting level at which this slot is being used. */
564 /* The offset of the slot from the frame_pointer, including extra space
565 for alignment. This info is for combine_temp_slots. */
566 HOST_WIDE_INT base_offset
;
567 /* The size of the slot, including extra space for alignment. This
568 info is for combine_temp_slots. */
569 HOST_WIDE_INT full_size
;
572 /* Entry for the below hash table. */
573 struct GTY((for_user
)) temp_slot_address_entry
{
576 struct temp_slot
*temp_slot
;
579 struct temp_address_hasher
: ggc_hasher
<temp_slot_address_entry
*>
581 static hashval_t
hash (temp_slot_address_entry
*);
582 static bool equal (temp_slot_address_entry
*, temp_slot_address_entry
*);
585 /* A table of addresses that represent a stack slot. The table is a mapping
586 from address RTXen to a temp slot. */
587 static GTY(()) hash_table
<temp_address_hasher
> *temp_slot_address_table
;
588 static size_t n_temp_slots_in_use
;
590 /* Removes temporary slot TEMP from LIST. */
593 cut_slot_from_list (struct temp_slot
*temp
, struct temp_slot
**list
)
596 temp
->next
->prev
= temp
->prev
;
598 temp
->prev
->next
= temp
->next
;
602 temp
->prev
= temp
->next
= NULL
;
605 /* Inserts temporary slot TEMP to LIST. */
608 insert_slot_to_list (struct temp_slot
*temp
, struct temp_slot
**list
)
612 (*list
)->prev
= temp
;
617 /* Returns the list of used temp slots at LEVEL. */
619 static struct temp_slot
**
620 temp_slots_at_level (int level
)
622 if (level
>= (int) vec_safe_length (used_temp_slots
))
623 vec_safe_grow_cleared (used_temp_slots
, level
+ 1);
625 return &(*used_temp_slots
)[level
];
628 /* Returns the maximal temporary slot level. */
631 max_slot_level (void)
633 if (!used_temp_slots
)
636 return used_temp_slots
->length () - 1;
639 /* Moves temporary slot TEMP to LEVEL. */
642 move_slot_to_level (struct temp_slot
*temp
, int level
)
644 cut_slot_from_list (temp
, temp_slots_at_level (temp
->level
));
645 insert_slot_to_list (temp
, temp_slots_at_level (level
));
649 /* Make temporary slot TEMP available. */
652 make_slot_available (struct temp_slot
*temp
)
654 cut_slot_from_list (temp
, temp_slots_at_level (temp
->level
));
655 insert_slot_to_list (temp
, &avail_temp_slots
);
658 n_temp_slots_in_use
--;
661 /* Compute the hash value for an address -> temp slot mapping.
662 The value is cached on the mapping entry. */
664 temp_slot_address_compute_hash (struct temp_slot_address_entry
*t
)
666 int do_not_record
= 0;
667 return hash_rtx (t
->address
, GET_MODE (t
->address
),
668 &do_not_record
, NULL
, false);
671 /* Return the hash value for an address -> temp slot mapping. */
673 temp_address_hasher::hash (temp_slot_address_entry
*t
)
678 /* Compare two address -> temp slot mapping entries. */
680 temp_address_hasher::equal (temp_slot_address_entry
*t1
,
681 temp_slot_address_entry
*t2
)
683 return exp_equiv_p (t1
->address
, t2
->address
, 0, true);
686 /* Add ADDRESS as an alias of TEMP_SLOT to the addess -> temp slot mapping. */
688 insert_temp_slot_address (rtx address
, struct temp_slot
*temp_slot
)
690 struct temp_slot_address_entry
*t
= ggc_alloc
<temp_slot_address_entry
> ();
691 t
->address
= address
;
692 t
->temp_slot
= temp_slot
;
693 t
->hash
= temp_slot_address_compute_hash (t
);
694 *temp_slot_address_table
->find_slot_with_hash (t
, t
->hash
, INSERT
) = t
;
697 /* Remove an address -> temp slot mapping entry if the temp slot is
698 not in use anymore. Callback for remove_unused_temp_slot_addresses. */
700 remove_unused_temp_slot_addresses_1 (temp_slot_address_entry
**slot
, void *)
702 const struct temp_slot_address_entry
*t
= *slot
;
703 if (! t
->temp_slot
->in_use
)
704 temp_slot_address_table
->clear_slot (slot
);
708 /* Remove all mappings of addresses to unused temp slots. */
710 remove_unused_temp_slot_addresses (void)
712 /* Use quicker clearing if there aren't any active temp slots. */
713 if (n_temp_slots_in_use
)
714 temp_slot_address_table
->traverse
715 <void *, remove_unused_temp_slot_addresses_1
> (NULL
);
717 temp_slot_address_table
->empty ();
720 /* Find the temp slot corresponding to the object at address X. */
722 static struct temp_slot
*
723 find_temp_slot_from_address (rtx x
)
726 struct temp_slot_address_entry tmp
, *t
;
728 /* First try the easy way:
729 See if X exists in the address -> temp slot mapping. */
731 tmp
.temp_slot
= NULL
;
732 tmp
.hash
= temp_slot_address_compute_hash (&tmp
);
733 t
= temp_slot_address_table
->find_with_hash (&tmp
, tmp
.hash
);
737 /* If we have a sum involving a register, see if it points to a temp
739 if (GET_CODE (x
) == PLUS
&& REG_P (XEXP (x
, 0))
740 && (p
= find_temp_slot_from_address (XEXP (x
, 0))) != 0)
742 else if (GET_CODE (x
) == PLUS
&& REG_P (XEXP (x
, 1))
743 && (p
= find_temp_slot_from_address (XEXP (x
, 1))) != 0)
746 /* Last resort: Address is a virtual stack var address. */
747 if (GET_CODE (x
) == PLUS
748 && XEXP (x
, 0) == virtual_stack_vars_rtx
749 && CONST_INT_P (XEXP (x
, 1)))
752 for (i
= max_slot_level (); i
>= 0; i
--)
753 for (p
= *temp_slots_at_level (i
); p
; p
= p
->next
)
755 if (INTVAL (XEXP (x
, 1)) >= p
->base_offset
756 && INTVAL (XEXP (x
, 1)) < p
->base_offset
+ p
->full_size
)
764 /* Allocate a temporary stack slot and record it for possible later
767 MODE is the machine mode to be given to the returned rtx.
769 SIZE is the size in units of the space required. We do no rounding here
770 since assign_stack_local will do any required rounding.
772 TYPE is the type that will be used for the stack slot. */
775 assign_stack_temp_for_type (machine_mode mode
, HOST_WIDE_INT size
,
779 struct temp_slot
*p
, *best_p
= 0, *selected
= NULL
, **pp
;
782 /* If SIZE is -1 it means that somebody tried to allocate a temporary
783 of a variable size. */
784 gcc_assert (size
!= -1);
786 align
= get_stack_local_alignment (type
, mode
);
788 /* Try to find an available, already-allocated temporary of the proper
789 mode which meets the size and alignment requirements. Choose the
790 smallest one with the closest alignment.
792 If assign_stack_temp is called outside of the tree->rtl expansion,
793 we cannot reuse the stack slots (that may still refer to
794 VIRTUAL_STACK_VARS_REGNUM). */
795 if (!virtuals_instantiated
)
797 for (p
= avail_temp_slots
; p
; p
= p
->next
)
799 if (p
->align
>= align
&& p
->size
>= size
800 && GET_MODE (p
->slot
) == mode
801 && objects_must_conflict_p (p
->type
, type
)
802 && (best_p
== 0 || best_p
->size
> p
->size
803 || (best_p
->size
== p
->size
&& best_p
->align
> p
->align
)))
805 if (p
->align
== align
&& p
->size
== size
)
808 cut_slot_from_list (selected
, &avail_temp_slots
);
817 /* Make our best, if any, the one to use. */
821 cut_slot_from_list (selected
, &avail_temp_slots
);
823 /* If there are enough aligned bytes left over, make them into a new
824 temp_slot so that the extra bytes don't get wasted. Do this only
825 for BLKmode slots, so that we can be sure of the alignment. */
826 if (GET_MODE (best_p
->slot
) == BLKmode
)
828 int alignment
= best_p
->align
/ BITS_PER_UNIT
;
829 HOST_WIDE_INT rounded_size
= CEIL_ROUND (size
, alignment
);
831 if (best_p
->size
- rounded_size
>= alignment
)
833 p
= ggc_alloc
<temp_slot
> ();
835 p
->size
= best_p
->size
- rounded_size
;
836 p
->base_offset
= best_p
->base_offset
+ rounded_size
;
837 p
->full_size
= best_p
->full_size
- rounded_size
;
838 p
->slot
= adjust_address_nv (best_p
->slot
, BLKmode
, rounded_size
);
839 p
->align
= best_p
->align
;
840 p
->type
= best_p
->type
;
841 insert_slot_to_list (p
, &avail_temp_slots
);
843 stack_slot_list
= gen_rtx_EXPR_LIST (VOIDmode
, p
->slot
,
846 best_p
->size
= rounded_size
;
847 best_p
->full_size
= rounded_size
;
852 /* If we still didn't find one, make a new temporary. */
855 HOST_WIDE_INT frame_offset_old
= frame_offset
;
857 p
= ggc_alloc
<temp_slot
> ();
859 /* We are passing an explicit alignment request to assign_stack_local.
860 One side effect of that is assign_stack_local will not round SIZE
861 to ensure the frame offset remains suitably aligned.
863 So for requests which depended on the rounding of SIZE, we go ahead
864 and round it now. We also make sure ALIGNMENT is at least
865 BIGGEST_ALIGNMENT. */
866 gcc_assert (mode
!= BLKmode
|| align
== BIGGEST_ALIGNMENT
);
867 p
->slot
= assign_stack_local_1 (mode
,
877 /* The following slot size computation is necessary because we don't
878 know the actual size of the temporary slot until assign_stack_local
879 has performed all the frame alignment and size rounding for the
880 requested temporary. Note that extra space added for alignment
881 can be either above or below this stack slot depending on which
882 way the frame grows. We include the extra space if and only if it
883 is above this slot. */
884 if (FRAME_GROWS_DOWNWARD
)
885 p
->size
= frame_offset_old
- frame_offset
;
889 /* Now define the fields used by combine_temp_slots. */
890 if (FRAME_GROWS_DOWNWARD
)
892 p
->base_offset
= frame_offset
;
893 p
->full_size
= frame_offset_old
- frame_offset
;
897 p
->base_offset
= frame_offset_old
;
898 p
->full_size
= frame_offset
- frame_offset_old
;
907 p
->level
= temp_slot_level
;
908 n_temp_slots_in_use
++;
910 pp
= temp_slots_at_level (p
->level
);
911 insert_slot_to_list (p
, pp
);
912 insert_temp_slot_address (XEXP (p
->slot
, 0), p
);
914 /* Create a new MEM rtx to avoid clobbering MEM flags of old slots. */
915 slot
= gen_rtx_MEM (mode
, XEXP (p
->slot
, 0));
916 stack_slot_list
= gen_rtx_EXPR_LIST (VOIDmode
, slot
, stack_slot_list
);
918 /* If we know the alias set for the memory that will be used, use
919 it. If there's no TYPE, then we don't know anything about the
920 alias set for the memory. */
921 set_mem_alias_set (slot
, type
? get_alias_set (type
) : 0);
922 set_mem_align (slot
, align
);
924 /* If a type is specified, set the relevant flags. */
926 MEM_VOLATILE_P (slot
) = TYPE_VOLATILE (type
);
927 MEM_NOTRAP_P (slot
) = 1;
932 /* Allocate a temporary stack slot and record it for possible later
933 reuse. First two arguments are same as in preceding function. */
936 assign_stack_temp (machine_mode mode
, HOST_WIDE_INT size
)
938 return assign_stack_temp_for_type (mode
, size
, NULL_TREE
);
941 /* Assign a temporary.
942 If TYPE_OR_DECL is a decl, then we are doing it on behalf of the decl
943 and so that should be used in error messages. In either case, we
944 allocate of the given type.
945 MEMORY_REQUIRED is 1 if the result must be addressable stack memory;
946 it is 0 if a register is OK.
947 DONT_PROMOTE is 1 if we should not promote values in register
951 assign_temp (tree type_or_decl
, int memory_required
,
952 int dont_promote ATTRIBUTE_UNUSED
)
960 if (DECL_P (type_or_decl
))
961 decl
= type_or_decl
, type
= TREE_TYPE (decl
);
963 decl
= NULL
, type
= type_or_decl
;
965 mode
= TYPE_MODE (type
);
967 unsignedp
= TYPE_UNSIGNED (type
);
970 if (mode
== BLKmode
|| memory_required
)
972 HOST_WIDE_INT size
= int_size_in_bytes (type
);
975 /* Zero sized arrays are GNU C extension. Set size to 1 to avoid
976 problems with allocating the stack space. */
980 /* Unfortunately, we don't yet know how to allocate variable-sized
981 temporaries. However, sometimes we can find a fixed upper limit on
982 the size, so try that instead. */
984 size
= max_int_size_in_bytes (type
);
986 /* The size of the temporary may be too large to fit into an integer. */
987 /* ??? Not sure this should happen except for user silliness, so limit
988 this to things that aren't compiler-generated temporaries. The
989 rest of the time we'll die in assign_stack_temp_for_type. */
990 if (decl
&& size
== -1
991 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
)
993 error ("size of variable %q+D is too large", decl
);
997 tmp
= assign_stack_temp_for_type (mode
, size
, type
);
1003 mode
= promote_mode (type
, mode
, &unsignedp
);
1006 return gen_reg_rtx (mode
);
1009 /* Combine temporary stack slots which are adjacent on the stack.
1011 This allows for better use of already allocated stack space. This is only
1012 done for BLKmode slots because we can be sure that we won't have alignment
1013 problems in this case. */
1016 combine_temp_slots (void)
1018 struct temp_slot
*p
, *q
, *next
, *next_q
;
1021 /* We can't combine slots, because the information about which slot
1022 is in which alias set will be lost. */
1023 if (flag_strict_aliasing
)
1026 /* If there are a lot of temp slots, don't do anything unless
1027 high levels of optimization. */
1028 if (! flag_expensive_optimizations
)
1029 for (p
= avail_temp_slots
, num_slots
= 0; p
; p
= p
->next
, num_slots
++)
1030 if (num_slots
> 100 || (num_slots
> 10 && optimize
== 0))
1033 for (p
= avail_temp_slots
; p
; p
= next
)
1039 if (GET_MODE (p
->slot
) != BLKmode
)
1042 for (q
= p
->next
; q
; q
= next_q
)
1048 if (GET_MODE (q
->slot
) != BLKmode
)
1051 if (p
->base_offset
+ p
->full_size
== q
->base_offset
)
1053 /* Q comes after P; combine Q into P. */
1055 p
->full_size
+= q
->full_size
;
1058 else if (q
->base_offset
+ q
->full_size
== p
->base_offset
)
1060 /* P comes after Q; combine P into Q. */
1062 q
->full_size
+= p
->full_size
;
1067 cut_slot_from_list (q
, &avail_temp_slots
);
1070 /* Either delete P or advance past it. */
1072 cut_slot_from_list (p
, &avail_temp_slots
);
1076 /* Indicate that NEW_RTX is an alternate way of referring to the temp
1077 slot that previously was known by OLD_RTX. */
1080 update_temp_slot_address (rtx old_rtx
, rtx new_rtx
)
1082 struct temp_slot
*p
;
1084 if (rtx_equal_p (old_rtx
, new_rtx
))
1087 p
= find_temp_slot_from_address (old_rtx
);
1089 /* If we didn't find one, see if both OLD_RTX is a PLUS. If so, and
1090 NEW_RTX is a register, see if one operand of the PLUS is a
1091 temporary location. If so, NEW_RTX points into it. Otherwise,
1092 if both OLD_RTX and NEW_RTX are a PLUS and if there is a register
1093 in common between them. If so, try a recursive call on those
1097 if (GET_CODE (old_rtx
) != PLUS
)
1100 if (REG_P (new_rtx
))
1102 update_temp_slot_address (XEXP (old_rtx
, 0), new_rtx
);
1103 update_temp_slot_address (XEXP (old_rtx
, 1), new_rtx
);
1106 else if (GET_CODE (new_rtx
) != PLUS
)
1109 if (rtx_equal_p (XEXP (old_rtx
, 0), XEXP (new_rtx
, 0)))
1110 update_temp_slot_address (XEXP (old_rtx
, 1), XEXP (new_rtx
, 1));
1111 else if (rtx_equal_p (XEXP (old_rtx
, 1), XEXP (new_rtx
, 0)))
1112 update_temp_slot_address (XEXP (old_rtx
, 0), XEXP (new_rtx
, 1));
1113 else if (rtx_equal_p (XEXP (old_rtx
, 0), XEXP (new_rtx
, 1)))
1114 update_temp_slot_address (XEXP (old_rtx
, 1), XEXP (new_rtx
, 0));
1115 else if (rtx_equal_p (XEXP (old_rtx
, 1), XEXP (new_rtx
, 1)))
1116 update_temp_slot_address (XEXP (old_rtx
, 0), XEXP (new_rtx
, 0));
1121 /* Otherwise add an alias for the temp's address. */
1122 insert_temp_slot_address (new_rtx
, p
);
1125 /* If X could be a reference to a temporary slot, mark that slot as
1126 belonging to the to one level higher than the current level. If X
1127 matched one of our slots, just mark that one. Otherwise, we can't
1128 easily predict which it is, so upgrade all of them.
1130 This is called when an ({...}) construct occurs and a statement
1131 returns a value in memory. */
1134 preserve_temp_slots (rtx x
)
1136 struct temp_slot
*p
= 0, *next
;
1141 /* If X is a register that is being used as a pointer, see if we have
1142 a temporary slot we know it points to. */
1143 if (REG_P (x
) && REG_POINTER (x
))
1144 p
= find_temp_slot_from_address (x
);
1146 /* If X is not in memory or is at a constant address, it cannot be in
1147 a temporary slot. */
1148 if (p
== 0 && (!MEM_P (x
) || CONSTANT_P (XEXP (x
, 0))))
1151 /* First see if we can find a match. */
1153 p
= find_temp_slot_from_address (XEXP (x
, 0));
1157 if (p
->level
== temp_slot_level
)
1158 move_slot_to_level (p
, temp_slot_level
- 1);
1162 /* Otherwise, preserve all non-kept slots at this level. */
1163 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1166 move_slot_to_level (p
, temp_slot_level
- 1);
1170 /* Free all temporaries used so far. This is normally called at the
1171 end of generating code for a statement. */
1174 free_temp_slots (void)
1176 struct temp_slot
*p
, *next
;
1177 bool some_available
= false;
1179 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1182 make_slot_available (p
);
1183 some_available
= true;
1188 remove_unused_temp_slot_addresses ();
1189 combine_temp_slots ();
1193 /* Push deeper into the nesting level for stack temporaries. */
1196 push_temp_slots (void)
1201 /* Pop a temporary nesting level. All slots in use in the current level
1205 pop_temp_slots (void)
1211 /* Initialize temporary slots. */
1214 init_temp_slots (void)
1216 /* We have not allocated any temporaries yet. */
1217 avail_temp_slots
= 0;
1218 vec_alloc (used_temp_slots
, 0);
1219 temp_slot_level
= 0;
1220 n_temp_slots_in_use
= 0;
1222 /* Set up the table to map addresses to temp slots. */
1223 if (! temp_slot_address_table
)
1224 temp_slot_address_table
= hash_table
<temp_address_hasher
>::create_ggc (32);
1226 temp_slot_address_table
->empty ();
1229 /* Functions and data structures to keep track of the values hard regs
1230 had at the start of the function. */
1232 /* Private type used by get_hard_reg_initial_reg, get_hard_reg_initial_val,
1233 and has_hard_reg_initial_val.. */
1234 typedef struct GTY(()) initial_value_pair
{
1237 } initial_value_pair
;
1238 /* ??? This could be a VEC but there is currently no way to define an
1239 opaque VEC type. This could be worked around by defining struct
1240 initial_value_pair in function.h. */
1241 typedef struct GTY(()) initial_value_struct
{
1244 initial_value_pair
* GTY ((length ("%h.num_entries"))) entries
;
1245 } initial_value_struct
;
1247 /* If a pseudo represents an initial hard reg (or expression), return
1248 it, else return NULL_RTX. */
1251 get_hard_reg_initial_reg (rtx reg
)
1253 struct initial_value_struct
*ivs
= crtl
->hard_reg_initial_vals
;
1259 for (i
= 0; i
< ivs
->num_entries
; i
++)
1260 if (rtx_equal_p (ivs
->entries
[i
].pseudo
, reg
))
1261 return ivs
->entries
[i
].hard_reg
;
1266 /* Make sure that there's a pseudo register of mode MODE that stores the
1267 initial value of hard register REGNO. Return an rtx for such a pseudo. */
1270 get_hard_reg_initial_val (machine_mode mode
, unsigned int regno
)
1272 struct initial_value_struct
*ivs
;
1275 rv
= has_hard_reg_initial_val (mode
, regno
);
1279 ivs
= crtl
->hard_reg_initial_vals
;
1282 ivs
= ggc_alloc
<initial_value_struct
> ();
1283 ivs
->num_entries
= 0;
1284 ivs
->max_entries
= 5;
1285 ivs
->entries
= ggc_vec_alloc
<initial_value_pair
> (5);
1286 crtl
->hard_reg_initial_vals
= ivs
;
1289 if (ivs
->num_entries
>= ivs
->max_entries
)
1291 ivs
->max_entries
+= 5;
1292 ivs
->entries
= GGC_RESIZEVEC (initial_value_pair
, ivs
->entries
,
1296 ivs
->entries
[ivs
->num_entries
].hard_reg
= gen_rtx_REG (mode
, regno
);
1297 ivs
->entries
[ivs
->num_entries
].pseudo
= gen_reg_rtx (mode
);
1299 return ivs
->entries
[ivs
->num_entries
++].pseudo
;
1302 /* See if get_hard_reg_initial_val has been used to create a pseudo
1303 for the initial value of hard register REGNO in mode MODE. Return
1304 the associated pseudo if so, otherwise return NULL. */
1307 has_hard_reg_initial_val (machine_mode mode
, unsigned int regno
)
1309 struct initial_value_struct
*ivs
;
1312 ivs
= crtl
->hard_reg_initial_vals
;
1314 for (i
= 0; i
< ivs
->num_entries
; i
++)
1315 if (GET_MODE (ivs
->entries
[i
].hard_reg
) == mode
1316 && REGNO (ivs
->entries
[i
].hard_reg
) == regno
)
1317 return ivs
->entries
[i
].pseudo
;
1323 emit_initial_value_sets (void)
1325 struct initial_value_struct
*ivs
= crtl
->hard_reg_initial_vals
;
1333 for (i
= 0; i
< ivs
->num_entries
; i
++)
1334 emit_move_insn (ivs
->entries
[i
].pseudo
, ivs
->entries
[i
].hard_reg
);
1338 emit_insn_at_entry (seq
);
1342 /* Return the hardreg-pseudoreg initial values pair entry I and
1343 TRUE if I is a valid entry, or FALSE if I is not a valid entry. */
1345 initial_value_entry (int i
, rtx
*hreg
, rtx
*preg
)
1347 struct initial_value_struct
*ivs
= crtl
->hard_reg_initial_vals
;
1348 if (!ivs
|| i
>= ivs
->num_entries
)
1351 *hreg
= ivs
->entries
[i
].hard_reg
;
1352 *preg
= ivs
->entries
[i
].pseudo
;
1356 /* These routines are responsible for converting virtual register references
1357 to the actual hard register references once RTL generation is complete.
1359 The following four variables are used for communication between the
1360 routines. They contain the offsets of the virtual registers from their
1361 respective hard registers. */
1363 static int in_arg_offset
;
1364 static int var_offset
;
1365 static int dynamic_offset
;
1366 static int out_arg_offset
;
1367 static int cfa_offset
;
1369 /* In most machines, the stack pointer register is equivalent to the bottom
1372 #ifndef STACK_POINTER_OFFSET
1373 #define STACK_POINTER_OFFSET 0
1376 #if defined (REG_PARM_STACK_SPACE) && !defined (INCOMING_REG_PARM_STACK_SPACE)
1377 #define INCOMING_REG_PARM_STACK_SPACE REG_PARM_STACK_SPACE
1380 /* If not defined, pick an appropriate default for the offset of dynamically
1381 allocated memory depending on the value of ACCUMULATE_OUTGOING_ARGS,
1382 INCOMING_REG_PARM_STACK_SPACE, and OUTGOING_REG_PARM_STACK_SPACE. */
1384 #ifndef STACK_DYNAMIC_OFFSET
1386 /* The bottom of the stack points to the actual arguments. If
1387 REG_PARM_STACK_SPACE is defined, this includes the space for the register
1388 parameters. However, if OUTGOING_REG_PARM_STACK space is not defined,
1389 stack space for register parameters is not pushed by the caller, but
1390 rather part of the fixed stack areas and hence not included in
1391 `crtl->outgoing_args_size'. Nevertheless, we must allow
1392 for it when allocating stack dynamic objects. */
1394 #ifdef INCOMING_REG_PARM_STACK_SPACE
1395 #define STACK_DYNAMIC_OFFSET(FNDECL) \
1396 ((ACCUMULATE_OUTGOING_ARGS \
1397 ? (crtl->outgoing_args_size \
1398 + (OUTGOING_REG_PARM_STACK_SPACE ((!(FNDECL) ? NULL_TREE : TREE_TYPE (FNDECL))) ? 0 \
1399 : INCOMING_REG_PARM_STACK_SPACE (FNDECL))) \
1400 : 0) + (STACK_POINTER_OFFSET))
1402 #define STACK_DYNAMIC_OFFSET(FNDECL) \
1403 ((ACCUMULATE_OUTGOING_ARGS ? crtl->outgoing_args_size : 0) \
1404 + (STACK_POINTER_OFFSET))
1409 /* Given a piece of RTX and a pointer to a HOST_WIDE_INT, if the RTX
1410 is a virtual register, return the equivalent hard register and set the
1411 offset indirectly through the pointer. Otherwise, return 0. */
1414 instantiate_new_reg (rtx x
, HOST_WIDE_INT
*poffset
)
1417 HOST_WIDE_INT offset
;
1419 if (x
== virtual_incoming_args_rtx
)
1421 if (stack_realign_drap
)
1423 /* Replace virtual_incoming_args_rtx with internal arg
1424 pointer if DRAP is used to realign stack. */
1425 new_rtx
= crtl
->args
.internal_arg_pointer
;
1429 new_rtx
= arg_pointer_rtx
, offset
= in_arg_offset
;
1431 else if (x
== virtual_stack_vars_rtx
)
1432 new_rtx
= frame_pointer_rtx
, offset
= var_offset
;
1433 else if (x
== virtual_stack_dynamic_rtx
)
1434 new_rtx
= stack_pointer_rtx
, offset
= dynamic_offset
;
1435 else if (x
== virtual_outgoing_args_rtx
)
1436 new_rtx
= stack_pointer_rtx
, offset
= out_arg_offset
;
1437 else if (x
== virtual_cfa_rtx
)
1439 #ifdef FRAME_POINTER_CFA_OFFSET
1440 new_rtx
= frame_pointer_rtx
;
1442 new_rtx
= arg_pointer_rtx
;
1444 offset
= cfa_offset
;
1446 else if (x
== virtual_preferred_stack_boundary_rtx
)
1448 new_rtx
= GEN_INT (crtl
->preferred_stack_boundary
/ BITS_PER_UNIT
);
1458 /* A subroutine of instantiate_virtual_regs. Instantiate any virtual
1459 registers present inside of *LOC. The expression is simplified,
1460 as much as possible, but is not to be considered "valid" in any sense
1461 implied by the target. Return true if any change is made. */
1464 instantiate_virtual_regs_in_rtx (rtx
*loc
)
1468 bool changed
= false;
1469 subrtx_ptr_iterator::array_type array
;
1470 FOR_EACH_SUBRTX_PTR (iter
, array
, loc
, NONCONST
)
1476 HOST_WIDE_INT offset
;
1477 switch (GET_CODE (x
))
1480 new_rtx
= instantiate_new_reg (x
, &offset
);
1483 *loc
= plus_constant (GET_MODE (x
), new_rtx
, offset
);
1486 iter
.skip_subrtxes ();
1490 new_rtx
= instantiate_new_reg (XEXP (x
, 0), &offset
);
1493 XEXP (x
, 0) = new_rtx
;
1494 *loc
= plus_constant (GET_MODE (x
), x
, offset
, true);
1496 iter
.skip_subrtxes ();
1500 /* FIXME -- from old code */
1501 /* If we have (plus (subreg (virtual-reg)) (const_int)), we know
1502 we can commute the PLUS and SUBREG because pointers into the
1503 frame are well-behaved. */
1514 /* A subroutine of instantiate_virtual_regs_in_insn. Return true if X
1515 matches the predicate for insn CODE operand OPERAND. */
1518 safe_insn_predicate (int code
, int operand
, rtx x
)
1520 return code
< 0 || insn_operand_matches ((enum insn_code
) code
, operand
, x
);
1523 /* A subroutine of instantiate_virtual_regs. Instantiate any virtual
1524 registers present inside of insn. The result will be a valid insn. */
1527 instantiate_virtual_regs_in_insn (rtx_insn
*insn
)
1529 HOST_WIDE_INT offset
;
1531 bool any_change
= false;
1532 rtx set
, new_rtx
, x
;
1535 /* There are some special cases to be handled first. */
1536 set
= single_set (insn
);
1539 /* We're allowed to assign to a virtual register. This is interpreted
1540 to mean that the underlying register gets assigned the inverse
1541 transformation. This is used, for example, in the handling of
1543 new_rtx
= instantiate_new_reg (SET_DEST (set
), &offset
);
1548 instantiate_virtual_regs_in_rtx (&SET_SRC (set
));
1549 x
= simplify_gen_binary (PLUS
, GET_MODE (new_rtx
), SET_SRC (set
),
1550 gen_int_mode (-offset
, GET_MODE (new_rtx
)));
1551 x
= force_operand (x
, new_rtx
);
1553 emit_move_insn (new_rtx
, x
);
1558 emit_insn_before (seq
, insn
);
1563 /* Handle a straight copy from a virtual register by generating a
1564 new add insn. The difference between this and falling through
1565 to the generic case is avoiding a new pseudo and eliminating a
1566 move insn in the initial rtl stream. */
1567 new_rtx
= instantiate_new_reg (SET_SRC (set
), &offset
);
1568 if (new_rtx
&& offset
!= 0
1569 && REG_P (SET_DEST (set
))
1570 && REGNO (SET_DEST (set
)) > LAST_VIRTUAL_REGISTER
)
1574 x
= expand_simple_binop (GET_MODE (SET_DEST (set
)), PLUS
, new_rtx
,
1575 gen_int_mode (offset
,
1576 GET_MODE (SET_DEST (set
))),
1577 SET_DEST (set
), 1, OPTAB_LIB_WIDEN
);
1578 if (x
!= SET_DEST (set
))
1579 emit_move_insn (SET_DEST (set
), x
);
1584 emit_insn_before (seq
, insn
);
1589 extract_insn (insn
);
1590 insn_code
= INSN_CODE (insn
);
1592 /* Handle a plus involving a virtual register by determining if the
1593 operands remain valid if they're modified in place. */
1594 if (GET_CODE (SET_SRC (set
)) == PLUS
1595 && recog_data
.n_operands
>= 3
1596 && recog_data
.operand_loc
[1] == &XEXP (SET_SRC (set
), 0)
1597 && recog_data
.operand_loc
[2] == &XEXP (SET_SRC (set
), 1)
1598 && CONST_INT_P (recog_data
.operand
[2])
1599 && (new_rtx
= instantiate_new_reg (recog_data
.operand
[1], &offset
)))
1601 offset
+= INTVAL (recog_data
.operand
[2]);
1603 /* If the sum is zero, then replace with a plain move. */
1605 && REG_P (SET_DEST (set
))
1606 && REGNO (SET_DEST (set
)) > LAST_VIRTUAL_REGISTER
)
1609 emit_move_insn (SET_DEST (set
), new_rtx
);
1613 emit_insn_before (seq
, insn
);
1618 x
= gen_int_mode (offset
, recog_data
.operand_mode
[2]);
1620 /* Using validate_change and apply_change_group here leaves
1621 recog_data in an invalid state. Since we know exactly what
1622 we want to check, do those two by hand. */
1623 if (safe_insn_predicate (insn_code
, 1, new_rtx
)
1624 && safe_insn_predicate (insn_code
, 2, x
))
1626 *recog_data
.operand_loc
[1] = recog_data
.operand
[1] = new_rtx
;
1627 *recog_data
.operand_loc
[2] = recog_data
.operand
[2] = x
;
1630 /* Fall through into the regular operand fixup loop in
1631 order to take care of operands other than 1 and 2. */
1637 extract_insn (insn
);
1638 insn_code
= INSN_CODE (insn
);
1641 /* In the general case, we expect virtual registers to appear only in
1642 operands, and then only as either bare registers or inside memories. */
1643 for (i
= 0; i
< recog_data
.n_operands
; ++i
)
1645 x
= recog_data
.operand
[i
];
1646 switch (GET_CODE (x
))
1650 rtx addr
= XEXP (x
, 0);
1652 if (!instantiate_virtual_regs_in_rtx (&addr
))
1656 x
= replace_equiv_address (x
, addr
, true);
1657 /* It may happen that the address with the virtual reg
1658 was valid (e.g. based on the virtual stack reg, which might
1659 be acceptable to the predicates with all offsets), whereas
1660 the address now isn't anymore, for instance when the address
1661 is still offsetted, but the base reg isn't virtual-stack-reg
1662 anymore. Below we would do a force_reg on the whole operand,
1663 but this insn might actually only accept memory. Hence,
1664 before doing that last resort, try to reload the address into
1665 a register, so this operand stays a MEM. */
1666 if (!safe_insn_predicate (insn_code
, i
, x
))
1668 addr
= force_reg (GET_MODE (addr
), addr
);
1669 x
= replace_equiv_address (x
, addr
, true);
1674 emit_insn_before (seq
, insn
);
1679 new_rtx
= instantiate_new_reg (x
, &offset
);
1680 if (new_rtx
== NULL
)
1688 /* Careful, special mode predicates may have stuff in
1689 insn_data[insn_code].operand[i].mode that isn't useful
1690 to us for computing a new value. */
1691 /* ??? Recognize address_operand and/or "p" constraints
1692 to see if (plus new offset) is a valid before we put
1693 this through expand_simple_binop. */
1694 x
= expand_simple_binop (GET_MODE (x
), PLUS
, new_rtx
,
1695 gen_int_mode (offset
, GET_MODE (x
)),
1696 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
1699 emit_insn_before (seq
, insn
);
1704 new_rtx
= instantiate_new_reg (SUBREG_REG (x
), &offset
);
1705 if (new_rtx
== NULL
)
1710 new_rtx
= expand_simple_binop
1711 (GET_MODE (new_rtx
), PLUS
, new_rtx
,
1712 gen_int_mode (offset
, GET_MODE (new_rtx
)),
1713 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
1716 emit_insn_before (seq
, insn
);
1718 x
= simplify_gen_subreg (recog_data
.operand_mode
[i
], new_rtx
,
1719 GET_MODE (new_rtx
), SUBREG_BYTE (x
));
1727 /* At this point, X contains the new value for the operand.
1728 Validate the new value vs the insn predicate. Note that
1729 asm insns will have insn_code -1 here. */
1730 if (!safe_insn_predicate (insn_code
, i
, x
))
1735 gcc_assert (REGNO (x
) <= LAST_VIRTUAL_REGISTER
);
1736 x
= copy_to_reg (x
);
1739 x
= force_reg (insn_data
[insn_code
].operand
[i
].mode
, x
);
1743 emit_insn_before (seq
, insn
);
1746 *recog_data
.operand_loc
[i
] = recog_data
.operand
[i
] = x
;
1752 /* Propagate operand changes into the duplicates. */
1753 for (i
= 0; i
< recog_data
.n_dups
; ++i
)
1754 *recog_data
.dup_loc
[i
]
1755 = copy_rtx (recog_data
.operand
[(unsigned)recog_data
.dup_num
[i
]]);
1757 /* Force re-recognition of the instruction for validation. */
1758 INSN_CODE (insn
) = -1;
1761 if (asm_noperands (PATTERN (insn
)) >= 0)
1763 if (!check_asm_operands (PATTERN (insn
)))
1765 error_for_asm (insn
, "impossible constraint in %<asm%>");
1766 /* For asm goto, instead of fixing up all the edges
1767 just clear the template and clear input operands
1768 (asm goto doesn't have any output operands). */
1771 rtx asm_op
= extract_asm_operands (PATTERN (insn
));
1772 ASM_OPERANDS_TEMPLATE (asm_op
) = ggc_strdup ("");
1773 ASM_OPERANDS_INPUT_VEC (asm_op
) = rtvec_alloc (0);
1774 ASM_OPERANDS_INPUT_CONSTRAINT_VEC (asm_op
) = rtvec_alloc (0);
1782 if (recog_memoized (insn
) < 0)
1783 fatal_insn_not_found (insn
);
1787 /* Subroutine of instantiate_decls. Given RTL representing a decl,
1788 do any instantiation required. */
1791 instantiate_decl_rtl (rtx x
)
1798 /* If this is a CONCAT, recurse for the pieces. */
1799 if (GET_CODE (x
) == CONCAT
)
1801 instantiate_decl_rtl (XEXP (x
, 0));
1802 instantiate_decl_rtl (XEXP (x
, 1));
1806 /* If this is not a MEM, no need to do anything. Similarly if the
1807 address is a constant or a register that is not a virtual register. */
1812 if (CONSTANT_P (addr
)
1814 && (REGNO (addr
) < FIRST_VIRTUAL_REGISTER
1815 || REGNO (addr
) > LAST_VIRTUAL_REGISTER
)))
1818 instantiate_virtual_regs_in_rtx (&XEXP (x
, 0));
1821 /* Helper for instantiate_decls called via walk_tree: Process all decls
1822 in the given DECL_VALUE_EXPR. */
1825 instantiate_expr (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
1833 if (DECL_RTL_SET_P (t
))
1834 instantiate_decl_rtl (DECL_RTL (t
));
1835 if (TREE_CODE (t
) == PARM_DECL
&& DECL_NAMELESS (t
)
1836 && DECL_INCOMING_RTL (t
))
1837 instantiate_decl_rtl (DECL_INCOMING_RTL (t
));
1838 if ((TREE_CODE (t
) == VAR_DECL
1839 || TREE_CODE (t
) == RESULT_DECL
)
1840 && DECL_HAS_VALUE_EXPR_P (t
))
1842 tree v
= DECL_VALUE_EXPR (t
);
1843 walk_tree (&v
, instantiate_expr
, NULL
, NULL
);
1850 /* Subroutine of instantiate_decls: Process all decls in the given
1851 BLOCK node and all its subblocks. */
1854 instantiate_decls_1 (tree let
)
1858 for (t
= BLOCK_VARS (let
); t
; t
= DECL_CHAIN (t
))
1860 if (DECL_RTL_SET_P (t
))
1861 instantiate_decl_rtl (DECL_RTL (t
));
1862 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (t
))
1864 tree v
= DECL_VALUE_EXPR (t
);
1865 walk_tree (&v
, instantiate_expr
, NULL
, NULL
);
1869 /* Process all subblocks. */
1870 for (t
= BLOCK_SUBBLOCKS (let
); t
; t
= BLOCK_CHAIN (t
))
1871 instantiate_decls_1 (t
);
1874 /* Scan all decls in FNDECL (both variables and parameters) and instantiate
1875 all virtual registers in their DECL_RTL's. */
1878 instantiate_decls (tree fndecl
)
1883 /* Process all parameters of the function. */
1884 for (decl
= DECL_ARGUMENTS (fndecl
); decl
; decl
= DECL_CHAIN (decl
))
1886 instantiate_decl_rtl (DECL_RTL (decl
));
1887 instantiate_decl_rtl (DECL_INCOMING_RTL (decl
));
1888 if (DECL_HAS_VALUE_EXPR_P (decl
))
1890 tree v
= DECL_VALUE_EXPR (decl
);
1891 walk_tree (&v
, instantiate_expr
, NULL
, NULL
);
1895 if ((decl
= DECL_RESULT (fndecl
))
1896 && TREE_CODE (decl
) == RESULT_DECL
)
1898 if (DECL_RTL_SET_P (decl
))
1899 instantiate_decl_rtl (DECL_RTL (decl
));
1900 if (DECL_HAS_VALUE_EXPR_P (decl
))
1902 tree v
= DECL_VALUE_EXPR (decl
);
1903 walk_tree (&v
, instantiate_expr
, NULL
, NULL
);
1907 /* Process the saved static chain if it exists. */
1908 decl
= DECL_STRUCT_FUNCTION (fndecl
)->static_chain_decl
;
1909 if (decl
&& DECL_HAS_VALUE_EXPR_P (decl
))
1910 instantiate_decl_rtl (DECL_RTL (DECL_VALUE_EXPR (decl
)));
1912 /* Now process all variables defined in the function or its subblocks. */
1913 instantiate_decls_1 (DECL_INITIAL (fndecl
));
1915 FOR_EACH_LOCAL_DECL (cfun
, ix
, decl
)
1916 if (DECL_RTL_SET_P (decl
))
1917 instantiate_decl_rtl (DECL_RTL (decl
));
1918 vec_free (cfun
->local_decls
);
1921 /* Pass through the INSNS of function FNDECL and convert virtual register
1922 references to hard register references. */
1925 instantiate_virtual_regs (void)
1929 /* Compute the offsets to use for this function. */
1930 in_arg_offset
= FIRST_PARM_OFFSET (current_function_decl
);
1931 var_offset
= STARTING_FRAME_OFFSET
;
1932 dynamic_offset
= STACK_DYNAMIC_OFFSET (current_function_decl
);
1933 out_arg_offset
= STACK_POINTER_OFFSET
;
1934 #ifdef FRAME_POINTER_CFA_OFFSET
1935 cfa_offset
= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
1937 cfa_offset
= ARG_POINTER_CFA_OFFSET (current_function_decl
);
1940 /* Initialize recognition, indicating that volatile is OK. */
1943 /* Scan through all the insns, instantiating every virtual register still
1945 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1948 /* These patterns in the instruction stream can never be recognized.
1949 Fortunately, they shouldn't contain virtual registers either. */
1950 if (GET_CODE (PATTERN (insn
)) == USE
1951 || GET_CODE (PATTERN (insn
)) == CLOBBER
1952 || GET_CODE (PATTERN (insn
)) == ASM_INPUT
)
1954 else if (DEBUG_INSN_P (insn
))
1955 instantiate_virtual_regs_in_rtx (&INSN_VAR_LOCATION (insn
));
1957 instantiate_virtual_regs_in_insn (insn
);
1959 if (insn
->deleted ())
1962 instantiate_virtual_regs_in_rtx (®_NOTES (insn
));
1964 /* Instantiate any virtual registers in CALL_INSN_FUNCTION_USAGE. */
1966 instantiate_virtual_regs_in_rtx (&CALL_INSN_FUNCTION_USAGE (insn
));
1969 /* Instantiate the virtual registers in the DECLs for debugging purposes. */
1970 instantiate_decls (current_function_decl
);
1972 targetm
.instantiate_decls ();
1974 /* Indicate that, from now on, assign_stack_local should use
1975 frame_pointer_rtx. */
1976 virtuals_instantiated
= 1;
1983 const pass_data pass_data_instantiate_virtual_regs
=
1985 RTL_PASS
, /* type */
1987 OPTGROUP_NONE
, /* optinfo_flags */
1988 TV_NONE
, /* tv_id */
1989 0, /* properties_required */
1990 0, /* properties_provided */
1991 0, /* properties_destroyed */
1992 0, /* todo_flags_start */
1993 0, /* todo_flags_finish */
1996 class pass_instantiate_virtual_regs
: public rtl_opt_pass
1999 pass_instantiate_virtual_regs (gcc::context
*ctxt
)
2000 : rtl_opt_pass (pass_data_instantiate_virtual_regs
, ctxt
)
2003 /* opt_pass methods: */
2004 virtual unsigned int execute (function
*)
2006 return instantiate_virtual_regs ();
2009 }; // class pass_instantiate_virtual_regs
2014 make_pass_instantiate_virtual_regs (gcc::context
*ctxt
)
2016 return new pass_instantiate_virtual_regs (ctxt
);
2020 /* Return 1 if EXP is an aggregate type (or a value with aggregate type).
2021 This means a type for which function calls must pass an address to the
2022 function or get an address back from the function.
2023 EXP may be a type node or an expression (whose type is tested). */
2026 aggregate_value_p (const_tree exp
, const_tree fntype
)
2028 const_tree type
= (TYPE_P (exp
)) ? exp
: TREE_TYPE (exp
);
2029 int i
, regno
, nregs
;
2033 switch (TREE_CODE (fntype
))
2037 tree fndecl
= get_callee_fndecl (fntype
);
2039 fntype
= TREE_TYPE (fndecl
);
2040 else if (CALL_EXPR_FN (fntype
))
2041 fntype
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (fntype
)));
2043 /* For internal functions, assume nothing needs to be
2044 returned in memory. */
2049 fntype
= TREE_TYPE (fntype
);
2054 case IDENTIFIER_NODE
:
2058 /* We don't expect other tree types here. */
2062 if (VOID_TYPE_P (type
))
2065 /* If a record should be passed the same as its first (and only) member
2066 don't pass it as an aggregate. */
2067 if (TREE_CODE (type
) == RECORD_TYPE
&& TYPE_TRANSPARENT_AGGR (type
))
2068 return aggregate_value_p (first_field (type
), fntype
);
2070 /* If the front end has decided that this needs to be passed by
2071 reference, do so. */
2072 if ((TREE_CODE (exp
) == PARM_DECL
|| TREE_CODE (exp
) == RESULT_DECL
)
2073 && DECL_BY_REFERENCE (exp
))
2076 /* Function types that are TREE_ADDRESSABLE force return in memory. */
2077 if (fntype
&& TREE_ADDRESSABLE (fntype
))
2080 /* Types that are TREE_ADDRESSABLE must be constructed in memory,
2081 and thus can't be returned in registers. */
2082 if (TREE_ADDRESSABLE (type
))
2085 if (flag_pcc_struct_return
&& AGGREGATE_TYPE_P (type
))
2088 if (targetm
.calls
.return_in_memory (type
, fntype
))
2091 /* Make sure we have suitable call-clobbered regs to return
2092 the value in; if not, we must return it in memory. */
2093 reg
= hard_function_value (type
, 0, fntype
, 0);
2095 /* If we have something other than a REG (e.g. a PARALLEL), then assume
2100 regno
= REGNO (reg
);
2101 nregs
= hard_regno_nregs
[regno
][TYPE_MODE (type
)];
2102 for (i
= 0; i
< nregs
; i
++)
2103 if (! call_used_regs
[regno
+ i
])
2109 /* Return true if we should assign DECL a pseudo register; false if it
2110 should live on the local stack. */
2113 use_register_for_decl (const_tree decl
)
2115 if (TREE_CODE (decl
) == SSA_NAME
)
2117 /* We often try to use the SSA_NAME, instead of its underlying
2118 decl, to get type information and guide decisions, to avoid
2119 differences of behavior between anonymous and named
2120 variables, but in this one case we have to go for the actual
2121 variable if there is one. The main reason is that, at least
2122 at -O0, we want to place user variables on the stack, but we
2123 don't mind using pseudos for anonymous or ignored temps.
2124 Should we take the SSA_NAME, we'd conclude all SSA_NAMEs
2125 should go in pseudos, whereas their corresponding variables
2126 might have to go on the stack. So, disregarding the decl
2127 here would negatively impact debug info at -O0, enable
2128 coalescing between SSA_NAMEs that ought to get different
2129 stack/pseudo assignments, and get the incoming argument
2130 processing thoroughly confused by PARM_DECLs expected to live
2131 in stack slots but assigned to pseudos. */
2132 if (!SSA_NAME_VAR (decl
))
2133 return TYPE_MODE (TREE_TYPE (decl
)) != BLKmode
2134 && !(flag_float_store
&& FLOAT_TYPE_P (TREE_TYPE (decl
)));
2136 decl
= SSA_NAME_VAR (decl
);
2139 if (!targetm
.calls
.allocate_stack_slots_for_args ())
2142 /* Honor volatile. */
2143 if (TREE_SIDE_EFFECTS (decl
))
2146 /* Honor addressability. */
2147 if (TREE_ADDRESSABLE (decl
))
2150 /* Decl is implicitly addressible by bound stores and loads
2151 if it is an aggregate holding bounds. */
2152 if (chkp_function_instrumented_p (current_function_decl
)
2154 && !BOUNDED_P (decl
)
2155 && chkp_type_has_pointer (TREE_TYPE (decl
)))
2158 /* Only register-like things go in registers. */
2159 if (DECL_MODE (decl
) == BLKmode
)
2162 /* If -ffloat-store specified, don't put explicit float variables
2164 /* ??? This should be checked after DECL_ARTIFICIAL, but tree-ssa
2165 propagates values across these stores, and it probably shouldn't. */
2166 if (flag_float_store
&& FLOAT_TYPE_P (TREE_TYPE (decl
)))
2169 /* If we're not interested in tracking debugging information for
2170 this decl, then we can certainly put it in a register. */
2171 if (DECL_IGNORED_P (decl
))
2177 if (!DECL_REGISTER (decl
))
2180 switch (TREE_CODE (TREE_TYPE (decl
)))
2184 case QUAL_UNION_TYPE
:
2185 /* When not optimizing, disregard register keyword for variables with
2186 types containing methods, otherwise the methods won't be callable
2187 from the debugger. */
2188 if (TYPE_METHODS (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))))
2198 /* Return true if TYPE should be passed by invisible reference. */
2201 pass_by_reference (CUMULATIVE_ARGS
*ca
, machine_mode mode
,
2202 tree type
, bool named_arg
)
2206 /* If this type contains non-trivial constructors, then it is
2207 forbidden for the middle-end to create any new copies. */
2208 if (TREE_ADDRESSABLE (type
))
2211 /* GCC post 3.4 passes *all* variable sized types by reference. */
2212 if (!TYPE_SIZE (type
) || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
2215 /* If a record type should be passed the same as its first (and only)
2216 member, use the type and mode of that member. */
2217 if (TREE_CODE (type
) == RECORD_TYPE
&& TYPE_TRANSPARENT_AGGR (type
))
2219 type
= TREE_TYPE (first_field (type
));
2220 mode
= TYPE_MODE (type
);
2224 return targetm
.calls
.pass_by_reference (pack_cumulative_args (ca
), mode
,
2228 /* Return true if TYPE, which is passed by reference, should be callee
2229 copied instead of caller copied. */
2232 reference_callee_copied (CUMULATIVE_ARGS
*ca
, machine_mode mode
,
2233 tree type
, bool named_arg
)
2235 if (type
&& TREE_ADDRESSABLE (type
))
2237 return targetm
.calls
.callee_copies (pack_cumulative_args (ca
), mode
, type
,
2241 /* Structures to communicate between the subroutines of assign_parms.
2242 The first holds data persistent across all parameters, the second
2243 is cleared out for each parameter. */
2245 struct assign_parm_data_all
2247 /* When INIT_CUMULATIVE_ARGS gets revamped, allocating CUMULATIVE_ARGS
2248 should become a job of the target or otherwise encapsulated. */
2249 CUMULATIVE_ARGS args_so_far_v
;
2250 cumulative_args_t args_so_far
;
2251 struct args_size stack_args_size
;
2252 tree function_result_decl
;
2254 rtx_insn
*first_conversion_insn
;
2255 rtx_insn
*last_conversion_insn
;
2256 HOST_WIDE_INT pretend_args_size
;
2257 HOST_WIDE_INT extra_pretend_bytes
;
2258 int reg_parm_stack_space
;
2261 struct assign_parm_data_one
2267 machine_mode nominal_mode
;
2268 machine_mode passed_mode
;
2269 machine_mode promoted_mode
;
2270 struct locate_and_pad_arg_data locate
;
2272 BOOL_BITFIELD named_arg
: 1;
2273 BOOL_BITFIELD passed_pointer
: 1;
2274 BOOL_BITFIELD on_stack
: 1;
2275 BOOL_BITFIELD loaded_in_reg
: 1;
2278 struct bounds_parm_data
2280 assign_parm_data_one parm_data
;
2287 /* A subroutine of assign_parms. Initialize ALL. */
2290 assign_parms_initialize_all (struct assign_parm_data_all
*all
)
2292 tree fntype ATTRIBUTE_UNUSED
;
2294 memset (all
, 0, sizeof (*all
));
2296 fntype
= TREE_TYPE (current_function_decl
);
2298 #ifdef INIT_CUMULATIVE_INCOMING_ARGS
2299 INIT_CUMULATIVE_INCOMING_ARGS (all
->args_so_far_v
, fntype
, NULL_RTX
);
2301 INIT_CUMULATIVE_ARGS (all
->args_so_far_v
, fntype
, NULL_RTX
,
2302 current_function_decl
, -1);
2304 all
->args_so_far
= pack_cumulative_args (&all
->args_so_far_v
);
2306 #ifdef INCOMING_REG_PARM_STACK_SPACE
2307 all
->reg_parm_stack_space
2308 = INCOMING_REG_PARM_STACK_SPACE (current_function_decl
);
2312 /* If ARGS contains entries with complex types, split the entry into two
2313 entries of the component type. Return a new list of substitutions are
2314 needed, else the old list. */
2317 split_complex_args (vec
<tree
> *args
)
2322 FOR_EACH_VEC_ELT (*args
, i
, p
)
2324 tree type
= TREE_TYPE (p
);
2325 if (TREE_CODE (type
) == COMPLEX_TYPE
2326 && targetm
.calls
.split_complex_arg (type
))
2329 tree subtype
= TREE_TYPE (type
);
2330 bool addressable
= TREE_ADDRESSABLE (p
);
2332 /* Rewrite the PARM_DECL's type with its component. */
2334 TREE_TYPE (p
) = subtype
;
2335 DECL_ARG_TYPE (p
) = TREE_TYPE (DECL_ARG_TYPE (p
));
2336 DECL_MODE (p
) = VOIDmode
;
2337 DECL_SIZE (p
) = NULL
;
2338 DECL_SIZE_UNIT (p
) = NULL
;
2339 /* If this arg must go in memory, put it in a pseudo here.
2340 We can't allow it to go in memory as per normal parms,
2341 because the usual place might not have the imag part
2342 adjacent to the real part. */
2343 DECL_ARTIFICIAL (p
) = addressable
;
2344 DECL_IGNORED_P (p
) = addressable
;
2345 TREE_ADDRESSABLE (p
) = 0;
2349 /* Build a second synthetic decl. */
2350 decl
= build_decl (EXPR_LOCATION (p
),
2351 PARM_DECL
, NULL_TREE
, subtype
);
2352 DECL_ARG_TYPE (decl
) = DECL_ARG_TYPE (p
);
2353 DECL_ARTIFICIAL (decl
) = addressable
;
2354 DECL_IGNORED_P (decl
) = addressable
;
2355 layout_decl (decl
, 0);
2356 args
->safe_insert (++i
, decl
);
2361 /* A subroutine of assign_parms. Adjust the parameter list to incorporate
2362 the hidden struct return argument, and (abi willing) complex args.
2363 Return the new parameter list. */
2366 assign_parms_augmented_arg_list (struct assign_parm_data_all
*all
)
2368 tree fndecl
= current_function_decl
;
2369 tree fntype
= TREE_TYPE (fndecl
);
2370 vec
<tree
> fnargs
= vNULL
;
2373 for (arg
= DECL_ARGUMENTS (fndecl
); arg
; arg
= DECL_CHAIN (arg
))
2374 fnargs
.safe_push (arg
);
2376 all
->orig_fnargs
= DECL_ARGUMENTS (fndecl
);
2378 /* If struct value address is treated as the first argument, make it so. */
2379 if (aggregate_value_p (DECL_RESULT (fndecl
), fndecl
)
2380 && ! cfun
->returns_pcc_struct
2381 && targetm
.calls
.struct_value_rtx (TREE_TYPE (fndecl
), 1) == 0)
2383 tree type
= build_pointer_type (TREE_TYPE (fntype
));
2386 decl
= build_decl (DECL_SOURCE_LOCATION (fndecl
),
2387 PARM_DECL
, get_identifier (".result_ptr"), type
);
2388 DECL_ARG_TYPE (decl
) = type
;
2389 DECL_ARTIFICIAL (decl
) = 1;
2390 DECL_NAMELESS (decl
) = 1;
2391 TREE_CONSTANT (decl
) = 1;
2393 DECL_CHAIN (decl
) = all
->orig_fnargs
;
2394 all
->orig_fnargs
= decl
;
2395 fnargs
.safe_insert (0, decl
);
2397 all
->function_result_decl
= decl
;
2399 /* If function is instrumented then bounds of the
2400 passed structure address is the second argument. */
2401 if (chkp_function_instrumented_p (fndecl
))
2403 decl
= build_decl (DECL_SOURCE_LOCATION (fndecl
),
2404 PARM_DECL
, get_identifier (".result_bnd"),
2405 pointer_bounds_type_node
);
2406 DECL_ARG_TYPE (decl
) = pointer_bounds_type_node
;
2407 DECL_ARTIFICIAL (decl
) = 1;
2408 DECL_NAMELESS (decl
) = 1;
2409 TREE_CONSTANT (decl
) = 1;
2411 DECL_CHAIN (decl
) = DECL_CHAIN (all
->orig_fnargs
);
2412 DECL_CHAIN (all
->orig_fnargs
) = decl
;
2413 fnargs
.safe_insert (1, decl
);
2417 /* If the target wants to split complex arguments into scalars, do so. */
2418 if (targetm
.calls
.split_complex_arg
)
2419 split_complex_args (&fnargs
);
2424 /* A subroutine of assign_parms. Examine PARM and pull out type and mode
2425 data for the parameter. Incorporate ABI specifics such as pass-by-
2426 reference and type promotion. */
2429 assign_parm_find_data_types (struct assign_parm_data_all
*all
, tree parm
,
2430 struct assign_parm_data_one
*data
)
2432 tree nominal_type
, passed_type
;
2433 machine_mode nominal_mode
, passed_mode
, promoted_mode
;
2436 memset (data
, 0, sizeof (*data
));
2438 /* NAMED_ARG is a misnomer. We really mean 'non-variadic'. */
2440 data
->named_arg
= 1; /* No variadic parms. */
2441 else if (DECL_CHAIN (parm
))
2442 data
->named_arg
= 1; /* Not the last non-variadic parm. */
2443 else if (targetm
.calls
.strict_argument_naming (all
->args_so_far
))
2444 data
->named_arg
= 1; /* Only variadic ones are unnamed. */
2446 data
->named_arg
= 0; /* Treat as variadic. */
2448 nominal_type
= TREE_TYPE (parm
);
2449 passed_type
= DECL_ARG_TYPE (parm
);
2451 /* Look out for errors propagating this far. Also, if the parameter's
2452 type is void then its value doesn't matter. */
2453 if (TREE_TYPE (parm
) == error_mark_node
2454 /* This can happen after weird syntax errors
2455 or if an enum type is defined among the parms. */
2456 || TREE_CODE (parm
) != PARM_DECL
2457 || passed_type
== NULL
2458 || VOID_TYPE_P (nominal_type
))
2460 nominal_type
= passed_type
= void_type_node
;
2461 nominal_mode
= passed_mode
= promoted_mode
= VOIDmode
;
2465 /* Find mode of arg as it is passed, and mode of arg as it should be
2466 during execution of this function. */
2467 passed_mode
= TYPE_MODE (passed_type
);
2468 nominal_mode
= TYPE_MODE (nominal_type
);
2470 /* If the parm is to be passed as a transparent union or record, use the
2471 type of the first field for the tests below. We have already verified
2472 that the modes are the same. */
2473 if ((TREE_CODE (passed_type
) == UNION_TYPE
2474 || TREE_CODE (passed_type
) == RECORD_TYPE
)
2475 && TYPE_TRANSPARENT_AGGR (passed_type
))
2476 passed_type
= TREE_TYPE (first_field (passed_type
));
2478 /* See if this arg was passed by invisible reference. */
2479 if (pass_by_reference (&all
->args_so_far_v
, passed_mode
,
2480 passed_type
, data
->named_arg
))
2482 passed_type
= nominal_type
= build_pointer_type (passed_type
);
2483 data
->passed_pointer
= true;
2484 passed_mode
= nominal_mode
= TYPE_MODE (nominal_type
);
2487 /* Find mode as it is passed by the ABI. */
2488 unsignedp
= TYPE_UNSIGNED (passed_type
);
2489 promoted_mode
= promote_function_mode (passed_type
, passed_mode
, &unsignedp
,
2490 TREE_TYPE (current_function_decl
), 0);
2493 data
->nominal_type
= nominal_type
;
2494 data
->passed_type
= passed_type
;
2495 data
->nominal_mode
= nominal_mode
;
2496 data
->passed_mode
= passed_mode
;
2497 data
->promoted_mode
= promoted_mode
;
2500 /* A subroutine of assign_parms. Invoke setup_incoming_varargs. */
2503 assign_parms_setup_varargs (struct assign_parm_data_all
*all
,
2504 struct assign_parm_data_one
*data
, bool no_rtl
)
2506 int varargs_pretend_bytes
= 0;
2508 targetm
.calls
.setup_incoming_varargs (all
->args_so_far
,
2509 data
->promoted_mode
,
2511 &varargs_pretend_bytes
, no_rtl
);
2513 /* If the back-end has requested extra stack space, record how much is
2514 needed. Do not change pretend_args_size otherwise since it may be
2515 nonzero from an earlier partial argument. */
2516 if (varargs_pretend_bytes
> 0)
2517 all
->pretend_args_size
= varargs_pretend_bytes
;
2520 /* A subroutine of assign_parms. Set DATA->ENTRY_PARM corresponding to
2521 the incoming location of the current parameter. */
2524 assign_parm_find_entry_rtl (struct assign_parm_data_all
*all
,
2525 struct assign_parm_data_one
*data
)
2527 HOST_WIDE_INT pretend_bytes
= 0;
2531 if (data
->promoted_mode
== VOIDmode
)
2533 data
->entry_parm
= data
->stack_parm
= const0_rtx
;
2537 entry_parm
= targetm
.calls
.function_incoming_arg (all
->args_so_far
,
2538 data
->promoted_mode
,
2542 if (entry_parm
== 0)
2543 data
->promoted_mode
= data
->passed_mode
;
2545 /* Determine parm's home in the stack, in case it arrives in the stack
2546 or we should pretend it did. Compute the stack position and rtx where
2547 the argument arrives and its size.
2549 There is one complexity here: If this was a parameter that would
2550 have been passed in registers, but wasn't only because it is
2551 __builtin_va_alist, we want locate_and_pad_parm to treat it as if
2552 it came in a register so that REG_PARM_STACK_SPACE isn't skipped.
2553 In this case, we call FUNCTION_ARG with NAMED set to 1 instead of 0
2554 as it was the previous time. */
2555 in_regs
= (entry_parm
!= 0) || POINTER_BOUNDS_TYPE_P (data
->passed_type
);
2556 #ifdef STACK_PARMS_IN_REG_PARM_AREA
2559 if (!in_regs
&& !data
->named_arg
)
2561 if (targetm
.calls
.pretend_outgoing_varargs_named (all
->args_so_far
))
2564 tem
= targetm
.calls
.function_incoming_arg (all
->args_so_far
,
2565 data
->promoted_mode
,
2566 data
->passed_type
, true);
2567 in_regs
= tem
!= NULL
;
2571 /* If this parameter was passed both in registers and in the stack, use
2572 the copy on the stack. */
2573 if (targetm
.calls
.must_pass_in_stack (data
->promoted_mode
,
2581 partial
= targetm
.calls
.arg_partial_bytes (all
->args_so_far
,
2582 data
->promoted_mode
,
2585 data
->partial
= partial
;
2587 /* The caller might already have allocated stack space for the
2588 register parameters. */
2589 if (partial
!= 0 && all
->reg_parm_stack_space
== 0)
2591 /* Part of this argument is passed in registers and part
2592 is passed on the stack. Ask the prologue code to extend
2593 the stack part so that we can recreate the full value.
2595 PRETEND_BYTES is the size of the registers we need to store.
2596 CURRENT_FUNCTION_PRETEND_ARGS_SIZE is the amount of extra
2597 stack space that the prologue should allocate.
2599 Internally, gcc assumes that the argument pointer is aligned
2600 to STACK_BOUNDARY bits. This is used both for alignment
2601 optimizations (see init_emit) and to locate arguments that are
2602 aligned to more than PARM_BOUNDARY bits. We must preserve this
2603 invariant by rounding CURRENT_FUNCTION_PRETEND_ARGS_SIZE up to
2604 a stack boundary. */
2606 /* We assume at most one partial arg, and it must be the first
2607 argument on the stack. */
2608 gcc_assert (!all
->extra_pretend_bytes
&& !all
->pretend_args_size
);
2610 pretend_bytes
= partial
;
2611 all
->pretend_args_size
= CEIL_ROUND (pretend_bytes
, STACK_BYTES
);
2613 /* We want to align relative to the actual stack pointer, so
2614 don't include this in the stack size until later. */
2615 all
->extra_pretend_bytes
= all
->pretend_args_size
;
2619 locate_and_pad_parm (data
->promoted_mode
, data
->passed_type
, in_regs
,
2620 all
->reg_parm_stack_space
,
2621 entry_parm
? data
->partial
: 0, current_function_decl
,
2622 &all
->stack_args_size
, &data
->locate
);
2624 /* Update parm_stack_boundary if this parameter is passed in the
2626 if (!in_regs
&& crtl
->parm_stack_boundary
< data
->locate
.boundary
)
2627 crtl
->parm_stack_boundary
= data
->locate
.boundary
;
2629 /* Adjust offsets to include the pretend args. */
2630 pretend_bytes
= all
->extra_pretend_bytes
- pretend_bytes
;
2631 data
->locate
.slot_offset
.constant
+= pretend_bytes
;
2632 data
->locate
.offset
.constant
+= pretend_bytes
;
2634 data
->entry_parm
= entry_parm
;
2637 /* A subroutine of assign_parms. If there is actually space on the stack
2638 for this parm, count it in stack_args_size and return true. */
2641 assign_parm_is_stack_parm (struct assign_parm_data_all
*all
,
2642 struct assign_parm_data_one
*data
)
2644 /* Bounds are never passed on the stack to keep compatibility
2645 with not instrumented code. */
2646 if (POINTER_BOUNDS_TYPE_P (data
->passed_type
))
2648 /* Trivially true if we've no incoming register. */
2649 else if (data
->entry_parm
== NULL
)
2651 /* Also true if we're partially in registers and partially not,
2652 since we've arranged to drop the entire argument on the stack. */
2653 else if (data
->partial
!= 0)
2655 /* Also true if the target says that it's passed in both registers
2656 and on the stack. */
2657 else if (GET_CODE (data
->entry_parm
) == PARALLEL
2658 && XEXP (XVECEXP (data
->entry_parm
, 0, 0), 0) == NULL_RTX
)
2660 /* Also true if the target says that there's stack allocated for
2661 all register parameters. */
2662 else if (all
->reg_parm_stack_space
> 0)
2664 /* Otherwise, no, this parameter has no ABI defined stack slot. */
2668 all
->stack_args_size
.constant
+= data
->locate
.size
.constant
;
2669 if (data
->locate
.size
.var
)
2670 ADD_PARM_SIZE (all
->stack_args_size
, data
->locate
.size
.var
);
2675 /* A subroutine of assign_parms. Given that this parameter is allocated
2676 stack space by the ABI, find it. */
2679 assign_parm_find_stack_rtl (tree parm
, struct assign_parm_data_one
*data
)
2681 rtx offset_rtx
, stack_parm
;
2682 unsigned int align
, boundary
;
2684 /* If we're passing this arg using a reg, make its stack home the
2685 aligned stack slot. */
2686 if (data
->entry_parm
)
2687 offset_rtx
= ARGS_SIZE_RTX (data
->locate
.slot_offset
);
2689 offset_rtx
= ARGS_SIZE_RTX (data
->locate
.offset
);
2691 stack_parm
= crtl
->args
.internal_arg_pointer
;
2692 if (offset_rtx
!= const0_rtx
)
2693 stack_parm
= gen_rtx_PLUS (Pmode
, stack_parm
, offset_rtx
);
2694 stack_parm
= gen_rtx_MEM (data
->promoted_mode
, stack_parm
);
2696 if (!data
->passed_pointer
)
2698 set_mem_attributes (stack_parm
, parm
, 1);
2699 /* set_mem_attributes could set MEM_SIZE to the passed mode's size,
2700 while promoted mode's size is needed. */
2701 if (data
->promoted_mode
!= BLKmode
2702 && data
->promoted_mode
!= DECL_MODE (parm
))
2704 set_mem_size (stack_parm
, GET_MODE_SIZE (data
->promoted_mode
));
2705 if (MEM_EXPR (stack_parm
) && MEM_OFFSET_KNOWN_P (stack_parm
))
2707 int offset
= subreg_lowpart_offset (DECL_MODE (parm
),
2708 data
->promoted_mode
);
2710 set_mem_offset (stack_parm
, MEM_OFFSET (stack_parm
) - offset
);
2715 boundary
= data
->locate
.boundary
;
2716 align
= BITS_PER_UNIT
;
2718 /* If we're padding upward, we know that the alignment of the slot
2719 is TARGET_FUNCTION_ARG_BOUNDARY. If we're using slot_offset, we're
2720 intentionally forcing upward padding. Otherwise we have to come
2721 up with a guess at the alignment based on OFFSET_RTX. */
2722 if (data
->locate
.where_pad
!= downward
|| data
->entry_parm
)
2724 else if (CONST_INT_P (offset_rtx
))
2726 align
= INTVAL (offset_rtx
) * BITS_PER_UNIT
| boundary
;
2727 align
= align
& -align
;
2729 set_mem_align (stack_parm
, align
);
2731 if (data
->entry_parm
)
2732 set_reg_attrs_for_parm (data
->entry_parm
, stack_parm
);
2734 data
->stack_parm
= stack_parm
;
2737 /* A subroutine of assign_parms. Adjust DATA->ENTRY_RTL such that it's
2738 always valid and contiguous. */
2741 assign_parm_adjust_entry_rtl (struct assign_parm_data_one
*data
)
2743 rtx entry_parm
= data
->entry_parm
;
2744 rtx stack_parm
= data
->stack_parm
;
2746 /* If this parm was passed part in regs and part in memory, pretend it
2747 arrived entirely in memory by pushing the register-part onto the stack.
2748 In the special case of a DImode or DFmode that is split, we could put
2749 it together in a pseudoreg directly, but for now that's not worth
2751 if (data
->partial
!= 0)
2753 /* Handle calls that pass values in multiple non-contiguous
2754 locations. The Irix 6 ABI has examples of this. */
2755 if (GET_CODE (entry_parm
) == PARALLEL
)
2756 emit_group_store (validize_mem (copy_rtx (stack_parm
)), entry_parm
,
2758 int_size_in_bytes (data
->passed_type
));
2761 gcc_assert (data
->partial
% UNITS_PER_WORD
== 0);
2762 move_block_from_reg (REGNO (entry_parm
),
2763 validize_mem (copy_rtx (stack_parm
)),
2764 data
->partial
/ UNITS_PER_WORD
);
2767 entry_parm
= stack_parm
;
2770 /* If we didn't decide this parm came in a register, by default it came
2772 else if (entry_parm
== NULL
)
2773 entry_parm
= stack_parm
;
2775 /* When an argument is passed in multiple locations, we can't make use
2776 of this information, but we can save some copying if the whole argument
2777 is passed in a single register. */
2778 else if (GET_CODE (entry_parm
) == PARALLEL
2779 && data
->nominal_mode
!= BLKmode
2780 && data
->passed_mode
!= BLKmode
)
2782 size_t i
, len
= XVECLEN (entry_parm
, 0);
2784 for (i
= 0; i
< len
; i
++)
2785 if (XEXP (XVECEXP (entry_parm
, 0, i
), 0) != NULL_RTX
2786 && REG_P (XEXP (XVECEXP (entry_parm
, 0, i
), 0))
2787 && (GET_MODE (XEXP (XVECEXP (entry_parm
, 0, i
), 0))
2788 == data
->passed_mode
)
2789 && INTVAL (XEXP (XVECEXP (entry_parm
, 0, i
), 1)) == 0)
2791 entry_parm
= XEXP (XVECEXP (entry_parm
, 0, i
), 0);
2796 data
->entry_parm
= entry_parm
;
2799 /* A subroutine of assign_parms. Reconstitute any values which were
2800 passed in multiple registers and would fit in a single register. */
2803 assign_parm_remove_parallels (struct assign_parm_data_one
*data
)
2805 rtx entry_parm
= data
->entry_parm
;
2807 /* Convert the PARALLEL to a REG of the same mode as the parallel.
2808 This can be done with register operations rather than on the
2809 stack, even if we will store the reconstituted parameter on the
2811 if (GET_CODE (entry_parm
) == PARALLEL
&& GET_MODE (entry_parm
) != BLKmode
)
2813 rtx parmreg
= gen_reg_rtx (GET_MODE (entry_parm
));
2814 emit_group_store (parmreg
, entry_parm
, data
->passed_type
,
2815 GET_MODE_SIZE (GET_MODE (entry_parm
)));
2816 entry_parm
= parmreg
;
2819 data
->entry_parm
= entry_parm
;
2822 /* Wrapper for use_register_for_decl, that special-cases the
2823 .result_ptr as the function's RESULT_DECL when the RESULT_DECL is
2824 passed by reference. */
2827 use_register_for_parm_decl (struct assign_parm_data_all
*all
, tree parm
)
2829 if (parm
== all
->function_result_decl
)
2831 tree result
= DECL_RESULT (current_function_decl
);
2833 if (DECL_BY_REFERENCE (result
))
2837 return use_register_for_decl (parm
);
2840 /* Wrapper for get_rtl_for_parm_ssa_default_def, that special-cases
2841 the .result_ptr as the function's RESULT_DECL when the RESULT_DECL
2842 is passed by reference. */
2845 rtl_for_parm (struct assign_parm_data_all
*all
, tree parm
)
2847 if (parm
== all
->function_result_decl
)
2849 tree result
= DECL_RESULT (current_function_decl
);
2851 if (!DECL_BY_REFERENCE (result
))
2857 return get_rtl_for_parm_ssa_default_def (parm
);
2860 /* Reset the location of PARM_DECLs and RESULT_DECLs that had
2861 SSA_NAMEs in multiple partitions, so that assign_parms will choose
2862 the default def, if it exists, or create new RTL to hold the unused
2863 entry value. If we are coalescing across variables, we want to
2864 reset the location too, because a parm without a default def
2865 (incoming value unused) might be coalesced with one with a default
2866 def, and then assign_parms would copy both incoming values to the
2867 same location, which might cause the wrong value to survive. */
2869 maybe_reset_rtl_for_parm (tree parm
)
2871 gcc_assert (TREE_CODE (parm
) == PARM_DECL
2872 || TREE_CODE (parm
) == RESULT_DECL
);
2873 if ((flag_tree_coalesce_vars
2874 || (DECL_RTL_SET_P (parm
) && DECL_RTL (parm
) == pc_rtx
))
2875 && is_gimple_reg (parm
))
2876 SET_DECL_RTL (parm
, NULL_RTX
);
2879 /* A subroutine of assign_parms. Adjust DATA->STACK_RTL such that it's
2880 always valid and properly aligned. */
2883 assign_parm_adjust_stack_rtl (struct assign_parm_data_all
*all
, tree parm
,
2884 struct assign_parm_data_one
*data
)
2886 rtx stack_parm
= data
->stack_parm
;
2888 /* If out-of-SSA assigned RTL to the parm default def, make sure we
2889 don't use what we might have computed before. */
2890 rtx ssa_assigned
= rtl_for_parm (all
, parm
);
2894 /* If we can't trust the parm stack slot to be aligned enough for its
2895 ultimate type, don't use that slot after entry. We'll make another
2896 stack slot, if we need one. */
2898 && ((STRICT_ALIGNMENT
2899 && (GET_MODE_ALIGNMENT (data
->nominal_mode
)
2900 > MEM_ALIGN (stack_parm
)))
2901 || (data
->nominal_type
2902 && TYPE_ALIGN (data
->nominal_type
) > MEM_ALIGN (stack_parm
)
2903 && MEM_ALIGN (stack_parm
) < PREFERRED_STACK_BOUNDARY
)))
2906 /* If parm was passed in memory, and we need to convert it on entry,
2907 don't store it back in that same slot. */
2908 else if (data
->entry_parm
== stack_parm
2909 && data
->nominal_mode
!= BLKmode
2910 && data
->nominal_mode
!= data
->passed_mode
)
2913 /* If stack protection is in effect for this function, don't leave any
2914 pointers in their passed stack slots. */
2915 else if (crtl
->stack_protect_guard
2916 && (flag_stack_protect
== 2
2917 || data
->passed_pointer
2918 || POINTER_TYPE_P (data
->nominal_type
)))
2921 data
->stack_parm
= stack_parm
;
2924 /* A subroutine of assign_parms. Return true if the current parameter
2925 should be stored as a BLKmode in the current frame. */
2928 assign_parm_setup_block_p (struct assign_parm_data_one
*data
)
2930 if (data
->nominal_mode
== BLKmode
)
2932 if (GET_MODE (data
->entry_parm
) == BLKmode
)
2935 #ifdef BLOCK_REG_PADDING
2936 /* Only assign_parm_setup_block knows how to deal with register arguments
2937 that are padded at the least significant end. */
2938 if (REG_P (data
->entry_parm
)
2939 && GET_MODE_SIZE (data
->promoted_mode
) < UNITS_PER_WORD
2940 && (BLOCK_REG_PADDING (data
->passed_mode
, data
->passed_type
, 1)
2941 == (BYTES_BIG_ENDIAN
? upward
: downward
)))
2948 /* A subroutine of assign_parms. Arrange for the parameter to be
2949 present and valid in DATA->STACK_RTL. */
2952 assign_parm_setup_block (struct assign_parm_data_all
*all
,
2953 tree parm
, struct assign_parm_data_one
*data
)
2955 rtx entry_parm
= data
->entry_parm
;
2956 rtx stack_parm
= data
->stack_parm
;
2958 HOST_WIDE_INT size_stored
;
2960 if (GET_CODE (entry_parm
) == PARALLEL
)
2961 entry_parm
= emit_group_move_into_temps (entry_parm
);
2963 size
= int_size_in_bytes (data
->passed_type
);
2964 size_stored
= CEIL_ROUND (size
, UNITS_PER_WORD
);
2966 if (stack_parm
== 0)
2968 DECL_ALIGN (parm
) = MAX (DECL_ALIGN (parm
), BITS_PER_WORD
);
2969 stack_parm
= rtl_for_parm (all
, parm
);
2971 stack_parm
= assign_stack_local (BLKmode
, size_stored
,
2974 stack_parm
= copy_rtx (stack_parm
);
2975 if (GET_MODE_SIZE (GET_MODE (entry_parm
)) == size
)
2976 PUT_MODE (stack_parm
, GET_MODE (entry_parm
));
2977 set_mem_attributes (stack_parm
, parm
, 1);
2980 /* If a BLKmode arrives in registers, copy it to a stack slot. Handle
2981 calls that pass values in multiple non-contiguous locations. */
2982 if (REG_P (entry_parm
) || GET_CODE (entry_parm
) == PARALLEL
)
2986 /* Note that we will be storing an integral number of words.
2987 So we have to be careful to ensure that we allocate an
2988 integral number of words. We do this above when we call
2989 assign_stack_local if space was not allocated in the argument
2990 list. If it was, this will not work if PARM_BOUNDARY is not
2991 a multiple of BITS_PER_WORD. It isn't clear how to fix this
2992 if it becomes a problem. Exception is when BLKmode arrives
2993 with arguments not conforming to word_mode. */
2995 if (data
->stack_parm
== 0)
2997 else if (GET_CODE (entry_parm
) == PARALLEL
)
3000 gcc_assert (!size
|| !(PARM_BOUNDARY
% BITS_PER_WORD
));
3002 mem
= validize_mem (copy_rtx (stack_parm
));
3004 /* Handle values in multiple non-contiguous locations. */
3005 if (GET_CODE (entry_parm
) == PARALLEL
)
3007 push_to_sequence2 (all
->first_conversion_insn
,
3008 all
->last_conversion_insn
);
3009 emit_group_store (mem
, entry_parm
, data
->passed_type
, size
);
3010 all
->first_conversion_insn
= get_insns ();
3011 all
->last_conversion_insn
= get_last_insn ();
3018 /* If SIZE is that of a mode no bigger than a word, just use
3019 that mode's store operation. */
3020 else if (size
<= UNITS_PER_WORD
)
3023 = mode_for_size (size
* BITS_PER_UNIT
, MODE_INT
, 0);
3026 #ifdef BLOCK_REG_PADDING
3027 && (size
== UNITS_PER_WORD
3028 || (BLOCK_REG_PADDING (mode
, data
->passed_type
, 1)
3029 != (BYTES_BIG_ENDIAN
? upward
: downward
)))
3035 /* We are really truncating a word_mode value containing
3036 SIZE bytes into a value of mode MODE. If such an
3037 operation requires no actual instructions, we can refer
3038 to the value directly in mode MODE, otherwise we must
3039 start with the register in word_mode and explicitly
3041 if (TRULY_NOOP_TRUNCATION (size
* BITS_PER_UNIT
, BITS_PER_WORD
))
3042 reg
= gen_rtx_REG (mode
, REGNO (entry_parm
));
3045 reg
= gen_rtx_REG (word_mode
, REGNO (entry_parm
));
3046 reg
= convert_to_mode (mode
, copy_to_reg (reg
), 1);
3048 emit_move_insn (change_address (mem
, mode
, 0), reg
);
3051 /* Blocks smaller than a word on a BYTES_BIG_ENDIAN
3052 machine must be aligned to the left before storing
3053 to memory. Note that the previous test doesn't
3054 handle all cases (e.g. SIZE == 3). */
3055 else if (size
!= UNITS_PER_WORD
3056 #ifdef BLOCK_REG_PADDING
3057 && (BLOCK_REG_PADDING (mode
, data
->passed_type
, 1)
3065 int by
= (UNITS_PER_WORD
- size
) * BITS_PER_UNIT
;
3066 rtx reg
= gen_rtx_REG (word_mode
, REGNO (entry_parm
));
3068 x
= expand_shift (LSHIFT_EXPR
, word_mode
, reg
, by
, NULL_RTX
, 1);
3069 tem
= change_address (mem
, word_mode
, 0);
3070 emit_move_insn (tem
, x
);
3073 move_block_from_reg (REGNO (entry_parm
), mem
,
3074 size_stored
/ UNITS_PER_WORD
);
3077 move_block_from_reg (REGNO (entry_parm
), mem
,
3078 size_stored
/ UNITS_PER_WORD
);
3080 else if (data
->stack_parm
== 0)
3082 push_to_sequence2 (all
->first_conversion_insn
, all
->last_conversion_insn
);
3083 emit_block_move (stack_parm
, data
->entry_parm
, GEN_INT (size
),
3085 all
->first_conversion_insn
= get_insns ();
3086 all
->last_conversion_insn
= get_last_insn ();
3090 data
->stack_parm
= stack_parm
;
3091 SET_DECL_RTL (parm
, stack_parm
);
3094 /* A subroutine of assign_parms. Allocate a pseudo to hold the current
3095 parameter. Get it there. Perform all ABI specified conversions. */
3098 assign_parm_setup_reg (struct assign_parm_data_all
*all
, tree parm
,
3099 struct assign_parm_data_one
*data
)
3101 rtx parmreg
, validated_mem
;
3102 rtx equiv_stack_parm
;
3103 machine_mode promoted_nominal_mode
;
3104 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (parm
));
3105 bool did_conversion
= false;
3106 bool need_conversion
, moved
;
3108 /* Store the parm in a pseudoregister during the function, but we may
3109 need to do it in a wider mode. Using 2 here makes the result
3110 consistent with promote_decl_mode and thus expand_expr_real_1. */
3111 promoted_nominal_mode
3112 = promote_function_mode (data
->nominal_type
, data
->nominal_mode
, &unsignedp
,
3113 TREE_TYPE (current_function_decl
), 2);
3115 rtx from_expand
= rtl_for_parm (all
, parm
);
3117 if (from_expand
&& !data
->passed_pointer
)
3119 parmreg
= from_expand
;
3120 gcc_assert (GET_MODE (parmreg
) == promoted_nominal_mode
);
3124 parmreg
= gen_reg_rtx (promoted_nominal_mode
);
3125 if (!DECL_ARTIFICIAL (parm
))
3126 mark_user_reg (parmreg
);
3129 /* If this was an item that we received a pointer to,
3130 set DECL_RTL appropriately. */
3131 if (data
->passed_pointer
)
3133 rtx x
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data
->passed_type
)), parmreg
);
3134 set_mem_attributes (x
, parm
, 1);
3135 SET_DECL_RTL (parm
, x
);
3138 SET_DECL_RTL (parm
, parmreg
);
3140 assign_parm_remove_parallels (data
);
3142 /* Copy the value into the register, thus bridging between
3143 assign_parm_find_data_types and expand_expr_real_1. */
3145 equiv_stack_parm
= data
->stack_parm
;
3146 if (!equiv_stack_parm
)
3147 equiv_stack_parm
= data
->entry_parm
;
3148 validated_mem
= validize_mem (copy_rtx (data
->entry_parm
));
3150 need_conversion
= (data
->nominal_mode
!= data
->passed_mode
3151 || promoted_nominal_mode
!= data
->promoted_mode
);
3155 && GET_MODE_CLASS (data
->nominal_mode
) == MODE_INT
3156 && data
->nominal_mode
== data
->passed_mode
3157 && data
->nominal_mode
== GET_MODE (data
->entry_parm
))
3159 /* ENTRY_PARM has been converted to PROMOTED_MODE, its
3160 mode, by the caller. We now have to convert it to
3161 NOMINAL_MODE, if different. However, PARMREG may be in
3162 a different mode than NOMINAL_MODE if it is being stored
3165 If ENTRY_PARM is a hard register, it might be in a register
3166 not valid for operating in its mode (e.g., an odd-numbered
3167 register for a DFmode). In that case, moves are the only
3168 thing valid, so we can't do a convert from there. This
3169 occurs when the calling sequence allow such misaligned
3172 In addition, the conversion may involve a call, which could
3173 clobber parameters which haven't been copied to pseudo
3176 First, we try to emit an insn which performs the necessary
3177 conversion. We verify that this insn does not clobber any
3180 enum insn_code icode
;
3183 icode
= can_extend_p (promoted_nominal_mode
, data
->passed_mode
,
3187 op1
= validated_mem
;
3188 if (icode
!= CODE_FOR_nothing
3189 && insn_operand_matches (icode
, 0, op0
)
3190 && insn_operand_matches (icode
, 1, op1
))
3192 enum rtx_code code
= unsignedp
? ZERO_EXTEND
: SIGN_EXTEND
;
3193 rtx_insn
*insn
, *insns
;
3195 HARD_REG_SET hardregs
;
3198 /* If op1 is a hard register that is likely spilled, first
3199 force it into a pseudo, otherwise combiner might extend
3200 its lifetime too much. */
3201 if (GET_CODE (t
) == SUBREG
)
3204 && HARD_REGISTER_P (t
)
3205 && ! TEST_HARD_REG_BIT (fixed_reg_set
, REGNO (t
))
3206 && targetm
.class_likely_spilled_p (REGNO_REG_CLASS (REGNO (t
))))
3208 t
= gen_reg_rtx (GET_MODE (op1
));
3209 emit_move_insn (t
, op1
);
3213 rtx_insn
*pat
= gen_extend_insn (op0
, t
, promoted_nominal_mode
,
3214 data
->passed_mode
, unsignedp
);
3216 insns
= get_insns ();
3219 CLEAR_HARD_REG_SET (hardregs
);
3220 for (insn
= insns
; insn
&& moved
; insn
= NEXT_INSN (insn
))
3223 note_stores (PATTERN (insn
), record_hard_reg_sets
,
3225 if (!hard_reg_set_empty_p (hardregs
))
3234 if (equiv_stack_parm
!= NULL_RTX
)
3235 equiv_stack_parm
= gen_rtx_fmt_e (code
, GET_MODE (parmreg
),
3242 /* Nothing to do. */
3244 else if (need_conversion
)
3246 /* We did not have an insn to convert directly, or the sequence
3247 generated appeared unsafe. We must first copy the parm to a
3248 pseudo reg, and save the conversion until after all
3249 parameters have been moved. */
3252 rtx tempreg
= gen_reg_rtx (GET_MODE (data
->entry_parm
));
3254 emit_move_insn (tempreg
, validated_mem
);
3256 push_to_sequence2 (all
->first_conversion_insn
, all
->last_conversion_insn
);
3257 tempreg
= convert_to_mode (data
->nominal_mode
, tempreg
, unsignedp
);
3259 if (GET_CODE (tempreg
) == SUBREG
3260 && GET_MODE (tempreg
) == data
->nominal_mode
3261 && REG_P (SUBREG_REG (tempreg
))
3262 && data
->nominal_mode
== data
->passed_mode
3263 && GET_MODE (SUBREG_REG (tempreg
)) == GET_MODE (data
->entry_parm
)
3264 && GET_MODE_SIZE (GET_MODE (tempreg
))
3265 < GET_MODE_SIZE (GET_MODE (data
->entry_parm
)))
3267 /* The argument is already sign/zero extended, so note it
3269 SUBREG_PROMOTED_VAR_P (tempreg
) = 1;
3270 SUBREG_PROMOTED_SET (tempreg
, unsignedp
);
3273 /* TREE_USED gets set erroneously during expand_assignment. */
3274 save_tree_used
= TREE_USED (parm
);
3275 expand_assignment (parm
, make_tree (data
->nominal_type
, tempreg
), false);
3276 TREE_USED (parm
) = save_tree_used
;
3277 all
->first_conversion_insn
= get_insns ();
3278 all
->last_conversion_insn
= get_last_insn ();
3281 did_conversion
= true;
3284 emit_move_insn (parmreg
, validated_mem
);
3286 /* If we were passed a pointer but the actual value can safely live
3287 in a register, retrieve it and use it directly. */
3288 if (data
->passed_pointer
3289 && (from_expand
|| TYPE_MODE (TREE_TYPE (parm
)) != BLKmode
))
3291 /* We can't use nominal_mode, because it will have been set to
3292 Pmode above. We must use the actual mode of the parm. */
3295 parmreg
= from_expand
;
3296 gcc_assert (GET_MODE (parmreg
) == TYPE_MODE (TREE_TYPE (parm
)));
3298 else if (use_register_for_decl (parm
))
3300 parmreg
= gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm
)));
3301 mark_user_reg (parmreg
);
3305 int align
= STACK_SLOT_ALIGNMENT (TREE_TYPE (parm
),
3306 TYPE_MODE (TREE_TYPE (parm
)),
3307 TYPE_ALIGN (TREE_TYPE (parm
)));
3309 = assign_stack_local (TYPE_MODE (TREE_TYPE (parm
)),
3310 GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parm
))),
3312 set_mem_attributes (parmreg
, parm
, 1);
3315 if (GET_MODE (parmreg
) != GET_MODE (DECL_RTL (parm
)))
3317 rtx tempreg
= gen_reg_rtx (GET_MODE (DECL_RTL (parm
)));
3318 int unsigned_p
= TYPE_UNSIGNED (TREE_TYPE (parm
));
3320 push_to_sequence2 (all
->first_conversion_insn
,
3321 all
->last_conversion_insn
);
3322 emit_move_insn (tempreg
, DECL_RTL (parm
));
3323 tempreg
= convert_to_mode (GET_MODE (parmreg
), tempreg
, unsigned_p
);
3324 emit_move_insn (parmreg
, tempreg
);
3325 all
->first_conversion_insn
= get_insns ();
3326 all
->last_conversion_insn
= get_last_insn ();
3329 did_conversion
= true;
3332 emit_move_insn (parmreg
, DECL_RTL (parm
));
3334 SET_DECL_RTL (parm
, parmreg
);
3336 /* STACK_PARM is the pointer, not the parm, and PARMREG is
3338 data
->stack_parm
= equiv_stack_parm
= NULL
;
3341 /* Mark the register as eliminable if we did no conversion and it was
3342 copied from memory at a fixed offset, and the arg pointer was not
3343 copied to a pseudo-reg. If the arg pointer is a pseudo reg or the
3344 offset formed an invalid address, such memory-equivalences as we
3345 make here would screw up life analysis for it. */
3346 if (data
->nominal_mode
== data
->passed_mode
3348 && equiv_stack_parm
!= 0
3349 && MEM_P (equiv_stack_parm
)
3350 && data
->locate
.offset
.var
== 0
3351 && reg_mentioned_p (virtual_incoming_args_rtx
,
3352 XEXP (equiv_stack_parm
, 0)))
3354 rtx_insn
*linsn
= get_last_insn ();
3358 /* Mark complex types separately. */
3359 if (GET_CODE (parmreg
) == CONCAT
)
3361 machine_mode submode
3362 = GET_MODE_INNER (GET_MODE (parmreg
));
3363 int regnor
= REGNO (XEXP (parmreg
, 0));
3364 int regnoi
= REGNO (XEXP (parmreg
, 1));
3365 rtx stackr
= adjust_address_nv (equiv_stack_parm
, submode
, 0);
3366 rtx stacki
= adjust_address_nv (equiv_stack_parm
, submode
,
3367 GET_MODE_SIZE (submode
));
3369 /* Scan backwards for the set of the real and
3371 for (sinsn
= linsn
; sinsn
!= 0;
3372 sinsn
= prev_nonnote_insn (sinsn
))
3374 set
= single_set (sinsn
);
3378 if (SET_DEST (set
) == regno_reg_rtx
[regnoi
])
3379 set_unique_reg_note (sinsn
, REG_EQUIV
, stacki
);
3380 else if (SET_DEST (set
) == regno_reg_rtx
[regnor
])
3381 set_unique_reg_note (sinsn
, REG_EQUIV
, stackr
);
3385 set_dst_reg_note (linsn
, REG_EQUIV
, equiv_stack_parm
, parmreg
);
3388 /* For pointer data type, suggest pointer register. */
3389 if (POINTER_TYPE_P (TREE_TYPE (parm
)))
3390 mark_reg_pointer (parmreg
,
3391 TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm
))));
3394 /* A subroutine of assign_parms. Allocate stack space to hold the current
3395 parameter. Get it there. Perform all ABI specified conversions. */
3398 assign_parm_setup_stack (struct assign_parm_data_all
*all
, tree parm
,
3399 struct assign_parm_data_one
*data
)
3401 /* Value must be stored in the stack slot STACK_PARM during function
3403 bool to_conversion
= false;
3405 assign_parm_remove_parallels (data
);
3407 if (data
->promoted_mode
!= data
->nominal_mode
)
3409 /* Conversion is required. */
3410 rtx tempreg
= gen_reg_rtx (GET_MODE (data
->entry_parm
));
3412 emit_move_insn (tempreg
, validize_mem (copy_rtx (data
->entry_parm
)));
3414 push_to_sequence2 (all
->first_conversion_insn
, all
->last_conversion_insn
);
3415 to_conversion
= true;
3417 data
->entry_parm
= convert_to_mode (data
->nominal_mode
, tempreg
,
3418 TYPE_UNSIGNED (TREE_TYPE (parm
)));
3420 if (data
->stack_parm
)
3422 int offset
= subreg_lowpart_offset (data
->nominal_mode
,
3423 GET_MODE (data
->stack_parm
));
3424 /* ??? This may need a big-endian conversion on sparc64. */
3426 = adjust_address (data
->stack_parm
, data
->nominal_mode
, 0);
3427 if (offset
&& MEM_OFFSET_KNOWN_P (data
->stack_parm
))
3428 set_mem_offset (data
->stack_parm
,
3429 MEM_OFFSET (data
->stack_parm
) + offset
);
3433 if (data
->entry_parm
!= data
->stack_parm
)
3437 if (data
->stack_parm
== 0)
3439 rtx x
= data
->stack_parm
= rtl_for_parm (all
, parm
);
3441 gcc_assert (GET_MODE (x
) == GET_MODE (data
->entry_parm
));
3444 if (data
->stack_parm
== 0)
3446 int align
= STACK_SLOT_ALIGNMENT (data
->passed_type
,
3447 GET_MODE (data
->entry_parm
),
3448 TYPE_ALIGN (data
->passed_type
));
3450 = assign_stack_local (GET_MODE (data
->entry_parm
),
3451 GET_MODE_SIZE (GET_MODE (data
->entry_parm
)),
3453 set_mem_attributes (data
->stack_parm
, parm
, 1);
3456 dest
= validize_mem (copy_rtx (data
->stack_parm
));
3457 src
= validize_mem (copy_rtx (data
->entry_parm
));
3461 /* Use a block move to handle potentially misaligned entry_parm. */
3463 push_to_sequence2 (all
->first_conversion_insn
,
3464 all
->last_conversion_insn
);
3465 to_conversion
= true;
3467 emit_block_move (dest
, src
,
3468 GEN_INT (int_size_in_bytes (data
->passed_type
)),
3472 emit_move_insn (dest
, src
);
3477 all
->first_conversion_insn
= get_insns ();
3478 all
->last_conversion_insn
= get_last_insn ();
3482 SET_DECL_RTL (parm
, data
->stack_parm
);
3485 /* A subroutine of assign_parms. If the ABI splits complex arguments, then
3486 undo the frobbing that we did in assign_parms_augmented_arg_list. */
3489 assign_parms_unsplit_complex (struct assign_parm_data_all
*all
,
3493 tree orig_fnargs
= all
->orig_fnargs
;
3496 for (parm
= orig_fnargs
; parm
; parm
= TREE_CHAIN (parm
), ++i
)
3498 if (TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
3499 && targetm
.calls
.split_complex_arg (TREE_TYPE (parm
)))
3501 rtx tmp
, real
, imag
;
3502 machine_mode inner
= GET_MODE_INNER (DECL_MODE (parm
));
3504 real
= DECL_RTL (fnargs
[i
]);
3505 imag
= DECL_RTL (fnargs
[i
+ 1]);
3506 if (inner
!= GET_MODE (real
))
3508 real
= gen_lowpart_SUBREG (inner
, real
);
3509 imag
= gen_lowpart_SUBREG (inner
, imag
);
3512 if (TREE_ADDRESSABLE (parm
))
3515 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (parm
));
3516 int align
= STACK_SLOT_ALIGNMENT (TREE_TYPE (parm
),
3518 TYPE_ALIGN (TREE_TYPE (parm
)));
3520 /* split_complex_arg put the real and imag parts in
3521 pseudos. Move them to memory. */
3522 tmp
= assign_stack_local (DECL_MODE (parm
), size
, align
);
3523 set_mem_attributes (tmp
, parm
, 1);
3524 rmem
= adjust_address_nv (tmp
, inner
, 0);
3525 imem
= adjust_address_nv (tmp
, inner
, GET_MODE_SIZE (inner
));
3526 push_to_sequence2 (all
->first_conversion_insn
,
3527 all
->last_conversion_insn
);
3528 emit_move_insn (rmem
, real
);
3529 emit_move_insn (imem
, imag
);
3530 all
->first_conversion_insn
= get_insns ();
3531 all
->last_conversion_insn
= get_last_insn ();
3535 tmp
= gen_rtx_CONCAT (DECL_MODE (parm
), real
, imag
);
3536 SET_DECL_RTL (parm
, tmp
);
3538 real
= DECL_INCOMING_RTL (fnargs
[i
]);
3539 imag
= DECL_INCOMING_RTL (fnargs
[i
+ 1]);
3540 if (inner
!= GET_MODE (real
))
3542 real
= gen_lowpart_SUBREG (inner
, real
);
3543 imag
= gen_lowpart_SUBREG (inner
, imag
);
3545 tmp
= gen_rtx_CONCAT (DECL_MODE (parm
), real
, imag
);
3546 set_decl_incoming_rtl (parm
, tmp
, false);
3552 /* Load bounds of PARM from bounds table. */
3554 assign_parm_load_bounds (struct assign_parm_data_one
*data
,
3560 unsigned i
, offs
= 0;
3562 rtx slot
= NULL
, ptr
= NULL
;
3567 bitmap_obstack_initialize (NULL
);
3568 slots
= BITMAP_ALLOC (NULL
);
3569 chkp_find_bound_slots (TREE_TYPE (parm
), slots
);
3570 EXECUTE_IF_SET_IN_BITMAP (slots
, 0, i
, bi
)
3580 BITMAP_FREE (slots
);
3581 bitmap_obstack_release (NULL
);
3584 /* We may have bounds not associated with any pointer. */
3586 offs
= bnd_no
* POINTER_SIZE
/ BITS_PER_UNIT
;
3588 /* Find associated pointer. */
3591 /* If bounds are not associated with any bounds,
3592 then it is passed in a register or special slot. */
3593 gcc_assert (data
->entry_parm
);
3596 else if (MEM_P (entry
))
3597 slot
= adjust_address (entry
, Pmode
, offs
);
3598 else if (REG_P (entry
))
3599 ptr
= gen_rtx_REG (Pmode
, REGNO (entry
) + bnd_no
);
3600 else if (GET_CODE (entry
) == PARALLEL
)
3601 ptr
= chkp_get_value_with_offs (entry
, GEN_INT (offs
));
3604 data
->entry_parm
= targetm
.calls
.load_bounds_for_arg (slot
, ptr
,
3608 /* Assign RTL expressions to the function's bounds parameters BNDARGS. */
3611 assign_bounds (vec
<bounds_parm_data
> &bndargs
,
3612 struct assign_parm_data_all
&all
)
3614 unsigned i
, pass
, handled
= 0;
3615 bounds_parm_data
*pbdata
;
3617 if (!bndargs
.exists ())
3620 /* We make few passes to store input bounds. Firstly handle bounds
3621 passed in registers. After that we load bounds passed in special
3622 slots. Finally we load bounds from Bounds Table. */
3623 for (pass
= 0; pass
< 3; pass
++)
3624 FOR_EACH_VEC_ELT (bndargs
, i
, pbdata
)
3626 /* Pass 0 => regs only. */
3628 && (!pbdata
->parm_data
.entry_parm
3629 || GET_CODE (pbdata
->parm_data
.entry_parm
) != REG
))
3631 /* Pass 1 => slots only. */
3633 && (!pbdata
->parm_data
.entry_parm
3634 || GET_CODE (pbdata
->parm_data
.entry_parm
) == REG
))
3636 /* Pass 2 => BT only. */
3638 && pbdata
->parm_data
.entry_parm
)
3641 if (!pbdata
->parm_data
.entry_parm
3642 || GET_CODE (pbdata
->parm_data
.entry_parm
) != REG
)
3643 assign_parm_load_bounds (&pbdata
->parm_data
, pbdata
->ptr_parm
,
3644 pbdata
->ptr_entry
, pbdata
->bound_no
);
3646 set_decl_incoming_rtl (pbdata
->bounds_parm
,
3647 pbdata
->parm_data
.entry_parm
, false);
3649 if (assign_parm_setup_block_p (&pbdata
->parm_data
))
3650 assign_parm_setup_block (&all
, pbdata
->bounds_parm
,
3651 &pbdata
->parm_data
);
3652 else if (pbdata
->parm_data
.passed_pointer
3653 || use_register_for_decl (pbdata
->bounds_parm
))
3654 assign_parm_setup_reg (&all
, pbdata
->bounds_parm
,
3655 &pbdata
->parm_data
);
3657 assign_parm_setup_stack (&all
, pbdata
->bounds_parm
,
3658 &pbdata
->parm_data
);
3660 /* Count handled bounds to make sure we miss nothing. */
3664 gcc_assert (handled
== bndargs
.length ());
3669 /* Assign RTL expressions to the function's parameters. This may involve
3670 copying them into registers and using those registers as the DECL_RTL. */
3673 assign_parms (tree fndecl
)
3675 struct assign_parm_data_all all
;
3678 unsigned i
, bound_no
= 0;
3679 tree last_arg
= NULL
;
3680 rtx last_arg_entry
= NULL
;
3681 vec
<bounds_parm_data
> bndargs
= vNULL
;
3682 bounds_parm_data bdata
;
3684 crtl
->args
.internal_arg_pointer
3685 = targetm
.calls
.internal_arg_pointer ();
3687 assign_parms_initialize_all (&all
);
3688 fnargs
= assign_parms_augmented_arg_list (&all
);
3690 FOR_EACH_VEC_ELT (fnargs
, i
, parm
)
3692 struct assign_parm_data_one data
;
3694 /* Extract the type of PARM; adjust it according to ABI. */
3695 assign_parm_find_data_types (&all
, parm
, &data
);
3697 /* Early out for errors and void parameters. */
3698 if (data
.passed_mode
== VOIDmode
)
3700 SET_DECL_RTL (parm
, const0_rtx
);
3701 DECL_INCOMING_RTL (parm
) = DECL_RTL (parm
);
3705 maybe_reset_rtl_for_parm (parm
);
3707 /* Estimate stack alignment from parameter alignment. */
3708 if (SUPPORTS_STACK_ALIGNMENT
)
3711 = targetm
.calls
.function_arg_boundary (data
.promoted_mode
,
3713 align
= MINIMUM_ALIGNMENT (data
.passed_type
, data
.promoted_mode
,
3715 if (TYPE_ALIGN (data
.nominal_type
) > align
)
3716 align
= MINIMUM_ALIGNMENT (data
.nominal_type
,
3717 TYPE_MODE (data
.nominal_type
),
3718 TYPE_ALIGN (data
.nominal_type
));
3719 if (crtl
->stack_alignment_estimated
< align
)
3721 gcc_assert (!crtl
->stack_realign_processed
);
3722 crtl
->stack_alignment_estimated
= align
;
3726 /* Find out where the parameter arrives in this function. */
3727 assign_parm_find_entry_rtl (&all
, &data
);
3729 /* Find out where stack space for this parameter might be. */
3730 if (assign_parm_is_stack_parm (&all
, &data
))
3732 assign_parm_find_stack_rtl (parm
, &data
);
3733 assign_parm_adjust_entry_rtl (&data
);
3735 if (!POINTER_BOUNDS_TYPE_P (data
.passed_type
))
3737 /* Remember where last non bounds arg was passed in case
3738 we have to load associated bounds for it from Bounds
3741 last_arg_entry
= data
.entry_parm
;
3744 /* Record permanently how this parm was passed. */
3745 if (data
.passed_pointer
)
3748 = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data
.passed_type
)),
3750 set_decl_incoming_rtl (parm
, incoming_rtl
, true);
3753 set_decl_incoming_rtl (parm
, data
.entry_parm
, false);
3755 assign_parm_adjust_stack_rtl (&all
, parm
, &data
);
3757 /* Bounds should be loaded in the particular order to
3758 have registers allocated correctly. Collect info about
3759 input bounds and load them later. */
3760 if (POINTER_BOUNDS_TYPE_P (data
.passed_type
))
3762 /* Expect bounds in instrumented functions only. */
3763 gcc_assert (chkp_function_instrumented_p (fndecl
));
3765 bdata
.parm_data
= data
;
3766 bdata
.bounds_parm
= parm
;
3767 bdata
.ptr_parm
= last_arg
;
3768 bdata
.ptr_entry
= last_arg_entry
;
3769 bdata
.bound_no
= bound_no
;
3770 bndargs
.safe_push (bdata
);
3774 if (assign_parm_setup_block_p (&data
))
3775 assign_parm_setup_block (&all
, parm
, &data
);
3776 else if (data
.passed_pointer
3777 || use_register_for_parm_decl (&all
, parm
))
3778 assign_parm_setup_reg (&all
, parm
, &data
);
3780 assign_parm_setup_stack (&all
, parm
, &data
);
3783 if (cfun
->stdarg
&& !DECL_CHAIN (parm
))
3785 int pretend_bytes
= 0;
3787 assign_parms_setup_varargs (&all
, &data
, false);
3789 if (chkp_function_instrumented_p (fndecl
))
3791 /* We expect this is the last parm. Otherwise it is wrong
3792 to assign bounds right now. */
3793 gcc_assert (i
== (fnargs
.length () - 1));
3794 assign_bounds (bndargs
, all
);
3795 targetm
.calls
.setup_incoming_vararg_bounds (all
.args_so_far
,
3803 /* Update info on where next arg arrives in registers. */
3804 targetm
.calls
.function_arg_advance (all
.args_so_far
, data
.promoted_mode
,
3805 data
.passed_type
, data
.named_arg
);
3807 if (POINTER_BOUNDS_TYPE_P (data
.passed_type
))
3811 assign_bounds (bndargs
, all
);
3813 if (targetm
.calls
.split_complex_arg
)
3814 assign_parms_unsplit_complex (&all
, fnargs
);
3818 /* Output all parameter conversion instructions (possibly including calls)
3819 now that all parameters have been copied out of hard registers. */
3820 emit_insn (all
.first_conversion_insn
);
3822 /* Estimate reload stack alignment from scalar return mode. */
3823 if (SUPPORTS_STACK_ALIGNMENT
)
3825 if (DECL_RESULT (fndecl
))
3827 tree type
= TREE_TYPE (DECL_RESULT (fndecl
));
3828 machine_mode mode
= TYPE_MODE (type
);
3832 && !AGGREGATE_TYPE_P (type
))
3834 unsigned int align
= GET_MODE_ALIGNMENT (mode
);
3835 if (crtl
->stack_alignment_estimated
< align
)
3837 gcc_assert (!crtl
->stack_realign_processed
);
3838 crtl
->stack_alignment_estimated
= align
;
3844 /* If we are receiving a struct value address as the first argument, set up
3845 the RTL for the function result. As this might require code to convert
3846 the transmitted address to Pmode, we do this here to ensure that possible
3847 preliminary conversions of the address have been emitted already. */
3848 if (all
.function_result_decl
)
3850 tree result
= DECL_RESULT (current_function_decl
);
3851 rtx addr
= DECL_RTL (all
.function_result_decl
);
3854 if (DECL_BY_REFERENCE (result
))
3856 SET_DECL_VALUE_EXPR (result
, all
.function_result_decl
);
3861 SET_DECL_VALUE_EXPR (result
,
3862 build1 (INDIRECT_REF
, TREE_TYPE (result
),
3863 all
.function_result_decl
));
3864 addr
= convert_memory_address (Pmode
, addr
);
3865 x
= gen_rtx_MEM (DECL_MODE (result
), addr
);
3866 set_mem_attributes (x
, result
, 1);
3869 DECL_HAS_VALUE_EXPR_P (result
) = 1;
3871 SET_DECL_RTL (result
, x
);
3874 /* We have aligned all the args, so add space for the pretend args. */
3875 crtl
->args
.pretend_args_size
= all
.pretend_args_size
;
3876 all
.stack_args_size
.constant
+= all
.extra_pretend_bytes
;
3877 crtl
->args
.size
= all
.stack_args_size
.constant
;
3879 /* Adjust function incoming argument size for alignment and
3882 crtl
->args
.size
= MAX (crtl
->args
.size
, all
.reg_parm_stack_space
);
3883 crtl
->args
.size
= CEIL_ROUND (crtl
->args
.size
,
3884 PARM_BOUNDARY
/ BITS_PER_UNIT
);
3886 if (ARGS_GROW_DOWNWARD
)
3888 crtl
->args
.arg_offset_rtx
3889 = (all
.stack_args_size
.var
== 0 ? GEN_INT (-all
.stack_args_size
.constant
)
3890 : expand_expr (size_diffop (all
.stack_args_size
.var
,
3891 size_int (-all
.stack_args_size
.constant
)),
3892 NULL_RTX
, VOIDmode
, EXPAND_NORMAL
));
3895 crtl
->args
.arg_offset_rtx
= ARGS_SIZE_RTX (all
.stack_args_size
);
3897 /* See how many bytes, if any, of its args a function should try to pop
3900 crtl
->args
.pops_args
= targetm
.calls
.return_pops_args (fndecl
,
3904 /* For stdarg.h function, save info about
3905 regs and stack space used by the named args. */
3907 crtl
->args
.info
= all
.args_so_far_v
;
3909 /* Set the rtx used for the function return value. Put this in its
3910 own variable so any optimizers that need this information don't have
3911 to include tree.h. Do this here so it gets done when an inlined
3912 function gets output. */
3915 = (DECL_RTL_SET_P (DECL_RESULT (fndecl
))
3916 ? DECL_RTL (DECL_RESULT (fndecl
)) : NULL_RTX
);
3918 /* If scalar return value was computed in a pseudo-reg, or was a named
3919 return value that got dumped to the stack, copy that to the hard
3921 if (DECL_RTL_SET_P (DECL_RESULT (fndecl
)))
3923 tree decl_result
= DECL_RESULT (fndecl
);
3924 rtx decl_rtl
= DECL_RTL (decl_result
);
3926 if (REG_P (decl_rtl
)
3927 ? REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
3928 : DECL_REGISTER (decl_result
))
3932 real_decl_rtl
= targetm
.calls
.function_value (TREE_TYPE (decl_result
),
3934 if (chkp_function_instrumented_p (fndecl
))
3936 = targetm
.calls
.chkp_function_value_bounds (TREE_TYPE (decl_result
),
3938 REG_FUNCTION_VALUE_P (real_decl_rtl
) = 1;
3939 /* The delay slot scheduler assumes that crtl->return_rtx
3940 holds the hard register containing the return value, not a
3941 temporary pseudo. */
3942 crtl
->return_rtx
= real_decl_rtl
;
3947 /* A subroutine of gimplify_parameters, invoked via walk_tree.
3948 For all seen types, gimplify their sizes. */
3951 gimplify_parm_type (tree
*tp
, int *walk_subtrees
, void *data
)
3958 if (POINTER_TYPE_P (t
))
3960 else if (TYPE_SIZE (t
) && !TREE_CONSTANT (TYPE_SIZE (t
))
3961 && !TYPE_SIZES_GIMPLIFIED (t
))
3963 gimplify_type_sizes (t
, (gimple_seq
*) data
);
3971 /* Gimplify the parameter list for current_function_decl. This involves
3972 evaluating SAVE_EXPRs of variable sized parameters and generating code
3973 to implement callee-copies reference parameters. Returns a sequence of
3974 statements to add to the beginning of the function. */
3977 gimplify_parameters (void)
3979 struct assign_parm_data_all all
;
3981 gimple_seq stmts
= NULL
;
3985 assign_parms_initialize_all (&all
);
3986 fnargs
= assign_parms_augmented_arg_list (&all
);
3988 FOR_EACH_VEC_ELT (fnargs
, i
, parm
)
3990 struct assign_parm_data_one data
;
3992 /* Extract the type of PARM; adjust it according to ABI. */
3993 assign_parm_find_data_types (&all
, parm
, &data
);
3995 /* Early out for errors and void parameters. */
3996 if (data
.passed_mode
== VOIDmode
|| DECL_SIZE (parm
) == NULL
)
3999 /* Update info on where next arg arrives in registers. */
4000 targetm
.calls
.function_arg_advance (all
.args_so_far
, data
.promoted_mode
,
4001 data
.passed_type
, data
.named_arg
);
4003 /* ??? Once upon a time variable_size stuffed parameter list
4004 SAVE_EXPRs (amongst others) onto a pending sizes list. This
4005 turned out to be less than manageable in the gimple world.
4006 Now we have to hunt them down ourselves. */
4007 walk_tree_without_duplicates (&data
.passed_type
,
4008 gimplify_parm_type
, &stmts
);
4010 if (TREE_CODE (DECL_SIZE_UNIT (parm
)) != INTEGER_CST
)
4012 gimplify_one_sizepos (&DECL_SIZE (parm
), &stmts
);
4013 gimplify_one_sizepos (&DECL_SIZE_UNIT (parm
), &stmts
);
4016 if (data
.passed_pointer
)
4018 tree type
= TREE_TYPE (data
.passed_type
);
4019 if (reference_callee_copied (&all
.args_so_far_v
, TYPE_MODE (type
),
4020 type
, data
.named_arg
))
4024 /* For constant-sized objects, this is trivial; for
4025 variable-sized objects, we have to play games. */
4026 if (TREE_CODE (DECL_SIZE_UNIT (parm
)) == INTEGER_CST
4027 && !(flag_stack_check
== GENERIC_STACK_CHECK
4028 && compare_tree_int (DECL_SIZE_UNIT (parm
),
4029 STACK_CHECK_MAX_VAR_SIZE
) > 0))
4031 local
= create_tmp_var (type
, get_name (parm
));
4032 DECL_IGNORED_P (local
) = 0;
4033 /* If PARM was addressable, move that flag over
4034 to the local copy, as its address will be taken,
4035 not the PARMs. Keep the parms address taken
4036 as we'll query that flag during gimplification. */
4037 if (TREE_ADDRESSABLE (parm
))
4038 TREE_ADDRESSABLE (local
) = 1;
4039 else if (TREE_CODE (type
) == COMPLEX_TYPE
4040 || TREE_CODE (type
) == VECTOR_TYPE
)
4041 DECL_GIMPLE_REG_P (local
) = 1;
4045 tree ptr_type
, addr
;
4047 ptr_type
= build_pointer_type (type
);
4048 addr
= create_tmp_reg (ptr_type
, get_name (parm
));
4049 DECL_IGNORED_P (addr
) = 0;
4050 local
= build_fold_indirect_ref (addr
);
4052 t
= builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN
);
4053 t
= build_call_expr (t
, 2, DECL_SIZE_UNIT (parm
),
4054 size_int (DECL_ALIGN (parm
)));
4056 /* The call has been built for a variable-sized object. */
4057 CALL_ALLOCA_FOR_VAR_P (t
) = 1;
4058 t
= fold_convert (ptr_type
, t
);
4059 t
= build2 (MODIFY_EXPR
, TREE_TYPE (addr
), addr
, t
);
4060 gimplify_and_add (t
, &stmts
);
4063 gimplify_assign (local
, parm
, &stmts
);
4065 SET_DECL_VALUE_EXPR (parm
, local
);
4066 DECL_HAS_VALUE_EXPR_P (parm
) = 1;
4076 /* Compute the size and offset from the start of the stacked arguments for a
4077 parm passed in mode PASSED_MODE and with type TYPE.
4079 INITIAL_OFFSET_PTR points to the current offset into the stacked
4082 The starting offset and size for this parm are returned in
4083 LOCATE->OFFSET and LOCATE->SIZE, respectively. When IN_REGS is
4084 nonzero, the offset is that of stack slot, which is returned in
4085 LOCATE->SLOT_OFFSET. LOCATE->ALIGNMENT_PAD is the amount of
4086 padding required from the initial offset ptr to the stack slot.
4088 IN_REGS is nonzero if the argument will be passed in registers. It will
4089 never be set if REG_PARM_STACK_SPACE is not defined.
4091 REG_PARM_STACK_SPACE is the number of bytes of stack space reserved
4092 for arguments which are passed in registers.
4094 FNDECL is the function in which the argument was defined.
4096 There are two types of rounding that are done. The first, controlled by
4097 TARGET_FUNCTION_ARG_BOUNDARY, forces the offset from the start of the
4098 argument list to be aligned to the specific boundary (in bits). This
4099 rounding affects the initial and starting offsets, but not the argument
4102 The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY,
4103 optionally rounds the size of the parm to PARM_BOUNDARY. The
4104 initial offset is not affected by this rounding, while the size always
4105 is and the starting offset may be. */
4107 /* LOCATE->OFFSET will be negative for ARGS_GROW_DOWNWARD case;
4108 INITIAL_OFFSET_PTR is positive because locate_and_pad_parm's
4109 callers pass in the total size of args so far as
4110 INITIAL_OFFSET_PTR. LOCATE->SIZE is always positive. */
4113 locate_and_pad_parm (machine_mode passed_mode
, tree type
, int in_regs
,
4114 int reg_parm_stack_space
, int partial
,
4115 tree fndecl ATTRIBUTE_UNUSED
,
4116 struct args_size
*initial_offset_ptr
,
4117 struct locate_and_pad_arg_data
*locate
)
4120 enum direction where_pad
;
4121 unsigned int boundary
, round_boundary
;
4122 int part_size_in_regs
;
4124 /* If we have found a stack parm before we reach the end of the
4125 area reserved for registers, skip that area. */
4128 if (reg_parm_stack_space
> 0)
4130 if (initial_offset_ptr
->var
)
4132 initial_offset_ptr
->var
4133 = size_binop (MAX_EXPR
, ARGS_SIZE_TREE (*initial_offset_ptr
),
4134 ssize_int (reg_parm_stack_space
));
4135 initial_offset_ptr
->constant
= 0;
4137 else if (initial_offset_ptr
->constant
< reg_parm_stack_space
)
4138 initial_offset_ptr
->constant
= reg_parm_stack_space
;
4142 part_size_in_regs
= (reg_parm_stack_space
== 0 ? partial
: 0);
4145 = type
? size_in_bytes (type
) : size_int (GET_MODE_SIZE (passed_mode
));
4146 where_pad
= FUNCTION_ARG_PADDING (passed_mode
, type
);
4147 boundary
= targetm
.calls
.function_arg_boundary (passed_mode
, type
);
4148 round_boundary
= targetm
.calls
.function_arg_round_boundary (passed_mode
,
4150 locate
->where_pad
= where_pad
;
4152 /* Alignment can't exceed MAX_SUPPORTED_STACK_ALIGNMENT. */
4153 if (boundary
> MAX_SUPPORTED_STACK_ALIGNMENT
)
4154 boundary
= MAX_SUPPORTED_STACK_ALIGNMENT
;
4156 locate
->boundary
= boundary
;
4158 if (SUPPORTS_STACK_ALIGNMENT
)
4160 /* stack_alignment_estimated can't change after stack has been
4162 if (crtl
->stack_alignment_estimated
< boundary
)
4164 if (!crtl
->stack_realign_processed
)
4165 crtl
->stack_alignment_estimated
= boundary
;
4168 /* If stack is realigned and stack alignment value
4169 hasn't been finalized, it is OK not to increase
4170 stack_alignment_estimated. The bigger alignment
4171 requirement is recorded in stack_alignment_needed
4173 gcc_assert (!crtl
->stack_realign_finalized
4174 && crtl
->stack_realign_needed
);
4179 /* Remember if the outgoing parameter requires extra alignment on the
4180 calling function side. */
4181 if (crtl
->stack_alignment_needed
< boundary
)
4182 crtl
->stack_alignment_needed
= boundary
;
4183 if (crtl
->preferred_stack_boundary
< boundary
)
4184 crtl
->preferred_stack_boundary
= boundary
;
4186 if (ARGS_GROW_DOWNWARD
)
4188 locate
->slot_offset
.constant
= -initial_offset_ptr
->constant
;
4189 if (initial_offset_ptr
->var
)
4190 locate
->slot_offset
.var
= size_binop (MINUS_EXPR
, ssize_int (0),
4191 initial_offset_ptr
->var
);
4195 if (where_pad
!= none
4196 && (!tree_fits_uhwi_p (sizetree
)
4197 || (tree_to_uhwi (sizetree
) * BITS_PER_UNIT
) % round_boundary
))
4198 s2
= round_up (s2
, round_boundary
/ BITS_PER_UNIT
);
4199 SUB_PARM_SIZE (locate
->slot_offset
, s2
);
4202 locate
->slot_offset
.constant
+= part_size_in_regs
;
4204 if (!in_regs
|| reg_parm_stack_space
> 0)
4205 pad_to_arg_alignment (&locate
->slot_offset
, boundary
,
4206 &locate
->alignment_pad
);
4208 locate
->size
.constant
= (-initial_offset_ptr
->constant
4209 - locate
->slot_offset
.constant
);
4210 if (initial_offset_ptr
->var
)
4211 locate
->size
.var
= size_binop (MINUS_EXPR
,
4212 size_binop (MINUS_EXPR
,
4214 initial_offset_ptr
->var
),
4215 locate
->slot_offset
.var
);
4217 /* Pad_below needs the pre-rounded size to know how much to pad
4219 locate
->offset
= locate
->slot_offset
;
4220 if (where_pad
== downward
)
4221 pad_below (&locate
->offset
, passed_mode
, sizetree
);
4226 if (!in_regs
|| reg_parm_stack_space
> 0)
4227 pad_to_arg_alignment (initial_offset_ptr
, boundary
,
4228 &locate
->alignment_pad
);
4229 locate
->slot_offset
= *initial_offset_ptr
;
4231 #ifdef PUSH_ROUNDING
4232 if (passed_mode
!= BLKmode
)
4233 sizetree
= size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree
)));
4236 /* Pad_below needs the pre-rounded size to know how much to pad below
4237 so this must be done before rounding up. */
4238 locate
->offset
= locate
->slot_offset
;
4239 if (where_pad
== downward
)
4240 pad_below (&locate
->offset
, passed_mode
, sizetree
);
4242 if (where_pad
!= none
4243 && (!tree_fits_uhwi_p (sizetree
)
4244 || (tree_to_uhwi (sizetree
) * BITS_PER_UNIT
) % round_boundary
))
4245 sizetree
= round_up (sizetree
, round_boundary
/ BITS_PER_UNIT
);
4247 ADD_PARM_SIZE (locate
->size
, sizetree
);
4249 locate
->size
.constant
-= part_size_in_regs
;
4252 #ifdef FUNCTION_ARG_OFFSET
4253 locate
->offset
.constant
+= FUNCTION_ARG_OFFSET (passed_mode
, type
);
4257 /* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY.
4258 BOUNDARY is measured in bits, but must be a multiple of a storage unit. */
4261 pad_to_arg_alignment (struct args_size
*offset_ptr
, int boundary
,
4262 struct args_size
*alignment_pad
)
4264 tree save_var
= NULL_TREE
;
4265 HOST_WIDE_INT save_constant
= 0;
4266 int boundary_in_bytes
= boundary
/ BITS_PER_UNIT
;
4267 HOST_WIDE_INT sp_offset
= STACK_POINTER_OFFSET
;
4269 #ifdef SPARC_STACK_BOUNDARY_HACK
4270 /* ??? The SPARC port may claim a STACK_BOUNDARY higher than
4271 the real alignment of %sp. However, when it does this, the
4272 alignment of %sp+STACK_POINTER_OFFSET is STACK_BOUNDARY. */
4273 if (SPARC_STACK_BOUNDARY_HACK
)
4277 if (boundary
> PARM_BOUNDARY
)
4279 save_var
= offset_ptr
->var
;
4280 save_constant
= offset_ptr
->constant
;
4283 alignment_pad
->var
= NULL_TREE
;
4284 alignment_pad
->constant
= 0;
4286 if (boundary
> BITS_PER_UNIT
)
4288 if (offset_ptr
->var
)
4290 tree sp_offset_tree
= ssize_int (sp_offset
);
4291 tree offset
= size_binop (PLUS_EXPR
,
4292 ARGS_SIZE_TREE (*offset_ptr
),
4295 if (ARGS_GROW_DOWNWARD
)
4296 rounded
= round_down (offset
, boundary
/ BITS_PER_UNIT
);
4298 rounded
= round_up (offset
, boundary
/ BITS_PER_UNIT
);
4300 offset_ptr
->var
= size_binop (MINUS_EXPR
, rounded
, sp_offset_tree
);
4301 /* ARGS_SIZE_TREE includes constant term. */
4302 offset_ptr
->constant
= 0;
4303 if (boundary
> PARM_BOUNDARY
)
4304 alignment_pad
->var
= size_binop (MINUS_EXPR
, offset_ptr
->var
,
4309 offset_ptr
->constant
= -sp_offset
+
4311 ? FLOOR_ROUND (offset_ptr
->constant
+ sp_offset
, boundary_in_bytes
)
4312 : CEIL_ROUND (offset_ptr
->constant
+ sp_offset
, boundary_in_bytes
));
4314 if (boundary
> PARM_BOUNDARY
)
4315 alignment_pad
->constant
= offset_ptr
->constant
- save_constant
;
4321 pad_below (struct args_size
*offset_ptr
, machine_mode passed_mode
, tree sizetree
)
4323 if (passed_mode
!= BLKmode
)
4325 if (GET_MODE_BITSIZE (passed_mode
) % PARM_BOUNDARY
)
4326 offset_ptr
->constant
4327 += (((GET_MODE_BITSIZE (passed_mode
) + PARM_BOUNDARY
- 1)
4328 / PARM_BOUNDARY
* PARM_BOUNDARY
/ BITS_PER_UNIT
)
4329 - GET_MODE_SIZE (passed_mode
));
4333 if (TREE_CODE (sizetree
) != INTEGER_CST
4334 || (TREE_INT_CST_LOW (sizetree
) * BITS_PER_UNIT
) % PARM_BOUNDARY
)
4336 /* Round the size up to multiple of PARM_BOUNDARY bits. */
4337 tree s2
= round_up (sizetree
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
4339 ADD_PARM_SIZE (*offset_ptr
, s2
);
4340 SUB_PARM_SIZE (*offset_ptr
, sizetree
);
4346 /* True if register REGNO was alive at a place where `setjmp' was
4347 called and was set more than once or is an argument. Such regs may
4348 be clobbered by `longjmp'. */
4351 regno_clobbered_at_setjmp (bitmap setjmp_crosses
, int regno
)
4353 /* There appear to be cases where some local vars never reach the
4354 backend but have bogus regnos. */
4355 if (regno
>= max_reg_num ())
4358 return ((REG_N_SETS (regno
) > 1
4359 || REGNO_REG_SET_P (df_get_live_out (ENTRY_BLOCK_PTR_FOR_FN (cfun
)),
4361 && REGNO_REG_SET_P (setjmp_crosses
, regno
));
4364 /* Walk the tree of blocks describing the binding levels within a
4365 function and warn about variables the might be killed by setjmp or
4366 vfork. This is done after calling flow_analysis before register
4367 allocation since that will clobber the pseudo-regs to hard
4371 setjmp_vars_warning (bitmap setjmp_crosses
, tree block
)
4375 for (decl
= BLOCK_VARS (block
); decl
; decl
= DECL_CHAIN (decl
))
4377 if (TREE_CODE (decl
) == VAR_DECL
4378 && DECL_RTL_SET_P (decl
)
4379 && REG_P (DECL_RTL (decl
))
4380 && regno_clobbered_at_setjmp (setjmp_crosses
, REGNO (DECL_RTL (decl
))))
4381 warning (OPT_Wclobbered
, "variable %q+D might be clobbered by"
4382 " %<longjmp%> or %<vfork%>", decl
);
4385 for (sub
= BLOCK_SUBBLOCKS (block
); sub
; sub
= BLOCK_CHAIN (sub
))
4386 setjmp_vars_warning (setjmp_crosses
, sub
);
4389 /* Do the appropriate part of setjmp_vars_warning
4390 but for arguments instead of local variables. */
4393 setjmp_args_warning (bitmap setjmp_crosses
)
4396 for (decl
= DECL_ARGUMENTS (current_function_decl
);
4397 decl
; decl
= DECL_CHAIN (decl
))
4398 if (DECL_RTL (decl
) != 0
4399 && REG_P (DECL_RTL (decl
))
4400 && regno_clobbered_at_setjmp (setjmp_crosses
, REGNO (DECL_RTL (decl
))))
4401 warning (OPT_Wclobbered
,
4402 "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>",
4406 /* Generate warning messages for variables live across setjmp. */
4409 generate_setjmp_warnings (void)
4411 bitmap setjmp_crosses
= regstat_get_setjmp_crosses ();
4413 if (n_basic_blocks_for_fn (cfun
) == NUM_FIXED_BLOCKS
4414 || bitmap_empty_p (setjmp_crosses
))
4417 setjmp_vars_warning (setjmp_crosses
, DECL_INITIAL (current_function_decl
));
4418 setjmp_args_warning (setjmp_crosses
);
4422 /* Reverse the order of elements in the fragment chain T of blocks,
4423 and return the new head of the chain (old last element).
4424 In addition to that clear BLOCK_SAME_RANGE flags when needed
4425 and adjust BLOCK_SUPERCONTEXT from the super fragment to
4426 its super fragment origin. */
4429 block_fragments_nreverse (tree t
)
4431 tree prev
= 0, block
, next
, prev_super
= 0;
4432 tree super
= BLOCK_SUPERCONTEXT (t
);
4433 if (BLOCK_FRAGMENT_ORIGIN (super
))
4434 super
= BLOCK_FRAGMENT_ORIGIN (super
);
4435 for (block
= t
; block
; block
= next
)
4437 next
= BLOCK_FRAGMENT_CHAIN (block
);
4438 BLOCK_FRAGMENT_CHAIN (block
) = prev
;
4439 if ((prev
&& !BLOCK_SAME_RANGE (prev
))
4440 || (BLOCK_FRAGMENT_CHAIN (BLOCK_SUPERCONTEXT (block
))
4442 BLOCK_SAME_RANGE (block
) = 0;
4443 prev_super
= BLOCK_SUPERCONTEXT (block
);
4444 BLOCK_SUPERCONTEXT (block
) = super
;
4447 t
= BLOCK_FRAGMENT_ORIGIN (t
);
4448 if (BLOCK_FRAGMENT_CHAIN (BLOCK_SUPERCONTEXT (t
))
4450 BLOCK_SAME_RANGE (t
) = 0;
4451 BLOCK_SUPERCONTEXT (t
) = super
;
4455 /* Reverse the order of elements in the chain T of blocks,
4456 and return the new head of the chain (old last element).
4457 Also do the same on subblocks and reverse the order of elements
4458 in BLOCK_FRAGMENT_CHAIN as well. */
4461 blocks_nreverse_all (tree t
)
4463 tree prev
= 0, block
, next
;
4464 for (block
= t
; block
; block
= next
)
4466 next
= BLOCK_CHAIN (block
);
4467 BLOCK_CHAIN (block
) = prev
;
4468 if (BLOCK_FRAGMENT_CHAIN (block
)
4469 && BLOCK_FRAGMENT_ORIGIN (block
) == NULL_TREE
)
4471 BLOCK_FRAGMENT_CHAIN (block
)
4472 = block_fragments_nreverse (BLOCK_FRAGMENT_CHAIN (block
));
4473 if (!BLOCK_SAME_RANGE (BLOCK_FRAGMENT_CHAIN (block
)))
4474 BLOCK_SAME_RANGE (block
) = 0;
4476 BLOCK_SUBBLOCKS (block
) = blocks_nreverse_all (BLOCK_SUBBLOCKS (block
));
4483 /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
4484 and create duplicate blocks. */
4485 /* ??? Need an option to either create block fragments or to create
4486 abstract origin duplicates of a source block. It really depends
4487 on what optimization has been performed. */
4490 reorder_blocks (void)
4492 tree block
= DECL_INITIAL (current_function_decl
);
4494 if (block
== NULL_TREE
)
4497 auto_vec
<tree
, 10> block_stack
;
4499 /* Reset the TREE_ASM_WRITTEN bit for all blocks. */
4500 clear_block_marks (block
);
4502 /* Prune the old trees away, so that they don't get in the way. */
4503 BLOCK_SUBBLOCKS (block
) = NULL_TREE
;
4504 BLOCK_CHAIN (block
) = NULL_TREE
;
4506 /* Recreate the block tree from the note nesting. */
4507 reorder_blocks_1 (get_insns (), block
, &block_stack
);
4508 BLOCK_SUBBLOCKS (block
) = blocks_nreverse_all (BLOCK_SUBBLOCKS (block
));
4511 /* Helper function for reorder_blocks. Reset TREE_ASM_WRITTEN. */
4514 clear_block_marks (tree block
)
4518 TREE_ASM_WRITTEN (block
) = 0;
4519 clear_block_marks (BLOCK_SUBBLOCKS (block
));
4520 block
= BLOCK_CHAIN (block
);
4525 reorder_blocks_1 (rtx_insn
*insns
, tree current_block
,
4526 vec
<tree
> *p_block_stack
)
4529 tree prev_beg
= NULL_TREE
, prev_end
= NULL_TREE
;
4531 for (insn
= insns
; insn
; insn
= NEXT_INSN (insn
))
4535 if (NOTE_KIND (insn
) == NOTE_INSN_BLOCK_BEG
)
4537 tree block
= NOTE_BLOCK (insn
);
4540 gcc_assert (BLOCK_FRAGMENT_ORIGIN (block
) == NULL_TREE
);
4544 BLOCK_SAME_RANGE (prev_end
) = 0;
4545 prev_end
= NULL_TREE
;
4547 /* If we have seen this block before, that means it now
4548 spans multiple address regions. Create a new fragment. */
4549 if (TREE_ASM_WRITTEN (block
))
4551 tree new_block
= copy_node (block
);
4553 BLOCK_SAME_RANGE (new_block
) = 0;
4554 BLOCK_FRAGMENT_ORIGIN (new_block
) = origin
;
4555 BLOCK_FRAGMENT_CHAIN (new_block
)
4556 = BLOCK_FRAGMENT_CHAIN (origin
);
4557 BLOCK_FRAGMENT_CHAIN (origin
) = new_block
;
4559 NOTE_BLOCK (insn
) = new_block
;
4563 if (prev_beg
== current_block
&& prev_beg
)
4564 BLOCK_SAME_RANGE (block
) = 1;
4568 BLOCK_SUBBLOCKS (block
) = 0;
4569 TREE_ASM_WRITTEN (block
) = 1;
4570 /* When there's only one block for the entire function,
4571 current_block == block and we mustn't do this, it
4572 will cause infinite recursion. */
4573 if (block
!= current_block
)
4576 if (block
!= origin
)
4577 gcc_assert (BLOCK_SUPERCONTEXT (origin
) == current_block
4578 || BLOCK_FRAGMENT_ORIGIN (BLOCK_SUPERCONTEXT
4581 if (p_block_stack
->is_empty ())
4582 super
= current_block
;
4585 super
= p_block_stack
->last ();
4586 gcc_assert (super
== current_block
4587 || BLOCK_FRAGMENT_ORIGIN (super
)
4590 BLOCK_SUPERCONTEXT (block
) = super
;
4591 BLOCK_CHAIN (block
) = BLOCK_SUBBLOCKS (current_block
);
4592 BLOCK_SUBBLOCKS (current_block
) = block
;
4593 current_block
= origin
;
4595 p_block_stack
->safe_push (block
);
4597 else if (NOTE_KIND (insn
) == NOTE_INSN_BLOCK_END
)
4599 NOTE_BLOCK (insn
) = p_block_stack
->pop ();
4600 current_block
= BLOCK_SUPERCONTEXT (current_block
);
4601 if (BLOCK_FRAGMENT_ORIGIN (current_block
))
4602 current_block
= BLOCK_FRAGMENT_ORIGIN (current_block
);
4603 prev_beg
= NULL_TREE
;
4604 prev_end
= BLOCK_SAME_RANGE (NOTE_BLOCK (insn
))
4605 ? NOTE_BLOCK (insn
) : NULL_TREE
;
4610 prev_beg
= NULL_TREE
;
4612 BLOCK_SAME_RANGE (prev_end
) = 0;
4613 prev_end
= NULL_TREE
;
4618 /* Reverse the order of elements in the chain T of blocks,
4619 and return the new head of the chain (old last element). */
4622 blocks_nreverse (tree t
)
4624 tree prev
= 0, block
, next
;
4625 for (block
= t
; block
; block
= next
)
4627 next
= BLOCK_CHAIN (block
);
4628 BLOCK_CHAIN (block
) = prev
;
4634 /* Concatenate two chains of blocks (chained through BLOCK_CHAIN)
4635 by modifying the last node in chain 1 to point to chain 2. */
4638 block_chainon (tree op1
, tree op2
)
4647 for (t1
= op1
; BLOCK_CHAIN (t1
); t1
= BLOCK_CHAIN (t1
))
4649 BLOCK_CHAIN (t1
) = op2
;
4651 #ifdef ENABLE_TREE_CHECKING
4654 for (t2
= op2
; t2
; t2
= BLOCK_CHAIN (t2
))
4655 gcc_assert (t2
!= t1
);
4662 /* Count the subblocks of the list starting with BLOCK. If VECTOR is
4663 non-NULL, list them all into VECTOR, in a depth-first preorder
4664 traversal of the block tree. Also clear TREE_ASM_WRITTEN in all
4668 all_blocks (tree block
, tree
*vector
)
4674 TREE_ASM_WRITTEN (block
) = 0;
4676 /* Record this block. */
4678 vector
[n_blocks
] = block
;
4682 /* Record the subblocks, and their subblocks... */
4683 n_blocks
+= all_blocks (BLOCK_SUBBLOCKS (block
),
4684 vector
? vector
+ n_blocks
: 0);
4685 block
= BLOCK_CHAIN (block
);
4691 /* Return a vector containing all the blocks rooted at BLOCK. The
4692 number of elements in the vector is stored in N_BLOCKS_P. The
4693 vector is dynamically allocated; it is the caller's responsibility
4694 to call `free' on the pointer returned. */
4697 get_block_vector (tree block
, int *n_blocks_p
)
4701 *n_blocks_p
= all_blocks (block
, NULL
);
4702 block_vector
= XNEWVEC (tree
, *n_blocks_p
);
4703 all_blocks (block
, block_vector
);
4705 return block_vector
;
4708 static GTY(()) int next_block_index
= 2;
4710 /* Set BLOCK_NUMBER for all the blocks in FN. */
4713 number_blocks (tree fn
)
4719 /* For SDB and XCOFF debugging output, we start numbering the blocks
4720 from 1 within each function, rather than keeping a running
4722 #if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
4723 if (write_symbols
== SDB_DEBUG
|| write_symbols
== XCOFF_DEBUG
)
4724 next_block_index
= 1;
4727 block_vector
= get_block_vector (DECL_INITIAL (fn
), &n_blocks
);
4729 /* The top-level BLOCK isn't numbered at all. */
4730 for (i
= 1; i
< n_blocks
; ++i
)
4731 /* We number the blocks from two. */
4732 BLOCK_NUMBER (block_vector
[i
]) = next_block_index
++;
4734 free (block_vector
);
4739 /* If VAR is present in a subblock of BLOCK, return the subblock. */
4742 debug_find_var_in_block_tree (tree var
, tree block
)
4746 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
4750 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= TREE_CHAIN (t
))
4752 tree ret
= debug_find_var_in_block_tree (var
, t
);
4760 /* Keep track of whether we're in a dummy function context. If we are,
4761 we don't want to invoke the set_current_function hook, because we'll
4762 get into trouble if the hook calls target_reinit () recursively or
4763 when the initial initialization is not yet complete. */
4765 static bool in_dummy_function
;
4767 /* Invoke the target hook when setting cfun. Update the optimization options
4768 if the function uses different options than the default. */
4771 invoke_set_current_function_hook (tree fndecl
)
4773 if (!in_dummy_function
)
4775 tree opts
= ((fndecl
)
4776 ? DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl
)
4777 : optimization_default_node
);
4780 opts
= optimization_default_node
;
4782 /* Change optimization options if needed. */
4783 if (optimization_current_node
!= opts
)
4785 optimization_current_node
= opts
;
4786 cl_optimization_restore (&global_options
, TREE_OPTIMIZATION (opts
));
4789 targetm
.set_current_function (fndecl
);
4790 this_fn_optabs
= this_target_optabs
;
4792 if (opts
!= optimization_default_node
)
4794 init_tree_optimization_optabs (opts
);
4795 if (TREE_OPTIMIZATION_OPTABS (opts
))
4796 this_fn_optabs
= (struct target_optabs
*)
4797 TREE_OPTIMIZATION_OPTABS (opts
);
4802 /* cfun should never be set directly; use this function. */
4805 set_cfun (struct function
*new_cfun
)
4807 if (cfun
!= new_cfun
)
4810 invoke_set_current_function_hook (new_cfun
? new_cfun
->decl
: NULL_TREE
);
4814 /* Initialized with NOGC, making this poisonous to the garbage collector. */
4816 static vec
<function_p
> cfun_stack
;
4818 /* Push the current cfun onto the stack, and set cfun to new_cfun. Also set
4819 current_function_decl accordingly. */
4822 push_cfun (struct function
*new_cfun
)
4824 gcc_assert ((!cfun
&& !current_function_decl
)
4825 || (cfun
&& current_function_decl
== cfun
->decl
));
4826 cfun_stack
.safe_push (cfun
);
4827 current_function_decl
= new_cfun
? new_cfun
->decl
: NULL_TREE
;
4828 set_cfun (new_cfun
);
4831 /* Pop cfun from the stack. Also set current_function_decl accordingly. */
4836 struct function
*new_cfun
= cfun_stack
.pop ();
4837 /* When in_dummy_function, we do have a cfun but current_function_decl is
4838 NULL. We also allow pushing NULL cfun and subsequently changing
4839 current_function_decl to something else and have both restored by
4841 gcc_checking_assert (in_dummy_function
4843 || current_function_decl
== cfun
->decl
);
4844 set_cfun (new_cfun
);
4845 current_function_decl
= new_cfun
? new_cfun
->decl
: NULL_TREE
;
4848 /* Return value of funcdef and increase it. */
4850 get_next_funcdef_no (void)
4852 return funcdef_no
++;
4855 /* Return value of funcdef. */
4857 get_last_funcdef_no (void)
4862 /* Allocate a function structure for FNDECL and set its contents
4863 to the defaults. Set cfun to the newly-allocated object.
4864 Some of the helper functions invoked during initialization assume
4865 that cfun has already been set. Therefore, assign the new object
4866 directly into cfun and invoke the back end hook explicitly at the
4867 very end, rather than initializing a temporary and calling set_cfun
4870 ABSTRACT_P is true if this is a function that will never be seen by
4871 the middle-end. Such functions are front-end concepts (like C++
4872 function templates) that do not correspond directly to functions
4873 placed in object files. */
4876 allocate_struct_function (tree fndecl
, bool abstract_p
)
4878 tree fntype
= fndecl
? TREE_TYPE (fndecl
) : NULL_TREE
;
4880 cfun
= ggc_cleared_alloc
<function
> ();
4882 init_eh_for_function ();
4884 if (init_machine_status
)
4885 cfun
->machine
= (*init_machine_status
) ();
4887 #ifdef OVERRIDE_ABI_FORMAT
4888 OVERRIDE_ABI_FORMAT (fndecl
);
4891 if (fndecl
!= NULL_TREE
)
4893 DECL_STRUCT_FUNCTION (fndecl
) = cfun
;
4894 cfun
->decl
= fndecl
;
4895 current_function_funcdef_no
= get_next_funcdef_no ();
4898 invoke_set_current_function_hook (fndecl
);
4900 if (fndecl
!= NULL_TREE
)
4902 tree result
= DECL_RESULT (fndecl
);
4903 if (!abstract_p
&& aggregate_value_p (result
, fndecl
))
4905 #ifdef PCC_STATIC_STRUCT_RETURN
4906 cfun
->returns_pcc_struct
= 1;
4908 cfun
->returns_struct
= 1;
4911 cfun
->stdarg
= stdarg_p (fntype
);
4913 /* Assume all registers in stdarg functions need to be saved. */
4914 cfun
->va_list_gpr_size
= VA_LIST_MAX_GPR_SIZE
;
4915 cfun
->va_list_fpr_size
= VA_LIST_MAX_FPR_SIZE
;
4917 /* ??? This could be set on a per-function basis by the front-end
4918 but is this worth the hassle? */
4919 cfun
->can_throw_non_call_exceptions
= flag_non_call_exceptions
;
4920 cfun
->can_delete_dead_exceptions
= flag_delete_dead_exceptions
;
4922 if (!profile_flag
&& !flag_instrument_function_entry_exit
)
4923 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl
) = 1;
4927 /* This is like allocate_struct_function, but pushes a new cfun for FNDECL
4928 instead of just setting it. */
4931 push_struct_function (tree fndecl
)
4933 /* When in_dummy_function we might be in the middle of a pop_cfun and
4934 current_function_decl and cfun may not match. */
4935 gcc_assert (in_dummy_function
4936 || (!cfun
&& !current_function_decl
)
4937 || (cfun
&& current_function_decl
== cfun
->decl
));
4938 cfun_stack
.safe_push (cfun
);
4939 current_function_decl
= fndecl
;
4940 allocate_struct_function (fndecl
, false);
4943 /* Reset crtl and other non-struct-function variables to defaults as
4944 appropriate for emitting rtl at the start of a function. */
4947 prepare_function_start (void)
4949 gcc_assert (!get_last_insn ());
4952 init_varasm_status ();
4954 default_rtl_profile ();
4956 if (flag_stack_usage_info
)
4958 cfun
->su
= ggc_cleared_alloc
<stack_usage
> ();
4959 cfun
->su
->static_stack_size
= -1;
4962 cse_not_expected
= ! optimize
;
4964 /* Caller save not needed yet. */
4965 caller_save_needed
= 0;
4967 /* We haven't done register allocation yet. */
4970 /* Indicate that we have not instantiated virtual registers yet. */
4971 virtuals_instantiated
= 0;
4973 /* Indicate that we want CONCATs now. */
4974 generating_concat_p
= 1;
4976 /* Indicate we have no need of a frame pointer yet. */
4977 frame_pointer_needed
= 0;
4981 push_dummy_function (bool with_decl
)
4983 tree fn_decl
, fn_type
, fn_result_decl
;
4985 gcc_assert (!in_dummy_function
);
4986 in_dummy_function
= true;
4990 fn_type
= build_function_type_list (void_type_node
, NULL_TREE
);
4991 fn_decl
= build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
, NULL_TREE
,
4993 fn_result_decl
= build_decl (UNKNOWN_LOCATION
, RESULT_DECL
,
4994 NULL_TREE
, void_type_node
);
4995 DECL_RESULT (fn_decl
) = fn_result_decl
;
4998 fn_decl
= NULL_TREE
;
5000 push_struct_function (fn_decl
);
5003 /* Initialize the rtl expansion mechanism so that we can do simple things
5004 like generate sequences. This is used to provide a context during global
5005 initialization of some passes. You must call expand_dummy_function_end
5006 to exit this context. */
5009 init_dummy_function_start (void)
5011 push_dummy_function (false);
5012 prepare_function_start ();
5015 /* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node)
5016 and initialize static variables for generating RTL for the statements
5020 init_function_start (tree subr
)
5022 if (subr
&& DECL_STRUCT_FUNCTION (subr
))
5023 set_cfun (DECL_STRUCT_FUNCTION (subr
));
5025 allocate_struct_function (subr
, false);
5027 /* Initialize backend, if needed. */
5030 prepare_function_start ();
5031 decide_function_section (subr
);
5033 /* Warn if this value is an aggregate type,
5034 regardless of which calling convention we are using for it. */
5035 if (AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr
))))
5036 warning (OPT_Waggregate_return
, "function returns an aggregate");
5039 /* Expand code to verify the stack_protect_guard. This is invoked at
5040 the end of a function to be protected. */
5042 #ifndef HAVE_stack_protect_test
5043 # define HAVE_stack_protect_test 0
5044 # define gen_stack_protect_test(x, y, z) (gcc_unreachable (), NULL_RTX)
5048 stack_protect_epilogue (void)
5050 tree guard_decl
= targetm
.stack_protect_guard ();
5051 rtx_code_label
*label
= gen_label_rtx ();
5054 x
= expand_normal (crtl
->stack_protect_guard
);
5055 y
= expand_normal (guard_decl
);
5057 /* Allow the target to compare Y with X without leaking either into
5059 switch ((int) (HAVE_stack_protect_test
!= 0))
5062 tmp
= gen_stack_protect_test (x
, y
, label
);
5071 emit_cmp_and_jump_insns (x
, y
, EQ
, NULL_RTX
, ptr_mode
, 1, label
);
5075 /* The noreturn predictor has been moved to the tree level. The rtl-level
5076 predictors estimate this branch about 20%, which isn't enough to get
5077 things moved out of line. Since this is the only extant case of adding
5078 a noreturn function at the rtl level, it doesn't seem worth doing ought
5079 except adding the prediction by hand. */
5080 tmp
= get_last_insn ();
5082 predict_insn_def (as_a
<rtx_insn
*> (tmp
), PRED_NORETURN
, TAKEN
);
5084 expand_call (targetm
.stack_protect_fail (), NULL_RTX
, /*ignore=*/true);
5089 /* Start the RTL for a new function, and set variables used for
5091 SUBR is the FUNCTION_DECL node.
5092 PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with
5093 the function's parameters, which must be run at any return statement. */
5096 expand_function_start (tree subr
)
5098 /* Make sure volatile mem refs aren't considered
5099 valid operands of arithmetic insns. */
5100 init_recog_no_volatile ();
5104 && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr
));
5107 = (stack_limit_rtx
!= NULL_RTX
&& ! DECL_NO_LIMIT_STACK (subr
));
5109 /* Make the label for return statements to jump to. Do not special
5110 case machines with special return instructions -- they will be
5111 handled later during jump, ifcvt, or epilogue creation. */
5112 return_label
= gen_label_rtx ();
5114 /* Initialize rtx used to return the value. */
5115 /* Do this before assign_parms so that we copy the struct value address
5116 before any library calls that assign parms might generate. */
5118 /* Decide whether to return the value in memory or in a register. */
5119 tree res
= DECL_RESULT (subr
);
5120 maybe_reset_rtl_for_parm (res
);
5121 if (aggregate_value_p (res
, subr
))
5123 /* Returning something that won't go in a register. */
5124 rtx value_address
= 0;
5126 #ifdef PCC_STATIC_STRUCT_RETURN
5127 if (cfun
->returns_pcc_struct
)
5129 int size
= int_size_in_bytes (TREE_TYPE (res
));
5130 value_address
= assemble_static_space (size
);
5135 rtx sv
= targetm
.calls
.struct_value_rtx (TREE_TYPE (subr
), 2);
5136 /* Expect to be passed the address of a place to store the value.
5137 If it is passed as an argument, assign_parms will take care of
5141 if (DECL_BY_REFERENCE (res
))
5142 value_address
= get_rtl_for_parm_ssa_default_def (res
);
5144 value_address
= gen_reg_rtx (Pmode
);
5145 emit_move_insn (value_address
, sv
);
5150 rtx x
= value_address
;
5151 if (!DECL_BY_REFERENCE (res
))
5153 x
= get_rtl_for_parm_ssa_default_def (res
);
5156 x
= gen_rtx_MEM (DECL_MODE (res
), value_address
);
5157 set_mem_attributes (x
, res
, 1);
5160 SET_DECL_RTL (res
, x
);
5163 else if (DECL_MODE (res
) == VOIDmode
)
5164 /* If return mode is void, this decl rtl should not be used. */
5165 SET_DECL_RTL (res
, NULL_RTX
);
5168 /* Compute the return values into a pseudo reg, which we will copy
5169 into the true return register after the cleanups are done. */
5170 tree return_type
= TREE_TYPE (res
);
5171 rtx x
= get_rtl_for_parm_ssa_default_def (res
);
5174 else if (TYPE_MODE (return_type
) != BLKmode
5175 && targetm
.calls
.return_in_msb (return_type
))
5176 /* expand_function_end will insert the appropriate padding in
5177 this case. Use the return value's natural (unpadded) mode
5178 within the function proper. */
5179 x
= gen_reg_rtx (TYPE_MODE (return_type
));
5182 /* In order to figure out what mode to use for the pseudo, we
5183 figure out what the mode of the eventual return register will
5184 actually be, and use that. */
5185 rtx hard_reg
= hard_function_value (return_type
, subr
, 0, 1);
5187 /* Structures that are returned in registers are not
5188 aggregate_value_p, so we may see a PARALLEL or a REG. */
5189 if (REG_P (hard_reg
))
5190 x
= gen_reg_rtx (GET_MODE (hard_reg
));
5193 gcc_assert (GET_CODE (hard_reg
) == PARALLEL
);
5194 x
= gen_group_rtx (hard_reg
);
5198 SET_DECL_RTL (res
, x
);
5200 /* Set DECL_REGISTER flag so that expand_function_end will copy the
5201 result to the real return register(s). */
5202 DECL_REGISTER (res
) = 1;
5204 if (chkp_function_instrumented_p (current_function_decl
))
5206 tree return_type
= TREE_TYPE (res
);
5207 rtx bounds
= targetm
.calls
.chkp_function_value_bounds (return_type
,
5209 SET_DECL_BOUNDS_RTL (res
, bounds
);
5213 /* Initialize rtx for parameters and local variables.
5214 In some cases this requires emitting insns. */
5215 assign_parms (subr
);
5217 /* If function gets a static chain arg, store it. */
5218 if (cfun
->static_chain_decl
)
5220 tree parm
= cfun
->static_chain_decl
;
5224 local
= get_rtl_for_parm_ssa_default_def (parm
);
5226 local
= gen_reg_rtx (Pmode
);
5227 chain
= targetm
.calls
.static_chain (current_function_decl
, true);
5229 set_decl_incoming_rtl (parm
, chain
, false);
5230 SET_DECL_RTL (parm
, local
);
5231 mark_reg_pointer (local
, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm
))));
5233 insn
= emit_move_insn (local
, chain
);
5235 /* Mark the register as eliminable, similar to parameters. */
5237 && reg_mentioned_p (arg_pointer_rtx
, XEXP (chain
, 0)))
5238 set_dst_reg_note (insn
, REG_EQUIV
, chain
, local
);
5240 /* If we aren't optimizing, save the static chain onto the stack. */
5243 tree saved_static_chain_decl
5244 = build_decl (DECL_SOURCE_LOCATION (parm
), VAR_DECL
,
5245 DECL_NAME (parm
), TREE_TYPE (parm
));
5246 rtx saved_static_chain_rtx
5247 = assign_stack_local (Pmode
, GET_MODE_SIZE (Pmode
), 0);
5248 SET_DECL_RTL (saved_static_chain_decl
, saved_static_chain_rtx
);
5249 emit_move_insn (saved_static_chain_rtx
, chain
);
5250 SET_DECL_VALUE_EXPR (parm
, saved_static_chain_decl
);
5251 DECL_HAS_VALUE_EXPR_P (parm
) = 1;
5255 /* If the function receives a non-local goto, then store the
5256 bits we need to restore the frame pointer. */
5257 if (cfun
->nonlocal_goto_save_area
)
5262 tree var
= TREE_OPERAND (cfun
->nonlocal_goto_save_area
, 0);
5263 gcc_assert (DECL_RTL_SET_P (var
));
5265 t_save
= build4 (ARRAY_REF
,
5266 TREE_TYPE (TREE_TYPE (cfun
->nonlocal_goto_save_area
)),
5267 cfun
->nonlocal_goto_save_area
,
5268 integer_zero_node
, NULL_TREE
, NULL_TREE
);
5269 r_save
= expand_expr (t_save
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
5270 gcc_assert (GET_MODE (r_save
) == Pmode
);
5272 emit_move_insn (r_save
, targetm
.builtin_setjmp_frame_value ());
5273 update_nonlocal_goto_save_area ();
5276 /* The following was moved from init_function_start.
5277 The move is supposed to make sdb output more accurate. */
5278 /* Indicate the beginning of the function body,
5279 as opposed to parm setup. */
5280 emit_note (NOTE_INSN_FUNCTION_BEG
);
5282 gcc_assert (NOTE_P (get_last_insn ()));
5284 parm_birth_insn
= get_last_insn ();
5289 PROFILE_HOOK (current_function_funcdef_no
);
5293 /* If we are doing generic stack checking, the probe should go here. */
5294 if (flag_stack_check
== GENERIC_STACK_CHECK
)
5295 stack_check_probe_note
= emit_note (NOTE_INSN_DELETED
);
5299 pop_dummy_function (void)
5302 in_dummy_function
= false;
5305 /* Undo the effects of init_dummy_function_start. */
5307 expand_dummy_function_end (void)
5309 gcc_assert (in_dummy_function
);
5311 /* End any sequences that failed to be closed due to syntax errors. */
5312 while (in_sequence_p ())
5315 /* Outside function body, can't compute type's actual size
5316 until next function's body starts. */
5318 free_after_parsing (cfun
);
5319 free_after_compilation (cfun
);
5320 pop_dummy_function ();
5323 /* Helper for diddle_return_value. */
5326 diddle_return_value_1 (void (*doit
) (rtx
, void *), void *arg
, rtx outgoing
)
5331 if (REG_P (outgoing
))
5332 (*doit
) (outgoing
, arg
);
5333 else if (GET_CODE (outgoing
) == PARALLEL
)
5337 for (i
= 0; i
< XVECLEN (outgoing
, 0); i
++)
5339 rtx x
= XEXP (XVECEXP (outgoing
, 0, i
), 0);
5341 if (REG_P (x
) && REGNO (x
) < FIRST_PSEUDO_REGISTER
)
5347 /* Call DOIT for each hard register used as a return value from
5348 the current function. */
5351 diddle_return_value (void (*doit
) (rtx
, void *), void *arg
)
5353 diddle_return_value_1 (doit
, arg
, crtl
->return_bnd
);
5354 diddle_return_value_1 (doit
, arg
, crtl
->return_rtx
);
5358 do_clobber_return_reg (rtx reg
, void *arg ATTRIBUTE_UNUSED
)
5364 clobber_return_register (void)
5366 diddle_return_value (do_clobber_return_reg
, NULL
);
5368 /* In case we do use pseudo to return value, clobber it too. */
5369 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl
)))
5371 tree decl_result
= DECL_RESULT (current_function_decl
);
5372 rtx decl_rtl
= DECL_RTL (decl_result
);
5373 if (REG_P (decl_rtl
) && REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
)
5375 do_clobber_return_reg (decl_rtl
, NULL
);
5381 do_use_return_reg (rtx reg
, void *arg ATTRIBUTE_UNUSED
)
5387 use_return_register (void)
5389 diddle_return_value (do_use_return_reg
, NULL
);
5392 /* Possibly warn about unused parameters. */
5394 do_warn_unused_parameter (tree fn
)
5398 for (decl
= DECL_ARGUMENTS (fn
);
5399 decl
; decl
= DECL_CHAIN (decl
))
5400 if (!TREE_USED (decl
) && TREE_CODE (decl
) == PARM_DECL
5401 && DECL_NAME (decl
) && !DECL_ARTIFICIAL (decl
)
5402 && !TREE_NO_WARNING (decl
))
5403 warning (OPT_Wunused_parameter
, "unused parameter %q+D", decl
);
5406 /* Set the location of the insn chain starting at INSN to LOC. */
5409 set_insn_locations (rtx_insn
*insn
, int loc
)
5411 while (insn
!= NULL
)
5414 INSN_LOCATION (insn
) = loc
;
5415 insn
= NEXT_INSN (insn
);
5419 /* Generate RTL for the end of the current function. */
5422 expand_function_end (void)
5424 /* If arg_pointer_save_area was referenced only from a nested
5425 function, we will not have initialized it yet. Do that now. */
5426 if (arg_pointer_save_area
&& ! crtl
->arg_pointer_save_area_init
)
5427 get_arg_pointer_save_area ();
5429 /* If we are doing generic stack checking and this function makes calls,
5430 do a stack probe at the start of the function to ensure we have enough
5431 space for another stack frame. */
5432 if (flag_stack_check
== GENERIC_STACK_CHECK
)
5434 rtx_insn
*insn
, *seq
;
5436 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
5439 rtx max_frame_size
= GEN_INT (STACK_CHECK_MAX_FRAME_SIZE
);
5441 if (STACK_CHECK_MOVING_SP
)
5442 anti_adjust_stack_and_probe (max_frame_size
, true);
5444 probe_stack_range (STACK_OLD_CHECK_PROTECT
, max_frame_size
);
5447 set_insn_locations (seq
, prologue_location
);
5448 emit_insn_before (seq
, stack_check_probe_note
);
5453 /* End any sequences that failed to be closed due to syntax errors. */
5454 while (in_sequence_p ())
5457 clear_pending_stack_adjust ();
5458 do_pending_stack_adjust ();
5460 /* Output a linenumber for the end of the function.
5461 SDB depends on this. */
5462 set_curr_insn_location (input_location
);
5464 /* Before the return label (if any), clobber the return
5465 registers so that they are not propagated live to the rest of
5466 the function. This can only happen with functions that drop
5467 through; if there had been a return statement, there would
5468 have either been a return rtx, or a jump to the return label.
5470 We delay actual code generation after the current_function_value_rtx
5472 rtx_insn
*clobber_after
= get_last_insn ();
5474 /* Output the label for the actual return from the function. */
5475 emit_label (return_label
);
5477 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
5479 /* Let except.c know where it should emit the call to unregister
5480 the function context for sjlj exceptions. */
5481 if (flag_exceptions
)
5482 sjlj_emit_function_exit_after (get_last_insn ());
5486 /* We want to ensure that instructions that may trap are not
5487 moved into the epilogue by scheduling, because we don't
5488 always emit unwind information for the epilogue. */
5489 if (cfun
->can_throw_non_call_exceptions
)
5490 emit_insn (gen_blockage ());
5493 /* If this is an implementation of throw, do what's necessary to
5494 communicate between __builtin_eh_return and the epilogue. */
5495 expand_eh_return ();
5497 /* If scalar return value was computed in a pseudo-reg, or was a named
5498 return value that got dumped to the stack, copy that to the hard
5500 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl
)))
5502 tree decl_result
= DECL_RESULT (current_function_decl
);
5503 rtx decl_rtl
= DECL_RTL (decl_result
);
5505 if (REG_P (decl_rtl
)
5506 ? REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
5507 : DECL_REGISTER (decl_result
))
5509 rtx real_decl_rtl
= crtl
->return_rtx
;
5511 /* This should be set in assign_parms. */
5512 gcc_assert (REG_FUNCTION_VALUE_P (real_decl_rtl
));
5514 /* If this is a BLKmode structure being returned in registers,
5515 then use the mode computed in expand_return. Note that if
5516 decl_rtl is memory, then its mode may have been changed,
5517 but that crtl->return_rtx has not. */
5518 if (GET_MODE (real_decl_rtl
) == BLKmode
)
5519 PUT_MODE (real_decl_rtl
, GET_MODE (decl_rtl
));
5521 /* If a non-BLKmode return value should be padded at the least
5522 significant end of the register, shift it left by the appropriate
5523 amount. BLKmode results are handled using the group load/store
5525 if (TYPE_MODE (TREE_TYPE (decl_result
)) != BLKmode
5526 && REG_P (real_decl_rtl
)
5527 && targetm
.calls
.return_in_msb (TREE_TYPE (decl_result
)))
5529 emit_move_insn (gen_rtx_REG (GET_MODE (decl_rtl
),
5530 REGNO (real_decl_rtl
)),
5532 shift_return_value (GET_MODE (decl_rtl
), true, real_decl_rtl
);
5534 /* If a named return value dumped decl_return to memory, then
5535 we may need to re-do the PROMOTE_MODE signed/unsigned
5537 else if (GET_MODE (real_decl_rtl
) != GET_MODE (decl_rtl
))
5539 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (decl_result
));
5540 promote_function_mode (TREE_TYPE (decl_result
),
5541 GET_MODE (decl_rtl
), &unsignedp
,
5542 TREE_TYPE (current_function_decl
), 1);
5544 convert_move (real_decl_rtl
, decl_rtl
, unsignedp
);
5546 else if (GET_CODE (real_decl_rtl
) == PARALLEL
)
5548 /* If expand_function_start has created a PARALLEL for decl_rtl,
5549 move the result to the real return registers. Otherwise, do
5550 a group load from decl_rtl for a named return. */
5551 if (GET_CODE (decl_rtl
) == PARALLEL
)
5552 emit_group_move (real_decl_rtl
, decl_rtl
);
5554 emit_group_load (real_decl_rtl
, decl_rtl
,
5555 TREE_TYPE (decl_result
),
5556 int_size_in_bytes (TREE_TYPE (decl_result
)));
5558 /* In the case of complex integer modes smaller than a word, we'll
5559 need to generate some non-trivial bitfield insertions. Do that
5560 on a pseudo and not the hard register. */
5561 else if (GET_CODE (decl_rtl
) == CONCAT
5562 && GET_MODE_CLASS (GET_MODE (decl_rtl
)) == MODE_COMPLEX_INT
5563 && GET_MODE_BITSIZE (GET_MODE (decl_rtl
)) <= BITS_PER_WORD
)
5565 int old_generating_concat_p
;
5568 old_generating_concat_p
= generating_concat_p
;
5569 generating_concat_p
= 0;
5570 tmp
= gen_reg_rtx (GET_MODE (decl_rtl
));
5571 generating_concat_p
= old_generating_concat_p
;
5573 emit_move_insn (tmp
, decl_rtl
);
5574 emit_move_insn (real_decl_rtl
, tmp
);
5577 emit_move_insn (real_decl_rtl
, decl_rtl
);
5581 /* If returning a structure, arrange to return the address of the value
5582 in a place where debuggers expect to find it.
5584 If returning a structure PCC style,
5585 the caller also depends on this value.
5586 And cfun->returns_pcc_struct is not necessarily set. */
5587 if ((cfun
->returns_struct
|| cfun
->returns_pcc_struct
)
5588 && !targetm
.calls
.omit_struct_return_reg
)
5590 rtx value_address
= DECL_RTL (DECL_RESULT (current_function_decl
));
5591 tree type
= TREE_TYPE (DECL_RESULT (current_function_decl
));
5594 if (DECL_BY_REFERENCE (DECL_RESULT (current_function_decl
)))
5595 type
= TREE_TYPE (type
);
5597 value_address
= XEXP (value_address
, 0);
5599 outgoing
= targetm
.calls
.function_value (build_pointer_type (type
),
5600 current_function_decl
, true);
5602 /* Mark this as a function return value so integrate will delete the
5603 assignment and USE below when inlining this function. */
5604 REG_FUNCTION_VALUE_P (outgoing
) = 1;
5606 /* The address may be ptr_mode and OUTGOING may be Pmode. */
5607 value_address
= convert_memory_address (GET_MODE (outgoing
),
5610 emit_move_insn (outgoing
, value_address
);
5612 /* Show return register used to hold result (in this case the address
5614 crtl
->return_rtx
= outgoing
;
5617 /* Emit the actual code to clobber return register. Don't emit
5618 it if clobber_after is a barrier, then the previous basic block
5619 certainly doesn't fall thru into the exit block. */
5620 if (!BARRIER_P (clobber_after
))
5623 clobber_return_register ();
5624 rtx_insn
*seq
= get_insns ();
5627 emit_insn_after (seq
, clobber_after
);
5630 /* Output the label for the naked return from the function. */
5631 if (naked_return_label
)
5632 emit_label (naked_return_label
);
5634 /* @@@ This is a kludge. We want to ensure that instructions that
5635 may trap are not moved into the epilogue by scheduling, because
5636 we don't always emit unwind information for the epilogue. */
5637 if (cfun
->can_throw_non_call_exceptions
5638 && targetm_common
.except_unwind_info (&global_options
) != UI_SJLJ
)
5639 emit_insn (gen_blockage ());
5641 /* If stack protection is enabled for this function, check the guard. */
5642 if (crtl
->stack_protect_guard
)
5643 stack_protect_epilogue ();
5645 /* If we had calls to alloca, and this machine needs
5646 an accurate stack pointer to exit the function,
5647 insert some code to save and restore the stack pointer. */
5648 if (! EXIT_IGNORE_STACK
5649 && cfun
->calls_alloca
)
5654 emit_stack_save (SAVE_FUNCTION
, &tem
);
5655 rtx_insn
*seq
= get_insns ();
5657 emit_insn_before (seq
, parm_birth_insn
);
5659 emit_stack_restore (SAVE_FUNCTION
, tem
);
5662 /* ??? This should no longer be necessary since stupid is no longer with
5663 us, but there are some parts of the compiler (eg reload_combine, and
5664 sh mach_dep_reorg) that still try and compute their own lifetime info
5665 instead of using the general framework. */
5666 use_return_register ();
5670 get_arg_pointer_save_area (void)
5672 rtx ret
= arg_pointer_save_area
;
5676 ret
= assign_stack_local (Pmode
, GET_MODE_SIZE (Pmode
), 0);
5677 arg_pointer_save_area
= ret
;
5680 if (! crtl
->arg_pointer_save_area_init
)
5682 /* Save the arg pointer at the beginning of the function. The
5683 generated stack slot may not be a valid memory address, so we
5684 have to check it and fix it if necessary. */
5686 emit_move_insn (validize_mem (copy_rtx (ret
)),
5687 crtl
->args
.internal_arg_pointer
);
5688 rtx_insn
*seq
= get_insns ();
5691 push_topmost_sequence ();
5692 emit_insn_after (seq
, entry_of_function ());
5693 pop_topmost_sequence ();
5695 crtl
->arg_pointer_save_area_init
= true;
5701 /* Add a list of INSNS to the hash HASHP, possibly allocating HASHP
5702 for the first time. */
5705 record_insns (rtx_insn
*insns
, rtx end
, hash_table
<insn_cache_hasher
> **hashp
)
5708 hash_table
<insn_cache_hasher
> *hash
= *hashp
;
5711 *hashp
= hash
= hash_table
<insn_cache_hasher
>::create_ggc (17);
5713 for (tmp
= insns
; tmp
!= end
; tmp
= NEXT_INSN (tmp
))
5715 rtx
*slot
= hash
->find_slot (tmp
, INSERT
);
5716 gcc_assert (*slot
== NULL
);
5721 /* INSN has been duplicated or replaced by as COPY, perhaps by duplicating a
5722 basic block, splitting or peepholes. If INSN is a prologue or epilogue
5723 insn, then record COPY as well. */
5726 maybe_copy_prologue_epilogue_insn (rtx insn
, rtx copy
)
5728 hash_table
<insn_cache_hasher
> *hash
;
5731 hash
= epilogue_insn_hash
;
5732 if (!hash
|| !hash
->find (insn
))
5734 hash
= prologue_insn_hash
;
5735 if (!hash
|| !hash
->find (insn
))
5739 slot
= hash
->find_slot (copy
, INSERT
);
5740 gcc_assert (*slot
== NULL
);
5744 /* Determine if any INSNs in HASH are, or are part of, INSN. Because
5745 we can be running after reorg, SEQUENCE rtl is possible. */
5748 contains (const_rtx insn
, hash_table
<insn_cache_hasher
> *hash
)
5753 if (NONJUMP_INSN_P (insn
) && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
5755 rtx_sequence
*seq
= as_a
<rtx_sequence
*> (PATTERN (insn
));
5757 for (i
= seq
->len () - 1; i
>= 0; i
--)
5758 if (hash
->find (seq
->element (i
)))
5763 return hash
->find (const_cast<rtx
> (insn
)) != NULL
;
5767 prologue_epilogue_contains (const_rtx insn
)
5769 if (contains (insn
, prologue_insn_hash
))
5771 if (contains (insn
, epilogue_insn_hash
))
5776 /* Insert use of return register before the end of BB. */
5779 emit_use_return_register_into_block (basic_block bb
)
5782 use_return_register ();
5783 rtx_insn
*seq
= get_insns ();
5785 rtx_insn
*insn
= BB_END (bb
);
5786 if (HAVE_cc0
&& reg_mentioned_p (cc0_rtx
, PATTERN (insn
)))
5787 insn
= prev_cc0_setter (insn
);
5789 emit_insn_before (seq
, insn
);
5793 /* Create a return pattern, either simple_return or return, depending on
5797 gen_return_pattern (bool simple_p
)
5799 if (!HAVE_simple_return
)
5800 gcc_assert (!simple_p
);
5802 return simple_p
? gen_simple_return () : gen_return ();
5805 /* Insert an appropriate return pattern at the end of block BB. This
5806 also means updating block_for_insn appropriately. SIMPLE_P is
5807 the same as in gen_return_pattern and passed to it. */
5810 emit_return_into_block (bool simple_p
, basic_block bb
)
5812 rtx_jump_insn
*jump
= emit_jump_insn_after (gen_return_pattern (simple_p
),
5814 rtx pat
= PATTERN (jump
);
5815 if (GET_CODE (pat
) == PARALLEL
)
5816 pat
= XVECEXP (pat
, 0, 0);
5817 gcc_assert (ANY_RETURN_P (pat
));
5818 JUMP_LABEL (jump
) = pat
;
5821 /* Set JUMP_LABEL for a return insn. */
5824 set_return_jump_label (rtx_insn
*returnjump
)
5826 rtx pat
= PATTERN (returnjump
);
5827 if (GET_CODE (pat
) == PARALLEL
)
5828 pat
= XVECEXP (pat
, 0, 0);
5829 if (ANY_RETURN_P (pat
))
5830 JUMP_LABEL (returnjump
) = pat
;
5832 JUMP_LABEL (returnjump
) = ret_rtx
;
5835 /* Return true if there are any active insns between HEAD and TAIL. */
5837 active_insn_between (rtx_insn
*head
, rtx_insn
*tail
)
5841 if (active_insn_p (tail
))
5845 tail
= PREV_INSN (tail
);
5850 /* LAST_BB is a block that exits, and empty of active instructions.
5851 Examine its predecessors for jumps that can be converted to
5852 (conditional) returns. */
5854 convert_jumps_to_returns (basic_block last_bb
, bool simple_p
,
5855 vec
<edge
> unconverted ATTRIBUTE_UNUSED
)
5861 auto_vec
<basic_block
> src_bbs (EDGE_COUNT (last_bb
->preds
));
5863 FOR_EACH_EDGE (e
, ei
, last_bb
->preds
)
5864 if (e
->src
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
))
5865 src_bbs
.quick_push (e
->src
);
5867 rtx_insn
*label
= BB_HEAD (last_bb
);
5869 FOR_EACH_VEC_ELT (src_bbs
, i
, bb
)
5871 rtx_insn
*jump
= BB_END (bb
);
5873 if (!JUMP_P (jump
) || JUMP_LABEL (jump
) != label
)
5876 e
= find_edge (bb
, last_bb
);
5878 /* If we have an unconditional jump, we can replace that
5879 with a simple return instruction. */
5880 if (simplejump_p (jump
))
5882 /* The use of the return register might be present in the exit
5883 fallthru block. Either:
5884 - removing the use is safe, and we should remove the use in
5885 the exit fallthru block, or
5886 - removing the use is not safe, and we should add it here.
5887 For now, we conservatively choose the latter. Either of the
5888 2 helps in crossjumping. */
5889 emit_use_return_register_into_block (bb
);
5891 emit_return_into_block (simple_p
, bb
);
5895 /* If we have a conditional jump branching to the last
5896 block, we can try to replace that with a conditional
5897 return instruction. */
5898 else if (condjump_p (jump
))
5903 dest
= simple_return_rtx
;
5906 if (!redirect_jump (as_a
<rtx_jump_insn
*> (jump
), dest
, 0))
5908 if (HAVE_simple_return
&& simple_p
)
5912 "Failed to redirect bb %d branch.\n", bb
->index
);
5913 unconverted
.safe_push (e
);
5918 /* See comment in simplejump_p case above. */
5919 emit_use_return_register_into_block (bb
);
5921 /* If this block has only one successor, it both jumps
5922 and falls through to the fallthru block, so we can't
5924 if (single_succ_p (bb
))
5929 if (HAVE_simple_return
&& simple_p
)
5933 "Failed to redirect bb %d branch.\n", bb
->index
);
5934 unconverted
.safe_push (e
);
5939 /* Fix up the CFG for the successful change we just made. */
5940 redirect_edge_succ (e
, EXIT_BLOCK_PTR_FOR_FN (cfun
));
5941 e
->flags
&= ~EDGE_CROSSING
;
5947 /* Emit a return insn for the exit fallthru block. */
5949 emit_return_for_exit (edge exit_fallthru_edge
, bool simple_p
)
5951 basic_block last_bb
= exit_fallthru_edge
->src
;
5953 if (JUMP_P (BB_END (last_bb
)))
5955 last_bb
= split_edge (exit_fallthru_edge
);
5956 exit_fallthru_edge
= single_succ_edge (last_bb
);
5958 emit_barrier_after (BB_END (last_bb
));
5959 emit_return_into_block (simple_p
, last_bb
);
5960 exit_fallthru_edge
->flags
&= ~EDGE_FALLTHRU
;
5965 /* Generate the prologue and epilogue RTL if the machine supports it. Thread
5966 this into place with notes indicating where the prologue ends and where
5967 the epilogue begins. Update the basic block information when possible.
5969 Notes on epilogue placement:
5970 There are several kinds of edges to the exit block:
5971 * a single fallthru edge from LAST_BB
5972 * possibly, edges from blocks containing sibcalls
5973 * possibly, fake edges from infinite loops
5975 The epilogue is always emitted on the fallthru edge from the last basic
5976 block in the function, LAST_BB, into the exit block.
5978 If LAST_BB is empty except for a label, it is the target of every
5979 other basic block in the function that ends in a return. If a
5980 target has a return or simple_return pattern (possibly with
5981 conditional variants), these basic blocks can be changed so that a
5982 return insn is emitted into them, and their target is adjusted to
5983 the real exit block.
5985 Notes on shrink wrapping: We implement a fairly conservative
5986 version of shrink-wrapping rather than the textbook one. We only
5987 generate a single prologue and a single epilogue. This is
5988 sufficient to catch a number of interesting cases involving early
5991 First, we identify the blocks that require the prologue to occur before
5992 them. These are the ones that modify a call-saved register, or reference
5993 any of the stack or frame pointer registers. To simplify things, we then
5994 mark everything reachable from these blocks as also requiring a prologue.
5995 This takes care of loops automatically, and avoids the need to examine
5996 whether MEMs reference the frame, since it is sufficient to check for
5997 occurrences of the stack or frame pointer.
5999 We then compute the set of blocks for which the need for a prologue
6000 is anticipatable (borrowing terminology from the shrink-wrapping
6001 description in Muchnick's book). These are the blocks which either
6002 require a prologue themselves, or those that have only successors
6003 where the prologue is anticipatable. The prologue needs to be
6004 inserted on all edges from BB1->BB2 where BB2 is in ANTIC and BB1
6005 is not. For the moment, we ensure that only one such edge exists.
6007 The epilogue is placed as described above, but we make a
6008 distinction between inserting return and simple_return patterns
6009 when modifying other blocks that end in a return. Blocks that end
6010 in a sibcall omit the sibcall_epilogue if the block is not in
6014 thread_prologue_and_epilogue_insns (void)
6017 vec
<edge
> unconverted_simple_returns
= vNULL
;
6018 bitmap_head bb_flags
;
6019 rtx_insn
*returnjump
;
6020 rtx_insn
*epilogue_end ATTRIBUTE_UNUSED
;
6021 rtx_insn
*prologue_seq ATTRIBUTE_UNUSED
, *split_prologue_seq ATTRIBUTE_UNUSED
;
6022 edge e
, entry_edge
, orig_entry_edge
, exit_fallthru_edge
;
6027 rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
6030 epilogue_end
= NULL
;
6033 /* Can't deal with multiple successors of the entry block at the
6034 moment. Function should always have at least one entry
6036 gcc_assert (single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
6037 entry_edge
= single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
6038 orig_entry_edge
= entry_edge
;
6040 split_prologue_seq
= NULL
;
6041 if (flag_split_stack
6042 && (lookup_attribute ("no_split_stack", DECL_ATTRIBUTES (cfun
->decl
))
6045 #ifndef HAVE_split_stack_prologue
6048 gcc_assert (HAVE_split_stack_prologue
);
6051 emit_insn (gen_split_stack_prologue ());
6052 split_prologue_seq
= get_insns ();
6055 record_insns (split_prologue_seq
, NULL
, &prologue_insn_hash
);
6056 set_insn_locations (split_prologue_seq
, prologue_location
);
6060 prologue_seq
= NULL
;
6061 #ifdef HAVE_prologue
6065 rtx_insn
*seq
= safe_as_a
<rtx_insn
*> (gen_prologue ());
6068 /* Insert an explicit USE for the frame pointer
6069 if the profiling is on and the frame pointer is required. */
6070 if (crtl
->profile
&& frame_pointer_needed
)
6071 emit_use (hard_frame_pointer_rtx
);
6073 /* Retain a map of the prologue insns. */
6074 record_insns (seq
, NULL
, &prologue_insn_hash
);
6075 emit_note (NOTE_INSN_PROLOGUE_END
);
6077 /* Ensure that instructions are not moved into the prologue when
6078 profiling is on. The call to the profiling routine can be
6079 emitted within the live range of a call-clobbered register. */
6080 if (!targetm
.profile_before_prologue () && crtl
->profile
)
6081 emit_insn (gen_blockage ());
6083 prologue_seq
= get_insns ();
6085 set_insn_locations (prologue_seq
, prologue_location
);
6089 bitmap_initialize (&bb_flags
, &bitmap_default_obstack
);
6091 /* Try to perform a kind of shrink-wrapping, making sure the
6092 prologue/epilogue is emitted only around those parts of the
6093 function that require it. */
6095 try_shrink_wrapping (&entry_edge
, orig_entry_edge
, &bb_flags
, prologue_seq
);
6097 if (split_prologue_seq
!= NULL_RTX
)
6099 insert_insn_on_edge (split_prologue_seq
, orig_entry_edge
);
6102 if (prologue_seq
!= NULL_RTX
)
6104 insert_insn_on_edge (prologue_seq
, entry_edge
);
6108 /* If the exit block has no non-fake predecessors, we don't need
6110 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
6111 if ((e
->flags
& EDGE_FAKE
) == 0)
6116 rtl_profile_for_bb (EXIT_BLOCK_PTR_FOR_FN (cfun
));
6118 exit_fallthru_edge
= find_fallthru_edge (EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
);
6120 if (HAVE_simple_return
&& entry_edge
!= orig_entry_edge
)
6122 = get_unconverted_simple_return (exit_fallthru_edge
, bb_flags
,
6123 &unconverted_simple_returns
,
6127 if (exit_fallthru_edge
== NULL
)
6132 basic_block last_bb
= exit_fallthru_edge
->src
;
6134 if (LABEL_P (BB_HEAD (last_bb
))
6135 && !active_insn_between (BB_HEAD (last_bb
), BB_END (last_bb
)))
6136 convert_jumps_to_returns (last_bb
, false, vNULL
);
6138 if (EDGE_COUNT (last_bb
->preds
) != 0
6139 && single_succ_p (last_bb
))
6141 last_bb
= emit_return_for_exit (exit_fallthru_edge
, false);
6142 epilogue_end
= returnjump
= BB_END (last_bb
);
6144 /* Emitting the return may add a basic block.
6145 Fix bb_flags for the added block. */
6146 if (HAVE_simple_return
&& last_bb
!= exit_fallthru_edge
->src
)
6147 bitmap_set_bit (&bb_flags
, last_bb
->index
);
6154 /* A small fib -- epilogue is not yet completed, but we wish to re-use
6155 this marker for the splits of EH_RETURN patterns, and nothing else
6156 uses the flag in the meantime. */
6157 epilogue_completed
= 1;
6159 #ifdef HAVE_eh_return
6160 /* Find non-fallthru edges that end with EH_RETURN instructions. On
6161 some targets, these get split to a special version of the epilogue
6162 code. In order to be able to properly annotate these with unwind
6163 info, try to split them now. If we get a valid split, drop an
6164 EPILOGUE_BEG note and mark the insns as epilogue insns. */
6165 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
6167 rtx_insn
*prev
, *last
, *trial
;
6169 if (e
->flags
& EDGE_FALLTHRU
)
6171 last
= BB_END (e
->src
);
6172 if (!eh_returnjump_p (last
))
6175 prev
= PREV_INSN (last
);
6176 trial
= try_split (PATTERN (last
), last
, 1);
6180 record_insns (NEXT_INSN (prev
), NEXT_INSN (trial
), &epilogue_insn_hash
);
6181 emit_note_after (NOTE_INSN_EPILOGUE_BEG
, prev
);
6185 /* If nothing falls through into the exit block, we don't need an
6188 if (exit_fallthru_edge
== NULL
)
6194 epilogue_end
= emit_note (NOTE_INSN_EPILOGUE_BEG
);
6195 rtx_insn
*seq
= as_a
<rtx_insn
*> (gen_epilogue ());
6197 emit_jump_insn (seq
);
6199 /* Retain a map of the epilogue insns. */
6200 record_insns (seq
, NULL
, &epilogue_insn_hash
);
6201 set_insn_locations (seq
, epilogue_location
);
6204 returnjump
= get_last_insn ();
6207 insert_insn_on_edge (seq
, exit_fallthru_edge
);
6210 if (JUMP_P (returnjump
))
6211 set_return_jump_label (returnjump
);
6217 if (! next_active_insn (BB_END (exit_fallthru_edge
->src
)))
6219 /* We have a fall-through edge to the exit block, the source is not
6220 at the end of the function, and there will be an assembler epilogue
6221 at the end of the function.
6222 We can't use force_nonfallthru here, because that would try to
6223 use return. Inserting a jump 'by hand' is extremely messy, so
6224 we take advantage of cfg_layout_finalize using
6225 fixup_fallthru_exit_predecessor. */
6226 cfg_layout_initialize (0);
6227 FOR_EACH_BB_FN (cur_bb
, cfun
)
6228 if (cur_bb
->index
>= NUM_FIXED_BLOCKS
6229 && cur_bb
->next_bb
->index
>= NUM_FIXED_BLOCKS
)
6230 cur_bb
->aux
= cur_bb
->next_bb
;
6231 cfg_layout_finalize ();
6236 default_rtl_profile ();
6242 commit_edge_insertions ();
6244 /* Look for basic blocks within the prologue insns. */
6245 blocks
= sbitmap_alloc (last_basic_block_for_fn (cfun
));
6246 bitmap_clear (blocks
);
6247 bitmap_set_bit (blocks
, entry_edge
->dest
->index
);
6248 bitmap_set_bit (blocks
, orig_entry_edge
->dest
->index
);
6249 find_many_sub_basic_blocks (blocks
);
6250 sbitmap_free (blocks
);
6252 /* The epilogue insns we inserted may cause the exit edge to no longer
6254 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
6256 if (((e
->flags
& EDGE_FALLTHRU
) != 0)
6257 && returnjump_p (BB_END (e
->src
)))
6258 e
->flags
&= ~EDGE_FALLTHRU
;
6262 if (HAVE_simple_return
)
6263 convert_to_simple_return (entry_edge
, orig_entry_edge
, bb_flags
,
6264 returnjump
, unconverted_simple_returns
);
6266 #ifdef HAVE_sibcall_epilogue
6267 /* Emit sibling epilogues before any sibling call sites. */
6268 for (ei
= ei_start (EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
); (e
=
6272 basic_block bb
= e
->src
;
6273 rtx_insn
*insn
= BB_END (bb
);
6277 || ! SIBLING_CALL_P (insn
)
6278 || (HAVE_simple_return
&& (entry_edge
!= orig_entry_edge
6279 && !bitmap_bit_p (&bb_flags
, bb
->index
))))
6285 ep_seq
= gen_sibcall_epilogue ();
6289 emit_note (NOTE_INSN_EPILOGUE_BEG
);
6291 rtx_insn
*seq
= get_insns ();
6294 /* Retain a map of the epilogue insns. Used in life analysis to
6295 avoid getting rid of sibcall epilogue insns. Do this before we
6296 actually emit the sequence. */
6297 record_insns (seq
, NULL
, &epilogue_insn_hash
);
6298 set_insn_locations (seq
, epilogue_location
);
6300 emit_insn_before (seq
, insn
);
6308 rtx_insn
*insn
, *next
;
6310 /* Similarly, move any line notes that appear after the epilogue.
6311 There is no need, however, to be quite so anal about the existence
6312 of such a note. Also possibly move
6313 NOTE_INSN_FUNCTION_BEG notes, as those can be relevant for debug
6315 for (insn
= epilogue_end
; insn
; insn
= next
)
6317 next
= NEXT_INSN (insn
);
6319 && (NOTE_KIND (insn
) == NOTE_INSN_FUNCTION_BEG
))
6320 reorder_insns (insn
, insn
, PREV_INSN (epilogue_end
));
6324 bitmap_clear (&bb_flags
);
6326 /* Threading the prologue and epilogue changes the artificial refs
6327 in the entry and exit blocks. */
6328 epilogue_completed
= 1;
6329 df_update_entry_exit_and_calls ();
6332 /* Reposition the prologue-end and epilogue-begin notes after
6333 instruction scheduling. */
6336 reposition_prologue_and_epilogue_notes (void)
6338 #if ! defined (HAVE_prologue) && ! defined (HAVE_sibcall_epilogue)
6343 /* Since the hash table is created on demand, the fact that it is
6344 non-null is a signal that it is non-empty. */
6345 if (prologue_insn_hash
!= NULL
)
6347 size_t len
= prologue_insn_hash
->elements ();
6348 rtx_insn
*insn
, *last
= NULL
, *note
= NULL
;
6350 /* Scan from the beginning until we reach the last prologue insn. */
6351 /* ??? While we do have the CFG intact, there are two problems:
6352 (1) The prologue can contain loops (typically probing the stack),
6353 which means that the end of the prologue isn't in the first bb.
6354 (2) Sometimes the PROLOGUE_END note gets pushed into the next bb. */
6355 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
6359 if (NOTE_KIND (insn
) == NOTE_INSN_PROLOGUE_END
)
6362 else if (contains (insn
, prologue_insn_hash
))
6374 /* Scan forward looking for the PROLOGUE_END note. It should
6375 be right at the beginning of the block, possibly with other
6376 insn notes that got moved there. */
6377 for (note
= NEXT_INSN (last
); ; note
= NEXT_INSN (note
))
6380 && NOTE_KIND (note
) == NOTE_INSN_PROLOGUE_END
)
6385 /* Avoid placing note between CODE_LABEL and BASIC_BLOCK note. */
6387 last
= NEXT_INSN (last
);
6388 reorder_insns (note
, note
, last
);
6392 if (epilogue_insn_hash
!= NULL
)
6397 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
6399 rtx_insn
*insn
, *first
= NULL
, *note
= NULL
;
6400 basic_block bb
= e
->src
;
6402 /* Scan from the beginning until we reach the first epilogue insn. */
6403 FOR_BB_INSNS (bb
, insn
)
6407 if (NOTE_KIND (insn
) == NOTE_INSN_EPILOGUE_BEG
)
6414 else if (first
== NULL
&& contains (insn
, epilogue_insn_hash
))
6424 /* If the function has a single basic block, and no real
6425 epilogue insns (e.g. sibcall with no cleanup), the
6426 epilogue note can get scheduled before the prologue
6427 note. If we have frame related prologue insns, having
6428 them scanned during the epilogue will result in a crash.
6429 In this case re-order the epilogue note to just before
6430 the last insn in the block. */
6432 first
= BB_END (bb
);
6434 if (PREV_INSN (first
) != note
)
6435 reorder_insns (note
, note
, PREV_INSN (first
));
6441 /* Returns the name of function declared by FNDECL. */
6443 fndecl_name (tree fndecl
)
6447 return lang_hooks
.decl_printable_name (fndecl
, 2);
6450 /* Returns the name of function FN. */
6452 function_name (struct function
*fn
)
6454 tree fndecl
= (fn
== NULL
) ? NULL
: fn
->decl
;
6455 return fndecl_name (fndecl
);
6458 /* Returns the name of the current function. */
6460 current_function_name (void)
6462 return function_name (cfun
);
6467 rest_of_handle_check_leaf_regs (void)
6469 #ifdef LEAF_REGISTERS
6470 crtl
->uses_only_leaf_regs
6471 = optimize
> 0 && only_leaf_regs_used () && leaf_function_p ();
6476 /* Insert a TYPE into the used types hash table of CFUN. */
6479 used_types_insert_helper (tree type
, struct function
*func
)
6481 if (type
!= NULL
&& func
!= NULL
)
6483 if (func
->used_types_hash
== NULL
)
6484 func
->used_types_hash
= hash_set
<tree
>::create_ggc (37);
6486 func
->used_types_hash
->add (type
);
6490 /* Given a type, insert it into the used hash table in cfun. */
6492 used_types_insert (tree t
)
6494 while (POINTER_TYPE_P (t
) || TREE_CODE (t
) == ARRAY_TYPE
)
6499 if (TREE_CODE (t
) == ERROR_MARK
)
6501 if (TYPE_NAME (t
) == NULL_TREE
6502 || TYPE_NAME (t
) == TYPE_NAME (TYPE_MAIN_VARIANT (t
)))
6503 t
= TYPE_MAIN_VARIANT (t
);
6504 if (debug_info_level
> DINFO_LEVEL_NONE
)
6507 used_types_insert_helper (t
, cfun
);
6510 /* So this might be a type referenced by a global variable.
6511 Record that type so that we can later decide to emit its
6512 debug information. */
6513 vec_safe_push (types_used_by_cur_var_decl
, t
);
6518 /* Helper to Hash a struct types_used_by_vars_entry. */
6521 hash_types_used_by_vars_entry (const struct types_used_by_vars_entry
*entry
)
6523 gcc_assert (entry
&& entry
->var_decl
&& entry
->type
);
6525 return iterative_hash_object (entry
->type
,
6526 iterative_hash_object (entry
->var_decl
, 0));
6529 /* Hash function of the types_used_by_vars_entry hash table. */
6532 used_type_hasher::hash (types_used_by_vars_entry
*entry
)
6534 return hash_types_used_by_vars_entry (entry
);
6537 /*Equality function of the types_used_by_vars_entry hash table. */
6540 used_type_hasher::equal (types_used_by_vars_entry
*e1
,
6541 types_used_by_vars_entry
*e2
)
6543 return (e1
->var_decl
== e2
->var_decl
&& e1
->type
== e2
->type
);
6546 /* Inserts an entry into the types_used_by_vars_hash hash table. */
6549 types_used_by_var_decl_insert (tree type
, tree var_decl
)
6551 if (type
!= NULL
&& var_decl
!= NULL
)
6553 types_used_by_vars_entry
**slot
;
6554 struct types_used_by_vars_entry e
;
6555 e
.var_decl
= var_decl
;
6557 if (types_used_by_vars_hash
== NULL
)
6558 types_used_by_vars_hash
6559 = hash_table
<used_type_hasher
>::create_ggc (37);
6561 slot
= types_used_by_vars_hash
->find_slot (&e
, INSERT
);
6564 struct types_used_by_vars_entry
*entry
;
6565 entry
= ggc_alloc
<types_used_by_vars_entry
> ();
6567 entry
->var_decl
= var_decl
;
6575 const pass_data pass_data_leaf_regs
=
6577 RTL_PASS
, /* type */
6578 "*leaf_regs", /* name */
6579 OPTGROUP_NONE
, /* optinfo_flags */
6580 TV_NONE
, /* tv_id */
6581 0, /* properties_required */
6582 0, /* properties_provided */
6583 0, /* properties_destroyed */
6584 0, /* todo_flags_start */
6585 0, /* todo_flags_finish */
6588 class pass_leaf_regs
: public rtl_opt_pass
6591 pass_leaf_regs (gcc::context
*ctxt
)
6592 : rtl_opt_pass (pass_data_leaf_regs
, ctxt
)
6595 /* opt_pass methods: */
6596 virtual unsigned int execute (function
*)
6598 return rest_of_handle_check_leaf_regs ();
6601 }; // class pass_leaf_regs
6606 make_pass_leaf_regs (gcc::context
*ctxt
)
6608 return new pass_leaf_regs (ctxt
);
6612 rest_of_handle_thread_prologue_and_epilogue (void)
6615 cleanup_cfg (CLEANUP_EXPENSIVE
);
6617 /* On some machines, the prologue and epilogue code, or parts thereof,
6618 can be represented as RTL. Doing so lets us schedule insns between
6619 it and the rest of the code and also allows delayed branch
6620 scheduling to operate in the epilogue. */
6621 thread_prologue_and_epilogue_insns ();
6623 /* Shrink-wrapping can result in unreachable edges in the epilogue,
6627 /* The stack usage info is finalized during prologue expansion. */
6628 if (flag_stack_usage_info
)
6629 output_stack_usage ();
6636 const pass_data pass_data_thread_prologue_and_epilogue
=
6638 RTL_PASS
, /* type */
6639 "pro_and_epilogue", /* name */
6640 OPTGROUP_NONE
, /* optinfo_flags */
6641 TV_THREAD_PROLOGUE_AND_EPILOGUE
, /* tv_id */
6642 0, /* properties_required */
6643 0, /* properties_provided */
6644 0, /* properties_destroyed */
6645 0, /* todo_flags_start */
6646 ( TODO_df_verify
| TODO_df_finish
), /* todo_flags_finish */
6649 class pass_thread_prologue_and_epilogue
: public rtl_opt_pass
6652 pass_thread_prologue_and_epilogue (gcc::context
*ctxt
)
6653 : rtl_opt_pass (pass_data_thread_prologue_and_epilogue
, ctxt
)
6656 /* opt_pass methods: */
6657 virtual unsigned int execute (function
*)
6659 return rest_of_handle_thread_prologue_and_epilogue ();
6662 }; // class pass_thread_prologue_and_epilogue
6667 make_pass_thread_prologue_and_epilogue (gcc::context
*ctxt
)
6669 return new pass_thread_prologue_and_epilogue (ctxt
);
6673 /* This mini-pass fixes fall-out from SSA in asm statements that have
6674 in-out constraints. Say you start with
6677 asm ("": "+mr" (inout));
6680 which is transformed very early to use explicit output and match operands:
6683 asm ("": "=mr" (inout) : "0" (inout));
6686 Or, after SSA and copyprop,
6688 asm ("": "=mr" (inout_2) : "0" (inout_1));
6691 Clearly inout_2 and inout_1 can't be coalesced easily anymore, as
6692 they represent two separate values, so they will get different pseudo
6693 registers during expansion. Then, since the two operands need to match
6694 per the constraints, but use different pseudo registers, reload can
6695 only register a reload for these operands. But reloads can only be
6696 satisfied by hardregs, not by memory, so we need a register for this
6697 reload, just because we are presented with non-matching operands.
6698 So, even though we allow memory for this operand, no memory can be
6699 used for it, just because the two operands don't match. This can
6700 cause reload failures on register-starved targets.
6702 So it's a symptom of reload not being able to use memory for reloads
6703 or, alternatively it's also a symptom of both operands not coming into
6704 reload as matching (in which case the pseudo could go to memory just
6705 fine, as the alternative allows it, and no reload would be necessary).
6706 We fix the latter problem here, by transforming
6708 asm ("": "=mr" (inout_2) : "0" (inout_1));
6713 asm ("": "=mr" (inout_2) : "0" (inout_2)); */
6716 match_asm_constraints_1 (rtx_insn
*insn
, rtx
*p_sets
, int noutputs
)
6719 bool changed
= false;
6720 rtx op
= SET_SRC (p_sets
[0]);
6721 int ninputs
= ASM_OPERANDS_INPUT_LENGTH (op
);
6722 rtvec inputs
= ASM_OPERANDS_INPUT_VEC (op
);
6723 bool *output_matched
= XALLOCAVEC (bool, noutputs
);
6725 memset (output_matched
, 0, noutputs
* sizeof (bool));
6726 for (i
= 0; i
< ninputs
; i
++)
6730 const char *constraint
= ASM_OPERANDS_INPUT_CONSTRAINT (op
, i
);
6734 if (*constraint
== '%')
6737 match
= strtoul (constraint
, &end
, 10);
6738 if (end
== constraint
)
6741 gcc_assert (match
< noutputs
);
6742 output
= SET_DEST (p_sets
[match
]);
6743 input
= RTVEC_ELT (inputs
, i
);
6744 /* Only do the transformation for pseudos. */
6745 if (! REG_P (output
)
6746 || rtx_equal_p (output
, input
)
6747 || (GET_MODE (input
) != VOIDmode
6748 && GET_MODE (input
) != GET_MODE (output
)))
6751 /* We can't do anything if the output is also used as input,
6752 as we're going to overwrite it. */
6753 for (j
= 0; j
< ninputs
; j
++)
6754 if (reg_overlap_mentioned_p (output
, RTVEC_ELT (inputs
, j
)))
6759 /* Avoid changing the same input several times. For
6760 asm ("" : "=mr" (out1), "=mr" (out2) : "0" (in), "1" (in));
6761 only change in once (to out1), rather than changing it
6762 first to out1 and afterwards to out2. */
6765 for (j
= 0; j
< noutputs
; j
++)
6766 if (output_matched
[j
] && input
== SET_DEST (p_sets
[j
]))
6771 output_matched
[match
] = true;
6774 emit_move_insn (output
, input
);
6775 insns
= get_insns ();
6777 emit_insn_before (insns
, insn
);
6779 /* Now replace all mentions of the input with output. We can't
6780 just replace the occurrence in inputs[i], as the register might
6781 also be used in some other input (or even in an address of an
6782 output), which would mean possibly increasing the number of
6783 inputs by one (namely 'output' in addition), which might pose
6784 a too complicated problem for reload to solve. E.g. this situation:
6786 asm ("" : "=r" (output), "=m" (input) : "0" (input))
6788 Here 'input' is used in two occurrences as input (once for the
6789 input operand, once for the address in the second output operand).
6790 If we would replace only the occurrence of the input operand (to
6791 make the matching) we would be left with this:
6794 asm ("" : "=r" (output), "=m" (input) : "0" (output))
6796 Now we suddenly have two different input values (containing the same
6797 value, but different pseudos) where we formerly had only one.
6798 With more complicated asms this might lead to reload failures
6799 which wouldn't have happen without this pass. So, iterate over
6800 all operands and replace all occurrences of the register used. */
6801 for (j
= 0; j
< noutputs
; j
++)
6802 if (!rtx_equal_p (SET_DEST (p_sets
[j
]), input
)
6803 && reg_overlap_mentioned_p (input
, SET_DEST (p_sets
[j
])))
6804 SET_DEST (p_sets
[j
]) = replace_rtx (SET_DEST (p_sets
[j
]),
6806 for (j
= 0; j
< ninputs
; j
++)
6807 if (reg_overlap_mentioned_p (input
, RTVEC_ELT (inputs
, j
)))
6808 RTVEC_ELT (inputs
, j
) = replace_rtx (RTVEC_ELT (inputs
, j
),
6815 df_insn_rescan (insn
);
6818 /* Add the decl D to the local_decls list of FUN. */
6821 add_local_decl (struct function
*fun
, tree d
)
6823 gcc_assert (TREE_CODE (d
) == VAR_DECL
);
6824 vec_safe_push (fun
->local_decls
, d
);
6829 const pass_data pass_data_match_asm_constraints
=
6831 RTL_PASS
, /* type */
6832 "asmcons", /* name */
6833 OPTGROUP_NONE
, /* optinfo_flags */
6834 TV_NONE
, /* tv_id */
6835 0, /* properties_required */
6836 0, /* properties_provided */
6837 0, /* properties_destroyed */
6838 0, /* todo_flags_start */
6839 0, /* todo_flags_finish */
6842 class pass_match_asm_constraints
: public rtl_opt_pass
6845 pass_match_asm_constraints (gcc::context
*ctxt
)
6846 : rtl_opt_pass (pass_data_match_asm_constraints
, ctxt
)
6849 /* opt_pass methods: */
6850 virtual unsigned int execute (function
*);
6852 }; // class pass_match_asm_constraints
6855 pass_match_asm_constraints::execute (function
*fun
)
6862 if (!crtl
->has_asm_statement
)
6865 df_set_flags (DF_DEFER_INSN_RESCAN
);
6866 FOR_EACH_BB_FN (bb
, fun
)
6868 FOR_BB_INSNS (bb
, insn
)
6873 pat
= PATTERN (insn
);
6874 if (GET_CODE (pat
) == PARALLEL
)
6875 p_sets
= &XVECEXP (pat
, 0, 0), noutputs
= XVECLEN (pat
, 0);
6876 else if (GET_CODE (pat
) == SET
)
6877 p_sets
= &PATTERN (insn
), noutputs
= 1;
6881 if (GET_CODE (*p_sets
) == SET
6882 && GET_CODE (SET_SRC (*p_sets
)) == ASM_OPERANDS
)
6883 match_asm_constraints_1 (insn
, p_sets
, noutputs
);
6887 return TODO_df_finish
;
6893 make_pass_match_asm_constraints (gcc::context
*ctxt
)
6895 return new pass_match_asm_constraints (ctxt
);
6899 #include "gt-function.h"