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"
42 #include "rtl-error.h"
44 #include "fold-const.h"
45 #include "stor-layout.h"
47 #include "stringpool.h"
50 #include "insn-config.h"
58 #include "insn-codes.h"
65 #include "langhooks.h"
67 #include "common/common-target.h"
68 #include "gimple-expr.h"
70 #include "tree-pass.h"
74 #include "cfgcleanup.h"
75 #include "cfgexpand.h"
76 #include "basic-block.h"
79 #include "bb-reorder.h"
80 #include "shrink-wrap.h"
83 #include "tree-chkp.h"
86 /* So we can assign to cfun in this file. */
89 #ifndef STACK_ALIGNMENT_NEEDED
90 #define STACK_ALIGNMENT_NEEDED 1
93 #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
95 /* Round a value to the lowest integer less than it that is a multiple of
96 the required alignment. Avoid using division in case the value is
97 negative. Assume the alignment is a power of two. */
98 #define FLOOR_ROUND(VALUE,ALIGN) ((VALUE) & ~((ALIGN) - 1))
100 /* Similar, but round to the next highest integer that meets the
102 #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
104 /* Nonzero once virtual register instantiation has been done.
105 assign_stack_local uses frame_pointer_rtx when this is nonzero.
106 calls.c:emit_library_call_value_1 uses it to set up
107 post-instantiation libcalls. */
108 int virtuals_instantiated
;
110 /* Assign unique numbers to labels generated for profiling, debugging, etc. */
111 static GTY(()) int funcdef_no
;
113 /* These variables hold pointers to functions to create and destroy
114 target specific, per-function data structures. */
115 struct machine_function
* (*init_machine_status
) (void);
117 /* The currently compiled function. */
118 struct function
*cfun
= 0;
120 /* These hashes record the prologue and epilogue insns. */
122 struct insn_cache_hasher
: ggc_cache_ptr_hash
<rtx_def
>
124 static hashval_t
hash (rtx x
) { return htab_hash_pointer (x
); }
125 static bool equal (rtx a
, rtx b
) { return a
== b
; }
129 hash_table
<insn_cache_hasher
> *prologue_insn_hash
;
131 hash_table
<insn_cache_hasher
> *epilogue_insn_hash
;
134 hash_table
<used_type_hasher
> *types_used_by_vars_hash
= NULL
;
135 vec
<tree
, va_gc
> *types_used_by_cur_var_decl
;
137 /* Forward declarations. */
139 static struct temp_slot
*find_temp_slot_from_address (rtx
);
140 static void pad_to_arg_alignment (struct args_size
*, int, struct args_size
*);
141 static void pad_below (struct args_size
*, machine_mode
, tree
);
142 static void reorder_blocks_1 (rtx_insn
*, tree
, vec
<tree
> *);
143 static int all_blocks (tree
, tree
*);
144 static tree
*get_block_vector (tree
, int *);
145 extern tree
debug_find_var_in_block_tree (tree
, tree
);
146 /* We always define `record_insns' even if it's not used so that we
147 can always export `prologue_epilogue_contains'. */
148 static void record_insns (rtx_insn
*, rtx
, hash_table
<insn_cache_hasher
> **)
150 static bool contains (const_rtx
, hash_table
<insn_cache_hasher
> *);
151 static void prepare_function_start (void);
152 static void do_clobber_return_reg (rtx
, void *);
153 static void do_use_return_reg (rtx
, void *);
154 static rtx
rtl_for_parm (struct assign_parm_data_all
*, tree
);
155 static void maybe_reset_rtl_for_parm (tree
);
158 /* Stack of nested functions. */
159 /* Keep track of the cfun stack. */
161 typedef struct function
*function_p
;
163 static vec
<function_p
> function_context_stack
;
165 /* Save the current context for compilation of a nested function.
166 This is called from language-specific code. */
169 push_function_context (void)
172 allocate_struct_function (NULL
, false);
174 function_context_stack
.safe_push (cfun
);
178 /* Restore the last saved context, at the end of a nested function.
179 This function is called from language-specific code. */
182 pop_function_context (void)
184 struct function
*p
= function_context_stack
.pop ();
186 current_function_decl
= p
->decl
;
188 /* Reset variables that have known state during rtx generation. */
189 virtuals_instantiated
= 0;
190 generating_concat_p
= 1;
193 /* Clear out all parts of the state in F that can safely be discarded
194 after the function has been parsed, but not compiled, to let
195 garbage collection reclaim the memory. */
198 free_after_parsing (struct function
*f
)
203 /* Clear out all parts of the state in F that can safely be discarded
204 after the function has been compiled, to let garbage collection
205 reclaim the memory. */
208 free_after_compilation (struct function
*f
)
210 prologue_insn_hash
= NULL
;
211 epilogue_insn_hash
= NULL
;
213 free (crtl
->emit
.regno_pointer_align
);
215 memset (crtl
, 0, sizeof (struct rtl_data
));
219 f
->curr_properties
&= ~PROP_cfg
;
221 regno_reg_rtx
= NULL
;
224 /* Return size needed for stack frame based on slots so far allocated.
225 This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY;
226 the caller may have to do that. */
229 get_frame_size (void)
231 if (FRAME_GROWS_DOWNWARD
)
232 return -frame_offset
;
237 /* Issue an error message and return TRUE if frame OFFSET overflows in
238 the signed target pointer arithmetics for function FUNC. Otherwise
242 frame_offset_overflow (HOST_WIDE_INT offset
, tree func
)
244 unsigned HOST_WIDE_INT size
= FRAME_GROWS_DOWNWARD
? -offset
: offset
;
246 if (size
> ((unsigned HOST_WIDE_INT
) 1 << (GET_MODE_BITSIZE (Pmode
) - 1))
247 /* Leave room for the fixed part of the frame. */
248 - 64 * UNITS_PER_WORD
)
250 error_at (DECL_SOURCE_LOCATION (func
),
251 "total size of local objects too large");
258 /* Return stack slot alignment in bits for TYPE and MODE. */
261 get_stack_local_alignment (tree type
, machine_mode mode
)
263 unsigned int alignment
;
266 alignment
= BIGGEST_ALIGNMENT
;
268 alignment
= GET_MODE_ALIGNMENT (mode
);
270 /* Allow the frond-end to (possibly) increase the alignment of this
273 type
= lang_hooks
.types
.type_for_mode (mode
, 0);
275 return STACK_SLOT_ALIGNMENT (type
, mode
, alignment
);
278 /* Determine whether it is possible to fit a stack slot of size SIZE and
279 alignment ALIGNMENT into an area in the stack frame that starts at
280 frame offset START and has a length of LENGTH. If so, store the frame
281 offset to be used for the stack slot in *POFFSET and return true;
282 return false otherwise. This function will extend the frame size when
283 given a start/length pair that lies at the end of the frame. */
286 try_fit_stack_local (HOST_WIDE_INT start
, HOST_WIDE_INT length
,
287 HOST_WIDE_INT size
, unsigned int alignment
,
288 HOST_WIDE_INT
*poffset
)
290 HOST_WIDE_INT this_frame_offset
;
291 int frame_off
, frame_alignment
, frame_phase
;
293 /* Calculate how many bytes the start of local variables is off from
295 frame_alignment
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
296 frame_off
= STARTING_FRAME_OFFSET
% frame_alignment
;
297 frame_phase
= frame_off
? frame_alignment
- frame_off
: 0;
299 /* Round the frame offset to the specified alignment. */
301 /* We must be careful here, since FRAME_OFFSET might be negative and
302 division with a negative dividend isn't as well defined as we might
303 like. So we instead assume that ALIGNMENT is a power of two and
304 use logical operations which are unambiguous. */
305 if (FRAME_GROWS_DOWNWARD
)
307 = (FLOOR_ROUND (start
+ length
- size
- frame_phase
,
308 (unsigned HOST_WIDE_INT
) alignment
)
312 = (CEIL_ROUND (start
- frame_phase
,
313 (unsigned HOST_WIDE_INT
) alignment
)
316 /* See if it fits. If this space is at the edge of the frame,
317 consider extending the frame to make it fit. Our caller relies on
318 this when allocating a new slot. */
319 if (frame_offset
== start
&& this_frame_offset
< frame_offset
)
320 frame_offset
= this_frame_offset
;
321 else if (this_frame_offset
< start
)
323 else if (start
+ length
== frame_offset
324 && this_frame_offset
+ size
> start
+ length
)
325 frame_offset
= this_frame_offset
+ size
;
326 else if (this_frame_offset
+ size
> start
+ length
)
329 *poffset
= this_frame_offset
;
333 /* Create a new frame_space structure describing free space in the stack
334 frame beginning at START and ending at END, and chain it into the
335 function's frame_space_list. */
338 add_frame_space (HOST_WIDE_INT start
, HOST_WIDE_INT end
)
340 struct frame_space
*space
= ggc_alloc
<frame_space
> ();
341 space
->next
= crtl
->frame_space_list
;
342 crtl
->frame_space_list
= space
;
343 space
->start
= start
;
344 space
->length
= end
- start
;
347 /* Allocate a stack slot of SIZE bytes and return a MEM rtx for it
348 with machine mode MODE.
350 ALIGN controls the amount of alignment for the address of the slot:
351 0 means according to MODE,
352 -1 means use BIGGEST_ALIGNMENT and round size to multiple of that,
353 -2 means use BITS_PER_UNIT,
354 positive specifies alignment boundary in bits.
356 KIND has ASLK_REDUCE_ALIGN bit set if it is OK to reduce
357 alignment and ASLK_RECORD_PAD bit set if we should remember
358 extra space we allocated for alignment purposes. When we are
359 called from assign_stack_temp_for_type, it is not set so we don't
360 track the same stack slot in two independent lists.
362 We do not round to stack_boundary here. */
365 assign_stack_local_1 (machine_mode mode
, HOST_WIDE_INT size
,
369 int bigend_correction
= 0;
370 HOST_WIDE_INT slot_offset
= 0, old_frame_offset
;
371 unsigned int alignment
, alignment_in_bits
;
375 alignment
= get_stack_local_alignment (NULL
, mode
);
376 alignment
/= BITS_PER_UNIT
;
378 else if (align
== -1)
380 alignment
= BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
;
381 size
= CEIL_ROUND (size
, alignment
);
383 else if (align
== -2)
384 alignment
= 1; /* BITS_PER_UNIT / BITS_PER_UNIT */
386 alignment
= align
/ BITS_PER_UNIT
;
388 alignment_in_bits
= alignment
* BITS_PER_UNIT
;
390 /* Ignore alignment if it exceeds MAX_SUPPORTED_STACK_ALIGNMENT. */
391 if (alignment_in_bits
> MAX_SUPPORTED_STACK_ALIGNMENT
)
393 alignment_in_bits
= MAX_SUPPORTED_STACK_ALIGNMENT
;
394 alignment
= alignment_in_bits
/ BITS_PER_UNIT
;
397 if (SUPPORTS_STACK_ALIGNMENT
)
399 if (crtl
->stack_alignment_estimated
< alignment_in_bits
)
401 if (!crtl
->stack_realign_processed
)
402 crtl
->stack_alignment_estimated
= alignment_in_bits
;
405 /* If stack is realigned and stack alignment value
406 hasn't been finalized, it is OK not to increase
407 stack_alignment_estimated. The bigger alignment
408 requirement is recorded in stack_alignment_needed
410 gcc_assert (!crtl
->stack_realign_finalized
);
411 if (!crtl
->stack_realign_needed
)
413 /* It is OK to reduce the alignment as long as the
414 requested size is 0 or the estimated stack
415 alignment >= mode alignment. */
416 gcc_assert ((kind
& ASLK_REDUCE_ALIGN
)
418 || (crtl
->stack_alignment_estimated
419 >= GET_MODE_ALIGNMENT (mode
)));
420 alignment_in_bits
= crtl
->stack_alignment_estimated
;
421 alignment
= alignment_in_bits
/ BITS_PER_UNIT
;
427 if (crtl
->stack_alignment_needed
< alignment_in_bits
)
428 crtl
->stack_alignment_needed
= alignment_in_bits
;
429 if (crtl
->max_used_stack_slot_alignment
< alignment_in_bits
)
430 crtl
->max_used_stack_slot_alignment
= alignment_in_bits
;
432 if (mode
!= BLKmode
|| size
!= 0)
434 if (kind
& ASLK_RECORD_PAD
)
436 struct frame_space
**psp
;
438 for (psp
= &crtl
->frame_space_list
; *psp
; psp
= &(*psp
)->next
)
440 struct frame_space
*space
= *psp
;
441 if (!try_fit_stack_local (space
->start
, space
->length
, size
,
442 alignment
, &slot_offset
))
445 if (slot_offset
> space
->start
)
446 add_frame_space (space
->start
, slot_offset
);
447 if (slot_offset
+ size
< space
->start
+ space
->length
)
448 add_frame_space (slot_offset
+ size
,
449 space
->start
+ space
->length
);
454 else if (!STACK_ALIGNMENT_NEEDED
)
456 slot_offset
= frame_offset
;
460 old_frame_offset
= frame_offset
;
462 if (FRAME_GROWS_DOWNWARD
)
464 frame_offset
-= size
;
465 try_fit_stack_local (frame_offset
, size
, size
, alignment
, &slot_offset
);
467 if (kind
& ASLK_RECORD_PAD
)
469 if (slot_offset
> frame_offset
)
470 add_frame_space (frame_offset
, slot_offset
);
471 if (slot_offset
+ size
< old_frame_offset
)
472 add_frame_space (slot_offset
+ size
, old_frame_offset
);
477 frame_offset
+= size
;
478 try_fit_stack_local (old_frame_offset
, size
, size
, alignment
, &slot_offset
);
480 if (kind
& ASLK_RECORD_PAD
)
482 if (slot_offset
> old_frame_offset
)
483 add_frame_space (old_frame_offset
, slot_offset
);
484 if (slot_offset
+ size
< frame_offset
)
485 add_frame_space (slot_offset
+ size
, frame_offset
);
490 /* On a big-endian machine, if we are allocating more space than we will use,
491 use the least significant bytes of those that are allocated. */
492 if (BYTES_BIG_ENDIAN
&& mode
!= BLKmode
&& GET_MODE_SIZE (mode
) < size
)
493 bigend_correction
= size
- GET_MODE_SIZE (mode
);
495 /* If we have already instantiated virtual registers, return the actual
496 address relative to the frame pointer. */
497 if (virtuals_instantiated
)
498 addr
= plus_constant (Pmode
, frame_pointer_rtx
,
500 (slot_offset
+ bigend_correction
501 + STARTING_FRAME_OFFSET
, Pmode
));
503 addr
= plus_constant (Pmode
, virtual_stack_vars_rtx
,
505 (slot_offset
+ bigend_correction
,
508 x
= gen_rtx_MEM (mode
, addr
);
509 set_mem_align (x
, alignment_in_bits
);
510 MEM_NOTRAP_P (x
) = 1;
513 = gen_rtx_EXPR_LIST (VOIDmode
, x
, stack_slot_list
);
515 if (frame_offset_overflow (frame_offset
, current_function_decl
))
521 /* Wrap up assign_stack_local_1 with last parameter as false. */
524 assign_stack_local (machine_mode mode
, HOST_WIDE_INT size
, int align
)
526 return assign_stack_local_1 (mode
, size
, align
, ASLK_RECORD_PAD
);
529 /* In order to evaluate some expressions, such as function calls returning
530 structures in memory, we need to temporarily allocate stack locations.
531 We record each allocated temporary in the following structure.
533 Associated with each temporary slot is a nesting level. When we pop up
534 one level, all temporaries associated with the previous level are freed.
535 Normally, all temporaries are freed after the execution of the statement
536 in which they were created. However, if we are inside a ({...}) grouping,
537 the result may be in a temporary and hence must be preserved. If the
538 result could be in a temporary, we preserve it if we can determine which
539 one it is in. If we cannot determine which temporary may contain the
540 result, all temporaries are preserved. A temporary is preserved by
541 pretending it was allocated at the previous nesting level. */
543 struct GTY(()) temp_slot
{
544 /* Points to next temporary slot. */
545 struct temp_slot
*next
;
546 /* Points to previous temporary slot. */
547 struct temp_slot
*prev
;
548 /* The rtx to used to reference the slot. */
550 /* The size, in units, of the slot. */
552 /* The type of the object in the slot, or zero if it doesn't correspond
553 to a type. We use this to determine whether a slot can be reused.
554 It can be reused if objects of the type of the new slot will always
555 conflict with objects of the type of the old slot. */
557 /* The alignment (in bits) of the slot. */
559 /* Nonzero if this temporary is currently in use. */
561 /* Nesting level at which this slot is being used. */
563 /* The offset of the slot from the frame_pointer, including extra space
564 for alignment. This info is for combine_temp_slots. */
565 HOST_WIDE_INT base_offset
;
566 /* The size of the slot, including extra space for alignment. This
567 info is for combine_temp_slots. */
568 HOST_WIDE_INT full_size
;
571 /* Entry for the below hash table. */
572 struct GTY((for_user
)) temp_slot_address_entry
{
575 struct temp_slot
*temp_slot
;
578 struct temp_address_hasher
: ggc_ptr_hash
<temp_slot_address_entry
>
580 static hashval_t
hash (temp_slot_address_entry
*);
581 static bool equal (temp_slot_address_entry
*, temp_slot_address_entry
*);
584 /* A table of addresses that represent a stack slot. The table is a mapping
585 from address RTXen to a temp slot. */
586 static GTY(()) hash_table
<temp_address_hasher
> *temp_slot_address_table
;
587 static size_t n_temp_slots_in_use
;
589 /* Removes temporary slot TEMP from LIST. */
592 cut_slot_from_list (struct temp_slot
*temp
, struct temp_slot
**list
)
595 temp
->next
->prev
= temp
->prev
;
597 temp
->prev
->next
= temp
->next
;
601 temp
->prev
= temp
->next
= NULL
;
604 /* Inserts temporary slot TEMP to LIST. */
607 insert_slot_to_list (struct temp_slot
*temp
, struct temp_slot
**list
)
611 (*list
)->prev
= temp
;
616 /* Returns the list of used temp slots at LEVEL. */
618 static struct temp_slot
**
619 temp_slots_at_level (int level
)
621 if (level
>= (int) vec_safe_length (used_temp_slots
))
622 vec_safe_grow_cleared (used_temp_slots
, level
+ 1);
624 return &(*used_temp_slots
)[level
];
627 /* Returns the maximal temporary slot level. */
630 max_slot_level (void)
632 if (!used_temp_slots
)
635 return used_temp_slots
->length () - 1;
638 /* Moves temporary slot TEMP to LEVEL. */
641 move_slot_to_level (struct temp_slot
*temp
, int level
)
643 cut_slot_from_list (temp
, temp_slots_at_level (temp
->level
));
644 insert_slot_to_list (temp
, temp_slots_at_level (level
));
648 /* Make temporary slot TEMP available. */
651 make_slot_available (struct temp_slot
*temp
)
653 cut_slot_from_list (temp
, temp_slots_at_level (temp
->level
));
654 insert_slot_to_list (temp
, &avail_temp_slots
);
657 n_temp_slots_in_use
--;
660 /* Compute the hash value for an address -> temp slot mapping.
661 The value is cached on the mapping entry. */
663 temp_slot_address_compute_hash (struct temp_slot_address_entry
*t
)
665 int do_not_record
= 0;
666 return hash_rtx (t
->address
, GET_MODE (t
->address
),
667 &do_not_record
, NULL
, false);
670 /* Return the hash value for an address -> temp slot mapping. */
672 temp_address_hasher::hash (temp_slot_address_entry
*t
)
677 /* Compare two address -> temp slot mapping entries. */
679 temp_address_hasher::equal (temp_slot_address_entry
*t1
,
680 temp_slot_address_entry
*t2
)
682 return exp_equiv_p (t1
->address
, t2
->address
, 0, true);
685 /* Add ADDRESS as an alias of TEMP_SLOT to the addess -> temp slot mapping. */
687 insert_temp_slot_address (rtx address
, struct temp_slot
*temp_slot
)
689 struct temp_slot_address_entry
*t
= ggc_alloc
<temp_slot_address_entry
> ();
690 t
->address
= address
;
691 t
->temp_slot
= temp_slot
;
692 t
->hash
= temp_slot_address_compute_hash (t
);
693 *temp_slot_address_table
->find_slot_with_hash (t
, t
->hash
, INSERT
) = t
;
696 /* Remove an address -> temp slot mapping entry if the temp slot is
697 not in use anymore. Callback for remove_unused_temp_slot_addresses. */
699 remove_unused_temp_slot_addresses_1 (temp_slot_address_entry
**slot
, void *)
701 const struct temp_slot_address_entry
*t
= *slot
;
702 if (! t
->temp_slot
->in_use
)
703 temp_slot_address_table
->clear_slot (slot
);
707 /* Remove all mappings of addresses to unused temp slots. */
709 remove_unused_temp_slot_addresses (void)
711 /* Use quicker clearing if there aren't any active temp slots. */
712 if (n_temp_slots_in_use
)
713 temp_slot_address_table
->traverse
714 <void *, remove_unused_temp_slot_addresses_1
> (NULL
);
716 temp_slot_address_table
->empty ();
719 /* Find the temp slot corresponding to the object at address X. */
721 static struct temp_slot
*
722 find_temp_slot_from_address (rtx x
)
725 struct temp_slot_address_entry tmp
, *t
;
727 /* First try the easy way:
728 See if X exists in the address -> temp slot mapping. */
730 tmp
.temp_slot
= NULL
;
731 tmp
.hash
= temp_slot_address_compute_hash (&tmp
);
732 t
= temp_slot_address_table
->find_with_hash (&tmp
, tmp
.hash
);
736 /* If we have a sum involving a register, see if it points to a temp
738 if (GET_CODE (x
) == PLUS
&& REG_P (XEXP (x
, 0))
739 && (p
= find_temp_slot_from_address (XEXP (x
, 0))) != 0)
741 else if (GET_CODE (x
) == PLUS
&& REG_P (XEXP (x
, 1))
742 && (p
= find_temp_slot_from_address (XEXP (x
, 1))) != 0)
745 /* Last resort: Address is a virtual stack var address. */
746 if (GET_CODE (x
) == PLUS
747 && XEXP (x
, 0) == virtual_stack_vars_rtx
748 && CONST_INT_P (XEXP (x
, 1)))
751 for (i
= max_slot_level (); i
>= 0; i
--)
752 for (p
= *temp_slots_at_level (i
); p
; p
= p
->next
)
754 if (INTVAL (XEXP (x
, 1)) >= p
->base_offset
755 && INTVAL (XEXP (x
, 1)) < p
->base_offset
+ p
->full_size
)
763 /* Allocate a temporary stack slot and record it for possible later
766 MODE is the machine mode to be given to the returned rtx.
768 SIZE is the size in units of the space required. We do no rounding here
769 since assign_stack_local will do any required rounding.
771 TYPE is the type that will be used for the stack slot. */
774 assign_stack_temp_for_type (machine_mode mode
, HOST_WIDE_INT size
,
778 struct temp_slot
*p
, *best_p
= 0, *selected
= NULL
, **pp
;
781 /* If SIZE is -1 it means that somebody tried to allocate a temporary
782 of a variable size. */
783 gcc_assert (size
!= -1);
785 align
= get_stack_local_alignment (type
, mode
);
787 /* Try to find an available, already-allocated temporary of the proper
788 mode which meets the size and alignment requirements. Choose the
789 smallest one with the closest alignment.
791 If assign_stack_temp is called outside of the tree->rtl expansion,
792 we cannot reuse the stack slots (that may still refer to
793 VIRTUAL_STACK_VARS_REGNUM). */
794 if (!virtuals_instantiated
)
796 for (p
= avail_temp_slots
; p
; p
= p
->next
)
798 if (p
->align
>= align
&& p
->size
>= size
799 && GET_MODE (p
->slot
) == mode
800 && objects_must_conflict_p (p
->type
, type
)
801 && (best_p
== 0 || best_p
->size
> p
->size
802 || (best_p
->size
== p
->size
&& best_p
->align
> p
->align
)))
804 if (p
->align
== align
&& p
->size
== size
)
807 cut_slot_from_list (selected
, &avail_temp_slots
);
816 /* Make our best, if any, the one to use. */
820 cut_slot_from_list (selected
, &avail_temp_slots
);
822 /* If there are enough aligned bytes left over, make them into a new
823 temp_slot so that the extra bytes don't get wasted. Do this only
824 for BLKmode slots, so that we can be sure of the alignment. */
825 if (GET_MODE (best_p
->slot
) == BLKmode
)
827 int alignment
= best_p
->align
/ BITS_PER_UNIT
;
828 HOST_WIDE_INT rounded_size
= CEIL_ROUND (size
, alignment
);
830 if (best_p
->size
- rounded_size
>= alignment
)
832 p
= ggc_alloc
<temp_slot
> ();
834 p
->size
= best_p
->size
- rounded_size
;
835 p
->base_offset
= best_p
->base_offset
+ rounded_size
;
836 p
->full_size
= best_p
->full_size
- rounded_size
;
837 p
->slot
= adjust_address_nv (best_p
->slot
, BLKmode
, rounded_size
);
838 p
->align
= best_p
->align
;
839 p
->type
= best_p
->type
;
840 insert_slot_to_list (p
, &avail_temp_slots
);
842 stack_slot_list
= gen_rtx_EXPR_LIST (VOIDmode
, p
->slot
,
845 best_p
->size
= rounded_size
;
846 best_p
->full_size
= rounded_size
;
851 /* If we still didn't find one, make a new temporary. */
854 HOST_WIDE_INT frame_offset_old
= frame_offset
;
856 p
= ggc_alloc
<temp_slot
> ();
858 /* We are passing an explicit alignment request to assign_stack_local.
859 One side effect of that is assign_stack_local will not round SIZE
860 to ensure the frame offset remains suitably aligned.
862 So for requests which depended on the rounding of SIZE, we go ahead
863 and round it now. We also make sure ALIGNMENT is at least
864 BIGGEST_ALIGNMENT. */
865 gcc_assert (mode
!= BLKmode
|| align
== BIGGEST_ALIGNMENT
);
866 p
->slot
= assign_stack_local_1 (mode
,
876 /* The following slot size computation is necessary because we don't
877 know the actual size of the temporary slot until assign_stack_local
878 has performed all the frame alignment and size rounding for the
879 requested temporary. Note that extra space added for alignment
880 can be either above or below this stack slot depending on which
881 way the frame grows. We include the extra space if and only if it
882 is above this slot. */
883 if (FRAME_GROWS_DOWNWARD
)
884 p
->size
= frame_offset_old
- frame_offset
;
888 /* Now define the fields used by combine_temp_slots. */
889 if (FRAME_GROWS_DOWNWARD
)
891 p
->base_offset
= frame_offset
;
892 p
->full_size
= frame_offset_old
- frame_offset
;
896 p
->base_offset
= frame_offset_old
;
897 p
->full_size
= frame_offset
- frame_offset_old
;
906 p
->level
= temp_slot_level
;
907 n_temp_slots_in_use
++;
909 pp
= temp_slots_at_level (p
->level
);
910 insert_slot_to_list (p
, pp
);
911 insert_temp_slot_address (XEXP (p
->slot
, 0), p
);
913 /* Create a new MEM rtx to avoid clobbering MEM flags of old slots. */
914 slot
= gen_rtx_MEM (mode
, XEXP (p
->slot
, 0));
915 stack_slot_list
= gen_rtx_EXPR_LIST (VOIDmode
, slot
, stack_slot_list
);
917 /* If we know the alias set for the memory that will be used, use
918 it. If there's no TYPE, then we don't know anything about the
919 alias set for the memory. */
920 set_mem_alias_set (slot
, type
? get_alias_set (type
) : 0);
921 set_mem_align (slot
, align
);
923 /* If a type is specified, set the relevant flags. */
925 MEM_VOLATILE_P (slot
) = TYPE_VOLATILE (type
);
926 MEM_NOTRAP_P (slot
) = 1;
931 /* Allocate a temporary stack slot and record it for possible later
932 reuse. First two arguments are same as in preceding function. */
935 assign_stack_temp (machine_mode mode
, HOST_WIDE_INT size
)
937 return assign_stack_temp_for_type (mode
, size
, NULL_TREE
);
940 /* Assign a temporary.
941 If TYPE_OR_DECL is a decl, then we are doing it on behalf of the decl
942 and so that should be used in error messages. In either case, we
943 allocate of the given type.
944 MEMORY_REQUIRED is 1 if the result must be addressable stack memory;
945 it is 0 if a register is OK.
946 DONT_PROMOTE is 1 if we should not promote values in register
950 assign_temp (tree type_or_decl
, int memory_required
,
951 int dont_promote ATTRIBUTE_UNUSED
)
959 if (DECL_P (type_or_decl
))
960 decl
= type_or_decl
, type
= TREE_TYPE (decl
);
962 decl
= NULL
, type
= type_or_decl
;
964 mode
= TYPE_MODE (type
);
966 unsignedp
= TYPE_UNSIGNED (type
);
969 if (mode
== BLKmode
|| memory_required
)
971 HOST_WIDE_INT size
= int_size_in_bytes (type
);
974 /* Zero sized arrays are GNU C extension. Set size to 1 to avoid
975 problems with allocating the stack space. */
979 /* Unfortunately, we don't yet know how to allocate variable-sized
980 temporaries. However, sometimes we can find a fixed upper limit on
981 the size, so try that instead. */
983 size
= max_int_size_in_bytes (type
);
985 /* The size of the temporary may be too large to fit into an integer. */
986 /* ??? Not sure this should happen except for user silliness, so limit
987 this to things that aren't compiler-generated temporaries. The
988 rest of the time we'll die in assign_stack_temp_for_type. */
989 if (decl
&& size
== -1
990 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
)
992 error ("size of variable %q+D is too large", decl
);
996 tmp
= assign_stack_temp_for_type (mode
, size
, type
);
1002 mode
= promote_mode (type
, mode
, &unsignedp
);
1005 return gen_reg_rtx (mode
);
1008 /* Combine temporary stack slots which are adjacent on the stack.
1010 This allows for better use of already allocated stack space. This is only
1011 done for BLKmode slots because we can be sure that we won't have alignment
1012 problems in this case. */
1015 combine_temp_slots (void)
1017 struct temp_slot
*p
, *q
, *next
, *next_q
;
1020 /* We can't combine slots, because the information about which slot
1021 is in which alias set will be lost. */
1022 if (flag_strict_aliasing
)
1025 /* If there are a lot of temp slots, don't do anything unless
1026 high levels of optimization. */
1027 if (! flag_expensive_optimizations
)
1028 for (p
= avail_temp_slots
, num_slots
= 0; p
; p
= p
->next
, num_slots
++)
1029 if (num_slots
> 100 || (num_slots
> 10 && optimize
== 0))
1032 for (p
= avail_temp_slots
; p
; p
= next
)
1038 if (GET_MODE (p
->slot
) != BLKmode
)
1041 for (q
= p
->next
; q
; q
= next_q
)
1047 if (GET_MODE (q
->slot
) != BLKmode
)
1050 if (p
->base_offset
+ p
->full_size
== q
->base_offset
)
1052 /* Q comes after P; combine Q into P. */
1054 p
->full_size
+= q
->full_size
;
1057 else if (q
->base_offset
+ q
->full_size
== p
->base_offset
)
1059 /* P comes after Q; combine P into Q. */
1061 q
->full_size
+= p
->full_size
;
1066 cut_slot_from_list (q
, &avail_temp_slots
);
1069 /* Either delete P or advance past it. */
1071 cut_slot_from_list (p
, &avail_temp_slots
);
1075 /* Indicate that NEW_RTX is an alternate way of referring to the temp
1076 slot that previously was known by OLD_RTX. */
1079 update_temp_slot_address (rtx old_rtx
, rtx new_rtx
)
1081 struct temp_slot
*p
;
1083 if (rtx_equal_p (old_rtx
, new_rtx
))
1086 p
= find_temp_slot_from_address (old_rtx
);
1088 /* If we didn't find one, see if both OLD_RTX is a PLUS. If so, and
1089 NEW_RTX is a register, see if one operand of the PLUS is a
1090 temporary location. If so, NEW_RTX points into it. Otherwise,
1091 if both OLD_RTX and NEW_RTX are a PLUS and if there is a register
1092 in common between them. If so, try a recursive call on those
1096 if (GET_CODE (old_rtx
) != PLUS
)
1099 if (REG_P (new_rtx
))
1101 update_temp_slot_address (XEXP (old_rtx
, 0), new_rtx
);
1102 update_temp_slot_address (XEXP (old_rtx
, 1), new_rtx
);
1105 else if (GET_CODE (new_rtx
) != PLUS
)
1108 if (rtx_equal_p (XEXP (old_rtx
, 0), XEXP (new_rtx
, 0)))
1109 update_temp_slot_address (XEXP (old_rtx
, 1), XEXP (new_rtx
, 1));
1110 else if (rtx_equal_p (XEXP (old_rtx
, 1), XEXP (new_rtx
, 0)))
1111 update_temp_slot_address (XEXP (old_rtx
, 0), XEXP (new_rtx
, 1));
1112 else if (rtx_equal_p (XEXP (old_rtx
, 0), XEXP (new_rtx
, 1)))
1113 update_temp_slot_address (XEXP (old_rtx
, 1), XEXP (new_rtx
, 0));
1114 else if (rtx_equal_p (XEXP (old_rtx
, 1), XEXP (new_rtx
, 1)))
1115 update_temp_slot_address (XEXP (old_rtx
, 0), XEXP (new_rtx
, 0));
1120 /* Otherwise add an alias for the temp's address. */
1121 insert_temp_slot_address (new_rtx
, p
);
1124 /* If X could be a reference to a temporary slot, mark that slot as
1125 belonging to the to one level higher than the current level. If X
1126 matched one of our slots, just mark that one. Otherwise, we can't
1127 easily predict which it is, so upgrade all of them.
1129 This is called when an ({...}) construct occurs and a statement
1130 returns a value in memory. */
1133 preserve_temp_slots (rtx x
)
1135 struct temp_slot
*p
= 0, *next
;
1140 /* If X is a register that is being used as a pointer, see if we have
1141 a temporary slot we know it points to. */
1142 if (REG_P (x
) && REG_POINTER (x
))
1143 p
= find_temp_slot_from_address (x
);
1145 /* If X is not in memory or is at a constant address, it cannot be in
1146 a temporary slot. */
1147 if (p
== 0 && (!MEM_P (x
) || CONSTANT_P (XEXP (x
, 0))))
1150 /* First see if we can find a match. */
1152 p
= find_temp_slot_from_address (XEXP (x
, 0));
1156 if (p
->level
== temp_slot_level
)
1157 move_slot_to_level (p
, temp_slot_level
- 1);
1161 /* Otherwise, preserve all non-kept slots at this level. */
1162 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1165 move_slot_to_level (p
, temp_slot_level
- 1);
1169 /* Free all temporaries used so far. This is normally called at the
1170 end of generating code for a statement. */
1173 free_temp_slots (void)
1175 struct temp_slot
*p
, *next
;
1176 bool some_available
= false;
1178 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1181 make_slot_available (p
);
1182 some_available
= true;
1187 remove_unused_temp_slot_addresses ();
1188 combine_temp_slots ();
1192 /* Push deeper into the nesting level for stack temporaries. */
1195 push_temp_slots (void)
1200 /* Pop a temporary nesting level. All slots in use in the current level
1204 pop_temp_slots (void)
1210 /* Initialize temporary slots. */
1213 init_temp_slots (void)
1215 /* We have not allocated any temporaries yet. */
1216 avail_temp_slots
= 0;
1217 vec_alloc (used_temp_slots
, 0);
1218 temp_slot_level
= 0;
1219 n_temp_slots_in_use
= 0;
1221 /* Set up the table to map addresses to temp slots. */
1222 if (! temp_slot_address_table
)
1223 temp_slot_address_table
= hash_table
<temp_address_hasher
>::create_ggc (32);
1225 temp_slot_address_table
->empty ();
1228 /* Functions and data structures to keep track of the values hard regs
1229 had at the start of the function. */
1231 /* Private type used by get_hard_reg_initial_reg, get_hard_reg_initial_val,
1232 and has_hard_reg_initial_val.. */
1233 typedef struct GTY(()) initial_value_pair
{
1236 } initial_value_pair
;
1237 /* ??? This could be a VEC but there is currently no way to define an
1238 opaque VEC type. This could be worked around by defining struct
1239 initial_value_pair in function.h. */
1240 typedef struct GTY(()) initial_value_struct
{
1243 initial_value_pair
* GTY ((length ("%h.num_entries"))) entries
;
1244 } initial_value_struct
;
1246 /* If a pseudo represents an initial hard reg (or expression), return
1247 it, else return NULL_RTX. */
1250 get_hard_reg_initial_reg (rtx reg
)
1252 struct initial_value_struct
*ivs
= crtl
->hard_reg_initial_vals
;
1258 for (i
= 0; i
< ivs
->num_entries
; i
++)
1259 if (rtx_equal_p (ivs
->entries
[i
].pseudo
, reg
))
1260 return ivs
->entries
[i
].hard_reg
;
1265 /* Make sure that there's a pseudo register of mode MODE that stores the
1266 initial value of hard register REGNO. Return an rtx for such a pseudo. */
1269 get_hard_reg_initial_val (machine_mode mode
, unsigned int regno
)
1271 struct initial_value_struct
*ivs
;
1274 rv
= has_hard_reg_initial_val (mode
, regno
);
1278 ivs
= crtl
->hard_reg_initial_vals
;
1281 ivs
= ggc_alloc
<initial_value_struct
> ();
1282 ivs
->num_entries
= 0;
1283 ivs
->max_entries
= 5;
1284 ivs
->entries
= ggc_vec_alloc
<initial_value_pair
> (5);
1285 crtl
->hard_reg_initial_vals
= ivs
;
1288 if (ivs
->num_entries
>= ivs
->max_entries
)
1290 ivs
->max_entries
+= 5;
1291 ivs
->entries
= GGC_RESIZEVEC (initial_value_pair
, ivs
->entries
,
1295 ivs
->entries
[ivs
->num_entries
].hard_reg
= gen_rtx_REG (mode
, regno
);
1296 ivs
->entries
[ivs
->num_entries
].pseudo
= gen_reg_rtx (mode
);
1298 return ivs
->entries
[ivs
->num_entries
++].pseudo
;
1301 /* See if get_hard_reg_initial_val has been used to create a pseudo
1302 for the initial value of hard register REGNO in mode MODE. Return
1303 the associated pseudo if so, otherwise return NULL. */
1306 has_hard_reg_initial_val (machine_mode mode
, unsigned int regno
)
1308 struct initial_value_struct
*ivs
;
1311 ivs
= crtl
->hard_reg_initial_vals
;
1313 for (i
= 0; i
< ivs
->num_entries
; i
++)
1314 if (GET_MODE (ivs
->entries
[i
].hard_reg
) == mode
1315 && REGNO (ivs
->entries
[i
].hard_reg
) == regno
)
1316 return ivs
->entries
[i
].pseudo
;
1322 emit_initial_value_sets (void)
1324 struct initial_value_struct
*ivs
= crtl
->hard_reg_initial_vals
;
1332 for (i
= 0; i
< ivs
->num_entries
; i
++)
1333 emit_move_insn (ivs
->entries
[i
].pseudo
, ivs
->entries
[i
].hard_reg
);
1337 emit_insn_at_entry (seq
);
1341 /* Return the hardreg-pseudoreg initial values pair entry I and
1342 TRUE if I is a valid entry, or FALSE if I is not a valid entry. */
1344 initial_value_entry (int i
, rtx
*hreg
, rtx
*preg
)
1346 struct initial_value_struct
*ivs
= crtl
->hard_reg_initial_vals
;
1347 if (!ivs
|| i
>= ivs
->num_entries
)
1350 *hreg
= ivs
->entries
[i
].hard_reg
;
1351 *preg
= ivs
->entries
[i
].pseudo
;
1355 /* These routines are responsible for converting virtual register references
1356 to the actual hard register references once RTL generation is complete.
1358 The following four variables are used for communication between the
1359 routines. They contain the offsets of the virtual registers from their
1360 respective hard registers. */
1362 static int in_arg_offset
;
1363 static int var_offset
;
1364 static int dynamic_offset
;
1365 static int out_arg_offset
;
1366 static int cfa_offset
;
1368 /* In most machines, the stack pointer register is equivalent to the bottom
1371 #ifndef STACK_POINTER_OFFSET
1372 #define STACK_POINTER_OFFSET 0
1375 #if defined (REG_PARM_STACK_SPACE) && !defined (INCOMING_REG_PARM_STACK_SPACE)
1376 #define INCOMING_REG_PARM_STACK_SPACE REG_PARM_STACK_SPACE
1379 /* If not defined, pick an appropriate default for the offset of dynamically
1380 allocated memory depending on the value of ACCUMULATE_OUTGOING_ARGS,
1381 INCOMING_REG_PARM_STACK_SPACE, and OUTGOING_REG_PARM_STACK_SPACE. */
1383 #ifndef STACK_DYNAMIC_OFFSET
1385 /* The bottom of the stack points to the actual arguments. If
1386 REG_PARM_STACK_SPACE is defined, this includes the space for the register
1387 parameters. However, if OUTGOING_REG_PARM_STACK space is not defined,
1388 stack space for register parameters is not pushed by the caller, but
1389 rather part of the fixed stack areas and hence not included in
1390 `crtl->outgoing_args_size'. Nevertheless, we must allow
1391 for it when allocating stack dynamic objects. */
1393 #ifdef INCOMING_REG_PARM_STACK_SPACE
1394 #define STACK_DYNAMIC_OFFSET(FNDECL) \
1395 ((ACCUMULATE_OUTGOING_ARGS \
1396 ? (crtl->outgoing_args_size \
1397 + (OUTGOING_REG_PARM_STACK_SPACE ((!(FNDECL) ? NULL_TREE : TREE_TYPE (FNDECL))) ? 0 \
1398 : INCOMING_REG_PARM_STACK_SPACE (FNDECL))) \
1399 : 0) + (STACK_POINTER_OFFSET))
1401 #define STACK_DYNAMIC_OFFSET(FNDECL) \
1402 ((ACCUMULATE_OUTGOING_ARGS ? crtl->outgoing_args_size : 0) \
1403 + (STACK_POINTER_OFFSET))
1408 /* Given a piece of RTX and a pointer to a HOST_WIDE_INT, if the RTX
1409 is a virtual register, return the equivalent hard register and set the
1410 offset indirectly through the pointer. Otherwise, return 0. */
1413 instantiate_new_reg (rtx x
, HOST_WIDE_INT
*poffset
)
1416 HOST_WIDE_INT offset
;
1418 if (x
== virtual_incoming_args_rtx
)
1420 if (stack_realign_drap
)
1422 /* Replace virtual_incoming_args_rtx with internal arg
1423 pointer if DRAP is used to realign stack. */
1424 new_rtx
= crtl
->args
.internal_arg_pointer
;
1428 new_rtx
= arg_pointer_rtx
, offset
= in_arg_offset
;
1430 else if (x
== virtual_stack_vars_rtx
)
1431 new_rtx
= frame_pointer_rtx
, offset
= var_offset
;
1432 else if (x
== virtual_stack_dynamic_rtx
)
1433 new_rtx
= stack_pointer_rtx
, offset
= dynamic_offset
;
1434 else if (x
== virtual_outgoing_args_rtx
)
1435 new_rtx
= stack_pointer_rtx
, offset
= out_arg_offset
;
1436 else if (x
== virtual_cfa_rtx
)
1438 #ifdef FRAME_POINTER_CFA_OFFSET
1439 new_rtx
= frame_pointer_rtx
;
1441 new_rtx
= arg_pointer_rtx
;
1443 offset
= cfa_offset
;
1445 else if (x
== virtual_preferred_stack_boundary_rtx
)
1447 new_rtx
= GEN_INT (crtl
->preferred_stack_boundary
/ BITS_PER_UNIT
);
1457 /* A subroutine of instantiate_virtual_regs. Instantiate any virtual
1458 registers present inside of *LOC. The expression is simplified,
1459 as much as possible, but is not to be considered "valid" in any sense
1460 implied by the target. Return true if any change is made. */
1463 instantiate_virtual_regs_in_rtx (rtx
*loc
)
1467 bool changed
= false;
1468 subrtx_ptr_iterator::array_type array
;
1469 FOR_EACH_SUBRTX_PTR (iter
, array
, loc
, NONCONST
)
1475 HOST_WIDE_INT offset
;
1476 switch (GET_CODE (x
))
1479 new_rtx
= instantiate_new_reg (x
, &offset
);
1482 *loc
= plus_constant (GET_MODE (x
), new_rtx
, offset
);
1485 iter
.skip_subrtxes ();
1489 new_rtx
= instantiate_new_reg (XEXP (x
, 0), &offset
);
1492 XEXP (x
, 0) = new_rtx
;
1493 *loc
= plus_constant (GET_MODE (x
), x
, offset
, true);
1495 iter
.skip_subrtxes ();
1499 /* FIXME -- from old code */
1500 /* If we have (plus (subreg (virtual-reg)) (const_int)), we know
1501 we can commute the PLUS and SUBREG because pointers into the
1502 frame are well-behaved. */
1513 /* A subroutine of instantiate_virtual_regs_in_insn. Return true if X
1514 matches the predicate for insn CODE operand OPERAND. */
1517 safe_insn_predicate (int code
, int operand
, rtx x
)
1519 return code
< 0 || insn_operand_matches ((enum insn_code
) code
, operand
, x
);
1522 /* A subroutine of instantiate_virtual_regs. Instantiate any virtual
1523 registers present inside of insn. The result will be a valid insn. */
1526 instantiate_virtual_regs_in_insn (rtx_insn
*insn
)
1528 HOST_WIDE_INT offset
;
1530 bool any_change
= false;
1531 rtx set
, new_rtx
, x
;
1534 /* There are some special cases to be handled first. */
1535 set
= single_set (insn
);
1538 /* We're allowed to assign to a virtual register. This is interpreted
1539 to mean that the underlying register gets assigned the inverse
1540 transformation. This is used, for example, in the handling of
1542 new_rtx
= instantiate_new_reg (SET_DEST (set
), &offset
);
1547 instantiate_virtual_regs_in_rtx (&SET_SRC (set
));
1548 x
= simplify_gen_binary (PLUS
, GET_MODE (new_rtx
), SET_SRC (set
),
1549 gen_int_mode (-offset
, GET_MODE (new_rtx
)));
1550 x
= force_operand (x
, new_rtx
);
1552 emit_move_insn (new_rtx
, x
);
1557 emit_insn_before (seq
, insn
);
1562 /* Handle a straight copy from a virtual register by generating a
1563 new add insn. The difference between this and falling through
1564 to the generic case is avoiding a new pseudo and eliminating a
1565 move insn in the initial rtl stream. */
1566 new_rtx
= instantiate_new_reg (SET_SRC (set
), &offset
);
1567 if (new_rtx
&& offset
!= 0
1568 && REG_P (SET_DEST (set
))
1569 && REGNO (SET_DEST (set
)) > LAST_VIRTUAL_REGISTER
)
1573 x
= expand_simple_binop (GET_MODE (SET_DEST (set
)), PLUS
, new_rtx
,
1574 gen_int_mode (offset
,
1575 GET_MODE (SET_DEST (set
))),
1576 SET_DEST (set
), 1, OPTAB_LIB_WIDEN
);
1577 if (x
!= SET_DEST (set
))
1578 emit_move_insn (SET_DEST (set
), x
);
1583 emit_insn_before (seq
, insn
);
1588 extract_insn (insn
);
1589 insn_code
= INSN_CODE (insn
);
1591 /* Handle a plus involving a virtual register by determining if the
1592 operands remain valid if they're modified in place. */
1593 if (GET_CODE (SET_SRC (set
)) == PLUS
1594 && recog_data
.n_operands
>= 3
1595 && recog_data
.operand_loc
[1] == &XEXP (SET_SRC (set
), 0)
1596 && recog_data
.operand_loc
[2] == &XEXP (SET_SRC (set
), 1)
1597 && CONST_INT_P (recog_data
.operand
[2])
1598 && (new_rtx
= instantiate_new_reg (recog_data
.operand
[1], &offset
)))
1600 offset
+= INTVAL (recog_data
.operand
[2]);
1602 /* If the sum is zero, then replace with a plain move. */
1604 && REG_P (SET_DEST (set
))
1605 && REGNO (SET_DEST (set
)) > LAST_VIRTUAL_REGISTER
)
1608 emit_move_insn (SET_DEST (set
), new_rtx
);
1612 emit_insn_before (seq
, insn
);
1617 x
= gen_int_mode (offset
, recog_data
.operand_mode
[2]);
1619 /* Using validate_change and apply_change_group here leaves
1620 recog_data in an invalid state. Since we know exactly what
1621 we want to check, do those two by hand. */
1622 if (safe_insn_predicate (insn_code
, 1, new_rtx
)
1623 && safe_insn_predicate (insn_code
, 2, x
))
1625 *recog_data
.operand_loc
[1] = recog_data
.operand
[1] = new_rtx
;
1626 *recog_data
.operand_loc
[2] = recog_data
.operand
[2] = x
;
1629 /* Fall through into the regular operand fixup loop in
1630 order to take care of operands other than 1 and 2. */
1636 extract_insn (insn
);
1637 insn_code
= INSN_CODE (insn
);
1640 /* In the general case, we expect virtual registers to appear only in
1641 operands, and then only as either bare registers or inside memories. */
1642 for (i
= 0; i
< recog_data
.n_operands
; ++i
)
1644 x
= recog_data
.operand
[i
];
1645 switch (GET_CODE (x
))
1649 rtx addr
= XEXP (x
, 0);
1651 if (!instantiate_virtual_regs_in_rtx (&addr
))
1655 x
= replace_equiv_address (x
, addr
, true);
1656 /* It may happen that the address with the virtual reg
1657 was valid (e.g. based on the virtual stack reg, which might
1658 be acceptable to the predicates with all offsets), whereas
1659 the address now isn't anymore, for instance when the address
1660 is still offsetted, but the base reg isn't virtual-stack-reg
1661 anymore. Below we would do a force_reg on the whole operand,
1662 but this insn might actually only accept memory. Hence,
1663 before doing that last resort, try to reload the address into
1664 a register, so this operand stays a MEM. */
1665 if (!safe_insn_predicate (insn_code
, i
, x
))
1667 addr
= force_reg (GET_MODE (addr
), addr
);
1668 x
= replace_equiv_address (x
, addr
, true);
1673 emit_insn_before (seq
, insn
);
1678 new_rtx
= instantiate_new_reg (x
, &offset
);
1679 if (new_rtx
== NULL
)
1687 /* Careful, special mode predicates may have stuff in
1688 insn_data[insn_code].operand[i].mode that isn't useful
1689 to us for computing a new value. */
1690 /* ??? Recognize address_operand and/or "p" constraints
1691 to see if (plus new offset) is a valid before we put
1692 this through expand_simple_binop. */
1693 x
= expand_simple_binop (GET_MODE (x
), PLUS
, new_rtx
,
1694 gen_int_mode (offset
, GET_MODE (x
)),
1695 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
1698 emit_insn_before (seq
, insn
);
1703 new_rtx
= instantiate_new_reg (SUBREG_REG (x
), &offset
);
1704 if (new_rtx
== NULL
)
1709 new_rtx
= expand_simple_binop
1710 (GET_MODE (new_rtx
), PLUS
, new_rtx
,
1711 gen_int_mode (offset
, GET_MODE (new_rtx
)),
1712 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
1715 emit_insn_before (seq
, insn
);
1717 x
= simplify_gen_subreg (recog_data
.operand_mode
[i
], new_rtx
,
1718 GET_MODE (new_rtx
), SUBREG_BYTE (x
));
1726 /* At this point, X contains the new value for the operand.
1727 Validate the new value vs the insn predicate. Note that
1728 asm insns will have insn_code -1 here. */
1729 if (!safe_insn_predicate (insn_code
, i
, x
))
1734 gcc_assert (REGNO (x
) <= LAST_VIRTUAL_REGISTER
);
1735 x
= copy_to_reg (x
);
1738 x
= force_reg (insn_data
[insn_code
].operand
[i
].mode
, x
);
1742 emit_insn_before (seq
, insn
);
1745 *recog_data
.operand_loc
[i
] = recog_data
.operand
[i
] = x
;
1751 /* Propagate operand changes into the duplicates. */
1752 for (i
= 0; i
< recog_data
.n_dups
; ++i
)
1753 *recog_data
.dup_loc
[i
]
1754 = copy_rtx (recog_data
.operand
[(unsigned)recog_data
.dup_num
[i
]]);
1756 /* Force re-recognition of the instruction for validation. */
1757 INSN_CODE (insn
) = -1;
1760 if (asm_noperands (PATTERN (insn
)) >= 0)
1762 if (!check_asm_operands (PATTERN (insn
)))
1764 error_for_asm (insn
, "impossible constraint in %<asm%>");
1765 /* For asm goto, instead of fixing up all the edges
1766 just clear the template and clear input operands
1767 (asm goto doesn't have any output operands). */
1770 rtx asm_op
= extract_asm_operands (PATTERN (insn
));
1771 ASM_OPERANDS_TEMPLATE (asm_op
) = ggc_strdup ("");
1772 ASM_OPERANDS_INPUT_VEC (asm_op
) = rtvec_alloc (0);
1773 ASM_OPERANDS_INPUT_CONSTRAINT_VEC (asm_op
) = rtvec_alloc (0);
1781 if (recog_memoized (insn
) < 0)
1782 fatal_insn_not_found (insn
);
1786 /* Subroutine of instantiate_decls. Given RTL representing a decl,
1787 do any instantiation required. */
1790 instantiate_decl_rtl (rtx x
)
1797 /* If this is a CONCAT, recurse for the pieces. */
1798 if (GET_CODE (x
) == CONCAT
)
1800 instantiate_decl_rtl (XEXP (x
, 0));
1801 instantiate_decl_rtl (XEXP (x
, 1));
1805 /* If this is not a MEM, no need to do anything. Similarly if the
1806 address is a constant or a register that is not a virtual register. */
1811 if (CONSTANT_P (addr
)
1813 && (REGNO (addr
) < FIRST_VIRTUAL_REGISTER
1814 || REGNO (addr
) > LAST_VIRTUAL_REGISTER
)))
1817 instantiate_virtual_regs_in_rtx (&XEXP (x
, 0));
1820 /* Helper for instantiate_decls called via walk_tree: Process all decls
1821 in the given DECL_VALUE_EXPR. */
1824 instantiate_expr (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
1832 if (DECL_RTL_SET_P (t
))
1833 instantiate_decl_rtl (DECL_RTL (t
));
1834 if (TREE_CODE (t
) == PARM_DECL
&& DECL_NAMELESS (t
)
1835 && DECL_INCOMING_RTL (t
))
1836 instantiate_decl_rtl (DECL_INCOMING_RTL (t
));
1837 if ((TREE_CODE (t
) == VAR_DECL
1838 || TREE_CODE (t
) == RESULT_DECL
)
1839 && DECL_HAS_VALUE_EXPR_P (t
))
1841 tree v
= DECL_VALUE_EXPR (t
);
1842 walk_tree (&v
, instantiate_expr
, NULL
, NULL
);
1849 /* Subroutine of instantiate_decls: Process all decls in the given
1850 BLOCK node and all its subblocks. */
1853 instantiate_decls_1 (tree let
)
1857 for (t
= BLOCK_VARS (let
); t
; t
= DECL_CHAIN (t
))
1859 if (DECL_RTL_SET_P (t
))
1860 instantiate_decl_rtl (DECL_RTL (t
));
1861 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (t
))
1863 tree v
= DECL_VALUE_EXPR (t
);
1864 walk_tree (&v
, instantiate_expr
, NULL
, NULL
);
1868 /* Process all subblocks. */
1869 for (t
= BLOCK_SUBBLOCKS (let
); t
; t
= BLOCK_CHAIN (t
))
1870 instantiate_decls_1 (t
);
1873 /* Scan all decls in FNDECL (both variables and parameters) and instantiate
1874 all virtual registers in their DECL_RTL's. */
1877 instantiate_decls (tree fndecl
)
1882 /* Process all parameters of the function. */
1883 for (decl
= DECL_ARGUMENTS (fndecl
); decl
; decl
= DECL_CHAIN (decl
))
1885 instantiate_decl_rtl (DECL_RTL (decl
));
1886 instantiate_decl_rtl (DECL_INCOMING_RTL (decl
));
1887 if (DECL_HAS_VALUE_EXPR_P (decl
))
1889 tree v
= DECL_VALUE_EXPR (decl
);
1890 walk_tree (&v
, instantiate_expr
, NULL
, NULL
);
1894 if ((decl
= DECL_RESULT (fndecl
))
1895 && TREE_CODE (decl
) == RESULT_DECL
)
1897 if (DECL_RTL_SET_P (decl
))
1898 instantiate_decl_rtl (DECL_RTL (decl
));
1899 if (DECL_HAS_VALUE_EXPR_P (decl
))
1901 tree v
= DECL_VALUE_EXPR (decl
);
1902 walk_tree (&v
, instantiate_expr
, NULL
, NULL
);
1906 /* Process the saved static chain if it exists. */
1907 decl
= DECL_STRUCT_FUNCTION (fndecl
)->static_chain_decl
;
1908 if (decl
&& DECL_HAS_VALUE_EXPR_P (decl
))
1909 instantiate_decl_rtl (DECL_RTL (DECL_VALUE_EXPR (decl
)));
1911 /* Now process all variables defined in the function or its subblocks. */
1912 instantiate_decls_1 (DECL_INITIAL (fndecl
));
1914 FOR_EACH_LOCAL_DECL (cfun
, ix
, decl
)
1915 if (DECL_RTL_SET_P (decl
))
1916 instantiate_decl_rtl (DECL_RTL (decl
));
1917 vec_free (cfun
->local_decls
);
1920 /* Pass through the INSNS of function FNDECL and convert virtual register
1921 references to hard register references. */
1924 instantiate_virtual_regs (void)
1928 /* Compute the offsets to use for this function. */
1929 in_arg_offset
= FIRST_PARM_OFFSET (current_function_decl
);
1930 var_offset
= STARTING_FRAME_OFFSET
;
1931 dynamic_offset
= STACK_DYNAMIC_OFFSET (current_function_decl
);
1932 out_arg_offset
= STACK_POINTER_OFFSET
;
1933 #ifdef FRAME_POINTER_CFA_OFFSET
1934 cfa_offset
= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
1936 cfa_offset
= ARG_POINTER_CFA_OFFSET (current_function_decl
);
1939 /* Initialize recognition, indicating that volatile is OK. */
1942 /* Scan through all the insns, instantiating every virtual register still
1944 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1947 /* These patterns in the instruction stream can never be recognized.
1948 Fortunately, they shouldn't contain virtual registers either. */
1949 if (GET_CODE (PATTERN (insn
)) == USE
1950 || GET_CODE (PATTERN (insn
)) == CLOBBER
1951 || GET_CODE (PATTERN (insn
)) == ASM_INPUT
)
1953 else if (DEBUG_INSN_P (insn
))
1954 instantiate_virtual_regs_in_rtx (&INSN_VAR_LOCATION (insn
));
1956 instantiate_virtual_regs_in_insn (insn
);
1958 if (insn
->deleted ())
1961 instantiate_virtual_regs_in_rtx (®_NOTES (insn
));
1963 /* Instantiate any virtual registers in CALL_INSN_FUNCTION_USAGE. */
1965 instantiate_virtual_regs_in_rtx (&CALL_INSN_FUNCTION_USAGE (insn
));
1968 /* Instantiate the virtual registers in the DECLs for debugging purposes. */
1969 instantiate_decls (current_function_decl
);
1971 targetm
.instantiate_decls ();
1973 /* Indicate that, from now on, assign_stack_local should use
1974 frame_pointer_rtx. */
1975 virtuals_instantiated
= 1;
1982 const pass_data pass_data_instantiate_virtual_regs
=
1984 RTL_PASS
, /* type */
1986 OPTGROUP_NONE
, /* optinfo_flags */
1987 TV_NONE
, /* tv_id */
1988 0, /* properties_required */
1989 0, /* properties_provided */
1990 0, /* properties_destroyed */
1991 0, /* todo_flags_start */
1992 0, /* todo_flags_finish */
1995 class pass_instantiate_virtual_regs
: public rtl_opt_pass
1998 pass_instantiate_virtual_regs (gcc::context
*ctxt
)
1999 : rtl_opt_pass (pass_data_instantiate_virtual_regs
, ctxt
)
2002 /* opt_pass methods: */
2003 virtual unsigned int execute (function
*)
2005 return instantiate_virtual_regs ();
2008 }; // class pass_instantiate_virtual_regs
2013 make_pass_instantiate_virtual_regs (gcc::context
*ctxt
)
2015 return new pass_instantiate_virtual_regs (ctxt
);
2019 /* Return 1 if EXP is an aggregate type (or a value with aggregate type).
2020 This means a type for which function calls must pass an address to the
2021 function or get an address back from the function.
2022 EXP may be a type node or an expression (whose type is tested). */
2025 aggregate_value_p (const_tree exp
, const_tree fntype
)
2027 const_tree type
= (TYPE_P (exp
)) ? exp
: TREE_TYPE (exp
);
2028 int i
, regno
, nregs
;
2032 switch (TREE_CODE (fntype
))
2036 tree fndecl
= get_callee_fndecl (fntype
);
2038 fntype
= TREE_TYPE (fndecl
);
2039 else if (CALL_EXPR_FN (fntype
))
2040 fntype
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (fntype
)));
2042 /* For internal functions, assume nothing needs to be
2043 returned in memory. */
2048 fntype
= TREE_TYPE (fntype
);
2053 case IDENTIFIER_NODE
:
2057 /* We don't expect other tree types here. */
2061 if (VOID_TYPE_P (type
))
2064 /* If a record should be passed the same as its first (and only) member
2065 don't pass it as an aggregate. */
2066 if (TREE_CODE (type
) == RECORD_TYPE
&& TYPE_TRANSPARENT_AGGR (type
))
2067 return aggregate_value_p (first_field (type
), fntype
);
2069 /* If the front end has decided that this needs to be passed by
2070 reference, do so. */
2071 if ((TREE_CODE (exp
) == PARM_DECL
|| TREE_CODE (exp
) == RESULT_DECL
)
2072 && DECL_BY_REFERENCE (exp
))
2075 /* Function types that are TREE_ADDRESSABLE force return in memory. */
2076 if (fntype
&& TREE_ADDRESSABLE (fntype
))
2079 /* Types that are TREE_ADDRESSABLE must be constructed in memory,
2080 and thus can't be returned in registers. */
2081 if (TREE_ADDRESSABLE (type
))
2084 if (flag_pcc_struct_return
&& AGGREGATE_TYPE_P (type
))
2087 if (targetm
.calls
.return_in_memory (type
, fntype
))
2090 /* Make sure we have suitable call-clobbered regs to return
2091 the value in; if not, we must return it in memory. */
2092 reg
= hard_function_value (type
, 0, fntype
, 0);
2094 /* If we have something other than a REG (e.g. a PARALLEL), then assume
2099 regno
= REGNO (reg
);
2100 nregs
= hard_regno_nregs
[regno
][TYPE_MODE (type
)];
2101 for (i
= 0; i
< nregs
; i
++)
2102 if (! call_used_regs
[regno
+ i
])
2108 /* Return true if we should assign DECL a pseudo register; false if it
2109 should live on the local stack. */
2112 use_register_for_decl (const_tree decl
)
2114 if (TREE_CODE (decl
) == SSA_NAME
)
2116 /* We often try to use the SSA_NAME, instead of its underlying
2117 decl, to get type information and guide decisions, to avoid
2118 differences of behavior between anonymous and named
2119 variables, but in this one case we have to go for the actual
2120 variable if there is one. The main reason is that, at least
2121 at -O0, we want to place user variables on the stack, but we
2122 don't mind using pseudos for anonymous or ignored temps.
2123 Should we take the SSA_NAME, we'd conclude all SSA_NAMEs
2124 should go in pseudos, whereas their corresponding variables
2125 might have to go on the stack. So, disregarding the decl
2126 here would negatively impact debug info at -O0, enable
2127 coalescing between SSA_NAMEs that ought to get different
2128 stack/pseudo assignments, and get the incoming argument
2129 processing thoroughly confused by PARM_DECLs expected to live
2130 in stack slots but assigned to pseudos. */
2131 if (!SSA_NAME_VAR (decl
))
2132 return TYPE_MODE (TREE_TYPE (decl
)) != BLKmode
2133 && !(flag_float_store
&& FLOAT_TYPE_P (TREE_TYPE (decl
)));
2135 decl
= SSA_NAME_VAR (decl
);
2138 /* Honor volatile. */
2139 if (TREE_SIDE_EFFECTS (decl
))
2142 /* Honor addressability. */
2143 if (TREE_ADDRESSABLE (decl
))
2146 /* Decl is implicitly addressible by bound stores and loads
2147 if it is an aggregate holding bounds. */
2148 if (chkp_function_instrumented_p (current_function_decl
)
2150 && !BOUNDED_P (decl
)
2151 && chkp_type_has_pointer (TREE_TYPE (decl
)))
2154 /* Only register-like things go in registers. */
2155 if (DECL_MODE (decl
) == BLKmode
)
2158 /* If -ffloat-store specified, don't put explicit float variables
2160 /* ??? This should be checked after DECL_ARTIFICIAL, but tree-ssa
2161 propagates values across these stores, and it probably shouldn't. */
2162 if (flag_float_store
&& FLOAT_TYPE_P (TREE_TYPE (decl
)))
2165 if (!targetm
.calls
.allocate_stack_slots_for_args ())
2168 /* If we're not interested in tracking debugging information for
2169 this decl, then we can certainly put it in a register. */
2170 if (DECL_IGNORED_P (decl
))
2176 if (!DECL_REGISTER (decl
))
2179 switch (TREE_CODE (TREE_TYPE (decl
)))
2183 case QUAL_UNION_TYPE
:
2184 /* When not optimizing, disregard register keyword for variables with
2185 types containing methods, otherwise the methods won't be callable
2186 from the debugger. */
2187 if (TYPE_METHODS (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))))
2197 /* Structures to communicate between the subroutines of assign_parms.
2198 The first holds data persistent across all parameters, the second
2199 is cleared out for each parameter. */
2201 struct assign_parm_data_all
2203 /* When INIT_CUMULATIVE_ARGS gets revamped, allocating CUMULATIVE_ARGS
2204 should become a job of the target or otherwise encapsulated. */
2205 CUMULATIVE_ARGS args_so_far_v
;
2206 cumulative_args_t args_so_far
;
2207 struct args_size stack_args_size
;
2208 tree function_result_decl
;
2210 rtx_insn
*first_conversion_insn
;
2211 rtx_insn
*last_conversion_insn
;
2212 HOST_WIDE_INT pretend_args_size
;
2213 HOST_WIDE_INT extra_pretend_bytes
;
2214 int reg_parm_stack_space
;
2217 struct assign_parm_data_one
2223 machine_mode nominal_mode
;
2224 machine_mode passed_mode
;
2225 machine_mode promoted_mode
;
2226 struct locate_and_pad_arg_data locate
;
2228 BOOL_BITFIELD named_arg
: 1;
2229 BOOL_BITFIELD passed_pointer
: 1;
2230 BOOL_BITFIELD on_stack
: 1;
2231 BOOL_BITFIELD loaded_in_reg
: 1;
2234 struct bounds_parm_data
2236 assign_parm_data_one parm_data
;
2243 /* A subroutine of assign_parms. Initialize ALL. */
2246 assign_parms_initialize_all (struct assign_parm_data_all
*all
)
2248 tree fntype ATTRIBUTE_UNUSED
;
2250 memset (all
, 0, sizeof (*all
));
2252 fntype
= TREE_TYPE (current_function_decl
);
2254 #ifdef INIT_CUMULATIVE_INCOMING_ARGS
2255 INIT_CUMULATIVE_INCOMING_ARGS (all
->args_so_far_v
, fntype
, NULL_RTX
);
2257 INIT_CUMULATIVE_ARGS (all
->args_so_far_v
, fntype
, NULL_RTX
,
2258 current_function_decl
, -1);
2260 all
->args_so_far
= pack_cumulative_args (&all
->args_so_far_v
);
2262 #ifdef INCOMING_REG_PARM_STACK_SPACE
2263 all
->reg_parm_stack_space
2264 = INCOMING_REG_PARM_STACK_SPACE (current_function_decl
);
2268 /* If ARGS contains entries with complex types, split the entry into two
2269 entries of the component type. Return a new list of substitutions are
2270 needed, else the old list. */
2273 split_complex_args (struct assign_parm_data_all
*all
, vec
<tree
> *args
)
2278 FOR_EACH_VEC_ELT (*args
, i
, p
)
2280 tree type
= TREE_TYPE (p
);
2281 if (TREE_CODE (type
) == COMPLEX_TYPE
2282 && targetm
.calls
.split_complex_arg (type
))
2286 tree subtype
= TREE_TYPE (type
);
2287 bool addressable
= TREE_ADDRESSABLE (p
);
2289 /* Rewrite the PARM_DECL's type with its component. */
2291 TREE_TYPE (p
) = subtype
;
2292 DECL_ARG_TYPE (p
) = TREE_TYPE (DECL_ARG_TYPE (p
));
2293 DECL_MODE (p
) = VOIDmode
;
2294 DECL_SIZE (p
) = NULL
;
2295 DECL_SIZE_UNIT (p
) = NULL
;
2296 /* If this arg must go in memory, put it in a pseudo here.
2297 We can't allow it to go in memory as per normal parms,
2298 because the usual place might not have the imag part
2299 adjacent to the real part. */
2300 DECL_ARTIFICIAL (p
) = addressable
;
2301 DECL_IGNORED_P (p
) = addressable
;
2302 TREE_ADDRESSABLE (p
) = 0;
2303 /* Reset the RTL before layout_decl, or it may change the
2304 mode of the RTL of the original argument copied to P. */
2305 SET_DECL_RTL (p
, NULL_RTX
);
2309 /* Build a second synthetic decl. */
2310 decl
= build_decl (EXPR_LOCATION (p
),
2311 PARM_DECL
, NULL_TREE
, subtype
);
2312 DECL_ARG_TYPE (decl
) = DECL_ARG_TYPE (p
);
2313 DECL_ARTIFICIAL (decl
) = addressable
;
2314 DECL_IGNORED_P (decl
) = addressable
;
2315 layout_decl (decl
, 0);
2316 args
->safe_insert (++i
, decl
);
2318 /* If we are expanding a function, rather than gimplifying
2319 it, propagate the RTL of the complex parm to the split
2320 declarations, and set their contexts so that
2321 maybe_reset_rtl_for_parm can recognize them and refrain
2322 from resetting their RTL. */
2323 if (currently_expanding_to_rtl
)
2325 maybe_reset_rtl_for_parm (cparm
);
2326 rtx rtl
= rtl_for_parm (all
, cparm
);
2329 SET_DECL_RTL (p
, read_complex_part (rtl
, false));
2330 SET_DECL_RTL (decl
, read_complex_part (rtl
, true));
2332 DECL_CONTEXT (p
) = cparm
;
2333 DECL_CONTEXT (decl
) = cparm
;
2340 /* A subroutine of assign_parms. Adjust the parameter list to incorporate
2341 the hidden struct return argument, and (abi willing) complex args.
2342 Return the new parameter list. */
2345 assign_parms_augmented_arg_list (struct assign_parm_data_all
*all
)
2347 tree fndecl
= current_function_decl
;
2348 tree fntype
= TREE_TYPE (fndecl
);
2349 vec
<tree
> fnargs
= vNULL
;
2352 for (arg
= DECL_ARGUMENTS (fndecl
); arg
; arg
= DECL_CHAIN (arg
))
2353 fnargs
.safe_push (arg
);
2355 all
->orig_fnargs
= DECL_ARGUMENTS (fndecl
);
2357 /* If struct value address is treated as the first argument, make it so. */
2358 if (aggregate_value_p (DECL_RESULT (fndecl
), fndecl
)
2359 && ! cfun
->returns_pcc_struct
2360 && targetm
.calls
.struct_value_rtx (TREE_TYPE (fndecl
), 1) == 0)
2362 tree type
= build_pointer_type (TREE_TYPE (fntype
));
2365 decl
= build_decl (DECL_SOURCE_LOCATION (fndecl
),
2366 PARM_DECL
, get_identifier (".result_ptr"), type
);
2367 DECL_ARG_TYPE (decl
) = type
;
2368 DECL_ARTIFICIAL (decl
) = 1;
2369 DECL_NAMELESS (decl
) = 1;
2370 TREE_CONSTANT (decl
) = 1;
2372 DECL_CHAIN (decl
) = all
->orig_fnargs
;
2373 all
->orig_fnargs
= decl
;
2374 fnargs
.safe_insert (0, decl
);
2376 all
->function_result_decl
= decl
;
2378 /* If function is instrumented then bounds of the
2379 passed structure address is the second argument. */
2380 if (chkp_function_instrumented_p (fndecl
))
2382 decl
= build_decl (DECL_SOURCE_LOCATION (fndecl
),
2383 PARM_DECL
, get_identifier (".result_bnd"),
2384 pointer_bounds_type_node
);
2385 DECL_ARG_TYPE (decl
) = pointer_bounds_type_node
;
2386 DECL_ARTIFICIAL (decl
) = 1;
2387 DECL_NAMELESS (decl
) = 1;
2388 TREE_CONSTANT (decl
) = 1;
2390 DECL_CHAIN (decl
) = DECL_CHAIN (all
->orig_fnargs
);
2391 DECL_CHAIN (all
->orig_fnargs
) = decl
;
2392 fnargs
.safe_insert (1, decl
);
2396 /* If the target wants to split complex arguments into scalars, do so. */
2397 if (targetm
.calls
.split_complex_arg
)
2398 split_complex_args (all
, &fnargs
);
2403 /* A subroutine of assign_parms. Examine PARM and pull out type and mode
2404 data for the parameter. Incorporate ABI specifics such as pass-by-
2405 reference and type promotion. */
2408 assign_parm_find_data_types (struct assign_parm_data_all
*all
, tree parm
,
2409 struct assign_parm_data_one
*data
)
2411 tree nominal_type
, passed_type
;
2412 machine_mode nominal_mode
, passed_mode
, promoted_mode
;
2415 memset (data
, 0, sizeof (*data
));
2417 /* NAMED_ARG is a misnomer. We really mean 'non-variadic'. */
2419 data
->named_arg
= 1; /* No variadic parms. */
2420 else if (DECL_CHAIN (parm
))
2421 data
->named_arg
= 1; /* Not the last non-variadic parm. */
2422 else if (targetm
.calls
.strict_argument_naming (all
->args_so_far
))
2423 data
->named_arg
= 1; /* Only variadic ones are unnamed. */
2425 data
->named_arg
= 0; /* Treat as variadic. */
2427 nominal_type
= TREE_TYPE (parm
);
2428 passed_type
= DECL_ARG_TYPE (parm
);
2430 /* Look out for errors propagating this far. Also, if the parameter's
2431 type is void then its value doesn't matter. */
2432 if (TREE_TYPE (parm
) == error_mark_node
2433 /* This can happen after weird syntax errors
2434 or if an enum type is defined among the parms. */
2435 || TREE_CODE (parm
) != PARM_DECL
2436 || passed_type
== NULL
2437 || VOID_TYPE_P (nominal_type
))
2439 nominal_type
= passed_type
= void_type_node
;
2440 nominal_mode
= passed_mode
= promoted_mode
= VOIDmode
;
2444 /* Find mode of arg as it is passed, and mode of arg as it should be
2445 during execution of this function. */
2446 passed_mode
= TYPE_MODE (passed_type
);
2447 nominal_mode
= TYPE_MODE (nominal_type
);
2449 /* If the parm is to be passed as a transparent union or record, use the
2450 type of the first field for the tests below. We have already verified
2451 that the modes are the same. */
2452 if ((TREE_CODE (passed_type
) == UNION_TYPE
2453 || TREE_CODE (passed_type
) == RECORD_TYPE
)
2454 && TYPE_TRANSPARENT_AGGR (passed_type
))
2455 passed_type
= TREE_TYPE (first_field (passed_type
));
2457 /* See if this arg was passed by invisible reference. */
2458 if (pass_by_reference (&all
->args_so_far_v
, passed_mode
,
2459 passed_type
, data
->named_arg
))
2461 passed_type
= nominal_type
= build_pointer_type (passed_type
);
2462 data
->passed_pointer
= true;
2463 passed_mode
= nominal_mode
= TYPE_MODE (nominal_type
);
2466 /* Find mode as it is passed by the ABI. */
2467 unsignedp
= TYPE_UNSIGNED (passed_type
);
2468 promoted_mode
= promote_function_mode (passed_type
, passed_mode
, &unsignedp
,
2469 TREE_TYPE (current_function_decl
), 0);
2472 data
->nominal_type
= nominal_type
;
2473 data
->passed_type
= passed_type
;
2474 data
->nominal_mode
= nominal_mode
;
2475 data
->passed_mode
= passed_mode
;
2476 data
->promoted_mode
= promoted_mode
;
2479 /* A subroutine of assign_parms. Invoke setup_incoming_varargs. */
2482 assign_parms_setup_varargs (struct assign_parm_data_all
*all
,
2483 struct assign_parm_data_one
*data
, bool no_rtl
)
2485 int varargs_pretend_bytes
= 0;
2487 targetm
.calls
.setup_incoming_varargs (all
->args_so_far
,
2488 data
->promoted_mode
,
2490 &varargs_pretend_bytes
, no_rtl
);
2492 /* If the back-end has requested extra stack space, record how much is
2493 needed. Do not change pretend_args_size otherwise since it may be
2494 nonzero from an earlier partial argument. */
2495 if (varargs_pretend_bytes
> 0)
2496 all
->pretend_args_size
= varargs_pretend_bytes
;
2499 /* A subroutine of assign_parms. Set DATA->ENTRY_PARM corresponding to
2500 the incoming location of the current parameter. */
2503 assign_parm_find_entry_rtl (struct assign_parm_data_all
*all
,
2504 struct assign_parm_data_one
*data
)
2506 HOST_WIDE_INT pretend_bytes
= 0;
2510 if (data
->promoted_mode
== VOIDmode
)
2512 data
->entry_parm
= data
->stack_parm
= const0_rtx
;
2516 entry_parm
= targetm
.calls
.function_incoming_arg (all
->args_so_far
,
2517 data
->promoted_mode
,
2521 if (entry_parm
== 0)
2522 data
->promoted_mode
= data
->passed_mode
;
2524 /* Determine parm's home in the stack, in case it arrives in the stack
2525 or we should pretend it did. Compute the stack position and rtx where
2526 the argument arrives and its size.
2528 There is one complexity here: If this was a parameter that would
2529 have been passed in registers, but wasn't only because it is
2530 __builtin_va_alist, we want locate_and_pad_parm to treat it as if
2531 it came in a register so that REG_PARM_STACK_SPACE isn't skipped.
2532 In this case, we call FUNCTION_ARG with NAMED set to 1 instead of 0
2533 as it was the previous time. */
2534 in_regs
= (entry_parm
!= 0) || POINTER_BOUNDS_TYPE_P (data
->passed_type
);
2535 #ifdef STACK_PARMS_IN_REG_PARM_AREA
2538 if (!in_regs
&& !data
->named_arg
)
2540 if (targetm
.calls
.pretend_outgoing_varargs_named (all
->args_so_far
))
2543 tem
= targetm
.calls
.function_incoming_arg (all
->args_so_far
,
2544 data
->promoted_mode
,
2545 data
->passed_type
, true);
2546 in_regs
= tem
!= NULL
;
2550 /* If this parameter was passed both in registers and in the stack, use
2551 the copy on the stack. */
2552 if (targetm
.calls
.must_pass_in_stack (data
->promoted_mode
,
2560 partial
= targetm
.calls
.arg_partial_bytes (all
->args_so_far
,
2561 data
->promoted_mode
,
2564 data
->partial
= partial
;
2566 /* The caller might already have allocated stack space for the
2567 register parameters. */
2568 if (partial
!= 0 && all
->reg_parm_stack_space
== 0)
2570 /* Part of this argument is passed in registers and part
2571 is passed on the stack. Ask the prologue code to extend
2572 the stack part so that we can recreate the full value.
2574 PRETEND_BYTES is the size of the registers we need to store.
2575 CURRENT_FUNCTION_PRETEND_ARGS_SIZE is the amount of extra
2576 stack space that the prologue should allocate.
2578 Internally, gcc assumes that the argument pointer is aligned
2579 to STACK_BOUNDARY bits. This is used both for alignment
2580 optimizations (see init_emit) and to locate arguments that are
2581 aligned to more than PARM_BOUNDARY bits. We must preserve this
2582 invariant by rounding CURRENT_FUNCTION_PRETEND_ARGS_SIZE up to
2583 a stack boundary. */
2585 /* We assume at most one partial arg, and it must be the first
2586 argument on the stack. */
2587 gcc_assert (!all
->extra_pretend_bytes
&& !all
->pretend_args_size
);
2589 pretend_bytes
= partial
;
2590 all
->pretend_args_size
= CEIL_ROUND (pretend_bytes
, STACK_BYTES
);
2592 /* We want to align relative to the actual stack pointer, so
2593 don't include this in the stack size until later. */
2594 all
->extra_pretend_bytes
= all
->pretend_args_size
;
2598 locate_and_pad_parm (data
->promoted_mode
, data
->passed_type
, in_regs
,
2599 all
->reg_parm_stack_space
,
2600 entry_parm
? data
->partial
: 0, current_function_decl
,
2601 &all
->stack_args_size
, &data
->locate
);
2603 /* Update parm_stack_boundary if this parameter is passed in the
2605 if (!in_regs
&& crtl
->parm_stack_boundary
< data
->locate
.boundary
)
2606 crtl
->parm_stack_boundary
= data
->locate
.boundary
;
2608 /* Adjust offsets to include the pretend args. */
2609 pretend_bytes
= all
->extra_pretend_bytes
- pretend_bytes
;
2610 data
->locate
.slot_offset
.constant
+= pretend_bytes
;
2611 data
->locate
.offset
.constant
+= pretend_bytes
;
2613 data
->entry_parm
= entry_parm
;
2616 /* A subroutine of assign_parms. If there is actually space on the stack
2617 for this parm, count it in stack_args_size and return true. */
2620 assign_parm_is_stack_parm (struct assign_parm_data_all
*all
,
2621 struct assign_parm_data_one
*data
)
2623 /* Bounds are never passed on the stack to keep compatibility
2624 with not instrumented code. */
2625 if (POINTER_BOUNDS_TYPE_P (data
->passed_type
))
2627 /* Trivially true if we've no incoming register. */
2628 else if (data
->entry_parm
== NULL
)
2630 /* Also true if we're partially in registers and partially not,
2631 since we've arranged to drop the entire argument on the stack. */
2632 else if (data
->partial
!= 0)
2634 /* Also true if the target says that it's passed in both registers
2635 and on the stack. */
2636 else if (GET_CODE (data
->entry_parm
) == PARALLEL
2637 && XEXP (XVECEXP (data
->entry_parm
, 0, 0), 0) == NULL_RTX
)
2639 /* Also true if the target says that there's stack allocated for
2640 all register parameters. */
2641 else if (all
->reg_parm_stack_space
> 0)
2643 /* Otherwise, no, this parameter has no ABI defined stack slot. */
2647 all
->stack_args_size
.constant
+= data
->locate
.size
.constant
;
2648 if (data
->locate
.size
.var
)
2649 ADD_PARM_SIZE (all
->stack_args_size
, data
->locate
.size
.var
);
2654 /* A subroutine of assign_parms. Given that this parameter is allocated
2655 stack space by the ABI, find it. */
2658 assign_parm_find_stack_rtl (tree parm
, struct assign_parm_data_one
*data
)
2660 rtx offset_rtx
, stack_parm
;
2661 unsigned int align
, boundary
;
2663 /* If we're passing this arg using a reg, make its stack home the
2664 aligned stack slot. */
2665 if (data
->entry_parm
)
2666 offset_rtx
= ARGS_SIZE_RTX (data
->locate
.slot_offset
);
2668 offset_rtx
= ARGS_SIZE_RTX (data
->locate
.offset
);
2670 stack_parm
= crtl
->args
.internal_arg_pointer
;
2671 if (offset_rtx
!= const0_rtx
)
2672 stack_parm
= gen_rtx_PLUS (Pmode
, stack_parm
, offset_rtx
);
2673 stack_parm
= gen_rtx_MEM (data
->promoted_mode
, stack_parm
);
2675 if (!data
->passed_pointer
)
2677 set_mem_attributes (stack_parm
, parm
, 1);
2678 /* set_mem_attributes could set MEM_SIZE to the passed mode's size,
2679 while promoted mode's size is needed. */
2680 if (data
->promoted_mode
!= BLKmode
2681 && data
->promoted_mode
!= DECL_MODE (parm
))
2683 set_mem_size (stack_parm
, GET_MODE_SIZE (data
->promoted_mode
));
2684 if (MEM_EXPR (stack_parm
) && MEM_OFFSET_KNOWN_P (stack_parm
))
2686 int offset
= subreg_lowpart_offset (DECL_MODE (parm
),
2687 data
->promoted_mode
);
2689 set_mem_offset (stack_parm
, MEM_OFFSET (stack_parm
) - offset
);
2694 boundary
= data
->locate
.boundary
;
2695 align
= BITS_PER_UNIT
;
2697 /* If we're padding upward, we know that the alignment of the slot
2698 is TARGET_FUNCTION_ARG_BOUNDARY. If we're using slot_offset, we're
2699 intentionally forcing upward padding. Otherwise we have to come
2700 up with a guess at the alignment based on OFFSET_RTX. */
2701 if (data
->locate
.where_pad
!= downward
|| data
->entry_parm
)
2703 else if (CONST_INT_P (offset_rtx
))
2705 align
= INTVAL (offset_rtx
) * BITS_PER_UNIT
| boundary
;
2706 align
= align
& -align
;
2708 set_mem_align (stack_parm
, align
);
2710 if (data
->entry_parm
)
2711 set_reg_attrs_for_parm (data
->entry_parm
, stack_parm
);
2713 data
->stack_parm
= stack_parm
;
2716 /* A subroutine of assign_parms. Adjust DATA->ENTRY_RTL such that it's
2717 always valid and contiguous. */
2720 assign_parm_adjust_entry_rtl (struct assign_parm_data_one
*data
)
2722 rtx entry_parm
= data
->entry_parm
;
2723 rtx stack_parm
= data
->stack_parm
;
2725 /* If this parm was passed part in regs and part in memory, pretend it
2726 arrived entirely in memory by pushing the register-part onto the stack.
2727 In the special case of a DImode or DFmode that is split, we could put
2728 it together in a pseudoreg directly, but for now that's not worth
2730 if (data
->partial
!= 0)
2732 /* Handle calls that pass values in multiple non-contiguous
2733 locations. The Irix 6 ABI has examples of this. */
2734 if (GET_CODE (entry_parm
) == PARALLEL
)
2735 emit_group_store (validize_mem (copy_rtx (stack_parm
)), entry_parm
,
2737 int_size_in_bytes (data
->passed_type
));
2740 gcc_assert (data
->partial
% UNITS_PER_WORD
== 0);
2741 move_block_from_reg (REGNO (entry_parm
),
2742 validize_mem (copy_rtx (stack_parm
)),
2743 data
->partial
/ UNITS_PER_WORD
);
2746 entry_parm
= stack_parm
;
2749 /* If we didn't decide this parm came in a register, by default it came
2751 else if (entry_parm
== NULL
)
2752 entry_parm
= stack_parm
;
2754 /* When an argument is passed in multiple locations, we can't make use
2755 of this information, but we can save some copying if the whole argument
2756 is passed in a single register. */
2757 else if (GET_CODE (entry_parm
) == PARALLEL
2758 && data
->nominal_mode
!= BLKmode
2759 && data
->passed_mode
!= BLKmode
)
2761 size_t i
, len
= XVECLEN (entry_parm
, 0);
2763 for (i
= 0; i
< len
; i
++)
2764 if (XEXP (XVECEXP (entry_parm
, 0, i
), 0) != NULL_RTX
2765 && REG_P (XEXP (XVECEXP (entry_parm
, 0, i
), 0))
2766 && (GET_MODE (XEXP (XVECEXP (entry_parm
, 0, i
), 0))
2767 == data
->passed_mode
)
2768 && INTVAL (XEXP (XVECEXP (entry_parm
, 0, i
), 1)) == 0)
2770 entry_parm
= XEXP (XVECEXP (entry_parm
, 0, i
), 0);
2775 data
->entry_parm
= entry_parm
;
2778 /* A subroutine of assign_parms. Reconstitute any values which were
2779 passed in multiple registers and would fit in a single register. */
2782 assign_parm_remove_parallels (struct assign_parm_data_one
*data
)
2784 rtx entry_parm
= data
->entry_parm
;
2786 /* Convert the PARALLEL to a REG of the same mode as the parallel.
2787 This can be done with register operations rather than on the
2788 stack, even if we will store the reconstituted parameter on the
2790 if (GET_CODE (entry_parm
) == PARALLEL
&& GET_MODE (entry_parm
) != BLKmode
)
2792 rtx parmreg
= gen_reg_rtx (GET_MODE (entry_parm
));
2793 emit_group_store (parmreg
, entry_parm
, data
->passed_type
,
2794 GET_MODE_SIZE (GET_MODE (entry_parm
)));
2795 entry_parm
= parmreg
;
2798 data
->entry_parm
= entry_parm
;
2801 /* Wrapper for use_register_for_decl, that special-cases the
2802 .result_ptr as the function's RESULT_DECL when the RESULT_DECL is
2803 passed by reference. */
2806 use_register_for_parm_decl (struct assign_parm_data_all
*all
, tree parm
)
2808 if (parm
== all
->function_result_decl
)
2810 tree result
= DECL_RESULT (current_function_decl
);
2812 if (DECL_BY_REFERENCE (result
))
2816 return use_register_for_decl (parm
);
2819 /* Wrapper for get_rtl_for_parm_ssa_default_def, that special-cases
2820 the .result_ptr as the function's RESULT_DECL when the RESULT_DECL
2821 is passed by reference. */
2824 rtl_for_parm (struct assign_parm_data_all
*all
, tree parm
)
2826 if (parm
== all
->function_result_decl
)
2828 tree result
= DECL_RESULT (current_function_decl
);
2830 if (!DECL_BY_REFERENCE (result
))
2836 return get_rtl_for_parm_ssa_default_def (parm
);
2839 /* Reset the location of PARM_DECLs and RESULT_DECLs that had
2840 SSA_NAMEs in multiple partitions, so that assign_parms will choose
2841 the default def, if it exists, or create new RTL to hold the unused
2842 entry value. If we are coalescing across variables, we want to
2843 reset the location too, because a parm without a default def
2844 (incoming value unused) might be coalesced with one with a default
2845 def, and then assign_parms would copy both incoming values to the
2846 same location, which might cause the wrong value to survive. */
2848 maybe_reset_rtl_for_parm (tree parm
)
2850 gcc_assert (TREE_CODE (parm
) == PARM_DECL
2851 || TREE_CODE (parm
) == RESULT_DECL
);
2853 /* This is a split complex parameter, and its context was set to its
2854 original PARM_DECL in split_complex_args so that we could
2855 recognize it here and not reset its RTL. */
2856 if (DECL_CONTEXT (parm
) && TREE_CODE (DECL_CONTEXT (parm
)) == PARM_DECL
)
2858 DECL_CONTEXT (parm
) = DECL_CONTEXT (DECL_CONTEXT (parm
));
2862 if ((flag_tree_coalesce_vars
2863 || (DECL_RTL_SET_P (parm
) && DECL_RTL (parm
) == pc_rtx
))
2864 && is_gimple_reg (parm
))
2865 SET_DECL_RTL (parm
, NULL_RTX
);
2868 /* A subroutine of assign_parms. Adjust DATA->STACK_RTL such that it's
2869 always valid and properly aligned. */
2872 assign_parm_adjust_stack_rtl (struct assign_parm_data_all
*all
, tree parm
,
2873 struct assign_parm_data_one
*data
)
2875 rtx stack_parm
= data
->stack_parm
;
2877 /* If out-of-SSA assigned RTL to the parm default def, make sure we
2878 don't use what we might have computed before. */
2879 rtx ssa_assigned
= rtl_for_parm (all
, parm
);
2883 /* If we can't trust the parm stack slot to be aligned enough for its
2884 ultimate type, don't use that slot after entry. We'll make another
2885 stack slot, if we need one. */
2887 && ((STRICT_ALIGNMENT
2888 && (GET_MODE_ALIGNMENT (data
->nominal_mode
)
2889 > MEM_ALIGN (stack_parm
)))
2890 || (data
->nominal_type
2891 && TYPE_ALIGN (data
->nominal_type
) > MEM_ALIGN (stack_parm
)
2892 && MEM_ALIGN (stack_parm
) < PREFERRED_STACK_BOUNDARY
)))
2895 /* If parm was passed in memory, and we need to convert it on entry,
2896 don't store it back in that same slot. */
2897 else if (data
->entry_parm
== stack_parm
2898 && data
->nominal_mode
!= BLKmode
2899 && data
->nominal_mode
!= data
->passed_mode
)
2902 /* If stack protection is in effect for this function, don't leave any
2903 pointers in their passed stack slots. */
2904 else if (crtl
->stack_protect_guard
2905 && (flag_stack_protect
== 2
2906 || data
->passed_pointer
2907 || POINTER_TYPE_P (data
->nominal_type
)))
2910 data
->stack_parm
= stack_parm
;
2913 /* A subroutine of assign_parms. Return true if the current parameter
2914 should be stored as a BLKmode in the current frame. */
2917 assign_parm_setup_block_p (struct assign_parm_data_one
*data
)
2919 if (data
->nominal_mode
== BLKmode
)
2921 if (GET_MODE (data
->entry_parm
) == BLKmode
)
2924 #ifdef BLOCK_REG_PADDING
2925 /* Only assign_parm_setup_block knows how to deal with register arguments
2926 that are padded at the least significant end. */
2927 if (REG_P (data
->entry_parm
)
2928 && GET_MODE_SIZE (data
->promoted_mode
) < UNITS_PER_WORD
2929 && (BLOCK_REG_PADDING (data
->passed_mode
, data
->passed_type
, 1)
2930 == (BYTES_BIG_ENDIAN
? upward
: downward
)))
2937 /* A subroutine of assign_parms. Arrange for the parameter to be
2938 present and valid in DATA->STACK_RTL. */
2941 assign_parm_setup_block (struct assign_parm_data_all
*all
,
2942 tree parm
, struct assign_parm_data_one
*data
)
2944 rtx entry_parm
= data
->entry_parm
;
2945 rtx stack_parm
= data
->stack_parm
;
2947 HOST_WIDE_INT size_stored
;
2949 if (GET_CODE (entry_parm
) == PARALLEL
)
2950 entry_parm
= emit_group_move_into_temps (entry_parm
);
2952 size
= int_size_in_bytes (data
->passed_type
);
2953 size_stored
= CEIL_ROUND (size
, UNITS_PER_WORD
);
2955 if (stack_parm
== 0)
2957 DECL_ALIGN (parm
) = MAX (DECL_ALIGN (parm
), BITS_PER_WORD
);
2958 rtx from_expand
= rtl_for_parm (all
, parm
);
2959 if (from_expand
&& (!parm_maybe_byref_p (parm
)
2960 || XEXP (from_expand
, 0) != NULL_RTX
))
2961 stack_parm
= copy_rtx (from_expand
);
2964 stack_parm
= assign_stack_local (BLKmode
, size_stored
,
2966 if (GET_MODE_SIZE (GET_MODE (entry_parm
)) == size
)
2967 PUT_MODE (stack_parm
, GET_MODE (entry_parm
));
2970 gcc_assert (GET_CODE (stack_parm
) == MEM
);
2971 gcc_assert (GET_CODE (from_expand
) == MEM
);
2972 gcc_assert (XEXP (from_expand
, 0) == NULL_RTX
);
2973 XEXP (from_expand
, 0) = XEXP (stack_parm
, 0);
2974 PUT_MODE (from_expand
, GET_MODE (stack_parm
));
2975 stack_parm
= copy_rtx (from_expand
);
2978 set_mem_attributes (stack_parm
, parm
, 1);
2982 /* If a BLKmode arrives in registers, copy it to a stack slot. Handle
2983 calls that pass values in multiple non-contiguous locations. */
2984 if (REG_P (entry_parm
) || GET_CODE (entry_parm
) == PARALLEL
)
2988 /* Note that we will be storing an integral number of words.
2989 So we have to be careful to ensure that we allocate an
2990 integral number of words. We do this above when we call
2991 assign_stack_local if space was not allocated in the argument
2992 list. If it was, this will not work if PARM_BOUNDARY is not
2993 a multiple of BITS_PER_WORD. It isn't clear how to fix this
2994 if it becomes a problem. Exception is when BLKmode arrives
2995 with arguments not conforming to word_mode. */
2997 if (data
->stack_parm
== 0)
2999 else if (GET_CODE (entry_parm
) == PARALLEL
)
3002 gcc_assert (!size
|| !(PARM_BOUNDARY
% BITS_PER_WORD
));
3004 mem
= validize_mem (copy_rtx (stack_parm
));
3006 /* Handle values in multiple non-contiguous locations. */
3007 if (GET_CODE (entry_parm
) == PARALLEL
)
3009 push_to_sequence2 (all
->first_conversion_insn
,
3010 all
->last_conversion_insn
);
3011 emit_group_store (mem
, entry_parm
, data
->passed_type
, size
);
3012 all
->first_conversion_insn
= get_insns ();
3013 all
->last_conversion_insn
= get_last_insn ();
3020 /* If SIZE is that of a mode no bigger than a word, just use
3021 that mode's store operation. */
3022 else if (size
<= UNITS_PER_WORD
)
3025 = mode_for_size (size
* BITS_PER_UNIT
, MODE_INT
, 0);
3028 #ifdef BLOCK_REG_PADDING
3029 && (size
== UNITS_PER_WORD
3030 || (BLOCK_REG_PADDING (mode
, data
->passed_type
, 1)
3031 != (BYTES_BIG_ENDIAN
? upward
: downward
)))
3037 /* We are really truncating a word_mode value containing
3038 SIZE bytes into a value of mode MODE. If such an
3039 operation requires no actual instructions, we can refer
3040 to the value directly in mode MODE, otherwise we must
3041 start with the register in word_mode and explicitly
3043 if (TRULY_NOOP_TRUNCATION (size
* BITS_PER_UNIT
, BITS_PER_WORD
))
3044 reg
= gen_rtx_REG (mode
, REGNO (entry_parm
));
3047 reg
= gen_rtx_REG (word_mode
, REGNO (entry_parm
));
3048 reg
= convert_to_mode (mode
, copy_to_reg (reg
), 1);
3050 emit_move_insn (change_address (mem
, mode
, 0), reg
);
3053 /* Blocks smaller than a word on a BYTES_BIG_ENDIAN
3054 machine must be aligned to the left before storing
3055 to memory. Note that the previous test doesn't
3056 handle all cases (e.g. SIZE == 3). */
3057 else if (size
!= UNITS_PER_WORD
3058 #ifdef BLOCK_REG_PADDING
3059 && (BLOCK_REG_PADDING (mode
, data
->passed_type
, 1)
3067 int by
= (UNITS_PER_WORD
- size
) * BITS_PER_UNIT
;
3068 rtx reg
= gen_rtx_REG (word_mode
, REGNO (entry_parm
));
3070 x
= expand_shift (LSHIFT_EXPR
, word_mode
, reg
, by
, NULL_RTX
, 1);
3071 tem
= change_address (mem
, word_mode
, 0);
3072 emit_move_insn (tem
, x
);
3075 move_block_from_reg (REGNO (entry_parm
), mem
,
3076 size_stored
/ UNITS_PER_WORD
);
3079 move_block_from_reg (REGNO (entry_parm
), mem
,
3080 size_stored
/ UNITS_PER_WORD
);
3082 else if (data
->stack_parm
== 0)
3084 push_to_sequence2 (all
->first_conversion_insn
, all
->last_conversion_insn
);
3085 emit_block_move (stack_parm
, data
->entry_parm
, GEN_INT (size
),
3087 all
->first_conversion_insn
= get_insns ();
3088 all
->last_conversion_insn
= get_last_insn ();
3092 data
->stack_parm
= stack_parm
;
3093 SET_DECL_RTL (parm
, stack_parm
);
3096 /* A subroutine of assign_parms. Allocate a pseudo to hold the current
3097 parameter. Get it there. Perform all ABI specified conversions. */
3100 assign_parm_setup_reg (struct assign_parm_data_all
*all
, tree parm
,
3101 struct assign_parm_data_one
*data
)
3103 rtx parmreg
, validated_mem
;
3104 rtx equiv_stack_parm
;
3105 machine_mode promoted_nominal_mode
;
3106 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (parm
));
3107 bool did_conversion
= false;
3108 bool need_conversion
, moved
;
3110 /* Store the parm in a pseudoregister during the function, but we may
3111 need to do it in a wider mode. Using 2 here makes the result
3112 consistent with promote_decl_mode and thus expand_expr_real_1. */
3113 promoted_nominal_mode
3114 = promote_function_mode (data
->nominal_type
, data
->nominal_mode
, &unsignedp
,
3115 TREE_TYPE (current_function_decl
), 2);
3117 rtx from_expand
= parmreg
= rtl_for_parm (all
, parm
);
3119 if (from_expand
&& !data
->passed_pointer
)
3121 if (GET_MODE (parmreg
) != promoted_nominal_mode
)
3122 parmreg
= gen_lowpart (promoted_nominal_mode
, parmreg
);
3124 else if (!from_expand
|| parm_maybe_byref_p (parm
))
3126 parmreg
= gen_reg_rtx (promoted_nominal_mode
);
3127 if (!DECL_ARTIFICIAL (parm
))
3128 mark_user_reg (parmreg
);
3132 gcc_assert (data
->passed_pointer
);
3133 gcc_assert (GET_CODE (from_expand
) == MEM
3134 && GET_MODE (from_expand
) == BLKmode
3135 && XEXP (from_expand
, 0) == NULL_RTX
);
3136 XEXP (from_expand
, 0) = parmreg
;
3140 /* If this was an item that we received a pointer to,
3141 set DECL_RTL appropriately. */
3143 SET_DECL_RTL (parm
, from_expand
);
3144 else if (data
->passed_pointer
)
3146 rtx x
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data
->passed_type
)), parmreg
);
3147 set_mem_attributes (x
, parm
, 1);
3148 SET_DECL_RTL (parm
, x
);
3151 SET_DECL_RTL (parm
, parmreg
);
3153 assign_parm_remove_parallels (data
);
3155 /* Copy the value into the register, thus bridging between
3156 assign_parm_find_data_types and expand_expr_real_1. */
3158 equiv_stack_parm
= data
->stack_parm
;
3159 if (!equiv_stack_parm
)
3160 equiv_stack_parm
= data
->entry_parm
;
3161 validated_mem
= validize_mem (copy_rtx (data
->entry_parm
));
3163 need_conversion
= (data
->nominal_mode
!= data
->passed_mode
3164 || promoted_nominal_mode
!= data
->promoted_mode
);
3165 gcc_assert (!(need_conversion
&& data
->passed_pointer
&& from_expand
));
3169 && GET_MODE_CLASS (data
->nominal_mode
) == MODE_INT
3170 && data
->nominal_mode
== data
->passed_mode
3171 && data
->nominal_mode
== GET_MODE (data
->entry_parm
))
3173 /* ENTRY_PARM has been converted to PROMOTED_MODE, its
3174 mode, by the caller. We now have to convert it to
3175 NOMINAL_MODE, if different. However, PARMREG may be in
3176 a different mode than NOMINAL_MODE if it is being stored
3179 If ENTRY_PARM is a hard register, it might be in a register
3180 not valid for operating in its mode (e.g., an odd-numbered
3181 register for a DFmode). In that case, moves are the only
3182 thing valid, so we can't do a convert from there. This
3183 occurs when the calling sequence allow such misaligned
3186 In addition, the conversion may involve a call, which could
3187 clobber parameters which haven't been copied to pseudo
3190 First, we try to emit an insn which performs the necessary
3191 conversion. We verify that this insn does not clobber any
3194 enum insn_code icode
;
3197 icode
= can_extend_p (promoted_nominal_mode
, data
->passed_mode
,
3201 op1
= validated_mem
;
3202 if (icode
!= CODE_FOR_nothing
3203 && insn_operand_matches (icode
, 0, op0
)
3204 && insn_operand_matches (icode
, 1, op1
))
3206 enum rtx_code code
= unsignedp
? ZERO_EXTEND
: SIGN_EXTEND
;
3207 rtx_insn
*insn
, *insns
;
3209 HARD_REG_SET hardregs
;
3212 /* If op1 is a hard register that is likely spilled, first
3213 force it into a pseudo, otherwise combiner might extend
3214 its lifetime too much. */
3215 if (GET_CODE (t
) == SUBREG
)
3218 && HARD_REGISTER_P (t
)
3219 && ! TEST_HARD_REG_BIT (fixed_reg_set
, REGNO (t
))
3220 && targetm
.class_likely_spilled_p (REGNO_REG_CLASS (REGNO (t
))))
3222 t
= gen_reg_rtx (GET_MODE (op1
));
3223 emit_move_insn (t
, op1
);
3227 rtx_insn
*pat
= gen_extend_insn (op0
, t
, promoted_nominal_mode
,
3228 data
->passed_mode
, unsignedp
);
3230 insns
= get_insns ();
3233 CLEAR_HARD_REG_SET (hardregs
);
3234 for (insn
= insns
; insn
&& moved
; insn
= NEXT_INSN (insn
))
3237 note_stores (PATTERN (insn
), record_hard_reg_sets
,
3239 if (!hard_reg_set_empty_p (hardregs
))
3248 if (equiv_stack_parm
!= NULL_RTX
)
3249 equiv_stack_parm
= gen_rtx_fmt_e (code
, GET_MODE (parmreg
),
3256 /* Nothing to do. */
3258 else if (need_conversion
)
3260 /* We did not have an insn to convert directly, or the sequence
3261 generated appeared unsafe. We must first copy the parm to a
3262 pseudo reg, and save the conversion until after all
3263 parameters have been moved. */
3266 rtx tempreg
= gen_reg_rtx (GET_MODE (data
->entry_parm
));
3268 emit_move_insn (tempreg
, validated_mem
);
3270 push_to_sequence2 (all
->first_conversion_insn
, all
->last_conversion_insn
);
3271 tempreg
= convert_to_mode (data
->nominal_mode
, tempreg
, unsignedp
);
3273 if (GET_CODE (tempreg
) == SUBREG
3274 && GET_MODE (tempreg
) == data
->nominal_mode
3275 && REG_P (SUBREG_REG (tempreg
))
3276 && data
->nominal_mode
== data
->passed_mode
3277 && GET_MODE (SUBREG_REG (tempreg
)) == GET_MODE (data
->entry_parm
)
3278 && GET_MODE_SIZE (GET_MODE (tempreg
))
3279 < GET_MODE_SIZE (GET_MODE (data
->entry_parm
)))
3281 /* The argument is already sign/zero extended, so note it
3283 SUBREG_PROMOTED_VAR_P (tempreg
) = 1;
3284 SUBREG_PROMOTED_SET (tempreg
, unsignedp
);
3287 /* TREE_USED gets set erroneously during expand_assignment. */
3288 save_tree_used
= TREE_USED (parm
);
3289 expand_assignment (parm
, make_tree (data
->nominal_type
, tempreg
), false);
3290 TREE_USED (parm
) = save_tree_used
;
3291 all
->first_conversion_insn
= get_insns ();
3292 all
->last_conversion_insn
= get_last_insn ();
3295 did_conversion
= true;
3297 /* We don't want to copy the incoming pointer to a parmreg expected
3298 to hold the value rather than the pointer. */
3299 else if (!data
->passed_pointer
|| parmreg
!= from_expand
)
3300 emit_move_insn (parmreg
, validated_mem
);
3302 /* If we were passed a pointer but the actual value can safely live
3303 in a register, retrieve it and use it directly. */
3304 if (data
->passed_pointer
3305 && (from_expand
|| TYPE_MODE (TREE_TYPE (parm
)) != BLKmode
))
3307 rtx src
= DECL_RTL (parm
);
3309 /* We can't use nominal_mode, because it will have been set to
3310 Pmode above. We must use the actual mode of the parm. */
3313 parmreg
= from_expand
;
3314 gcc_assert (GET_MODE (parmreg
) == TYPE_MODE (TREE_TYPE (parm
)));
3315 src
= gen_rtx_MEM (GET_MODE (parmreg
), validated_mem
);
3316 set_mem_attributes (src
, parm
, 1);
3318 else if (use_register_for_decl (parm
))
3320 parmreg
= gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm
)));
3321 mark_user_reg (parmreg
);
3325 int align
= STACK_SLOT_ALIGNMENT (TREE_TYPE (parm
),
3326 TYPE_MODE (TREE_TYPE (parm
)),
3327 TYPE_ALIGN (TREE_TYPE (parm
)));
3329 = assign_stack_local (TYPE_MODE (TREE_TYPE (parm
)),
3330 GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parm
))),
3332 set_mem_attributes (parmreg
, parm
, 1);
3335 if (GET_MODE (parmreg
) != GET_MODE (src
))
3337 rtx tempreg
= gen_reg_rtx (GET_MODE (src
));
3338 int unsigned_p
= TYPE_UNSIGNED (TREE_TYPE (parm
));
3340 push_to_sequence2 (all
->first_conversion_insn
,
3341 all
->last_conversion_insn
);
3342 emit_move_insn (tempreg
, src
);
3343 tempreg
= convert_to_mode (GET_MODE (parmreg
), tempreg
, unsigned_p
);
3344 emit_move_insn (parmreg
, tempreg
);
3345 all
->first_conversion_insn
= get_insns ();
3346 all
->last_conversion_insn
= get_last_insn ();
3349 did_conversion
= true;
3351 else if (GET_MODE (parmreg
) == BLKmode
)
3352 gcc_assert (parm_maybe_byref_p (parm
));
3354 emit_move_insn (parmreg
, src
);
3356 SET_DECL_RTL (parm
, parmreg
);
3358 /* STACK_PARM is the pointer, not the parm, and PARMREG is
3360 data
->stack_parm
= equiv_stack_parm
= NULL
;
3363 /* Mark the register as eliminable if we did no conversion and it was
3364 copied from memory at a fixed offset, and the arg pointer was not
3365 copied to a pseudo-reg. If the arg pointer is a pseudo reg or the
3366 offset formed an invalid address, such memory-equivalences as we
3367 make here would screw up life analysis for it. */
3368 if (data
->nominal_mode
== data
->passed_mode
3370 && equiv_stack_parm
!= 0
3371 && MEM_P (equiv_stack_parm
)
3372 && data
->locate
.offset
.var
== 0
3373 && reg_mentioned_p (virtual_incoming_args_rtx
,
3374 XEXP (equiv_stack_parm
, 0)))
3376 rtx_insn
*linsn
= get_last_insn ();
3380 /* Mark complex types separately. */
3381 if (GET_CODE (parmreg
) == CONCAT
)
3383 machine_mode submode
3384 = GET_MODE_INNER (GET_MODE (parmreg
));
3385 int regnor
= REGNO (XEXP (parmreg
, 0));
3386 int regnoi
= REGNO (XEXP (parmreg
, 1));
3387 rtx stackr
= adjust_address_nv (equiv_stack_parm
, submode
, 0);
3388 rtx stacki
= adjust_address_nv (equiv_stack_parm
, submode
,
3389 GET_MODE_SIZE (submode
));
3391 /* Scan backwards for the set of the real and
3393 for (sinsn
= linsn
; sinsn
!= 0;
3394 sinsn
= prev_nonnote_insn (sinsn
))
3396 set
= single_set (sinsn
);
3400 if (SET_DEST (set
) == regno_reg_rtx
[regnoi
])
3401 set_unique_reg_note (sinsn
, REG_EQUIV
, stacki
);
3402 else if (SET_DEST (set
) == regno_reg_rtx
[regnor
])
3403 set_unique_reg_note (sinsn
, REG_EQUIV
, stackr
);
3407 set_dst_reg_note (linsn
, REG_EQUIV
, equiv_stack_parm
, parmreg
);
3410 /* For pointer data type, suggest pointer register. */
3411 if (POINTER_TYPE_P (TREE_TYPE (parm
)))
3412 mark_reg_pointer (parmreg
,
3413 TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm
))));
3416 /* A subroutine of assign_parms. Allocate stack space to hold the current
3417 parameter. Get it there. Perform all ABI specified conversions. */
3420 assign_parm_setup_stack (struct assign_parm_data_all
*all
, tree parm
,
3421 struct assign_parm_data_one
*data
)
3423 /* Value must be stored in the stack slot STACK_PARM during function
3425 bool to_conversion
= false;
3427 assign_parm_remove_parallels (data
);
3429 if (data
->promoted_mode
!= data
->nominal_mode
)
3431 /* Conversion is required. */
3432 rtx tempreg
= gen_reg_rtx (GET_MODE (data
->entry_parm
));
3434 emit_move_insn (tempreg
, validize_mem (copy_rtx (data
->entry_parm
)));
3436 push_to_sequence2 (all
->first_conversion_insn
, all
->last_conversion_insn
);
3437 to_conversion
= true;
3439 data
->entry_parm
= convert_to_mode (data
->nominal_mode
, tempreg
,
3440 TYPE_UNSIGNED (TREE_TYPE (parm
)));
3442 if (data
->stack_parm
)
3444 int offset
= subreg_lowpart_offset (data
->nominal_mode
,
3445 GET_MODE (data
->stack_parm
));
3446 /* ??? This may need a big-endian conversion on sparc64. */
3448 = adjust_address (data
->stack_parm
, data
->nominal_mode
, 0);
3449 if (offset
&& MEM_OFFSET_KNOWN_P (data
->stack_parm
))
3450 set_mem_offset (data
->stack_parm
,
3451 MEM_OFFSET (data
->stack_parm
) + offset
);
3455 if (data
->entry_parm
!= data
->stack_parm
)
3459 if (data
->stack_parm
== 0)
3461 rtx x
= data
->stack_parm
= rtl_for_parm (all
, parm
);
3463 gcc_assert (GET_MODE (x
) == GET_MODE (data
->entry_parm
));
3466 if (data
->stack_parm
== 0)
3468 int align
= STACK_SLOT_ALIGNMENT (data
->passed_type
,
3469 GET_MODE (data
->entry_parm
),
3470 TYPE_ALIGN (data
->passed_type
));
3472 = assign_stack_local (GET_MODE (data
->entry_parm
),
3473 GET_MODE_SIZE (GET_MODE (data
->entry_parm
)),
3475 set_mem_attributes (data
->stack_parm
, parm
, 1);
3478 dest
= validize_mem (copy_rtx (data
->stack_parm
));
3479 src
= validize_mem (copy_rtx (data
->entry_parm
));
3483 /* Use a block move to handle potentially misaligned entry_parm. */
3485 push_to_sequence2 (all
->first_conversion_insn
,
3486 all
->last_conversion_insn
);
3487 to_conversion
= true;
3489 emit_block_move (dest
, src
,
3490 GEN_INT (int_size_in_bytes (data
->passed_type
)),
3494 emit_move_insn (dest
, src
);
3499 all
->first_conversion_insn
= get_insns ();
3500 all
->last_conversion_insn
= get_last_insn ();
3504 SET_DECL_RTL (parm
, data
->stack_parm
);
3507 /* A subroutine of assign_parms. If the ABI splits complex arguments, then
3508 undo the frobbing that we did in assign_parms_augmented_arg_list. */
3511 assign_parms_unsplit_complex (struct assign_parm_data_all
*all
,
3515 tree orig_fnargs
= all
->orig_fnargs
;
3518 for (parm
= orig_fnargs
; parm
; parm
= TREE_CHAIN (parm
), ++i
)
3520 if (TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
3521 && targetm
.calls
.split_complex_arg (TREE_TYPE (parm
)))
3523 rtx tmp
, real
, imag
;
3524 machine_mode inner
= GET_MODE_INNER (DECL_MODE (parm
));
3526 real
= DECL_RTL (fnargs
[i
]);
3527 imag
= DECL_RTL (fnargs
[i
+ 1]);
3528 if (inner
!= GET_MODE (real
))
3530 real
= simplify_gen_subreg (inner
, real
, GET_MODE (real
),
3531 subreg_lowpart_offset
3532 (inner
, GET_MODE (real
)));
3533 imag
= simplify_gen_subreg (inner
, imag
, GET_MODE (imag
),
3534 subreg_lowpart_offset
3535 (inner
, GET_MODE (imag
)));
3538 if ((tmp
= rtl_for_parm (all
, parm
)) != NULL_RTX
3539 && rtx_equal_p (real
,
3540 read_complex_part (tmp
, false))
3541 && rtx_equal_p (imag
,
3542 read_complex_part (tmp
, true)))
3543 ; /* We now have the right rtl in tmp. */
3544 else if (TREE_ADDRESSABLE (parm
))
3547 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (parm
));
3548 int align
= STACK_SLOT_ALIGNMENT (TREE_TYPE (parm
),
3550 TYPE_ALIGN (TREE_TYPE (parm
)));
3552 /* split_complex_arg put the real and imag parts in
3553 pseudos. Move them to memory. */
3554 tmp
= assign_stack_local (DECL_MODE (parm
), size
, align
);
3555 set_mem_attributes (tmp
, parm
, 1);
3556 rmem
= adjust_address_nv (tmp
, inner
, 0);
3557 imem
= adjust_address_nv (tmp
, inner
, GET_MODE_SIZE (inner
));
3558 push_to_sequence2 (all
->first_conversion_insn
,
3559 all
->last_conversion_insn
);
3560 emit_move_insn (rmem
, real
);
3561 emit_move_insn (imem
, imag
);
3562 all
->first_conversion_insn
= get_insns ();
3563 all
->last_conversion_insn
= get_last_insn ();
3567 tmp
= gen_rtx_CONCAT (DECL_MODE (parm
), real
, imag
);
3568 SET_DECL_RTL (parm
, tmp
);
3570 real
= DECL_INCOMING_RTL (fnargs
[i
]);
3571 imag
= DECL_INCOMING_RTL (fnargs
[i
+ 1]);
3572 if (inner
!= GET_MODE (real
))
3574 real
= gen_lowpart_SUBREG (inner
, real
);
3575 imag
= gen_lowpart_SUBREG (inner
, imag
);
3577 tmp
= gen_rtx_CONCAT (DECL_MODE (parm
), real
, imag
);
3578 set_decl_incoming_rtl (parm
, tmp
, false);
3584 /* Load bounds of PARM from bounds table. */
3586 assign_parm_load_bounds (struct assign_parm_data_one
*data
,
3592 unsigned i
, offs
= 0;
3594 rtx slot
= NULL
, ptr
= NULL
;
3599 bitmap_obstack_initialize (NULL
);
3600 slots
= BITMAP_ALLOC (NULL
);
3601 chkp_find_bound_slots (TREE_TYPE (parm
), slots
);
3602 EXECUTE_IF_SET_IN_BITMAP (slots
, 0, i
, bi
)
3612 BITMAP_FREE (slots
);
3613 bitmap_obstack_release (NULL
);
3616 /* We may have bounds not associated with any pointer. */
3618 offs
= bnd_no
* POINTER_SIZE
/ BITS_PER_UNIT
;
3620 /* Find associated pointer. */
3623 /* If bounds are not associated with any bounds,
3624 then it is passed in a register or special slot. */
3625 gcc_assert (data
->entry_parm
);
3628 else if (MEM_P (entry
))
3629 slot
= adjust_address (entry
, Pmode
, offs
);
3630 else if (REG_P (entry
))
3631 ptr
= gen_rtx_REG (Pmode
, REGNO (entry
) + bnd_no
);
3632 else if (GET_CODE (entry
) == PARALLEL
)
3633 ptr
= chkp_get_value_with_offs (entry
, GEN_INT (offs
));
3636 data
->entry_parm
= targetm
.calls
.load_bounds_for_arg (slot
, ptr
,
3640 /* Assign RTL expressions to the function's bounds parameters BNDARGS. */
3643 assign_bounds (vec
<bounds_parm_data
> &bndargs
,
3644 struct assign_parm_data_all
&all
,
3645 bool assign_regs
, bool assign_special
,
3649 bounds_parm_data
*pbdata
;
3651 if (!bndargs
.exists ())
3654 /* We make few passes to store input bounds. Firstly handle bounds
3655 passed in registers. After that we load bounds passed in special
3656 slots. Finally we load bounds from Bounds Table. */
3657 for (pass
= 0; pass
< 3; pass
++)
3658 FOR_EACH_VEC_ELT (bndargs
, i
, pbdata
)
3660 /* Pass 0 => regs only. */
3663 ||(!pbdata
->parm_data
.entry_parm
3664 || GET_CODE (pbdata
->parm_data
.entry_parm
) != REG
)))
3666 /* Pass 1 => slots only. */
3669 || (!pbdata
->parm_data
.entry_parm
3670 || GET_CODE (pbdata
->parm_data
.entry_parm
) == REG
)))
3672 /* Pass 2 => BT only. */
3675 || pbdata
->parm_data
.entry_parm
))
3678 if (!pbdata
->parm_data
.entry_parm
3679 || GET_CODE (pbdata
->parm_data
.entry_parm
) != REG
)
3680 assign_parm_load_bounds (&pbdata
->parm_data
, pbdata
->ptr_parm
,
3681 pbdata
->ptr_entry
, pbdata
->bound_no
);
3683 set_decl_incoming_rtl (pbdata
->bounds_parm
,
3684 pbdata
->parm_data
.entry_parm
, false);
3686 if (assign_parm_setup_block_p (&pbdata
->parm_data
))
3687 assign_parm_setup_block (&all
, pbdata
->bounds_parm
,
3688 &pbdata
->parm_data
);
3689 else if (pbdata
->parm_data
.passed_pointer
3690 || use_register_for_parm_decl (&all
, pbdata
->bounds_parm
))
3691 assign_parm_setup_reg (&all
, pbdata
->bounds_parm
,
3692 &pbdata
->parm_data
);
3694 assign_parm_setup_stack (&all
, pbdata
->bounds_parm
,
3695 &pbdata
->parm_data
);
3699 /* Assign RTL expressions to the function's parameters. This may involve
3700 copying them into registers and using those registers as the DECL_RTL. */
3703 assign_parms (tree fndecl
)
3705 struct assign_parm_data_all all
;
3708 unsigned i
, bound_no
= 0;
3709 tree last_arg
= NULL
;
3710 rtx last_arg_entry
= NULL
;
3711 vec
<bounds_parm_data
> bndargs
= vNULL
;
3712 bounds_parm_data bdata
;
3714 crtl
->args
.internal_arg_pointer
3715 = targetm
.calls
.internal_arg_pointer ();
3717 assign_parms_initialize_all (&all
);
3718 fnargs
= assign_parms_augmented_arg_list (&all
);
3720 FOR_EACH_VEC_ELT (fnargs
, i
, parm
)
3722 struct assign_parm_data_one data
;
3724 /* Extract the type of PARM; adjust it according to ABI. */
3725 assign_parm_find_data_types (&all
, parm
, &data
);
3727 /* Early out for errors and void parameters. */
3728 if (data
.passed_mode
== VOIDmode
)
3730 SET_DECL_RTL (parm
, const0_rtx
);
3731 DECL_INCOMING_RTL (parm
) = DECL_RTL (parm
);
3735 maybe_reset_rtl_for_parm (parm
);
3737 /* Estimate stack alignment from parameter alignment. */
3738 if (SUPPORTS_STACK_ALIGNMENT
)
3741 = targetm
.calls
.function_arg_boundary (data
.promoted_mode
,
3743 align
= MINIMUM_ALIGNMENT (data
.passed_type
, data
.promoted_mode
,
3745 if (TYPE_ALIGN (data
.nominal_type
) > align
)
3746 align
= MINIMUM_ALIGNMENT (data
.nominal_type
,
3747 TYPE_MODE (data
.nominal_type
),
3748 TYPE_ALIGN (data
.nominal_type
));
3749 if (crtl
->stack_alignment_estimated
< align
)
3751 gcc_assert (!crtl
->stack_realign_processed
);
3752 crtl
->stack_alignment_estimated
= align
;
3756 /* Find out where the parameter arrives in this function. */
3757 assign_parm_find_entry_rtl (&all
, &data
);
3759 /* Find out where stack space for this parameter might be. */
3760 if (assign_parm_is_stack_parm (&all
, &data
))
3762 assign_parm_find_stack_rtl (parm
, &data
);
3763 assign_parm_adjust_entry_rtl (&data
);
3765 if (!POINTER_BOUNDS_TYPE_P (data
.passed_type
))
3767 /* Remember where last non bounds arg was passed in case
3768 we have to load associated bounds for it from Bounds
3771 last_arg_entry
= data
.entry_parm
;
3774 /* Record permanently how this parm was passed. */
3775 if (data
.passed_pointer
)
3778 = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data
.passed_type
)),
3780 set_decl_incoming_rtl (parm
, incoming_rtl
, true);
3783 set_decl_incoming_rtl (parm
, data
.entry_parm
, false);
3785 assign_parm_adjust_stack_rtl (&all
, parm
, &data
);
3787 /* Bounds should be loaded in the particular order to
3788 have registers allocated correctly. Collect info about
3789 input bounds and load them later. */
3790 if (POINTER_BOUNDS_TYPE_P (data
.passed_type
))
3792 /* Expect bounds in instrumented functions only. */
3793 gcc_assert (chkp_function_instrumented_p (fndecl
));
3795 bdata
.parm_data
= data
;
3796 bdata
.bounds_parm
= parm
;
3797 bdata
.ptr_parm
= last_arg
;
3798 bdata
.ptr_entry
= last_arg_entry
;
3799 bdata
.bound_no
= bound_no
;
3800 bndargs
.safe_push (bdata
);
3804 if (assign_parm_setup_block_p (&data
))
3805 assign_parm_setup_block (&all
, parm
, &data
);
3806 else if (data
.passed_pointer
3807 || use_register_for_parm_decl (&all
, parm
))
3808 assign_parm_setup_reg (&all
, parm
, &data
);
3810 assign_parm_setup_stack (&all
, parm
, &data
);
3813 if (cfun
->stdarg
&& !DECL_CHAIN (parm
))
3815 int pretend_bytes
= 0;
3817 assign_parms_setup_varargs (&all
, &data
, false);
3819 if (chkp_function_instrumented_p (fndecl
))
3821 /* We expect this is the last parm. Otherwise it is wrong
3822 to assign bounds right now. */
3823 gcc_assert (i
== (fnargs
.length () - 1));
3824 assign_bounds (bndargs
, all
, true, false, false);
3825 targetm
.calls
.setup_incoming_vararg_bounds (all
.args_so_far
,
3830 assign_bounds (bndargs
, all
, false, true, true);
3835 /* Update info on where next arg arrives in registers. */
3836 targetm
.calls
.function_arg_advance (all
.args_so_far
, data
.promoted_mode
,
3837 data
.passed_type
, data
.named_arg
);
3839 if (POINTER_BOUNDS_TYPE_P (data
.passed_type
))
3843 assign_bounds (bndargs
, all
, true, true, true);
3846 if (targetm
.calls
.split_complex_arg
)
3847 assign_parms_unsplit_complex (&all
, fnargs
);
3851 /* Output all parameter conversion instructions (possibly including calls)
3852 now that all parameters have been copied out of hard registers. */
3853 emit_insn (all
.first_conversion_insn
);
3855 /* Estimate reload stack alignment from scalar return mode. */
3856 if (SUPPORTS_STACK_ALIGNMENT
)
3858 if (DECL_RESULT (fndecl
))
3860 tree type
= TREE_TYPE (DECL_RESULT (fndecl
));
3861 machine_mode mode
= TYPE_MODE (type
);
3865 && !AGGREGATE_TYPE_P (type
))
3867 unsigned int align
= GET_MODE_ALIGNMENT (mode
);
3868 if (crtl
->stack_alignment_estimated
< align
)
3870 gcc_assert (!crtl
->stack_realign_processed
);
3871 crtl
->stack_alignment_estimated
= align
;
3877 /* If we are receiving a struct value address as the first argument, set up
3878 the RTL for the function result. As this might require code to convert
3879 the transmitted address to Pmode, we do this here to ensure that possible
3880 preliminary conversions of the address have been emitted already. */
3881 if (all
.function_result_decl
)
3883 tree result
= DECL_RESULT (current_function_decl
);
3884 rtx addr
= DECL_RTL (all
.function_result_decl
);
3887 if (DECL_BY_REFERENCE (result
))
3889 SET_DECL_VALUE_EXPR (result
, all
.function_result_decl
);
3894 SET_DECL_VALUE_EXPR (result
,
3895 build1 (INDIRECT_REF
, TREE_TYPE (result
),
3896 all
.function_result_decl
));
3897 addr
= convert_memory_address (Pmode
, addr
);
3898 x
= gen_rtx_MEM (DECL_MODE (result
), addr
);
3899 set_mem_attributes (x
, result
, 1);
3902 DECL_HAS_VALUE_EXPR_P (result
) = 1;
3904 SET_DECL_RTL (result
, x
);
3907 /* We have aligned all the args, so add space for the pretend args. */
3908 crtl
->args
.pretend_args_size
= all
.pretend_args_size
;
3909 all
.stack_args_size
.constant
+= all
.extra_pretend_bytes
;
3910 crtl
->args
.size
= all
.stack_args_size
.constant
;
3912 /* Adjust function incoming argument size for alignment and
3915 crtl
->args
.size
= MAX (crtl
->args
.size
, all
.reg_parm_stack_space
);
3916 crtl
->args
.size
= CEIL_ROUND (crtl
->args
.size
,
3917 PARM_BOUNDARY
/ BITS_PER_UNIT
);
3919 if (ARGS_GROW_DOWNWARD
)
3921 crtl
->args
.arg_offset_rtx
3922 = (all
.stack_args_size
.var
== 0 ? GEN_INT (-all
.stack_args_size
.constant
)
3923 : expand_expr (size_diffop (all
.stack_args_size
.var
,
3924 size_int (-all
.stack_args_size
.constant
)),
3925 NULL_RTX
, VOIDmode
, EXPAND_NORMAL
));
3928 crtl
->args
.arg_offset_rtx
= ARGS_SIZE_RTX (all
.stack_args_size
);
3930 /* See how many bytes, if any, of its args a function should try to pop
3933 crtl
->args
.pops_args
= targetm
.calls
.return_pops_args (fndecl
,
3937 /* For stdarg.h function, save info about
3938 regs and stack space used by the named args. */
3940 crtl
->args
.info
= all
.args_so_far_v
;
3942 /* Set the rtx used for the function return value. Put this in its
3943 own variable so any optimizers that need this information don't have
3944 to include tree.h. Do this here so it gets done when an inlined
3945 function gets output. */
3948 = (DECL_RTL_SET_P (DECL_RESULT (fndecl
))
3949 ? DECL_RTL (DECL_RESULT (fndecl
)) : NULL_RTX
);
3951 /* If scalar return value was computed in a pseudo-reg, or was a named
3952 return value that got dumped to the stack, copy that to the hard
3954 if (DECL_RTL_SET_P (DECL_RESULT (fndecl
)))
3956 tree decl_result
= DECL_RESULT (fndecl
);
3957 rtx decl_rtl
= DECL_RTL (decl_result
);
3959 if (REG_P (decl_rtl
)
3960 ? REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
3961 : DECL_REGISTER (decl_result
))
3965 real_decl_rtl
= targetm
.calls
.function_value (TREE_TYPE (decl_result
),
3967 if (chkp_function_instrumented_p (fndecl
))
3969 = targetm
.calls
.chkp_function_value_bounds (TREE_TYPE (decl_result
),
3971 REG_FUNCTION_VALUE_P (real_decl_rtl
) = 1;
3972 /* The delay slot scheduler assumes that crtl->return_rtx
3973 holds the hard register containing the return value, not a
3974 temporary pseudo. */
3975 crtl
->return_rtx
= real_decl_rtl
;
3980 /* A subroutine of gimplify_parameters, invoked via walk_tree.
3981 For all seen types, gimplify their sizes. */
3984 gimplify_parm_type (tree
*tp
, int *walk_subtrees
, void *data
)
3991 if (POINTER_TYPE_P (t
))
3993 else if (TYPE_SIZE (t
) && !TREE_CONSTANT (TYPE_SIZE (t
))
3994 && !TYPE_SIZES_GIMPLIFIED (t
))
3996 gimplify_type_sizes (t
, (gimple_seq
*) data
);
4004 /* Gimplify the parameter list for current_function_decl. This involves
4005 evaluating SAVE_EXPRs of variable sized parameters and generating code
4006 to implement callee-copies reference parameters. Returns a sequence of
4007 statements to add to the beginning of the function. */
4010 gimplify_parameters (void)
4012 struct assign_parm_data_all all
;
4014 gimple_seq stmts
= NULL
;
4018 assign_parms_initialize_all (&all
);
4019 fnargs
= assign_parms_augmented_arg_list (&all
);
4021 FOR_EACH_VEC_ELT (fnargs
, i
, parm
)
4023 struct assign_parm_data_one data
;
4025 /* Extract the type of PARM; adjust it according to ABI. */
4026 assign_parm_find_data_types (&all
, parm
, &data
);
4028 /* Early out for errors and void parameters. */
4029 if (data
.passed_mode
== VOIDmode
|| DECL_SIZE (parm
) == NULL
)
4032 /* Update info on where next arg arrives in registers. */
4033 targetm
.calls
.function_arg_advance (all
.args_so_far
, data
.promoted_mode
,
4034 data
.passed_type
, data
.named_arg
);
4036 /* ??? Once upon a time variable_size stuffed parameter list
4037 SAVE_EXPRs (amongst others) onto a pending sizes list. This
4038 turned out to be less than manageable in the gimple world.
4039 Now we have to hunt them down ourselves. */
4040 walk_tree_without_duplicates (&data
.passed_type
,
4041 gimplify_parm_type
, &stmts
);
4043 if (TREE_CODE (DECL_SIZE_UNIT (parm
)) != INTEGER_CST
)
4045 gimplify_one_sizepos (&DECL_SIZE (parm
), &stmts
);
4046 gimplify_one_sizepos (&DECL_SIZE_UNIT (parm
), &stmts
);
4049 if (data
.passed_pointer
)
4051 tree type
= TREE_TYPE (data
.passed_type
);
4052 if (reference_callee_copied (&all
.args_so_far_v
, TYPE_MODE (type
),
4053 type
, data
.named_arg
))
4057 /* For constant-sized objects, this is trivial; for
4058 variable-sized objects, we have to play games. */
4059 if (TREE_CODE (DECL_SIZE_UNIT (parm
)) == INTEGER_CST
4060 && !(flag_stack_check
== GENERIC_STACK_CHECK
4061 && compare_tree_int (DECL_SIZE_UNIT (parm
),
4062 STACK_CHECK_MAX_VAR_SIZE
) > 0))
4064 local
= create_tmp_var (type
, get_name (parm
));
4065 DECL_IGNORED_P (local
) = 0;
4066 /* If PARM was addressable, move that flag over
4067 to the local copy, as its address will be taken,
4068 not the PARMs. Keep the parms address taken
4069 as we'll query that flag during gimplification. */
4070 if (TREE_ADDRESSABLE (parm
))
4071 TREE_ADDRESSABLE (local
) = 1;
4072 else if (TREE_CODE (type
) == COMPLEX_TYPE
4073 || TREE_CODE (type
) == VECTOR_TYPE
)
4074 DECL_GIMPLE_REG_P (local
) = 1;
4078 tree ptr_type
, addr
;
4080 ptr_type
= build_pointer_type (type
);
4081 addr
= create_tmp_reg (ptr_type
, get_name (parm
));
4082 DECL_IGNORED_P (addr
) = 0;
4083 local
= build_fold_indirect_ref (addr
);
4085 t
= builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN
);
4086 t
= build_call_expr (t
, 2, DECL_SIZE_UNIT (parm
),
4087 size_int (DECL_ALIGN (parm
)));
4089 /* The call has been built for a variable-sized object. */
4090 CALL_ALLOCA_FOR_VAR_P (t
) = 1;
4091 t
= fold_convert (ptr_type
, t
);
4092 t
= build2 (MODIFY_EXPR
, TREE_TYPE (addr
), addr
, t
);
4093 gimplify_and_add (t
, &stmts
);
4096 gimplify_assign (local
, parm
, &stmts
);
4098 SET_DECL_VALUE_EXPR (parm
, local
);
4099 DECL_HAS_VALUE_EXPR_P (parm
) = 1;
4109 /* Compute the size and offset from the start of the stacked arguments for a
4110 parm passed in mode PASSED_MODE and with type TYPE.
4112 INITIAL_OFFSET_PTR points to the current offset into the stacked
4115 The starting offset and size for this parm are returned in
4116 LOCATE->OFFSET and LOCATE->SIZE, respectively. When IN_REGS is
4117 nonzero, the offset is that of stack slot, which is returned in
4118 LOCATE->SLOT_OFFSET. LOCATE->ALIGNMENT_PAD is the amount of
4119 padding required from the initial offset ptr to the stack slot.
4121 IN_REGS is nonzero if the argument will be passed in registers. It will
4122 never be set if REG_PARM_STACK_SPACE is not defined.
4124 REG_PARM_STACK_SPACE is the number of bytes of stack space reserved
4125 for arguments which are passed in registers.
4127 FNDECL is the function in which the argument was defined.
4129 There are two types of rounding that are done. The first, controlled by
4130 TARGET_FUNCTION_ARG_BOUNDARY, forces the offset from the start of the
4131 argument list to be aligned to the specific boundary (in bits). This
4132 rounding affects the initial and starting offsets, but not the argument
4135 The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY,
4136 optionally rounds the size of the parm to PARM_BOUNDARY. The
4137 initial offset is not affected by this rounding, while the size always
4138 is and the starting offset may be. */
4140 /* LOCATE->OFFSET will be negative for ARGS_GROW_DOWNWARD case;
4141 INITIAL_OFFSET_PTR is positive because locate_and_pad_parm's
4142 callers pass in the total size of args so far as
4143 INITIAL_OFFSET_PTR. LOCATE->SIZE is always positive. */
4146 locate_and_pad_parm (machine_mode passed_mode
, tree type
, int in_regs
,
4147 int reg_parm_stack_space
, int partial
,
4148 tree fndecl ATTRIBUTE_UNUSED
,
4149 struct args_size
*initial_offset_ptr
,
4150 struct locate_and_pad_arg_data
*locate
)
4153 enum direction where_pad
;
4154 unsigned int boundary
, round_boundary
;
4155 int part_size_in_regs
;
4157 /* If we have found a stack parm before we reach the end of the
4158 area reserved for registers, skip that area. */
4161 if (reg_parm_stack_space
> 0)
4163 if (initial_offset_ptr
->var
)
4165 initial_offset_ptr
->var
4166 = size_binop (MAX_EXPR
, ARGS_SIZE_TREE (*initial_offset_ptr
),
4167 ssize_int (reg_parm_stack_space
));
4168 initial_offset_ptr
->constant
= 0;
4170 else if (initial_offset_ptr
->constant
< reg_parm_stack_space
)
4171 initial_offset_ptr
->constant
= reg_parm_stack_space
;
4175 part_size_in_regs
= (reg_parm_stack_space
== 0 ? partial
: 0);
4178 = type
? size_in_bytes (type
) : size_int (GET_MODE_SIZE (passed_mode
));
4179 where_pad
= FUNCTION_ARG_PADDING (passed_mode
, type
);
4180 boundary
= targetm
.calls
.function_arg_boundary (passed_mode
, type
);
4181 round_boundary
= targetm
.calls
.function_arg_round_boundary (passed_mode
,
4183 locate
->where_pad
= where_pad
;
4185 /* Alignment can't exceed MAX_SUPPORTED_STACK_ALIGNMENT. */
4186 if (boundary
> MAX_SUPPORTED_STACK_ALIGNMENT
)
4187 boundary
= MAX_SUPPORTED_STACK_ALIGNMENT
;
4189 locate
->boundary
= boundary
;
4191 if (SUPPORTS_STACK_ALIGNMENT
)
4193 /* stack_alignment_estimated can't change after stack has been
4195 if (crtl
->stack_alignment_estimated
< boundary
)
4197 if (!crtl
->stack_realign_processed
)
4198 crtl
->stack_alignment_estimated
= boundary
;
4201 /* If stack is realigned and stack alignment value
4202 hasn't been finalized, it is OK not to increase
4203 stack_alignment_estimated. The bigger alignment
4204 requirement is recorded in stack_alignment_needed
4206 gcc_assert (!crtl
->stack_realign_finalized
4207 && crtl
->stack_realign_needed
);
4212 /* Remember if the outgoing parameter requires extra alignment on the
4213 calling function side. */
4214 if (crtl
->stack_alignment_needed
< boundary
)
4215 crtl
->stack_alignment_needed
= boundary
;
4216 if (crtl
->preferred_stack_boundary
< boundary
)
4217 crtl
->preferred_stack_boundary
= boundary
;
4219 if (ARGS_GROW_DOWNWARD
)
4221 locate
->slot_offset
.constant
= -initial_offset_ptr
->constant
;
4222 if (initial_offset_ptr
->var
)
4223 locate
->slot_offset
.var
= size_binop (MINUS_EXPR
, ssize_int (0),
4224 initial_offset_ptr
->var
);
4228 if (where_pad
!= none
4229 && (!tree_fits_uhwi_p (sizetree
)
4230 || (tree_to_uhwi (sizetree
) * BITS_PER_UNIT
) % round_boundary
))
4231 s2
= round_up (s2
, round_boundary
/ BITS_PER_UNIT
);
4232 SUB_PARM_SIZE (locate
->slot_offset
, s2
);
4235 locate
->slot_offset
.constant
+= part_size_in_regs
;
4237 if (!in_regs
|| reg_parm_stack_space
> 0)
4238 pad_to_arg_alignment (&locate
->slot_offset
, boundary
,
4239 &locate
->alignment_pad
);
4241 locate
->size
.constant
= (-initial_offset_ptr
->constant
4242 - locate
->slot_offset
.constant
);
4243 if (initial_offset_ptr
->var
)
4244 locate
->size
.var
= size_binop (MINUS_EXPR
,
4245 size_binop (MINUS_EXPR
,
4247 initial_offset_ptr
->var
),
4248 locate
->slot_offset
.var
);
4250 /* Pad_below needs the pre-rounded size to know how much to pad
4252 locate
->offset
= locate
->slot_offset
;
4253 if (where_pad
== downward
)
4254 pad_below (&locate
->offset
, passed_mode
, sizetree
);
4259 if (!in_regs
|| reg_parm_stack_space
> 0)
4260 pad_to_arg_alignment (initial_offset_ptr
, boundary
,
4261 &locate
->alignment_pad
);
4262 locate
->slot_offset
= *initial_offset_ptr
;
4264 #ifdef PUSH_ROUNDING
4265 if (passed_mode
!= BLKmode
)
4266 sizetree
= size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree
)));
4269 /* Pad_below needs the pre-rounded size to know how much to pad below
4270 so this must be done before rounding up. */
4271 locate
->offset
= locate
->slot_offset
;
4272 if (where_pad
== downward
)
4273 pad_below (&locate
->offset
, passed_mode
, sizetree
);
4275 if (where_pad
!= none
4276 && (!tree_fits_uhwi_p (sizetree
)
4277 || (tree_to_uhwi (sizetree
) * BITS_PER_UNIT
) % round_boundary
))
4278 sizetree
= round_up (sizetree
, round_boundary
/ BITS_PER_UNIT
);
4280 ADD_PARM_SIZE (locate
->size
, sizetree
);
4282 locate
->size
.constant
-= part_size_in_regs
;
4285 #ifdef FUNCTION_ARG_OFFSET
4286 locate
->offset
.constant
+= FUNCTION_ARG_OFFSET (passed_mode
, type
);
4290 /* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY.
4291 BOUNDARY is measured in bits, but must be a multiple of a storage unit. */
4294 pad_to_arg_alignment (struct args_size
*offset_ptr
, int boundary
,
4295 struct args_size
*alignment_pad
)
4297 tree save_var
= NULL_TREE
;
4298 HOST_WIDE_INT save_constant
= 0;
4299 int boundary_in_bytes
= boundary
/ BITS_PER_UNIT
;
4300 HOST_WIDE_INT sp_offset
= STACK_POINTER_OFFSET
;
4302 #ifdef SPARC_STACK_BOUNDARY_HACK
4303 /* ??? The SPARC port may claim a STACK_BOUNDARY higher than
4304 the real alignment of %sp. However, when it does this, the
4305 alignment of %sp+STACK_POINTER_OFFSET is STACK_BOUNDARY. */
4306 if (SPARC_STACK_BOUNDARY_HACK
)
4310 if (boundary
> PARM_BOUNDARY
)
4312 save_var
= offset_ptr
->var
;
4313 save_constant
= offset_ptr
->constant
;
4316 alignment_pad
->var
= NULL_TREE
;
4317 alignment_pad
->constant
= 0;
4319 if (boundary
> BITS_PER_UNIT
)
4321 if (offset_ptr
->var
)
4323 tree sp_offset_tree
= ssize_int (sp_offset
);
4324 tree offset
= size_binop (PLUS_EXPR
,
4325 ARGS_SIZE_TREE (*offset_ptr
),
4328 if (ARGS_GROW_DOWNWARD
)
4329 rounded
= round_down (offset
, boundary
/ BITS_PER_UNIT
);
4331 rounded
= round_up (offset
, boundary
/ BITS_PER_UNIT
);
4333 offset_ptr
->var
= size_binop (MINUS_EXPR
, rounded
, sp_offset_tree
);
4334 /* ARGS_SIZE_TREE includes constant term. */
4335 offset_ptr
->constant
= 0;
4336 if (boundary
> PARM_BOUNDARY
)
4337 alignment_pad
->var
= size_binop (MINUS_EXPR
, offset_ptr
->var
,
4342 offset_ptr
->constant
= -sp_offset
+
4344 ? FLOOR_ROUND (offset_ptr
->constant
+ sp_offset
, boundary_in_bytes
)
4345 : CEIL_ROUND (offset_ptr
->constant
+ sp_offset
, boundary_in_bytes
));
4347 if (boundary
> PARM_BOUNDARY
)
4348 alignment_pad
->constant
= offset_ptr
->constant
- save_constant
;
4354 pad_below (struct args_size
*offset_ptr
, machine_mode passed_mode
, tree sizetree
)
4356 if (passed_mode
!= BLKmode
)
4358 if (GET_MODE_BITSIZE (passed_mode
) % PARM_BOUNDARY
)
4359 offset_ptr
->constant
4360 += (((GET_MODE_BITSIZE (passed_mode
) + PARM_BOUNDARY
- 1)
4361 / PARM_BOUNDARY
* PARM_BOUNDARY
/ BITS_PER_UNIT
)
4362 - GET_MODE_SIZE (passed_mode
));
4366 if (TREE_CODE (sizetree
) != INTEGER_CST
4367 || (TREE_INT_CST_LOW (sizetree
) * BITS_PER_UNIT
) % PARM_BOUNDARY
)
4369 /* Round the size up to multiple of PARM_BOUNDARY bits. */
4370 tree s2
= round_up (sizetree
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
4372 ADD_PARM_SIZE (*offset_ptr
, s2
);
4373 SUB_PARM_SIZE (*offset_ptr
, sizetree
);
4379 /* True if register REGNO was alive at a place where `setjmp' was
4380 called and was set more than once or is an argument. Such regs may
4381 be clobbered by `longjmp'. */
4384 regno_clobbered_at_setjmp (bitmap setjmp_crosses
, int regno
)
4386 /* There appear to be cases where some local vars never reach the
4387 backend but have bogus regnos. */
4388 if (regno
>= max_reg_num ())
4391 return ((REG_N_SETS (regno
) > 1
4392 || REGNO_REG_SET_P (df_get_live_out (ENTRY_BLOCK_PTR_FOR_FN (cfun
)),
4394 && REGNO_REG_SET_P (setjmp_crosses
, regno
));
4397 /* Walk the tree of blocks describing the binding levels within a
4398 function and warn about variables the might be killed by setjmp or
4399 vfork. This is done after calling flow_analysis before register
4400 allocation since that will clobber the pseudo-regs to hard
4404 setjmp_vars_warning (bitmap setjmp_crosses
, tree block
)
4408 for (decl
= BLOCK_VARS (block
); decl
; decl
= DECL_CHAIN (decl
))
4410 if (TREE_CODE (decl
) == VAR_DECL
4411 && DECL_RTL_SET_P (decl
)
4412 && REG_P (DECL_RTL (decl
))
4413 && regno_clobbered_at_setjmp (setjmp_crosses
, REGNO (DECL_RTL (decl
))))
4414 warning (OPT_Wclobbered
, "variable %q+D might be clobbered by"
4415 " %<longjmp%> or %<vfork%>", decl
);
4418 for (sub
= BLOCK_SUBBLOCKS (block
); sub
; sub
= BLOCK_CHAIN (sub
))
4419 setjmp_vars_warning (setjmp_crosses
, sub
);
4422 /* Do the appropriate part of setjmp_vars_warning
4423 but for arguments instead of local variables. */
4426 setjmp_args_warning (bitmap setjmp_crosses
)
4429 for (decl
= DECL_ARGUMENTS (current_function_decl
);
4430 decl
; decl
= DECL_CHAIN (decl
))
4431 if (DECL_RTL (decl
) != 0
4432 && REG_P (DECL_RTL (decl
))
4433 && regno_clobbered_at_setjmp (setjmp_crosses
, REGNO (DECL_RTL (decl
))))
4434 warning (OPT_Wclobbered
,
4435 "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>",
4439 /* Generate warning messages for variables live across setjmp. */
4442 generate_setjmp_warnings (void)
4444 bitmap setjmp_crosses
= regstat_get_setjmp_crosses ();
4446 if (n_basic_blocks_for_fn (cfun
) == NUM_FIXED_BLOCKS
4447 || bitmap_empty_p (setjmp_crosses
))
4450 setjmp_vars_warning (setjmp_crosses
, DECL_INITIAL (current_function_decl
));
4451 setjmp_args_warning (setjmp_crosses
);
4455 /* Reverse the order of elements in the fragment chain T of blocks,
4456 and return the new head of the chain (old last element).
4457 In addition to that clear BLOCK_SAME_RANGE flags when needed
4458 and adjust BLOCK_SUPERCONTEXT from the super fragment to
4459 its super fragment origin. */
4462 block_fragments_nreverse (tree t
)
4464 tree prev
= 0, block
, next
, prev_super
= 0;
4465 tree super
= BLOCK_SUPERCONTEXT (t
);
4466 if (BLOCK_FRAGMENT_ORIGIN (super
))
4467 super
= BLOCK_FRAGMENT_ORIGIN (super
);
4468 for (block
= t
; block
; block
= next
)
4470 next
= BLOCK_FRAGMENT_CHAIN (block
);
4471 BLOCK_FRAGMENT_CHAIN (block
) = prev
;
4472 if ((prev
&& !BLOCK_SAME_RANGE (prev
))
4473 || (BLOCK_FRAGMENT_CHAIN (BLOCK_SUPERCONTEXT (block
))
4475 BLOCK_SAME_RANGE (block
) = 0;
4476 prev_super
= BLOCK_SUPERCONTEXT (block
);
4477 BLOCK_SUPERCONTEXT (block
) = super
;
4480 t
= BLOCK_FRAGMENT_ORIGIN (t
);
4481 if (BLOCK_FRAGMENT_CHAIN (BLOCK_SUPERCONTEXT (t
))
4483 BLOCK_SAME_RANGE (t
) = 0;
4484 BLOCK_SUPERCONTEXT (t
) = super
;
4488 /* Reverse the order of elements in the chain T of blocks,
4489 and return the new head of the chain (old last element).
4490 Also do the same on subblocks and reverse the order of elements
4491 in BLOCK_FRAGMENT_CHAIN as well. */
4494 blocks_nreverse_all (tree t
)
4496 tree prev
= 0, block
, next
;
4497 for (block
= t
; block
; block
= next
)
4499 next
= BLOCK_CHAIN (block
);
4500 BLOCK_CHAIN (block
) = prev
;
4501 if (BLOCK_FRAGMENT_CHAIN (block
)
4502 && BLOCK_FRAGMENT_ORIGIN (block
) == NULL_TREE
)
4504 BLOCK_FRAGMENT_CHAIN (block
)
4505 = block_fragments_nreverse (BLOCK_FRAGMENT_CHAIN (block
));
4506 if (!BLOCK_SAME_RANGE (BLOCK_FRAGMENT_CHAIN (block
)))
4507 BLOCK_SAME_RANGE (block
) = 0;
4509 BLOCK_SUBBLOCKS (block
) = blocks_nreverse_all (BLOCK_SUBBLOCKS (block
));
4516 /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
4517 and create duplicate blocks. */
4518 /* ??? Need an option to either create block fragments or to create
4519 abstract origin duplicates of a source block. It really depends
4520 on what optimization has been performed. */
4523 reorder_blocks (void)
4525 tree block
= DECL_INITIAL (current_function_decl
);
4527 if (block
== NULL_TREE
)
4530 auto_vec
<tree
, 10> block_stack
;
4532 /* Reset the TREE_ASM_WRITTEN bit for all blocks. */
4533 clear_block_marks (block
);
4535 /* Prune the old trees away, so that they don't get in the way. */
4536 BLOCK_SUBBLOCKS (block
) = NULL_TREE
;
4537 BLOCK_CHAIN (block
) = NULL_TREE
;
4539 /* Recreate the block tree from the note nesting. */
4540 reorder_blocks_1 (get_insns (), block
, &block_stack
);
4541 BLOCK_SUBBLOCKS (block
) = blocks_nreverse_all (BLOCK_SUBBLOCKS (block
));
4544 /* Helper function for reorder_blocks. Reset TREE_ASM_WRITTEN. */
4547 clear_block_marks (tree block
)
4551 TREE_ASM_WRITTEN (block
) = 0;
4552 clear_block_marks (BLOCK_SUBBLOCKS (block
));
4553 block
= BLOCK_CHAIN (block
);
4558 reorder_blocks_1 (rtx_insn
*insns
, tree current_block
,
4559 vec
<tree
> *p_block_stack
)
4562 tree prev_beg
= NULL_TREE
, prev_end
= NULL_TREE
;
4564 for (insn
= insns
; insn
; insn
= NEXT_INSN (insn
))
4568 if (NOTE_KIND (insn
) == NOTE_INSN_BLOCK_BEG
)
4570 tree block
= NOTE_BLOCK (insn
);
4573 gcc_assert (BLOCK_FRAGMENT_ORIGIN (block
) == NULL_TREE
);
4577 BLOCK_SAME_RANGE (prev_end
) = 0;
4578 prev_end
= NULL_TREE
;
4580 /* If we have seen this block before, that means it now
4581 spans multiple address regions. Create a new fragment. */
4582 if (TREE_ASM_WRITTEN (block
))
4584 tree new_block
= copy_node (block
);
4586 BLOCK_SAME_RANGE (new_block
) = 0;
4587 BLOCK_FRAGMENT_ORIGIN (new_block
) = origin
;
4588 BLOCK_FRAGMENT_CHAIN (new_block
)
4589 = BLOCK_FRAGMENT_CHAIN (origin
);
4590 BLOCK_FRAGMENT_CHAIN (origin
) = new_block
;
4592 NOTE_BLOCK (insn
) = new_block
;
4596 if (prev_beg
== current_block
&& prev_beg
)
4597 BLOCK_SAME_RANGE (block
) = 1;
4601 BLOCK_SUBBLOCKS (block
) = 0;
4602 TREE_ASM_WRITTEN (block
) = 1;
4603 /* When there's only one block for the entire function,
4604 current_block == block and we mustn't do this, it
4605 will cause infinite recursion. */
4606 if (block
!= current_block
)
4609 if (block
!= origin
)
4610 gcc_assert (BLOCK_SUPERCONTEXT (origin
) == current_block
4611 || BLOCK_FRAGMENT_ORIGIN (BLOCK_SUPERCONTEXT
4614 if (p_block_stack
->is_empty ())
4615 super
= current_block
;
4618 super
= p_block_stack
->last ();
4619 gcc_assert (super
== current_block
4620 || BLOCK_FRAGMENT_ORIGIN (super
)
4623 BLOCK_SUPERCONTEXT (block
) = super
;
4624 BLOCK_CHAIN (block
) = BLOCK_SUBBLOCKS (current_block
);
4625 BLOCK_SUBBLOCKS (current_block
) = block
;
4626 current_block
= origin
;
4628 p_block_stack
->safe_push (block
);
4630 else if (NOTE_KIND (insn
) == NOTE_INSN_BLOCK_END
)
4632 NOTE_BLOCK (insn
) = p_block_stack
->pop ();
4633 current_block
= BLOCK_SUPERCONTEXT (current_block
);
4634 if (BLOCK_FRAGMENT_ORIGIN (current_block
))
4635 current_block
= BLOCK_FRAGMENT_ORIGIN (current_block
);
4636 prev_beg
= NULL_TREE
;
4637 prev_end
= BLOCK_SAME_RANGE (NOTE_BLOCK (insn
))
4638 ? NOTE_BLOCK (insn
) : NULL_TREE
;
4643 prev_beg
= NULL_TREE
;
4645 BLOCK_SAME_RANGE (prev_end
) = 0;
4646 prev_end
= NULL_TREE
;
4651 /* Reverse the order of elements in the chain T of blocks,
4652 and return the new head of the chain (old last element). */
4655 blocks_nreverse (tree t
)
4657 tree prev
= 0, block
, next
;
4658 for (block
= t
; block
; block
= next
)
4660 next
= BLOCK_CHAIN (block
);
4661 BLOCK_CHAIN (block
) = prev
;
4667 /* Concatenate two chains of blocks (chained through BLOCK_CHAIN)
4668 by modifying the last node in chain 1 to point to chain 2. */
4671 block_chainon (tree op1
, tree op2
)
4680 for (t1
= op1
; BLOCK_CHAIN (t1
); t1
= BLOCK_CHAIN (t1
))
4682 BLOCK_CHAIN (t1
) = op2
;
4684 #ifdef ENABLE_TREE_CHECKING
4687 for (t2
= op2
; t2
; t2
= BLOCK_CHAIN (t2
))
4688 gcc_assert (t2
!= t1
);
4695 /* Count the subblocks of the list starting with BLOCK. If VECTOR is
4696 non-NULL, list them all into VECTOR, in a depth-first preorder
4697 traversal of the block tree. Also clear TREE_ASM_WRITTEN in all
4701 all_blocks (tree block
, tree
*vector
)
4707 TREE_ASM_WRITTEN (block
) = 0;
4709 /* Record this block. */
4711 vector
[n_blocks
] = block
;
4715 /* Record the subblocks, and their subblocks... */
4716 n_blocks
+= all_blocks (BLOCK_SUBBLOCKS (block
),
4717 vector
? vector
+ n_blocks
: 0);
4718 block
= BLOCK_CHAIN (block
);
4724 /* Return a vector containing all the blocks rooted at BLOCK. The
4725 number of elements in the vector is stored in N_BLOCKS_P. The
4726 vector is dynamically allocated; it is the caller's responsibility
4727 to call `free' on the pointer returned. */
4730 get_block_vector (tree block
, int *n_blocks_p
)
4734 *n_blocks_p
= all_blocks (block
, NULL
);
4735 block_vector
= XNEWVEC (tree
, *n_blocks_p
);
4736 all_blocks (block
, block_vector
);
4738 return block_vector
;
4741 static GTY(()) int next_block_index
= 2;
4743 /* Set BLOCK_NUMBER for all the blocks in FN. */
4746 number_blocks (tree fn
)
4752 /* For SDB and XCOFF debugging output, we start numbering the blocks
4753 from 1 within each function, rather than keeping a running
4755 #if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
4756 if (write_symbols
== SDB_DEBUG
|| write_symbols
== XCOFF_DEBUG
)
4757 next_block_index
= 1;
4760 block_vector
= get_block_vector (DECL_INITIAL (fn
), &n_blocks
);
4762 /* The top-level BLOCK isn't numbered at all. */
4763 for (i
= 1; i
< n_blocks
; ++i
)
4764 /* We number the blocks from two. */
4765 BLOCK_NUMBER (block_vector
[i
]) = next_block_index
++;
4767 free (block_vector
);
4772 /* If VAR is present in a subblock of BLOCK, return the subblock. */
4775 debug_find_var_in_block_tree (tree var
, tree block
)
4779 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
4783 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= TREE_CHAIN (t
))
4785 tree ret
= debug_find_var_in_block_tree (var
, t
);
4793 /* Keep track of whether we're in a dummy function context. If we are,
4794 we don't want to invoke the set_current_function hook, because we'll
4795 get into trouble if the hook calls target_reinit () recursively or
4796 when the initial initialization is not yet complete. */
4798 static bool in_dummy_function
;
4800 /* Invoke the target hook when setting cfun. Update the optimization options
4801 if the function uses different options than the default. */
4804 invoke_set_current_function_hook (tree fndecl
)
4806 if (!in_dummy_function
)
4808 tree opts
= ((fndecl
)
4809 ? DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl
)
4810 : optimization_default_node
);
4813 opts
= optimization_default_node
;
4815 /* Change optimization options if needed. */
4816 if (optimization_current_node
!= opts
)
4818 optimization_current_node
= opts
;
4819 cl_optimization_restore (&global_options
, TREE_OPTIMIZATION (opts
));
4822 targetm
.set_current_function (fndecl
);
4823 this_fn_optabs
= this_target_optabs
;
4825 if (opts
!= optimization_default_node
)
4827 init_tree_optimization_optabs (opts
);
4828 if (TREE_OPTIMIZATION_OPTABS (opts
))
4829 this_fn_optabs
= (struct target_optabs
*)
4830 TREE_OPTIMIZATION_OPTABS (opts
);
4835 /* cfun should never be set directly; use this function. */
4838 set_cfun (struct function
*new_cfun
)
4840 if (cfun
!= new_cfun
)
4843 invoke_set_current_function_hook (new_cfun
? new_cfun
->decl
: NULL_TREE
);
4847 /* Initialized with NOGC, making this poisonous to the garbage collector. */
4849 static vec
<function_p
> cfun_stack
;
4851 /* Push the current cfun onto the stack, and set cfun to new_cfun. Also set
4852 current_function_decl accordingly. */
4855 push_cfun (struct function
*new_cfun
)
4857 gcc_assert ((!cfun
&& !current_function_decl
)
4858 || (cfun
&& current_function_decl
== cfun
->decl
));
4859 cfun_stack
.safe_push (cfun
);
4860 current_function_decl
= new_cfun
? new_cfun
->decl
: NULL_TREE
;
4861 set_cfun (new_cfun
);
4864 /* Pop cfun from the stack. Also set current_function_decl accordingly. */
4869 struct function
*new_cfun
= cfun_stack
.pop ();
4870 /* When in_dummy_function, we do have a cfun but current_function_decl is
4871 NULL. We also allow pushing NULL cfun and subsequently changing
4872 current_function_decl to something else and have both restored by
4874 gcc_checking_assert (in_dummy_function
4876 || current_function_decl
== cfun
->decl
);
4877 set_cfun (new_cfun
);
4878 current_function_decl
= new_cfun
? new_cfun
->decl
: NULL_TREE
;
4881 /* Return value of funcdef and increase it. */
4883 get_next_funcdef_no (void)
4885 return funcdef_no
++;
4888 /* Return value of funcdef. */
4890 get_last_funcdef_no (void)
4895 /* Allocate a function structure for FNDECL and set its contents
4896 to the defaults. Set cfun to the newly-allocated object.
4897 Some of the helper functions invoked during initialization assume
4898 that cfun has already been set. Therefore, assign the new object
4899 directly into cfun and invoke the back end hook explicitly at the
4900 very end, rather than initializing a temporary and calling set_cfun
4903 ABSTRACT_P is true if this is a function that will never be seen by
4904 the middle-end. Such functions are front-end concepts (like C++
4905 function templates) that do not correspond directly to functions
4906 placed in object files. */
4909 allocate_struct_function (tree fndecl
, bool abstract_p
)
4911 tree fntype
= fndecl
? TREE_TYPE (fndecl
) : NULL_TREE
;
4913 cfun
= ggc_cleared_alloc
<function
> ();
4915 init_eh_for_function ();
4917 if (init_machine_status
)
4918 cfun
->machine
= (*init_machine_status
) ();
4920 #ifdef OVERRIDE_ABI_FORMAT
4921 OVERRIDE_ABI_FORMAT (fndecl
);
4924 if (fndecl
!= NULL_TREE
)
4926 DECL_STRUCT_FUNCTION (fndecl
) = cfun
;
4927 cfun
->decl
= fndecl
;
4928 current_function_funcdef_no
= get_next_funcdef_no ();
4931 invoke_set_current_function_hook (fndecl
);
4933 if (fndecl
!= NULL_TREE
)
4935 tree result
= DECL_RESULT (fndecl
);
4936 if (!abstract_p
&& aggregate_value_p (result
, fndecl
))
4938 #ifdef PCC_STATIC_STRUCT_RETURN
4939 cfun
->returns_pcc_struct
= 1;
4941 cfun
->returns_struct
= 1;
4944 cfun
->stdarg
= stdarg_p (fntype
);
4946 /* Assume all registers in stdarg functions need to be saved. */
4947 cfun
->va_list_gpr_size
= VA_LIST_MAX_GPR_SIZE
;
4948 cfun
->va_list_fpr_size
= VA_LIST_MAX_FPR_SIZE
;
4950 /* ??? This could be set on a per-function basis by the front-end
4951 but is this worth the hassle? */
4952 cfun
->can_throw_non_call_exceptions
= flag_non_call_exceptions
;
4953 cfun
->can_delete_dead_exceptions
= flag_delete_dead_exceptions
;
4955 if (!profile_flag
&& !flag_instrument_function_entry_exit
)
4956 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl
) = 1;
4960 /* This is like allocate_struct_function, but pushes a new cfun for FNDECL
4961 instead of just setting it. */
4964 push_struct_function (tree fndecl
)
4966 /* When in_dummy_function we might be in the middle of a pop_cfun and
4967 current_function_decl and cfun may not match. */
4968 gcc_assert (in_dummy_function
4969 || (!cfun
&& !current_function_decl
)
4970 || (cfun
&& current_function_decl
== cfun
->decl
));
4971 cfun_stack
.safe_push (cfun
);
4972 current_function_decl
= fndecl
;
4973 allocate_struct_function (fndecl
, false);
4976 /* Reset crtl and other non-struct-function variables to defaults as
4977 appropriate for emitting rtl at the start of a function. */
4980 prepare_function_start (void)
4982 gcc_assert (!get_last_insn ());
4985 init_varasm_status ();
4987 default_rtl_profile ();
4989 if (flag_stack_usage_info
)
4991 cfun
->su
= ggc_cleared_alloc
<stack_usage
> ();
4992 cfun
->su
->static_stack_size
= -1;
4995 cse_not_expected
= ! optimize
;
4997 /* Caller save not needed yet. */
4998 caller_save_needed
= 0;
5000 /* We haven't done register allocation yet. */
5003 /* Indicate that we have not instantiated virtual registers yet. */
5004 virtuals_instantiated
= 0;
5006 /* Indicate that we want CONCATs now. */
5007 generating_concat_p
= 1;
5009 /* Indicate we have no need of a frame pointer yet. */
5010 frame_pointer_needed
= 0;
5014 push_dummy_function (bool with_decl
)
5016 tree fn_decl
, fn_type
, fn_result_decl
;
5018 gcc_assert (!in_dummy_function
);
5019 in_dummy_function
= true;
5023 fn_type
= build_function_type_list (void_type_node
, NULL_TREE
);
5024 fn_decl
= build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
, NULL_TREE
,
5026 fn_result_decl
= build_decl (UNKNOWN_LOCATION
, RESULT_DECL
,
5027 NULL_TREE
, void_type_node
);
5028 DECL_RESULT (fn_decl
) = fn_result_decl
;
5031 fn_decl
= NULL_TREE
;
5033 push_struct_function (fn_decl
);
5036 /* Initialize the rtl expansion mechanism so that we can do simple things
5037 like generate sequences. This is used to provide a context during global
5038 initialization of some passes. You must call expand_dummy_function_end
5039 to exit this context. */
5042 init_dummy_function_start (void)
5044 push_dummy_function (false);
5045 prepare_function_start ();
5048 /* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node)
5049 and initialize static variables for generating RTL for the statements
5053 init_function_start (tree subr
)
5055 if (subr
&& DECL_STRUCT_FUNCTION (subr
))
5056 set_cfun (DECL_STRUCT_FUNCTION (subr
));
5058 allocate_struct_function (subr
, false);
5060 /* Initialize backend, if needed. */
5063 prepare_function_start ();
5064 decide_function_section (subr
);
5066 /* Warn if this value is an aggregate type,
5067 regardless of which calling convention we are using for it. */
5068 if (AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr
))))
5069 warning (OPT_Waggregate_return
, "function returns an aggregate");
5072 /* Expand code to verify the stack_protect_guard. This is invoked at
5073 the end of a function to be protected. */
5076 stack_protect_epilogue (void)
5078 tree guard_decl
= targetm
.stack_protect_guard ();
5079 rtx_code_label
*label
= gen_label_rtx ();
5083 x
= expand_normal (crtl
->stack_protect_guard
);
5084 y
= expand_normal (guard_decl
);
5086 /* Allow the target to compare Y with X without leaking either into
5088 if (targetm
.have_stack_protect_test ()
5089 && ((seq
= targetm
.gen_stack_protect_test (x
, y
, label
)) != NULL_RTX
))
5092 emit_cmp_and_jump_insns (x
, y
, EQ
, NULL_RTX
, ptr_mode
, 1, label
);
5094 /* The noreturn predictor has been moved to the tree level. The rtl-level
5095 predictors estimate this branch about 20%, which isn't enough to get
5096 things moved out of line. Since this is the only extant case of adding
5097 a noreturn function at the rtl level, it doesn't seem worth doing ought
5098 except adding the prediction by hand. */
5099 tmp
= get_last_insn ();
5101 predict_insn_def (as_a
<rtx_insn
*> (tmp
), PRED_NORETURN
, TAKEN
);
5103 expand_call (targetm
.stack_protect_fail (), NULL_RTX
, /*ignore=*/true);
5108 /* Start the RTL for a new function, and set variables used for
5110 SUBR is the FUNCTION_DECL node.
5111 PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with
5112 the function's parameters, which must be run at any return statement. */
5115 expand_function_start (tree subr
)
5117 /* Make sure volatile mem refs aren't considered
5118 valid operands of arithmetic insns. */
5119 init_recog_no_volatile ();
5123 && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr
));
5126 = (stack_limit_rtx
!= NULL_RTX
&& ! DECL_NO_LIMIT_STACK (subr
));
5128 /* Make the label for return statements to jump to. Do not special
5129 case machines with special return instructions -- they will be
5130 handled later during jump, ifcvt, or epilogue creation. */
5131 return_label
= gen_label_rtx ();
5133 /* Initialize rtx used to return the value. */
5134 /* Do this before assign_parms so that we copy the struct value address
5135 before any library calls that assign parms might generate. */
5137 /* Decide whether to return the value in memory or in a register. */
5138 tree res
= DECL_RESULT (subr
);
5139 maybe_reset_rtl_for_parm (res
);
5140 if (aggregate_value_p (res
, subr
))
5142 /* Returning something that won't go in a register. */
5143 rtx value_address
= 0;
5145 #ifdef PCC_STATIC_STRUCT_RETURN
5146 if (cfun
->returns_pcc_struct
)
5148 int size
= int_size_in_bytes (TREE_TYPE (res
));
5149 value_address
= assemble_static_space (size
);
5154 rtx sv
= targetm
.calls
.struct_value_rtx (TREE_TYPE (subr
), 2);
5155 /* Expect to be passed the address of a place to store the value.
5156 If it is passed as an argument, assign_parms will take care of
5160 if (DECL_BY_REFERENCE (res
))
5161 value_address
= get_rtl_for_parm_ssa_default_def (res
);
5163 value_address
= gen_reg_rtx (Pmode
);
5164 emit_move_insn (value_address
, sv
);
5169 rtx x
= value_address
;
5170 if (!DECL_BY_REFERENCE (res
))
5172 x
= get_rtl_for_parm_ssa_default_def (res
);
5175 x
= gen_rtx_MEM (DECL_MODE (res
), value_address
);
5176 set_mem_attributes (x
, res
, 1);
5179 SET_DECL_RTL (res
, x
);
5182 else if (DECL_MODE (res
) == VOIDmode
)
5183 /* If return mode is void, this decl rtl should not be used. */
5184 SET_DECL_RTL (res
, NULL_RTX
);
5187 /* Compute the return values into a pseudo reg, which we will copy
5188 into the true return register after the cleanups are done. */
5189 tree return_type
= TREE_TYPE (res
);
5190 rtx x
= get_rtl_for_parm_ssa_default_def (res
);
5193 else if (TYPE_MODE (return_type
) != BLKmode
5194 && targetm
.calls
.return_in_msb (return_type
))
5195 /* expand_function_end will insert the appropriate padding in
5196 this case. Use the return value's natural (unpadded) mode
5197 within the function proper. */
5198 x
= gen_reg_rtx (TYPE_MODE (return_type
));
5201 /* In order to figure out what mode to use for the pseudo, we
5202 figure out what the mode of the eventual return register will
5203 actually be, and use that. */
5204 rtx hard_reg
= hard_function_value (return_type
, subr
, 0, 1);
5206 /* Structures that are returned in registers are not
5207 aggregate_value_p, so we may see a PARALLEL or a REG. */
5208 if (REG_P (hard_reg
))
5209 x
= gen_reg_rtx (GET_MODE (hard_reg
));
5212 gcc_assert (GET_CODE (hard_reg
) == PARALLEL
);
5213 x
= gen_group_rtx (hard_reg
);
5217 SET_DECL_RTL (res
, x
);
5219 /* Set DECL_REGISTER flag so that expand_function_end will copy the
5220 result to the real return register(s). */
5221 DECL_REGISTER (res
) = 1;
5223 if (chkp_function_instrumented_p (current_function_decl
))
5225 tree return_type
= TREE_TYPE (res
);
5226 rtx bounds
= targetm
.calls
.chkp_function_value_bounds (return_type
,
5228 SET_DECL_BOUNDS_RTL (res
, bounds
);
5232 /* Initialize rtx for parameters and local variables.
5233 In some cases this requires emitting insns. */
5234 assign_parms (subr
);
5236 /* If function gets a static chain arg, store it. */
5237 if (cfun
->static_chain_decl
)
5239 tree parm
= cfun
->static_chain_decl
;
5243 local
= get_rtl_for_parm_ssa_default_def (parm
);
5245 local
= gen_reg_rtx (Pmode
);
5246 chain
= targetm
.calls
.static_chain (current_function_decl
, true);
5248 set_decl_incoming_rtl (parm
, chain
, false);
5249 SET_DECL_RTL (parm
, local
);
5250 mark_reg_pointer (local
, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm
))));
5252 if (GET_MODE (local
) != Pmode
)
5253 local
= convert_to_mode (Pmode
, local
,
5254 TYPE_UNSIGNED (TREE_TYPE (parm
)));
5256 insn
= emit_move_insn (local
, chain
);
5258 /* Mark the register as eliminable, similar to parameters. */
5260 && reg_mentioned_p (arg_pointer_rtx
, XEXP (chain
, 0)))
5261 set_dst_reg_note (insn
, REG_EQUIV
, chain
, local
);
5263 /* If we aren't optimizing, save the static chain onto the stack. */
5266 tree saved_static_chain_decl
5267 = build_decl (DECL_SOURCE_LOCATION (parm
), VAR_DECL
,
5268 DECL_NAME (parm
), TREE_TYPE (parm
));
5269 rtx saved_static_chain_rtx
5270 = assign_stack_local (Pmode
, GET_MODE_SIZE (Pmode
), 0);
5271 SET_DECL_RTL (saved_static_chain_decl
, saved_static_chain_rtx
);
5272 emit_move_insn (saved_static_chain_rtx
, chain
);
5273 SET_DECL_VALUE_EXPR (parm
, saved_static_chain_decl
);
5274 DECL_HAS_VALUE_EXPR_P (parm
) = 1;
5278 /* If the function receives a non-local goto, then store the
5279 bits we need to restore the frame pointer. */
5280 if (cfun
->nonlocal_goto_save_area
)
5285 tree var
= TREE_OPERAND (cfun
->nonlocal_goto_save_area
, 0);
5286 gcc_assert (DECL_RTL_SET_P (var
));
5288 t_save
= build4 (ARRAY_REF
,
5289 TREE_TYPE (TREE_TYPE (cfun
->nonlocal_goto_save_area
)),
5290 cfun
->nonlocal_goto_save_area
,
5291 integer_zero_node
, NULL_TREE
, NULL_TREE
);
5292 r_save
= expand_expr (t_save
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
5293 gcc_assert (GET_MODE (r_save
) == Pmode
);
5295 emit_move_insn (r_save
, targetm
.builtin_setjmp_frame_value ());
5296 update_nonlocal_goto_save_area ();
5299 /* The following was moved from init_function_start.
5300 The move is supposed to make sdb output more accurate. */
5301 /* Indicate the beginning of the function body,
5302 as opposed to parm setup. */
5303 emit_note (NOTE_INSN_FUNCTION_BEG
);
5305 gcc_assert (NOTE_P (get_last_insn ()));
5307 parm_birth_insn
= get_last_insn ();
5312 PROFILE_HOOK (current_function_funcdef_no
);
5316 /* If we are doing generic stack checking, the probe should go here. */
5317 if (flag_stack_check
== GENERIC_STACK_CHECK
)
5318 stack_check_probe_note
= emit_note (NOTE_INSN_DELETED
);
5322 pop_dummy_function (void)
5325 in_dummy_function
= false;
5328 /* Undo the effects of init_dummy_function_start. */
5330 expand_dummy_function_end (void)
5332 gcc_assert (in_dummy_function
);
5334 /* End any sequences that failed to be closed due to syntax errors. */
5335 while (in_sequence_p ())
5338 /* Outside function body, can't compute type's actual size
5339 until next function's body starts. */
5341 free_after_parsing (cfun
);
5342 free_after_compilation (cfun
);
5343 pop_dummy_function ();
5346 /* Helper for diddle_return_value. */
5349 diddle_return_value_1 (void (*doit
) (rtx
, void *), void *arg
, rtx outgoing
)
5354 if (REG_P (outgoing
))
5355 (*doit
) (outgoing
, arg
);
5356 else if (GET_CODE (outgoing
) == PARALLEL
)
5360 for (i
= 0; i
< XVECLEN (outgoing
, 0); i
++)
5362 rtx x
= XEXP (XVECEXP (outgoing
, 0, i
), 0);
5364 if (REG_P (x
) && REGNO (x
) < FIRST_PSEUDO_REGISTER
)
5370 /* Call DOIT for each hard register used as a return value from
5371 the current function. */
5374 diddle_return_value (void (*doit
) (rtx
, void *), void *arg
)
5376 diddle_return_value_1 (doit
, arg
, crtl
->return_bnd
);
5377 diddle_return_value_1 (doit
, arg
, crtl
->return_rtx
);
5381 do_clobber_return_reg (rtx reg
, void *arg ATTRIBUTE_UNUSED
)
5387 clobber_return_register (void)
5389 diddle_return_value (do_clobber_return_reg
, NULL
);
5391 /* In case we do use pseudo to return value, clobber it too. */
5392 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl
)))
5394 tree decl_result
= DECL_RESULT (current_function_decl
);
5395 rtx decl_rtl
= DECL_RTL (decl_result
);
5396 if (REG_P (decl_rtl
) && REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
)
5398 do_clobber_return_reg (decl_rtl
, NULL
);
5404 do_use_return_reg (rtx reg
, void *arg ATTRIBUTE_UNUSED
)
5410 use_return_register (void)
5412 diddle_return_value (do_use_return_reg
, NULL
);
5415 /* Set the location of the insn chain starting at INSN to LOC. */
5418 set_insn_locations (rtx_insn
*insn
, int loc
)
5420 while (insn
!= NULL
)
5423 INSN_LOCATION (insn
) = loc
;
5424 insn
= NEXT_INSN (insn
);
5428 /* Generate RTL for the end of the current function. */
5431 expand_function_end (void)
5433 /* If arg_pointer_save_area was referenced only from a nested
5434 function, we will not have initialized it yet. Do that now. */
5435 if (arg_pointer_save_area
&& ! crtl
->arg_pointer_save_area_init
)
5436 get_arg_pointer_save_area ();
5438 /* If we are doing generic stack checking and this function makes calls,
5439 do a stack probe at the start of the function to ensure we have enough
5440 space for another stack frame. */
5441 if (flag_stack_check
== GENERIC_STACK_CHECK
)
5443 rtx_insn
*insn
, *seq
;
5445 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
5448 rtx max_frame_size
= GEN_INT (STACK_CHECK_MAX_FRAME_SIZE
);
5450 if (STACK_CHECK_MOVING_SP
)
5451 anti_adjust_stack_and_probe (max_frame_size
, true);
5453 probe_stack_range (STACK_OLD_CHECK_PROTECT
, max_frame_size
);
5456 set_insn_locations (seq
, prologue_location
);
5457 emit_insn_before (seq
, stack_check_probe_note
);
5462 /* End any sequences that failed to be closed due to syntax errors. */
5463 while (in_sequence_p ())
5466 clear_pending_stack_adjust ();
5467 do_pending_stack_adjust ();
5469 /* Output a linenumber for the end of the function.
5470 SDB depends on this. */
5471 set_curr_insn_location (input_location
);
5473 /* Before the return label (if any), clobber the return
5474 registers so that they are not propagated live to the rest of
5475 the function. This can only happen with functions that drop
5476 through; if there had been a return statement, there would
5477 have either been a return rtx, or a jump to the return label.
5479 We delay actual code generation after the current_function_value_rtx
5481 rtx_insn
*clobber_after
= get_last_insn ();
5483 /* Output the label for the actual return from the function. */
5484 emit_label (return_label
);
5486 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
5488 /* Let except.c know where it should emit the call to unregister
5489 the function context for sjlj exceptions. */
5490 if (flag_exceptions
)
5491 sjlj_emit_function_exit_after (get_last_insn ());
5495 /* We want to ensure that instructions that may trap are not
5496 moved into the epilogue by scheduling, because we don't
5497 always emit unwind information for the epilogue. */
5498 if (cfun
->can_throw_non_call_exceptions
)
5499 emit_insn (gen_blockage ());
5502 /* If this is an implementation of throw, do what's necessary to
5503 communicate between __builtin_eh_return and the epilogue. */
5504 expand_eh_return ();
5506 /* If scalar return value was computed in a pseudo-reg, or was a named
5507 return value that got dumped to the stack, copy that to the hard
5509 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl
)))
5511 tree decl_result
= DECL_RESULT (current_function_decl
);
5512 rtx decl_rtl
= DECL_RTL (decl_result
);
5514 if (REG_P (decl_rtl
)
5515 ? REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
5516 : DECL_REGISTER (decl_result
))
5518 rtx real_decl_rtl
= crtl
->return_rtx
;
5520 /* This should be set in assign_parms. */
5521 gcc_assert (REG_FUNCTION_VALUE_P (real_decl_rtl
));
5523 /* If this is a BLKmode structure being returned in registers,
5524 then use the mode computed in expand_return. Note that if
5525 decl_rtl is memory, then its mode may have been changed,
5526 but that crtl->return_rtx has not. */
5527 if (GET_MODE (real_decl_rtl
) == BLKmode
)
5528 PUT_MODE (real_decl_rtl
, GET_MODE (decl_rtl
));
5530 /* If a non-BLKmode return value should be padded at the least
5531 significant end of the register, shift it left by the appropriate
5532 amount. BLKmode results are handled using the group load/store
5534 if (TYPE_MODE (TREE_TYPE (decl_result
)) != BLKmode
5535 && REG_P (real_decl_rtl
)
5536 && targetm
.calls
.return_in_msb (TREE_TYPE (decl_result
)))
5538 emit_move_insn (gen_rtx_REG (GET_MODE (decl_rtl
),
5539 REGNO (real_decl_rtl
)),
5541 shift_return_value (GET_MODE (decl_rtl
), true, real_decl_rtl
);
5543 /* If a named return value dumped decl_return to memory, then
5544 we may need to re-do the PROMOTE_MODE signed/unsigned
5546 else if (GET_MODE (real_decl_rtl
) != GET_MODE (decl_rtl
))
5548 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (decl_result
));
5549 promote_function_mode (TREE_TYPE (decl_result
),
5550 GET_MODE (decl_rtl
), &unsignedp
,
5551 TREE_TYPE (current_function_decl
), 1);
5553 convert_move (real_decl_rtl
, decl_rtl
, unsignedp
);
5555 else if (GET_CODE (real_decl_rtl
) == PARALLEL
)
5557 /* If expand_function_start has created a PARALLEL for decl_rtl,
5558 move the result to the real return registers. Otherwise, do
5559 a group load from decl_rtl for a named return. */
5560 if (GET_CODE (decl_rtl
) == PARALLEL
)
5561 emit_group_move (real_decl_rtl
, decl_rtl
);
5563 emit_group_load (real_decl_rtl
, decl_rtl
,
5564 TREE_TYPE (decl_result
),
5565 int_size_in_bytes (TREE_TYPE (decl_result
)));
5567 /* In the case of complex integer modes smaller than a word, we'll
5568 need to generate some non-trivial bitfield insertions. Do that
5569 on a pseudo and not the hard register. */
5570 else if (GET_CODE (decl_rtl
) == CONCAT
5571 && GET_MODE_CLASS (GET_MODE (decl_rtl
)) == MODE_COMPLEX_INT
5572 && GET_MODE_BITSIZE (GET_MODE (decl_rtl
)) <= BITS_PER_WORD
)
5574 int old_generating_concat_p
;
5577 old_generating_concat_p
= generating_concat_p
;
5578 generating_concat_p
= 0;
5579 tmp
= gen_reg_rtx (GET_MODE (decl_rtl
));
5580 generating_concat_p
= old_generating_concat_p
;
5582 emit_move_insn (tmp
, decl_rtl
);
5583 emit_move_insn (real_decl_rtl
, tmp
);
5586 emit_move_insn (real_decl_rtl
, decl_rtl
);
5590 /* If returning a structure, arrange to return the address of the value
5591 in a place where debuggers expect to find it.
5593 If returning a structure PCC style,
5594 the caller also depends on this value.
5595 And cfun->returns_pcc_struct is not necessarily set. */
5596 if ((cfun
->returns_struct
|| cfun
->returns_pcc_struct
)
5597 && !targetm
.calls
.omit_struct_return_reg
)
5599 rtx value_address
= DECL_RTL (DECL_RESULT (current_function_decl
));
5600 tree type
= TREE_TYPE (DECL_RESULT (current_function_decl
));
5603 if (DECL_BY_REFERENCE (DECL_RESULT (current_function_decl
)))
5604 type
= TREE_TYPE (type
);
5606 value_address
= XEXP (value_address
, 0);
5608 outgoing
= targetm
.calls
.function_value (build_pointer_type (type
),
5609 current_function_decl
, true);
5611 /* Mark this as a function return value so integrate will delete the
5612 assignment and USE below when inlining this function. */
5613 REG_FUNCTION_VALUE_P (outgoing
) = 1;
5615 /* The address may be ptr_mode and OUTGOING may be Pmode. */
5616 value_address
= convert_memory_address (GET_MODE (outgoing
),
5619 emit_move_insn (outgoing
, value_address
);
5621 /* Show return register used to hold result (in this case the address
5623 crtl
->return_rtx
= outgoing
;
5626 /* Emit the actual code to clobber return register. Don't emit
5627 it if clobber_after is a barrier, then the previous basic block
5628 certainly doesn't fall thru into the exit block. */
5629 if (!BARRIER_P (clobber_after
))
5632 clobber_return_register ();
5633 rtx_insn
*seq
= get_insns ();
5636 emit_insn_after (seq
, clobber_after
);
5639 /* Output the label for the naked return from the function. */
5640 if (naked_return_label
)
5641 emit_label (naked_return_label
);
5643 /* @@@ This is a kludge. We want to ensure that instructions that
5644 may trap are not moved into the epilogue by scheduling, because
5645 we don't always emit unwind information for the epilogue. */
5646 if (cfun
->can_throw_non_call_exceptions
5647 && targetm_common
.except_unwind_info (&global_options
) != UI_SJLJ
)
5648 emit_insn (gen_blockage ());
5650 /* If stack protection is enabled for this function, check the guard. */
5651 if (crtl
->stack_protect_guard
)
5652 stack_protect_epilogue ();
5654 /* If we had calls to alloca, and this machine needs
5655 an accurate stack pointer to exit the function,
5656 insert some code to save and restore the stack pointer. */
5657 if (! EXIT_IGNORE_STACK
5658 && cfun
->calls_alloca
)
5663 emit_stack_save (SAVE_FUNCTION
, &tem
);
5664 rtx_insn
*seq
= get_insns ();
5666 emit_insn_before (seq
, parm_birth_insn
);
5668 emit_stack_restore (SAVE_FUNCTION
, tem
);
5671 /* ??? This should no longer be necessary since stupid is no longer with
5672 us, but there are some parts of the compiler (eg reload_combine, and
5673 sh mach_dep_reorg) that still try and compute their own lifetime info
5674 instead of using the general framework. */
5675 use_return_register ();
5679 get_arg_pointer_save_area (void)
5681 rtx ret
= arg_pointer_save_area
;
5685 ret
= assign_stack_local (Pmode
, GET_MODE_SIZE (Pmode
), 0);
5686 arg_pointer_save_area
= ret
;
5689 if (! crtl
->arg_pointer_save_area_init
)
5691 /* Save the arg pointer at the beginning of the function. The
5692 generated stack slot may not be a valid memory address, so we
5693 have to check it and fix it if necessary. */
5695 emit_move_insn (validize_mem (copy_rtx (ret
)),
5696 crtl
->args
.internal_arg_pointer
);
5697 rtx_insn
*seq
= get_insns ();
5700 push_topmost_sequence ();
5701 emit_insn_after (seq
, entry_of_function ());
5702 pop_topmost_sequence ();
5704 crtl
->arg_pointer_save_area_init
= true;
5710 /* Add a list of INSNS to the hash HASHP, possibly allocating HASHP
5711 for the first time. */
5714 record_insns (rtx_insn
*insns
, rtx end
, hash_table
<insn_cache_hasher
> **hashp
)
5717 hash_table
<insn_cache_hasher
> *hash
= *hashp
;
5720 *hashp
= hash
= hash_table
<insn_cache_hasher
>::create_ggc (17);
5722 for (tmp
= insns
; tmp
!= end
; tmp
= NEXT_INSN (tmp
))
5724 rtx
*slot
= hash
->find_slot (tmp
, INSERT
);
5725 gcc_assert (*slot
== NULL
);
5730 /* INSN has been duplicated or replaced by as COPY, perhaps by duplicating a
5731 basic block, splitting or peepholes. If INSN is a prologue or epilogue
5732 insn, then record COPY as well. */
5735 maybe_copy_prologue_epilogue_insn (rtx insn
, rtx copy
)
5737 hash_table
<insn_cache_hasher
> *hash
;
5740 hash
= epilogue_insn_hash
;
5741 if (!hash
|| !hash
->find (insn
))
5743 hash
= prologue_insn_hash
;
5744 if (!hash
|| !hash
->find (insn
))
5748 slot
= hash
->find_slot (copy
, INSERT
);
5749 gcc_assert (*slot
== NULL
);
5753 /* Determine if any INSNs in HASH are, or are part of, INSN. Because
5754 we can be running after reorg, SEQUENCE rtl is possible. */
5757 contains (const_rtx insn
, hash_table
<insn_cache_hasher
> *hash
)
5762 if (NONJUMP_INSN_P (insn
) && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
5764 rtx_sequence
*seq
= as_a
<rtx_sequence
*> (PATTERN (insn
));
5766 for (i
= seq
->len () - 1; i
>= 0; i
--)
5767 if (hash
->find (seq
->element (i
)))
5772 return hash
->find (const_cast<rtx
> (insn
)) != NULL
;
5776 prologue_epilogue_contains (const_rtx insn
)
5778 if (contains (insn
, prologue_insn_hash
))
5780 if (contains (insn
, epilogue_insn_hash
))
5785 /* Insert use of return register before the end of BB. */
5788 emit_use_return_register_into_block (basic_block bb
)
5791 use_return_register ();
5792 rtx_insn
*seq
= get_insns ();
5794 rtx_insn
*insn
= BB_END (bb
);
5795 if (HAVE_cc0
&& reg_mentioned_p (cc0_rtx
, PATTERN (insn
)))
5796 insn
= prev_cc0_setter (insn
);
5798 emit_insn_before (seq
, insn
);
5802 /* Create a return pattern, either simple_return or return, depending on
5806 gen_return_pattern (bool simple_p
)
5809 ? targetm
.gen_simple_return ()
5810 : targetm
.gen_return ());
5813 /* Insert an appropriate return pattern at the end of block BB. This
5814 also means updating block_for_insn appropriately. SIMPLE_P is
5815 the same as in gen_return_pattern and passed to it. */
5818 emit_return_into_block (bool simple_p
, basic_block bb
)
5820 rtx_jump_insn
*jump
= emit_jump_insn_after (gen_return_pattern (simple_p
),
5822 rtx pat
= PATTERN (jump
);
5823 if (GET_CODE (pat
) == PARALLEL
)
5824 pat
= XVECEXP (pat
, 0, 0);
5825 gcc_assert (ANY_RETURN_P (pat
));
5826 JUMP_LABEL (jump
) = pat
;
5829 /* Set JUMP_LABEL for a return insn. */
5832 set_return_jump_label (rtx_insn
*returnjump
)
5834 rtx pat
= PATTERN (returnjump
);
5835 if (GET_CODE (pat
) == PARALLEL
)
5836 pat
= XVECEXP (pat
, 0, 0);
5837 if (ANY_RETURN_P (pat
))
5838 JUMP_LABEL (returnjump
) = pat
;
5840 JUMP_LABEL (returnjump
) = ret_rtx
;
5843 /* Return true if there are any active insns between HEAD and TAIL. */
5845 active_insn_between (rtx_insn
*head
, rtx_insn
*tail
)
5849 if (active_insn_p (tail
))
5853 tail
= PREV_INSN (tail
);
5858 /* LAST_BB is a block that exits, and empty of active instructions.
5859 Examine its predecessors for jumps that can be converted to
5860 (conditional) returns. */
5862 convert_jumps_to_returns (basic_block last_bb
, bool simple_p
,
5863 vec
<edge
> unconverted ATTRIBUTE_UNUSED
)
5869 auto_vec
<basic_block
> src_bbs (EDGE_COUNT (last_bb
->preds
));
5871 FOR_EACH_EDGE (e
, ei
, last_bb
->preds
)
5872 if (e
->src
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
))
5873 src_bbs
.quick_push (e
->src
);
5875 rtx_insn
*label
= BB_HEAD (last_bb
);
5877 FOR_EACH_VEC_ELT (src_bbs
, i
, bb
)
5879 rtx_insn
*jump
= BB_END (bb
);
5881 if (!JUMP_P (jump
) || JUMP_LABEL (jump
) != label
)
5884 e
= find_edge (bb
, last_bb
);
5886 /* If we have an unconditional jump, we can replace that
5887 with a simple return instruction. */
5888 if (simplejump_p (jump
))
5890 /* The use of the return register might be present in the exit
5891 fallthru block. Either:
5892 - removing the use is safe, and we should remove the use in
5893 the exit fallthru block, or
5894 - removing the use is not safe, and we should add it here.
5895 For now, we conservatively choose the latter. Either of the
5896 2 helps in crossjumping. */
5897 emit_use_return_register_into_block (bb
);
5899 emit_return_into_block (simple_p
, bb
);
5903 /* If we have a conditional jump branching to the last
5904 block, we can try to replace that with a conditional
5905 return instruction. */
5906 else if (condjump_p (jump
))
5911 dest
= simple_return_rtx
;
5914 if (!redirect_jump (as_a
<rtx_jump_insn
*> (jump
), dest
, 0))
5916 if (targetm
.have_simple_return () && simple_p
)
5920 "Failed to redirect bb %d branch.\n", bb
->index
);
5921 unconverted
.safe_push (e
);
5926 /* See comment in simplejump_p case above. */
5927 emit_use_return_register_into_block (bb
);
5929 /* If this block has only one successor, it both jumps
5930 and falls through to the fallthru block, so we can't
5932 if (single_succ_p (bb
))
5937 if (targetm
.have_simple_return () && simple_p
)
5941 "Failed to redirect bb %d branch.\n", bb
->index
);
5942 unconverted
.safe_push (e
);
5947 /* Fix up the CFG for the successful change we just made. */
5948 redirect_edge_succ (e
, EXIT_BLOCK_PTR_FOR_FN (cfun
));
5949 e
->flags
&= ~EDGE_CROSSING
;
5955 /* Emit a return insn for the exit fallthru block. */
5957 emit_return_for_exit (edge exit_fallthru_edge
, bool simple_p
)
5959 basic_block last_bb
= exit_fallthru_edge
->src
;
5961 if (JUMP_P (BB_END (last_bb
)))
5963 last_bb
= split_edge (exit_fallthru_edge
);
5964 exit_fallthru_edge
= single_succ_edge (last_bb
);
5966 emit_barrier_after (BB_END (last_bb
));
5967 emit_return_into_block (simple_p
, last_bb
);
5968 exit_fallthru_edge
->flags
&= ~EDGE_FALLTHRU
;
5973 /* Generate the prologue and epilogue RTL if the machine supports it. Thread
5974 this into place with notes indicating where the prologue ends and where
5975 the epilogue begins. Update the basic block information when possible.
5977 Notes on epilogue placement:
5978 There are several kinds of edges to the exit block:
5979 * a single fallthru edge from LAST_BB
5980 * possibly, edges from blocks containing sibcalls
5981 * possibly, fake edges from infinite loops
5983 The epilogue is always emitted on the fallthru edge from the last basic
5984 block in the function, LAST_BB, into the exit block.
5986 If LAST_BB is empty except for a label, it is the target of every
5987 other basic block in the function that ends in a return. If a
5988 target has a return or simple_return pattern (possibly with
5989 conditional variants), these basic blocks can be changed so that a
5990 return insn is emitted into them, and their target is adjusted to
5991 the real exit block.
5993 Notes on shrink wrapping: We implement a fairly conservative
5994 version of shrink-wrapping rather than the textbook one. We only
5995 generate a single prologue and a single epilogue. This is
5996 sufficient to catch a number of interesting cases involving early
5999 First, we identify the blocks that require the prologue to occur before
6000 them. These are the ones that modify a call-saved register, or reference
6001 any of the stack or frame pointer registers. To simplify things, we then
6002 mark everything reachable from these blocks as also requiring a prologue.
6003 This takes care of loops automatically, and avoids the need to examine
6004 whether MEMs reference the frame, since it is sufficient to check for
6005 occurrences of the stack or frame pointer.
6007 We then compute the set of blocks for which the need for a prologue
6008 is anticipatable (borrowing terminology from the shrink-wrapping
6009 description in Muchnick's book). These are the blocks which either
6010 require a prologue themselves, or those that have only successors
6011 where the prologue is anticipatable. The prologue needs to be
6012 inserted on all edges from BB1->BB2 where BB2 is in ANTIC and BB1
6013 is not. For the moment, we ensure that only one such edge exists.
6015 The epilogue is placed as described above, but we make a
6016 distinction between inserting return and simple_return patterns
6017 when modifying other blocks that end in a return. Blocks that end
6018 in a sibcall omit the sibcall_epilogue if the block is not in
6022 thread_prologue_and_epilogue_insns (void)
6025 vec
<edge
> unconverted_simple_returns
= vNULL
;
6026 bitmap_head bb_flags
;
6027 rtx_insn
*returnjump
;
6028 rtx_insn
*epilogue_end ATTRIBUTE_UNUSED
;
6029 rtx_insn
*prologue_seq ATTRIBUTE_UNUSED
, *split_prologue_seq ATTRIBUTE_UNUSED
;
6030 edge e
, entry_edge
, orig_entry_edge
, exit_fallthru_edge
;
6035 rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
6038 epilogue_end
= NULL
;
6041 /* Can't deal with multiple successors of the entry block at the
6042 moment. Function should always have at least one entry
6044 gcc_assert (single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
6045 entry_edge
= single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
6046 orig_entry_edge
= entry_edge
;
6048 split_prologue_seq
= NULL
;
6049 if (flag_split_stack
6050 && (lookup_attribute ("no_split_stack", DECL_ATTRIBUTES (cfun
->decl
))
6054 emit_insn (targetm
.gen_split_stack_prologue ());
6055 split_prologue_seq
= get_insns ();
6058 record_insns (split_prologue_seq
, NULL
, &prologue_insn_hash
);
6059 set_insn_locations (split_prologue_seq
, prologue_location
);
6062 prologue_seq
= NULL
;
6063 if (targetm
.have_prologue ())
6066 rtx_insn
*seq
= targetm
.gen_prologue ();
6069 /* Insert an explicit USE for the frame pointer
6070 if the profiling is on and the frame pointer is required. */
6071 if (crtl
->profile
&& frame_pointer_needed
)
6072 emit_use (hard_frame_pointer_rtx
);
6074 /* Retain a map of the prologue insns. */
6075 record_insns (seq
, NULL
, &prologue_insn_hash
);
6076 emit_note (NOTE_INSN_PROLOGUE_END
);
6078 /* Ensure that instructions are not moved into the prologue when
6079 profiling is on. The call to the profiling routine can be
6080 emitted within the live range of a call-clobbered register. */
6081 if (!targetm
.profile_before_prologue () && crtl
->profile
)
6082 emit_insn (gen_blockage ());
6084 prologue_seq
= get_insns ();
6086 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 (targetm
.have_simple_return () && entry_edge
!= orig_entry_edge
)
6122 = get_unconverted_simple_return (exit_fallthru_edge
, bb_flags
,
6123 &unconverted_simple_returns
,
6125 if (targetm
.have_return ())
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 (targetm
.have_simple_return ()
6147 && last_bb
!= exit_fallthru_edge
->src
)
6148 bitmap_set_bit (&bb_flags
, last_bb
->index
);
6155 /* A small fib -- epilogue is not yet completed, but we wish to re-use
6156 this marker for the splits of EH_RETURN patterns, and nothing else
6157 uses the flag in the meantime. */
6158 epilogue_completed
= 1;
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
);
6184 /* If nothing falls through into the exit block, we don't need an
6187 if (exit_fallthru_edge
== NULL
)
6190 if (targetm
.have_epilogue ())
6193 epilogue_end
= emit_note (NOTE_INSN_EPILOGUE_BEG
);
6194 rtx_insn
*seq
= targetm
.gen_epilogue ();
6196 emit_jump_insn (seq
);
6198 /* Retain a map of the epilogue insns. */
6199 record_insns (seq
, NULL
, &epilogue_insn_hash
);
6200 set_insn_locations (seq
, epilogue_location
);
6203 returnjump
= get_last_insn ();
6206 insert_insn_on_edge (seq
, exit_fallthru_edge
);
6209 if (JUMP_P (returnjump
))
6210 set_return_jump_label (returnjump
);
6216 if (! next_active_insn (BB_END (exit_fallthru_edge
->src
)))
6218 /* We have a fall-through edge to the exit block, the source is not
6219 at the end of the function, and there will be an assembler epilogue
6220 at the end of the function.
6221 We can't use force_nonfallthru here, because that would try to
6222 use return. Inserting a jump 'by hand' is extremely messy, so
6223 we take advantage of cfg_layout_finalize using
6224 fixup_fallthru_exit_predecessor. */
6225 cfg_layout_initialize (0);
6226 FOR_EACH_BB_FN (cur_bb
, cfun
)
6227 if (cur_bb
->index
>= NUM_FIXED_BLOCKS
6228 && cur_bb
->next_bb
->index
>= NUM_FIXED_BLOCKS
)
6229 cur_bb
->aux
= cur_bb
->next_bb
;
6230 cfg_layout_finalize ();
6235 default_rtl_profile ();
6241 commit_edge_insertions ();
6243 /* Look for basic blocks within the prologue insns. */
6244 blocks
= sbitmap_alloc (last_basic_block_for_fn (cfun
));
6245 bitmap_clear (blocks
);
6246 bitmap_set_bit (blocks
, entry_edge
->dest
->index
);
6247 bitmap_set_bit (blocks
, orig_entry_edge
->dest
->index
);
6248 find_many_sub_basic_blocks (blocks
);
6249 sbitmap_free (blocks
);
6251 /* The epilogue insns we inserted may cause the exit edge to no longer
6253 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
6255 if (((e
->flags
& EDGE_FALLTHRU
) != 0)
6256 && returnjump_p (BB_END (e
->src
)))
6257 e
->flags
&= ~EDGE_FALLTHRU
;
6261 if (targetm
.have_simple_return ())
6262 convert_to_simple_return (entry_edge
, orig_entry_edge
, bb_flags
,
6263 returnjump
, unconverted_simple_returns
);
6265 /* Emit sibling epilogues before any sibling call sites. */
6266 for (ei
= ei_start (EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
); (e
=
6270 basic_block bb
= e
->src
;
6271 rtx_insn
*insn
= BB_END (bb
);
6274 || ! SIBLING_CALL_P (insn
)
6275 || (targetm
.have_simple_return ()
6276 && entry_edge
!= orig_entry_edge
6277 && !bitmap_bit_p (&bb_flags
, bb
->index
)))
6283 if (rtx_insn
*ep_seq
= targetm
.gen_sibcall_epilogue ())
6286 emit_note (NOTE_INSN_EPILOGUE_BEG
);
6288 rtx_insn
*seq
= get_insns ();
6291 /* Retain a map of the epilogue insns. Used in life analysis to
6292 avoid getting rid of sibcall epilogue insns. Do this before we
6293 actually emit the sequence. */
6294 record_insns (seq
, NULL
, &epilogue_insn_hash
);
6295 set_insn_locations (seq
, epilogue_location
);
6297 emit_insn_before (seq
, insn
);
6304 rtx_insn
*insn
, *next
;
6306 /* Similarly, move any line notes that appear after the epilogue.
6307 There is no need, however, to be quite so anal about the existence
6308 of such a note. Also possibly move
6309 NOTE_INSN_FUNCTION_BEG notes, as those can be relevant for debug
6311 for (insn
= epilogue_end
; insn
; insn
= next
)
6313 next
= NEXT_INSN (insn
);
6315 && (NOTE_KIND (insn
) == NOTE_INSN_FUNCTION_BEG
))
6316 reorder_insns (insn
, insn
, PREV_INSN (epilogue_end
));
6320 bitmap_clear (&bb_flags
);
6322 /* Threading the prologue and epilogue changes the artificial refs
6323 in the entry and exit blocks. */
6324 epilogue_completed
= 1;
6325 df_update_entry_exit_and_calls ();
6328 /* Reposition the prologue-end and epilogue-begin notes after
6329 instruction scheduling. */
6332 reposition_prologue_and_epilogue_notes (void)
6334 if (!targetm
.have_prologue ()
6335 && !targetm
.have_epilogue ()
6336 && !targetm
.have_sibcall_epilogue ())
6339 /* Since the hash table is created on demand, the fact that it is
6340 non-null is a signal that it is non-empty. */
6341 if (prologue_insn_hash
!= NULL
)
6343 size_t len
= prologue_insn_hash
->elements ();
6344 rtx_insn
*insn
, *last
= NULL
, *note
= NULL
;
6346 /* Scan from the beginning until we reach the last prologue insn. */
6347 /* ??? While we do have the CFG intact, there are two problems:
6348 (1) The prologue can contain loops (typically probing the stack),
6349 which means that the end of the prologue isn't in the first bb.
6350 (2) Sometimes the PROLOGUE_END note gets pushed into the next bb. */
6351 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
6355 if (NOTE_KIND (insn
) == NOTE_INSN_PROLOGUE_END
)
6358 else if (contains (insn
, prologue_insn_hash
))
6370 /* Scan forward looking for the PROLOGUE_END note. It should
6371 be right at the beginning of the block, possibly with other
6372 insn notes that got moved there. */
6373 for (note
= NEXT_INSN (last
); ; note
= NEXT_INSN (note
))
6376 && NOTE_KIND (note
) == NOTE_INSN_PROLOGUE_END
)
6381 /* Avoid placing note between CODE_LABEL and BASIC_BLOCK note. */
6383 last
= NEXT_INSN (last
);
6384 reorder_insns (note
, note
, last
);
6388 if (epilogue_insn_hash
!= NULL
)
6393 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
6395 rtx_insn
*insn
, *first
= NULL
, *note
= NULL
;
6396 basic_block bb
= e
->src
;
6398 /* Scan from the beginning until we reach the first epilogue insn. */
6399 FOR_BB_INSNS (bb
, insn
)
6403 if (NOTE_KIND (insn
) == NOTE_INSN_EPILOGUE_BEG
)
6410 else if (first
== NULL
&& contains (insn
, epilogue_insn_hash
))
6420 /* If the function has a single basic block, and no real
6421 epilogue insns (e.g. sibcall with no cleanup), the
6422 epilogue note can get scheduled before the prologue
6423 note. If we have frame related prologue insns, having
6424 them scanned during the epilogue will result in a crash.
6425 In this case re-order the epilogue note to just before
6426 the last insn in the block. */
6428 first
= BB_END (bb
);
6430 if (PREV_INSN (first
) != note
)
6431 reorder_insns (note
, note
, PREV_INSN (first
));
6437 /* Returns the name of function declared by FNDECL. */
6439 fndecl_name (tree fndecl
)
6443 return lang_hooks
.decl_printable_name (fndecl
, 2);
6446 /* Returns the name of function FN. */
6448 function_name (struct function
*fn
)
6450 tree fndecl
= (fn
== NULL
) ? NULL
: fn
->decl
;
6451 return fndecl_name (fndecl
);
6454 /* Returns the name of the current function. */
6456 current_function_name (void)
6458 return function_name (cfun
);
6463 rest_of_handle_check_leaf_regs (void)
6465 #ifdef LEAF_REGISTERS
6466 crtl
->uses_only_leaf_regs
6467 = optimize
> 0 && only_leaf_regs_used () && leaf_function_p ();
6472 /* Insert a TYPE into the used types hash table of CFUN. */
6475 used_types_insert_helper (tree type
, struct function
*func
)
6477 if (type
!= NULL
&& func
!= NULL
)
6479 if (func
->used_types_hash
== NULL
)
6480 func
->used_types_hash
= hash_set
<tree
>::create_ggc (37);
6482 func
->used_types_hash
->add (type
);
6486 /* Given a type, insert it into the used hash table in cfun. */
6488 used_types_insert (tree t
)
6490 while (POINTER_TYPE_P (t
) || TREE_CODE (t
) == ARRAY_TYPE
)
6495 if (TREE_CODE (t
) == ERROR_MARK
)
6497 if (TYPE_NAME (t
) == NULL_TREE
6498 || TYPE_NAME (t
) == TYPE_NAME (TYPE_MAIN_VARIANT (t
)))
6499 t
= TYPE_MAIN_VARIANT (t
);
6500 if (debug_info_level
> DINFO_LEVEL_NONE
)
6503 used_types_insert_helper (t
, cfun
);
6506 /* So this might be a type referenced by a global variable.
6507 Record that type so that we can later decide to emit its
6508 debug information. */
6509 vec_safe_push (types_used_by_cur_var_decl
, t
);
6514 /* Helper to Hash a struct types_used_by_vars_entry. */
6517 hash_types_used_by_vars_entry (const struct types_used_by_vars_entry
*entry
)
6519 gcc_assert (entry
&& entry
->var_decl
&& entry
->type
);
6521 return iterative_hash_object (entry
->type
,
6522 iterative_hash_object (entry
->var_decl
, 0));
6525 /* Hash function of the types_used_by_vars_entry hash table. */
6528 used_type_hasher::hash (types_used_by_vars_entry
*entry
)
6530 return hash_types_used_by_vars_entry (entry
);
6533 /*Equality function of the types_used_by_vars_entry hash table. */
6536 used_type_hasher::equal (types_used_by_vars_entry
*e1
,
6537 types_used_by_vars_entry
*e2
)
6539 return (e1
->var_decl
== e2
->var_decl
&& e1
->type
== e2
->type
);
6542 /* Inserts an entry into the types_used_by_vars_hash hash table. */
6545 types_used_by_var_decl_insert (tree type
, tree var_decl
)
6547 if (type
!= NULL
&& var_decl
!= NULL
)
6549 types_used_by_vars_entry
**slot
;
6550 struct types_used_by_vars_entry e
;
6551 e
.var_decl
= var_decl
;
6553 if (types_used_by_vars_hash
== NULL
)
6554 types_used_by_vars_hash
6555 = hash_table
<used_type_hasher
>::create_ggc (37);
6557 slot
= types_used_by_vars_hash
->find_slot (&e
, INSERT
);
6560 struct types_used_by_vars_entry
*entry
;
6561 entry
= ggc_alloc
<types_used_by_vars_entry
> ();
6563 entry
->var_decl
= var_decl
;
6571 const pass_data pass_data_leaf_regs
=
6573 RTL_PASS
, /* type */
6574 "*leaf_regs", /* name */
6575 OPTGROUP_NONE
, /* optinfo_flags */
6576 TV_NONE
, /* tv_id */
6577 0, /* properties_required */
6578 0, /* properties_provided */
6579 0, /* properties_destroyed */
6580 0, /* todo_flags_start */
6581 0, /* todo_flags_finish */
6584 class pass_leaf_regs
: public rtl_opt_pass
6587 pass_leaf_regs (gcc::context
*ctxt
)
6588 : rtl_opt_pass (pass_data_leaf_regs
, ctxt
)
6591 /* opt_pass methods: */
6592 virtual unsigned int execute (function
*)
6594 return rest_of_handle_check_leaf_regs ();
6597 }; // class pass_leaf_regs
6602 make_pass_leaf_regs (gcc::context
*ctxt
)
6604 return new pass_leaf_regs (ctxt
);
6608 rest_of_handle_thread_prologue_and_epilogue (void)
6611 cleanup_cfg (CLEANUP_EXPENSIVE
);
6613 /* On some machines, the prologue and epilogue code, or parts thereof,
6614 can be represented as RTL. Doing so lets us schedule insns between
6615 it and the rest of the code and also allows delayed branch
6616 scheduling to operate in the epilogue. */
6617 thread_prologue_and_epilogue_insns ();
6619 /* Shrink-wrapping can result in unreachable edges in the epilogue,
6623 /* The stack usage info is finalized during prologue expansion. */
6624 if (flag_stack_usage_info
)
6625 output_stack_usage ();
6632 const pass_data pass_data_thread_prologue_and_epilogue
=
6634 RTL_PASS
, /* type */
6635 "pro_and_epilogue", /* name */
6636 OPTGROUP_NONE
, /* optinfo_flags */
6637 TV_THREAD_PROLOGUE_AND_EPILOGUE
, /* tv_id */
6638 0, /* properties_required */
6639 0, /* properties_provided */
6640 0, /* properties_destroyed */
6641 0, /* todo_flags_start */
6642 ( TODO_df_verify
| TODO_df_finish
), /* todo_flags_finish */
6645 class pass_thread_prologue_and_epilogue
: public rtl_opt_pass
6648 pass_thread_prologue_and_epilogue (gcc::context
*ctxt
)
6649 : rtl_opt_pass (pass_data_thread_prologue_and_epilogue
, ctxt
)
6652 /* opt_pass methods: */
6653 virtual unsigned int execute (function
*)
6655 return rest_of_handle_thread_prologue_and_epilogue ();
6658 }; // class pass_thread_prologue_and_epilogue
6663 make_pass_thread_prologue_and_epilogue (gcc::context
*ctxt
)
6665 return new pass_thread_prologue_and_epilogue (ctxt
);
6669 /* This mini-pass fixes fall-out from SSA in asm statements that have
6670 in-out constraints. Say you start with
6673 asm ("": "+mr" (inout));
6676 which is transformed very early to use explicit output and match operands:
6679 asm ("": "=mr" (inout) : "0" (inout));
6682 Or, after SSA and copyprop,
6684 asm ("": "=mr" (inout_2) : "0" (inout_1));
6687 Clearly inout_2 and inout_1 can't be coalesced easily anymore, as
6688 they represent two separate values, so they will get different pseudo
6689 registers during expansion. Then, since the two operands need to match
6690 per the constraints, but use different pseudo registers, reload can
6691 only register a reload for these operands. But reloads can only be
6692 satisfied by hardregs, not by memory, so we need a register for this
6693 reload, just because we are presented with non-matching operands.
6694 So, even though we allow memory for this operand, no memory can be
6695 used for it, just because the two operands don't match. This can
6696 cause reload failures on register-starved targets.
6698 So it's a symptom of reload not being able to use memory for reloads
6699 or, alternatively it's also a symptom of both operands not coming into
6700 reload as matching (in which case the pseudo could go to memory just
6701 fine, as the alternative allows it, and no reload would be necessary).
6702 We fix the latter problem here, by transforming
6704 asm ("": "=mr" (inout_2) : "0" (inout_1));
6709 asm ("": "=mr" (inout_2) : "0" (inout_2)); */
6712 match_asm_constraints_1 (rtx_insn
*insn
, rtx
*p_sets
, int noutputs
)
6715 bool changed
= false;
6716 rtx op
= SET_SRC (p_sets
[0]);
6717 int ninputs
= ASM_OPERANDS_INPUT_LENGTH (op
);
6718 rtvec inputs
= ASM_OPERANDS_INPUT_VEC (op
);
6719 bool *output_matched
= XALLOCAVEC (bool, noutputs
);
6721 memset (output_matched
, 0, noutputs
* sizeof (bool));
6722 for (i
= 0; i
< ninputs
; i
++)
6726 const char *constraint
= ASM_OPERANDS_INPUT_CONSTRAINT (op
, i
);
6730 if (*constraint
== '%')
6733 match
= strtoul (constraint
, &end
, 10);
6734 if (end
== constraint
)
6737 gcc_assert (match
< noutputs
);
6738 output
= SET_DEST (p_sets
[match
]);
6739 input
= RTVEC_ELT (inputs
, i
);
6740 /* Only do the transformation for pseudos. */
6741 if (! REG_P (output
)
6742 || rtx_equal_p (output
, input
)
6743 || (GET_MODE (input
) != VOIDmode
6744 && GET_MODE (input
) != GET_MODE (output
)))
6747 /* We can't do anything if the output is also used as input,
6748 as we're going to overwrite it. */
6749 for (j
= 0; j
< ninputs
; j
++)
6750 if (reg_overlap_mentioned_p (output
, RTVEC_ELT (inputs
, j
)))
6755 /* Avoid changing the same input several times. For
6756 asm ("" : "=mr" (out1), "=mr" (out2) : "0" (in), "1" (in));
6757 only change in once (to out1), rather than changing it
6758 first to out1 and afterwards to out2. */
6761 for (j
= 0; j
< noutputs
; j
++)
6762 if (output_matched
[j
] && input
== SET_DEST (p_sets
[j
]))
6767 output_matched
[match
] = true;
6770 emit_move_insn (output
, input
);
6771 insns
= get_insns ();
6773 emit_insn_before (insns
, insn
);
6775 /* Now replace all mentions of the input with output. We can't
6776 just replace the occurrence in inputs[i], as the register might
6777 also be used in some other input (or even in an address of an
6778 output), which would mean possibly increasing the number of
6779 inputs by one (namely 'output' in addition), which might pose
6780 a too complicated problem for reload to solve. E.g. this situation:
6782 asm ("" : "=r" (output), "=m" (input) : "0" (input))
6784 Here 'input' is used in two occurrences as input (once for the
6785 input operand, once for the address in the second output operand).
6786 If we would replace only the occurrence of the input operand (to
6787 make the matching) we would be left with this:
6790 asm ("" : "=r" (output), "=m" (input) : "0" (output))
6792 Now we suddenly have two different input values (containing the same
6793 value, but different pseudos) where we formerly had only one.
6794 With more complicated asms this might lead to reload failures
6795 which wouldn't have happen without this pass. So, iterate over
6796 all operands and replace all occurrences of the register used. */
6797 for (j
= 0; j
< noutputs
; j
++)
6798 if (!rtx_equal_p (SET_DEST (p_sets
[j
]), input
)
6799 && reg_overlap_mentioned_p (input
, SET_DEST (p_sets
[j
])))
6800 SET_DEST (p_sets
[j
]) = replace_rtx (SET_DEST (p_sets
[j
]),
6802 for (j
= 0; j
< ninputs
; j
++)
6803 if (reg_overlap_mentioned_p (input
, RTVEC_ELT (inputs
, j
)))
6804 RTVEC_ELT (inputs
, j
) = replace_rtx (RTVEC_ELT (inputs
, j
),
6811 df_insn_rescan (insn
);
6814 /* Add the decl D to the local_decls list of FUN. */
6817 add_local_decl (struct function
*fun
, tree d
)
6819 gcc_assert (TREE_CODE (d
) == VAR_DECL
);
6820 vec_safe_push (fun
->local_decls
, d
);
6825 const pass_data pass_data_match_asm_constraints
=
6827 RTL_PASS
, /* type */
6828 "asmcons", /* name */
6829 OPTGROUP_NONE
, /* optinfo_flags */
6830 TV_NONE
, /* tv_id */
6831 0, /* properties_required */
6832 0, /* properties_provided */
6833 0, /* properties_destroyed */
6834 0, /* todo_flags_start */
6835 0, /* todo_flags_finish */
6838 class pass_match_asm_constraints
: public rtl_opt_pass
6841 pass_match_asm_constraints (gcc::context
*ctxt
)
6842 : rtl_opt_pass (pass_data_match_asm_constraints
, ctxt
)
6845 /* opt_pass methods: */
6846 virtual unsigned int execute (function
*);
6848 }; // class pass_match_asm_constraints
6851 pass_match_asm_constraints::execute (function
*fun
)
6858 if (!crtl
->has_asm_statement
)
6861 df_set_flags (DF_DEFER_INSN_RESCAN
);
6862 FOR_EACH_BB_FN (bb
, fun
)
6864 FOR_BB_INSNS (bb
, insn
)
6869 pat
= PATTERN (insn
);
6870 if (GET_CODE (pat
) == PARALLEL
)
6871 p_sets
= &XVECEXP (pat
, 0, 0), noutputs
= XVECLEN (pat
, 0);
6872 else if (GET_CODE (pat
) == SET
)
6873 p_sets
= &PATTERN (insn
), noutputs
= 1;
6877 if (GET_CODE (*p_sets
) == SET
6878 && GET_CODE (SET_SRC (*p_sets
)) == ASM_OPERANDS
)
6879 match_asm_constraints_1 (insn
, p_sets
, noutputs
);
6883 return TODO_df_finish
;
6889 make_pass_match_asm_constraints (gcc::context
*ctxt
)
6891 return new pass_match_asm_constraints (ctxt
);
6895 #include "gt-function.h"