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"
41 #include "rtl-error.h"
43 #include "fold-const.h"
44 #include "stor-layout.h"
46 #include "stringpool.h"
49 #include "insn-config.h"
57 #include "insn-codes.h"
64 #include "langhooks.h"
66 #include "common/common-target.h"
67 #include "gimple-expr.h"
69 #include "tree-pass.h"
73 #include "cfgcleanup.h"
75 #include "bb-reorder.h"
76 #include "shrink-wrap.h"
79 #include "tree-chkp.h"
82 /* So we can assign to cfun in this file. */
85 #ifndef STACK_ALIGNMENT_NEEDED
86 #define STACK_ALIGNMENT_NEEDED 1
89 #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
91 /* Round a value to the lowest integer less than it that is a multiple of
92 the required alignment. Avoid using division in case the value is
93 negative. Assume the alignment is a power of two. */
94 #define FLOOR_ROUND(VALUE,ALIGN) ((VALUE) & ~((ALIGN) - 1))
96 /* Similar, but round to the next highest integer that meets the
98 #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
100 /* Nonzero once virtual register instantiation has been done.
101 assign_stack_local uses frame_pointer_rtx when this is nonzero.
102 calls.c:emit_library_call_value_1 uses it to set up
103 post-instantiation libcalls. */
104 int virtuals_instantiated
;
106 /* Assign unique numbers to labels generated for profiling, debugging, etc. */
107 static GTY(()) int funcdef_no
;
109 /* These variables hold pointers to functions to create and destroy
110 target specific, per-function data structures. */
111 struct machine_function
* (*init_machine_status
) (void);
113 /* The currently compiled function. */
114 struct function
*cfun
= 0;
116 /* These hashes record the prologue and epilogue insns. */
118 struct insn_cache_hasher
: ggc_cache_ptr_hash
<rtx_def
>
120 static hashval_t
hash (rtx x
) { return htab_hash_pointer (x
); }
121 static bool equal (rtx a
, rtx b
) { return a
== b
; }
125 hash_table
<insn_cache_hasher
> *prologue_insn_hash
;
127 hash_table
<insn_cache_hasher
> *epilogue_insn_hash
;
130 hash_table
<used_type_hasher
> *types_used_by_vars_hash
= NULL
;
131 vec
<tree
, va_gc
> *types_used_by_cur_var_decl
;
133 /* Forward declarations. */
135 static struct temp_slot
*find_temp_slot_from_address (rtx
);
136 static void pad_to_arg_alignment (struct args_size
*, int, struct args_size
*);
137 static void pad_below (struct args_size
*, machine_mode
, tree
);
138 static void reorder_blocks_1 (rtx_insn
*, tree
, vec
<tree
> *);
139 static int all_blocks (tree
, tree
*);
140 static tree
*get_block_vector (tree
, int *);
141 extern tree
debug_find_var_in_block_tree (tree
, tree
);
142 /* We always define `record_insns' even if it's not used so that we
143 can always export `prologue_epilogue_contains'. */
144 static void record_insns (rtx_insn
*, rtx
, hash_table
<insn_cache_hasher
> **)
146 static bool contains (const_rtx
, hash_table
<insn_cache_hasher
> *);
147 static void prepare_function_start (void);
148 static void do_clobber_return_reg (rtx
, void *);
149 static void do_use_return_reg (rtx
, void *);
151 /* Stack of nested functions. */
152 /* Keep track of the cfun stack. */
154 typedef struct function
*function_p
;
156 static vec
<function_p
> function_context_stack
;
158 /* Save the current context for compilation of a nested function.
159 This is called from language-specific code. */
162 push_function_context (void)
165 allocate_struct_function (NULL
, false);
167 function_context_stack
.safe_push (cfun
);
171 /* Restore the last saved context, at the end of a nested function.
172 This function is called from language-specific code. */
175 pop_function_context (void)
177 struct function
*p
= function_context_stack
.pop ();
179 current_function_decl
= p
->decl
;
181 /* Reset variables that have known state during rtx generation. */
182 virtuals_instantiated
= 0;
183 generating_concat_p
= 1;
186 /* Clear out all parts of the state in F that can safely be discarded
187 after the function has been parsed, but not compiled, to let
188 garbage collection reclaim the memory. */
191 free_after_parsing (struct function
*f
)
196 /* Clear out all parts of the state in F that can safely be discarded
197 after the function has been compiled, to let garbage collection
198 reclaim the memory. */
201 free_after_compilation (struct function
*f
)
203 prologue_insn_hash
= NULL
;
204 epilogue_insn_hash
= NULL
;
206 free (crtl
->emit
.regno_pointer_align
);
208 memset (crtl
, 0, sizeof (struct rtl_data
));
212 f
->curr_properties
&= ~PROP_cfg
;
214 regno_reg_rtx
= NULL
;
217 /* Return size needed for stack frame based on slots so far allocated.
218 This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY;
219 the caller may have to do that. */
222 get_frame_size (void)
224 if (FRAME_GROWS_DOWNWARD
)
225 return -frame_offset
;
230 /* Issue an error message and return TRUE if frame OFFSET overflows in
231 the signed target pointer arithmetics for function FUNC. Otherwise
235 frame_offset_overflow (HOST_WIDE_INT offset
, tree func
)
237 unsigned HOST_WIDE_INT size
= FRAME_GROWS_DOWNWARD
? -offset
: offset
;
239 if (size
> ((unsigned HOST_WIDE_INT
) 1 << (GET_MODE_BITSIZE (Pmode
) - 1))
240 /* Leave room for the fixed part of the frame. */
241 - 64 * UNITS_PER_WORD
)
243 error_at (DECL_SOURCE_LOCATION (func
),
244 "total size of local objects too large");
251 /* Return stack slot alignment in bits for TYPE and MODE. */
254 get_stack_local_alignment (tree type
, machine_mode mode
)
256 unsigned int alignment
;
259 alignment
= BIGGEST_ALIGNMENT
;
261 alignment
= GET_MODE_ALIGNMENT (mode
);
263 /* Allow the frond-end to (possibly) increase the alignment of this
266 type
= lang_hooks
.types
.type_for_mode (mode
, 0);
268 return STACK_SLOT_ALIGNMENT (type
, mode
, alignment
);
271 /* Determine whether it is possible to fit a stack slot of size SIZE and
272 alignment ALIGNMENT into an area in the stack frame that starts at
273 frame offset START and has a length of LENGTH. If so, store the frame
274 offset to be used for the stack slot in *POFFSET and return true;
275 return false otherwise. This function will extend the frame size when
276 given a start/length pair that lies at the end of the frame. */
279 try_fit_stack_local (HOST_WIDE_INT start
, HOST_WIDE_INT length
,
280 HOST_WIDE_INT size
, unsigned int alignment
,
281 HOST_WIDE_INT
*poffset
)
283 HOST_WIDE_INT this_frame_offset
;
284 int frame_off
, frame_alignment
, frame_phase
;
286 /* Calculate how many bytes the start of local variables is off from
288 frame_alignment
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
289 frame_off
= STARTING_FRAME_OFFSET
% frame_alignment
;
290 frame_phase
= frame_off
? frame_alignment
- frame_off
: 0;
292 /* Round the frame offset to the specified alignment. */
294 /* We must be careful here, since FRAME_OFFSET might be negative and
295 division with a negative dividend isn't as well defined as we might
296 like. So we instead assume that ALIGNMENT is a power of two and
297 use logical operations which are unambiguous. */
298 if (FRAME_GROWS_DOWNWARD
)
300 = (FLOOR_ROUND (start
+ length
- size
- frame_phase
,
301 (unsigned HOST_WIDE_INT
) alignment
)
305 = (CEIL_ROUND (start
- frame_phase
,
306 (unsigned HOST_WIDE_INT
) alignment
)
309 /* See if it fits. If this space is at the edge of the frame,
310 consider extending the frame to make it fit. Our caller relies on
311 this when allocating a new slot. */
312 if (frame_offset
== start
&& this_frame_offset
< frame_offset
)
313 frame_offset
= this_frame_offset
;
314 else if (this_frame_offset
< start
)
316 else if (start
+ length
== frame_offset
317 && this_frame_offset
+ size
> start
+ length
)
318 frame_offset
= this_frame_offset
+ size
;
319 else if (this_frame_offset
+ size
> start
+ length
)
322 *poffset
= this_frame_offset
;
326 /* Create a new frame_space structure describing free space in the stack
327 frame beginning at START and ending at END, and chain it into the
328 function's frame_space_list. */
331 add_frame_space (HOST_WIDE_INT start
, HOST_WIDE_INT end
)
333 struct frame_space
*space
= ggc_alloc
<frame_space
> ();
334 space
->next
= crtl
->frame_space_list
;
335 crtl
->frame_space_list
= space
;
336 space
->start
= start
;
337 space
->length
= end
- start
;
340 /* Allocate a stack slot of SIZE bytes and return a MEM rtx for it
341 with machine mode MODE.
343 ALIGN controls the amount of alignment for the address of the slot:
344 0 means according to MODE,
345 -1 means use BIGGEST_ALIGNMENT and round size to multiple of that,
346 -2 means use BITS_PER_UNIT,
347 positive specifies alignment boundary in bits.
349 KIND has ASLK_REDUCE_ALIGN bit set if it is OK to reduce
350 alignment and ASLK_RECORD_PAD bit set if we should remember
351 extra space we allocated for alignment purposes. When we are
352 called from assign_stack_temp_for_type, it is not set so we don't
353 track the same stack slot in two independent lists.
355 We do not round to stack_boundary here. */
358 assign_stack_local_1 (machine_mode mode
, HOST_WIDE_INT size
,
362 int bigend_correction
= 0;
363 HOST_WIDE_INT slot_offset
= 0, old_frame_offset
;
364 unsigned int alignment
, alignment_in_bits
;
368 alignment
= get_stack_local_alignment (NULL
, mode
);
369 alignment
/= BITS_PER_UNIT
;
371 else if (align
== -1)
373 alignment
= BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
;
374 size
= CEIL_ROUND (size
, alignment
);
376 else if (align
== -2)
377 alignment
= 1; /* BITS_PER_UNIT / BITS_PER_UNIT */
379 alignment
= align
/ BITS_PER_UNIT
;
381 alignment_in_bits
= alignment
* BITS_PER_UNIT
;
383 /* Ignore alignment if it exceeds MAX_SUPPORTED_STACK_ALIGNMENT. */
384 if (alignment_in_bits
> MAX_SUPPORTED_STACK_ALIGNMENT
)
386 alignment_in_bits
= MAX_SUPPORTED_STACK_ALIGNMENT
;
387 alignment
= alignment_in_bits
/ BITS_PER_UNIT
;
390 if (SUPPORTS_STACK_ALIGNMENT
)
392 if (crtl
->stack_alignment_estimated
< alignment_in_bits
)
394 if (!crtl
->stack_realign_processed
)
395 crtl
->stack_alignment_estimated
= alignment_in_bits
;
398 /* If stack is realigned and stack alignment value
399 hasn't been finalized, it is OK not to increase
400 stack_alignment_estimated. The bigger alignment
401 requirement is recorded in stack_alignment_needed
403 gcc_assert (!crtl
->stack_realign_finalized
);
404 if (!crtl
->stack_realign_needed
)
406 /* It is OK to reduce the alignment as long as the
407 requested size is 0 or the estimated stack
408 alignment >= mode alignment. */
409 gcc_assert ((kind
& ASLK_REDUCE_ALIGN
)
411 || (crtl
->stack_alignment_estimated
412 >= GET_MODE_ALIGNMENT (mode
)));
413 alignment_in_bits
= crtl
->stack_alignment_estimated
;
414 alignment
= alignment_in_bits
/ BITS_PER_UNIT
;
420 if (crtl
->stack_alignment_needed
< alignment_in_bits
)
421 crtl
->stack_alignment_needed
= alignment_in_bits
;
422 if (crtl
->max_used_stack_slot_alignment
< alignment_in_bits
)
423 crtl
->max_used_stack_slot_alignment
= alignment_in_bits
;
425 if (mode
!= BLKmode
|| size
!= 0)
427 if (kind
& ASLK_RECORD_PAD
)
429 struct frame_space
**psp
;
431 for (psp
= &crtl
->frame_space_list
; *psp
; psp
= &(*psp
)->next
)
433 struct frame_space
*space
= *psp
;
434 if (!try_fit_stack_local (space
->start
, space
->length
, size
,
435 alignment
, &slot_offset
))
438 if (slot_offset
> space
->start
)
439 add_frame_space (space
->start
, slot_offset
);
440 if (slot_offset
+ size
< space
->start
+ space
->length
)
441 add_frame_space (slot_offset
+ size
,
442 space
->start
+ space
->length
);
447 else if (!STACK_ALIGNMENT_NEEDED
)
449 slot_offset
= frame_offset
;
453 old_frame_offset
= frame_offset
;
455 if (FRAME_GROWS_DOWNWARD
)
457 frame_offset
-= size
;
458 try_fit_stack_local (frame_offset
, size
, size
, alignment
, &slot_offset
);
460 if (kind
& ASLK_RECORD_PAD
)
462 if (slot_offset
> frame_offset
)
463 add_frame_space (frame_offset
, slot_offset
);
464 if (slot_offset
+ size
< old_frame_offset
)
465 add_frame_space (slot_offset
+ size
, old_frame_offset
);
470 frame_offset
+= size
;
471 try_fit_stack_local (old_frame_offset
, size
, size
, alignment
, &slot_offset
);
473 if (kind
& ASLK_RECORD_PAD
)
475 if (slot_offset
> old_frame_offset
)
476 add_frame_space (old_frame_offset
, slot_offset
);
477 if (slot_offset
+ size
< frame_offset
)
478 add_frame_space (slot_offset
+ size
, frame_offset
);
483 /* On a big-endian machine, if we are allocating more space than we will use,
484 use the least significant bytes of those that are allocated. */
485 if (BYTES_BIG_ENDIAN
&& mode
!= BLKmode
&& GET_MODE_SIZE (mode
) < size
)
486 bigend_correction
= size
- GET_MODE_SIZE (mode
);
488 /* If we have already instantiated virtual registers, return the actual
489 address relative to the frame pointer. */
490 if (virtuals_instantiated
)
491 addr
= plus_constant (Pmode
, frame_pointer_rtx
,
493 (slot_offset
+ bigend_correction
494 + STARTING_FRAME_OFFSET
, Pmode
));
496 addr
= plus_constant (Pmode
, virtual_stack_vars_rtx
,
498 (slot_offset
+ bigend_correction
,
501 x
= gen_rtx_MEM (mode
, addr
);
502 set_mem_align (x
, alignment_in_bits
);
503 MEM_NOTRAP_P (x
) = 1;
506 = gen_rtx_EXPR_LIST (VOIDmode
, x
, stack_slot_list
);
508 if (frame_offset_overflow (frame_offset
, current_function_decl
))
514 /* Wrap up assign_stack_local_1 with last parameter as false. */
517 assign_stack_local (machine_mode mode
, HOST_WIDE_INT size
, int align
)
519 return assign_stack_local_1 (mode
, size
, align
, ASLK_RECORD_PAD
);
522 /* In order to evaluate some expressions, such as function calls returning
523 structures in memory, we need to temporarily allocate stack locations.
524 We record each allocated temporary in the following structure.
526 Associated with each temporary slot is a nesting level. When we pop up
527 one level, all temporaries associated with the previous level are freed.
528 Normally, all temporaries are freed after the execution of the statement
529 in which they were created. However, if we are inside a ({...}) grouping,
530 the result may be in a temporary and hence must be preserved. If the
531 result could be in a temporary, we preserve it if we can determine which
532 one it is in. If we cannot determine which temporary may contain the
533 result, all temporaries are preserved. A temporary is preserved by
534 pretending it was allocated at the previous nesting level. */
536 struct GTY(()) temp_slot
{
537 /* Points to next temporary slot. */
538 struct temp_slot
*next
;
539 /* Points to previous temporary slot. */
540 struct temp_slot
*prev
;
541 /* The rtx to used to reference the slot. */
543 /* The size, in units, of the slot. */
545 /* The type of the object in the slot, or zero if it doesn't correspond
546 to a type. We use this to determine whether a slot can be reused.
547 It can be reused if objects of the type of the new slot will always
548 conflict with objects of the type of the old slot. */
550 /* The alignment (in bits) of the slot. */
552 /* Nonzero if this temporary is currently in use. */
554 /* Nesting level at which this slot is being used. */
556 /* The offset of the slot from the frame_pointer, including extra space
557 for alignment. This info is for combine_temp_slots. */
558 HOST_WIDE_INT base_offset
;
559 /* The size of the slot, including extra space for alignment. This
560 info is for combine_temp_slots. */
561 HOST_WIDE_INT full_size
;
564 /* Entry for the below hash table. */
565 struct GTY((for_user
)) temp_slot_address_entry
{
568 struct temp_slot
*temp_slot
;
571 struct temp_address_hasher
: ggc_ptr_hash
<temp_slot_address_entry
>
573 static hashval_t
hash (temp_slot_address_entry
*);
574 static bool equal (temp_slot_address_entry
*, temp_slot_address_entry
*);
577 /* A table of addresses that represent a stack slot. The table is a mapping
578 from address RTXen to a temp slot. */
579 static GTY(()) hash_table
<temp_address_hasher
> *temp_slot_address_table
;
580 static size_t n_temp_slots_in_use
;
582 /* Removes temporary slot TEMP from LIST. */
585 cut_slot_from_list (struct temp_slot
*temp
, struct temp_slot
**list
)
588 temp
->next
->prev
= temp
->prev
;
590 temp
->prev
->next
= temp
->next
;
594 temp
->prev
= temp
->next
= NULL
;
597 /* Inserts temporary slot TEMP to LIST. */
600 insert_slot_to_list (struct temp_slot
*temp
, struct temp_slot
**list
)
604 (*list
)->prev
= temp
;
609 /* Returns the list of used temp slots at LEVEL. */
611 static struct temp_slot
**
612 temp_slots_at_level (int level
)
614 if (level
>= (int) vec_safe_length (used_temp_slots
))
615 vec_safe_grow_cleared (used_temp_slots
, level
+ 1);
617 return &(*used_temp_slots
)[level
];
620 /* Returns the maximal temporary slot level. */
623 max_slot_level (void)
625 if (!used_temp_slots
)
628 return used_temp_slots
->length () - 1;
631 /* Moves temporary slot TEMP to LEVEL. */
634 move_slot_to_level (struct temp_slot
*temp
, int level
)
636 cut_slot_from_list (temp
, temp_slots_at_level (temp
->level
));
637 insert_slot_to_list (temp
, temp_slots_at_level (level
));
641 /* Make temporary slot TEMP available. */
644 make_slot_available (struct temp_slot
*temp
)
646 cut_slot_from_list (temp
, temp_slots_at_level (temp
->level
));
647 insert_slot_to_list (temp
, &avail_temp_slots
);
650 n_temp_slots_in_use
--;
653 /* Compute the hash value for an address -> temp slot mapping.
654 The value is cached on the mapping entry. */
656 temp_slot_address_compute_hash (struct temp_slot_address_entry
*t
)
658 int do_not_record
= 0;
659 return hash_rtx (t
->address
, GET_MODE (t
->address
),
660 &do_not_record
, NULL
, false);
663 /* Return the hash value for an address -> temp slot mapping. */
665 temp_address_hasher::hash (temp_slot_address_entry
*t
)
670 /* Compare two address -> temp slot mapping entries. */
672 temp_address_hasher::equal (temp_slot_address_entry
*t1
,
673 temp_slot_address_entry
*t2
)
675 return exp_equiv_p (t1
->address
, t2
->address
, 0, true);
678 /* Add ADDRESS as an alias of TEMP_SLOT to the addess -> temp slot mapping. */
680 insert_temp_slot_address (rtx address
, struct temp_slot
*temp_slot
)
682 struct temp_slot_address_entry
*t
= ggc_alloc
<temp_slot_address_entry
> ();
683 t
->address
= address
;
684 t
->temp_slot
= temp_slot
;
685 t
->hash
= temp_slot_address_compute_hash (t
);
686 *temp_slot_address_table
->find_slot_with_hash (t
, t
->hash
, INSERT
) = t
;
689 /* Remove an address -> temp slot mapping entry if the temp slot is
690 not in use anymore. Callback for remove_unused_temp_slot_addresses. */
692 remove_unused_temp_slot_addresses_1 (temp_slot_address_entry
**slot
, void *)
694 const struct temp_slot_address_entry
*t
= *slot
;
695 if (! t
->temp_slot
->in_use
)
696 temp_slot_address_table
->clear_slot (slot
);
700 /* Remove all mappings of addresses to unused temp slots. */
702 remove_unused_temp_slot_addresses (void)
704 /* Use quicker clearing if there aren't any active temp slots. */
705 if (n_temp_slots_in_use
)
706 temp_slot_address_table
->traverse
707 <void *, remove_unused_temp_slot_addresses_1
> (NULL
);
709 temp_slot_address_table
->empty ();
712 /* Find the temp slot corresponding to the object at address X. */
714 static struct temp_slot
*
715 find_temp_slot_from_address (rtx x
)
718 struct temp_slot_address_entry tmp
, *t
;
720 /* First try the easy way:
721 See if X exists in the address -> temp slot mapping. */
723 tmp
.temp_slot
= NULL
;
724 tmp
.hash
= temp_slot_address_compute_hash (&tmp
);
725 t
= temp_slot_address_table
->find_with_hash (&tmp
, tmp
.hash
);
729 /* If we have a sum involving a register, see if it points to a temp
731 if (GET_CODE (x
) == PLUS
&& REG_P (XEXP (x
, 0))
732 && (p
= find_temp_slot_from_address (XEXP (x
, 0))) != 0)
734 else if (GET_CODE (x
) == PLUS
&& REG_P (XEXP (x
, 1))
735 && (p
= find_temp_slot_from_address (XEXP (x
, 1))) != 0)
738 /* Last resort: Address is a virtual stack var address. */
739 if (GET_CODE (x
) == PLUS
740 && XEXP (x
, 0) == virtual_stack_vars_rtx
741 && CONST_INT_P (XEXP (x
, 1)))
744 for (i
= max_slot_level (); i
>= 0; i
--)
745 for (p
= *temp_slots_at_level (i
); p
; p
= p
->next
)
747 if (INTVAL (XEXP (x
, 1)) >= p
->base_offset
748 && INTVAL (XEXP (x
, 1)) < p
->base_offset
+ p
->full_size
)
756 /* Allocate a temporary stack slot and record it for possible later
759 MODE is the machine mode to be given to the returned rtx.
761 SIZE is the size in units of the space required. We do no rounding here
762 since assign_stack_local will do any required rounding.
764 TYPE is the type that will be used for the stack slot. */
767 assign_stack_temp_for_type (machine_mode mode
, HOST_WIDE_INT size
,
771 struct temp_slot
*p
, *best_p
= 0, *selected
= NULL
, **pp
;
774 /* If SIZE is -1 it means that somebody tried to allocate a temporary
775 of a variable size. */
776 gcc_assert (size
!= -1);
778 align
= get_stack_local_alignment (type
, mode
);
780 /* Try to find an available, already-allocated temporary of the proper
781 mode which meets the size and alignment requirements. Choose the
782 smallest one with the closest alignment.
784 If assign_stack_temp is called outside of the tree->rtl expansion,
785 we cannot reuse the stack slots (that may still refer to
786 VIRTUAL_STACK_VARS_REGNUM). */
787 if (!virtuals_instantiated
)
789 for (p
= avail_temp_slots
; p
; p
= p
->next
)
791 if (p
->align
>= align
&& p
->size
>= size
792 && GET_MODE (p
->slot
) == mode
793 && objects_must_conflict_p (p
->type
, type
)
794 && (best_p
== 0 || best_p
->size
> p
->size
795 || (best_p
->size
== p
->size
&& best_p
->align
> p
->align
)))
797 if (p
->align
== align
&& p
->size
== size
)
800 cut_slot_from_list (selected
, &avail_temp_slots
);
809 /* Make our best, if any, the one to use. */
813 cut_slot_from_list (selected
, &avail_temp_slots
);
815 /* If there are enough aligned bytes left over, make them into a new
816 temp_slot so that the extra bytes don't get wasted. Do this only
817 for BLKmode slots, so that we can be sure of the alignment. */
818 if (GET_MODE (best_p
->slot
) == BLKmode
)
820 int alignment
= best_p
->align
/ BITS_PER_UNIT
;
821 HOST_WIDE_INT rounded_size
= CEIL_ROUND (size
, alignment
);
823 if (best_p
->size
- rounded_size
>= alignment
)
825 p
= ggc_alloc
<temp_slot
> ();
827 p
->size
= best_p
->size
- rounded_size
;
828 p
->base_offset
= best_p
->base_offset
+ rounded_size
;
829 p
->full_size
= best_p
->full_size
- rounded_size
;
830 p
->slot
= adjust_address_nv (best_p
->slot
, BLKmode
, rounded_size
);
831 p
->align
= best_p
->align
;
832 p
->type
= best_p
->type
;
833 insert_slot_to_list (p
, &avail_temp_slots
);
835 stack_slot_list
= gen_rtx_EXPR_LIST (VOIDmode
, p
->slot
,
838 best_p
->size
= rounded_size
;
839 best_p
->full_size
= rounded_size
;
844 /* If we still didn't find one, make a new temporary. */
847 HOST_WIDE_INT frame_offset_old
= frame_offset
;
849 p
= ggc_alloc
<temp_slot
> ();
851 /* We are passing an explicit alignment request to assign_stack_local.
852 One side effect of that is assign_stack_local will not round SIZE
853 to ensure the frame offset remains suitably aligned.
855 So for requests which depended on the rounding of SIZE, we go ahead
856 and round it now. We also make sure ALIGNMENT is at least
857 BIGGEST_ALIGNMENT. */
858 gcc_assert (mode
!= BLKmode
|| align
== BIGGEST_ALIGNMENT
);
859 p
->slot
= assign_stack_local_1 (mode
,
869 /* The following slot size computation is necessary because we don't
870 know the actual size of the temporary slot until assign_stack_local
871 has performed all the frame alignment and size rounding for the
872 requested temporary. Note that extra space added for alignment
873 can be either above or below this stack slot depending on which
874 way the frame grows. We include the extra space if and only if it
875 is above this slot. */
876 if (FRAME_GROWS_DOWNWARD
)
877 p
->size
= frame_offset_old
- frame_offset
;
881 /* Now define the fields used by combine_temp_slots. */
882 if (FRAME_GROWS_DOWNWARD
)
884 p
->base_offset
= frame_offset
;
885 p
->full_size
= frame_offset_old
- frame_offset
;
889 p
->base_offset
= frame_offset_old
;
890 p
->full_size
= frame_offset
- frame_offset_old
;
899 p
->level
= temp_slot_level
;
900 n_temp_slots_in_use
++;
902 pp
= temp_slots_at_level (p
->level
);
903 insert_slot_to_list (p
, pp
);
904 insert_temp_slot_address (XEXP (p
->slot
, 0), p
);
906 /* Create a new MEM rtx to avoid clobbering MEM flags of old slots. */
907 slot
= gen_rtx_MEM (mode
, XEXP (p
->slot
, 0));
908 stack_slot_list
= gen_rtx_EXPR_LIST (VOIDmode
, slot
, stack_slot_list
);
910 /* If we know the alias set for the memory that will be used, use
911 it. If there's no TYPE, then we don't know anything about the
912 alias set for the memory. */
913 set_mem_alias_set (slot
, type
? get_alias_set (type
) : 0);
914 set_mem_align (slot
, align
);
916 /* If a type is specified, set the relevant flags. */
918 MEM_VOLATILE_P (slot
) = TYPE_VOLATILE (type
);
919 MEM_NOTRAP_P (slot
) = 1;
924 /* Allocate a temporary stack slot and record it for possible later
925 reuse. First two arguments are same as in preceding function. */
928 assign_stack_temp (machine_mode mode
, HOST_WIDE_INT size
)
930 return assign_stack_temp_for_type (mode
, size
, NULL_TREE
);
933 /* Assign a temporary.
934 If TYPE_OR_DECL is a decl, then we are doing it on behalf of the decl
935 and so that should be used in error messages. In either case, we
936 allocate of the given type.
937 MEMORY_REQUIRED is 1 if the result must be addressable stack memory;
938 it is 0 if a register is OK.
939 DONT_PROMOTE is 1 if we should not promote values in register
943 assign_temp (tree type_or_decl
, int memory_required
,
944 int dont_promote ATTRIBUTE_UNUSED
)
952 if (DECL_P (type_or_decl
))
953 decl
= type_or_decl
, type
= TREE_TYPE (decl
);
955 decl
= NULL
, type
= type_or_decl
;
957 mode
= TYPE_MODE (type
);
959 unsignedp
= TYPE_UNSIGNED (type
);
962 if (mode
== BLKmode
|| memory_required
)
964 HOST_WIDE_INT size
= int_size_in_bytes (type
);
967 /* Zero sized arrays are GNU C extension. Set size to 1 to avoid
968 problems with allocating the stack space. */
972 /* Unfortunately, we don't yet know how to allocate variable-sized
973 temporaries. However, sometimes we can find a fixed upper limit on
974 the size, so try that instead. */
976 size
= max_int_size_in_bytes (type
);
978 /* The size of the temporary may be too large to fit into an integer. */
979 /* ??? Not sure this should happen except for user silliness, so limit
980 this to things that aren't compiler-generated temporaries. The
981 rest of the time we'll die in assign_stack_temp_for_type. */
982 if (decl
&& size
== -1
983 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
)
985 error ("size of variable %q+D is too large", decl
);
989 tmp
= assign_stack_temp_for_type (mode
, size
, type
);
995 mode
= promote_mode (type
, mode
, &unsignedp
);
998 return gen_reg_rtx (mode
);
1001 /* Combine temporary stack slots which are adjacent on the stack.
1003 This allows for better use of already allocated stack space. This is only
1004 done for BLKmode slots because we can be sure that we won't have alignment
1005 problems in this case. */
1008 combine_temp_slots (void)
1010 struct temp_slot
*p
, *q
, *next
, *next_q
;
1013 /* We can't combine slots, because the information about which slot
1014 is in which alias set will be lost. */
1015 if (flag_strict_aliasing
)
1018 /* If there are a lot of temp slots, don't do anything unless
1019 high levels of optimization. */
1020 if (! flag_expensive_optimizations
)
1021 for (p
= avail_temp_slots
, num_slots
= 0; p
; p
= p
->next
, num_slots
++)
1022 if (num_slots
> 100 || (num_slots
> 10 && optimize
== 0))
1025 for (p
= avail_temp_slots
; p
; p
= next
)
1031 if (GET_MODE (p
->slot
) != BLKmode
)
1034 for (q
= p
->next
; q
; q
= next_q
)
1040 if (GET_MODE (q
->slot
) != BLKmode
)
1043 if (p
->base_offset
+ p
->full_size
== q
->base_offset
)
1045 /* Q comes after P; combine Q into P. */
1047 p
->full_size
+= q
->full_size
;
1050 else if (q
->base_offset
+ q
->full_size
== p
->base_offset
)
1052 /* P comes after Q; combine P into Q. */
1054 q
->full_size
+= p
->full_size
;
1059 cut_slot_from_list (q
, &avail_temp_slots
);
1062 /* Either delete P or advance past it. */
1064 cut_slot_from_list (p
, &avail_temp_slots
);
1068 /* Indicate that NEW_RTX is an alternate way of referring to the temp
1069 slot that previously was known by OLD_RTX. */
1072 update_temp_slot_address (rtx old_rtx
, rtx new_rtx
)
1074 struct temp_slot
*p
;
1076 if (rtx_equal_p (old_rtx
, new_rtx
))
1079 p
= find_temp_slot_from_address (old_rtx
);
1081 /* If we didn't find one, see if both OLD_RTX is a PLUS. If so, and
1082 NEW_RTX is a register, see if one operand of the PLUS is a
1083 temporary location. If so, NEW_RTX points into it. Otherwise,
1084 if both OLD_RTX and NEW_RTX are a PLUS and if there is a register
1085 in common between them. If so, try a recursive call on those
1089 if (GET_CODE (old_rtx
) != PLUS
)
1092 if (REG_P (new_rtx
))
1094 update_temp_slot_address (XEXP (old_rtx
, 0), new_rtx
);
1095 update_temp_slot_address (XEXP (old_rtx
, 1), new_rtx
);
1098 else if (GET_CODE (new_rtx
) != PLUS
)
1101 if (rtx_equal_p (XEXP (old_rtx
, 0), XEXP (new_rtx
, 0)))
1102 update_temp_slot_address (XEXP (old_rtx
, 1), XEXP (new_rtx
, 1));
1103 else if (rtx_equal_p (XEXP (old_rtx
, 1), XEXP (new_rtx
, 0)))
1104 update_temp_slot_address (XEXP (old_rtx
, 0), XEXP (new_rtx
, 1));
1105 else if (rtx_equal_p (XEXP (old_rtx
, 0), XEXP (new_rtx
, 1)))
1106 update_temp_slot_address (XEXP (old_rtx
, 1), XEXP (new_rtx
, 0));
1107 else if (rtx_equal_p (XEXP (old_rtx
, 1), XEXP (new_rtx
, 1)))
1108 update_temp_slot_address (XEXP (old_rtx
, 0), XEXP (new_rtx
, 0));
1113 /* Otherwise add an alias for the temp's address. */
1114 insert_temp_slot_address (new_rtx
, p
);
1117 /* If X could be a reference to a temporary slot, mark that slot as
1118 belonging to the to one level higher than the current level. If X
1119 matched one of our slots, just mark that one. Otherwise, we can't
1120 easily predict which it is, so upgrade all of them.
1122 This is called when an ({...}) construct occurs and a statement
1123 returns a value in memory. */
1126 preserve_temp_slots (rtx x
)
1128 struct temp_slot
*p
= 0, *next
;
1133 /* If X is a register that is being used as a pointer, see if we have
1134 a temporary slot we know it points to. */
1135 if (REG_P (x
) && REG_POINTER (x
))
1136 p
= find_temp_slot_from_address (x
);
1138 /* If X is not in memory or is at a constant address, it cannot be in
1139 a temporary slot. */
1140 if (p
== 0 && (!MEM_P (x
) || CONSTANT_P (XEXP (x
, 0))))
1143 /* First see if we can find a match. */
1145 p
= find_temp_slot_from_address (XEXP (x
, 0));
1149 if (p
->level
== temp_slot_level
)
1150 move_slot_to_level (p
, temp_slot_level
- 1);
1154 /* Otherwise, preserve all non-kept slots at this level. */
1155 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1158 move_slot_to_level (p
, temp_slot_level
- 1);
1162 /* Free all temporaries used so far. This is normally called at the
1163 end of generating code for a statement. */
1166 free_temp_slots (void)
1168 struct temp_slot
*p
, *next
;
1169 bool some_available
= false;
1171 for (p
= *temp_slots_at_level (temp_slot_level
); p
; p
= next
)
1174 make_slot_available (p
);
1175 some_available
= true;
1180 remove_unused_temp_slot_addresses ();
1181 combine_temp_slots ();
1185 /* Push deeper into the nesting level for stack temporaries. */
1188 push_temp_slots (void)
1193 /* Pop a temporary nesting level. All slots in use in the current level
1197 pop_temp_slots (void)
1203 /* Initialize temporary slots. */
1206 init_temp_slots (void)
1208 /* We have not allocated any temporaries yet. */
1209 avail_temp_slots
= 0;
1210 vec_alloc (used_temp_slots
, 0);
1211 temp_slot_level
= 0;
1212 n_temp_slots_in_use
= 0;
1214 /* Set up the table to map addresses to temp slots. */
1215 if (! temp_slot_address_table
)
1216 temp_slot_address_table
= hash_table
<temp_address_hasher
>::create_ggc (32);
1218 temp_slot_address_table
->empty ();
1221 /* Functions and data structures to keep track of the values hard regs
1222 had at the start of the function. */
1224 /* Private type used by get_hard_reg_initial_reg, get_hard_reg_initial_val,
1225 and has_hard_reg_initial_val.. */
1226 typedef struct GTY(()) initial_value_pair
{
1229 } initial_value_pair
;
1230 /* ??? This could be a VEC but there is currently no way to define an
1231 opaque VEC type. This could be worked around by defining struct
1232 initial_value_pair in function.h. */
1233 typedef struct GTY(()) initial_value_struct
{
1236 initial_value_pair
* GTY ((length ("%h.num_entries"))) entries
;
1237 } initial_value_struct
;
1239 /* If a pseudo represents an initial hard reg (or expression), return
1240 it, else return NULL_RTX. */
1243 get_hard_reg_initial_reg (rtx reg
)
1245 struct initial_value_struct
*ivs
= crtl
->hard_reg_initial_vals
;
1251 for (i
= 0; i
< ivs
->num_entries
; i
++)
1252 if (rtx_equal_p (ivs
->entries
[i
].pseudo
, reg
))
1253 return ivs
->entries
[i
].hard_reg
;
1258 /* Make sure that there's a pseudo register of mode MODE that stores the
1259 initial value of hard register REGNO. Return an rtx for such a pseudo. */
1262 get_hard_reg_initial_val (machine_mode mode
, unsigned int regno
)
1264 struct initial_value_struct
*ivs
;
1267 rv
= has_hard_reg_initial_val (mode
, regno
);
1271 ivs
= crtl
->hard_reg_initial_vals
;
1274 ivs
= ggc_alloc
<initial_value_struct
> ();
1275 ivs
->num_entries
= 0;
1276 ivs
->max_entries
= 5;
1277 ivs
->entries
= ggc_vec_alloc
<initial_value_pair
> (5);
1278 crtl
->hard_reg_initial_vals
= ivs
;
1281 if (ivs
->num_entries
>= ivs
->max_entries
)
1283 ivs
->max_entries
+= 5;
1284 ivs
->entries
= GGC_RESIZEVEC (initial_value_pair
, ivs
->entries
,
1288 ivs
->entries
[ivs
->num_entries
].hard_reg
= gen_rtx_REG (mode
, regno
);
1289 ivs
->entries
[ivs
->num_entries
].pseudo
= gen_reg_rtx (mode
);
1291 return ivs
->entries
[ivs
->num_entries
++].pseudo
;
1294 /* See if get_hard_reg_initial_val has been used to create a pseudo
1295 for the initial value of hard register REGNO in mode MODE. Return
1296 the associated pseudo if so, otherwise return NULL. */
1299 has_hard_reg_initial_val (machine_mode mode
, unsigned int regno
)
1301 struct initial_value_struct
*ivs
;
1304 ivs
= crtl
->hard_reg_initial_vals
;
1306 for (i
= 0; i
< ivs
->num_entries
; i
++)
1307 if (GET_MODE (ivs
->entries
[i
].hard_reg
) == mode
1308 && REGNO (ivs
->entries
[i
].hard_reg
) == regno
)
1309 return ivs
->entries
[i
].pseudo
;
1315 emit_initial_value_sets (void)
1317 struct initial_value_struct
*ivs
= crtl
->hard_reg_initial_vals
;
1325 for (i
= 0; i
< ivs
->num_entries
; i
++)
1326 emit_move_insn (ivs
->entries
[i
].pseudo
, ivs
->entries
[i
].hard_reg
);
1330 emit_insn_at_entry (seq
);
1334 /* Return the hardreg-pseudoreg initial values pair entry I and
1335 TRUE if I is a valid entry, or FALSE if I is not a valid entry. */
1337 initial_value_entry (int i
, rtx
*hreg
, rtx
*preg
)
1339 struct initial_value_struct
*ivs
= crtl
->hard_reg_initial_vals
;
1340 if (!ivs
|| i
>= ivs
->num_entries
)
1343 *hreg
= ivs
->entries
[i
].hard_reg
;
1344 *preg
= ivs
->entries
[i
].pseudo
;
1348 /* These routines are responsible for converting virtual register references
1349 to the actual hard register references once RTL generation is complete.
1351 The following four variables are used for communication between the
1352 routines. They contain the offsets of the virtual registers from their
1353 respective hard registers. */
1355 static int in_arg_offset
;
1356 static int var_offset
;
1357 static int dynamic_offset
;
1358 static int out_arg_offset
;
1359 static int cfa_offset
;
1361 /* In most machines, the stack pointer register is equivalent to the bottom
1364 #ifndef STACK_POINTER_OFFSET
1365 #define STACK_POINTER_OFFSET 0
1368 #if defined (REG_PARM_STACK_SPACE) && !defined (INCOMING_REG_PARM_STACK_SPACE)
1369 #define INCOMING_REG_PARM_STACK_SPACE REG_PARM_STACK_SPACE
1372 /* If not defined, pick an appropriate default for the offset of dynamically
1373 allocated memory depending on the value of ACCUMULATE_OUTGOING_ARGS,
1374 INCOMING_REG_PARM_STACK_SPACE, and OUTGOING_REG_PARM_STACK_SPACE. */
1376 #ifndef STACK_DYNAMIC_OFFSET
1378 /* The bottom of the stack points to the actual arguments. If
1379 REG_PARM_STACK_SPACE is defined, this includes the space for the register
1380 parameters. However, if OUTGOING_REG_PARM_STACK space is not defined,
1381 stack space for register parameters is not pushed by the caller, but
1382 rather part of the fixed stack areas and hence not included in
1383 `crtl->outgoing_args_size'. Nevertheless, we must allow
1384 for it when allocating stack dynamic objects. */
1386 #ifdef INCOMING_REG_PARM_STACK_SPACE
1387 #define STACK_DYNAMIC_OFFSET(FNDECL) \
1388 ((ACCUMULATE_OUTGOING_ARGS \
1389 ? (crtl->outgoing_args_size \
1390 + (OUTGOING_REG_PARM_STACK_SPACE ((!(FNDECL) ? NULL_TREE : TREE_TYPE (FNDECL))) ? 0 \
1391 : INCOMING_REG_PARM_STACK_SPACE (FNDECL))) \
1392 : 0) + (STACK_POINTER_OFFSET))
1394 #define STACK_DYNAMIC_OFFSET(FNDECL) \
1395 ((ACCUMULATE_OUTGOING_ARGS ? crtl->outgoing_args_size : 0) \
1396 + (STACK_POINTER_OFFSET))
1401 /* Given a piece of RTX and a pointer to a HOST_WIDE_INT, if the RTX
1402 is a virtual register, return the equivalent hard register and set the
1403 offset indirectly through the pointer. Otherwise, return 0. */
1406 instantiate_new_reg (rtx x
, HOST_WIDE_INT
*poffset
)
1409 HOST_WIDE_INT offset
;
1411 if (x
== virtual_incoming_args_rtx
)
1413 if (stack_realign_drap
)
1415 /* Replace virtual_incoming_args_rtx with internal arg
1416 pointer if DRAP is used to realign stack. */
1417 new_rtx
= crtl
->args
.internal_arg_pointer
;
1421 new_rtx
= arg_pointer_rtx
, offset
= in_arg_offset
;
1423 else if (x
== virtual_stack_vars_rtx
)
1424 new_rtx
= frame_pointer_rtx
, offset
= var_offset
;
1425 else if (x
== virtual_stack_dynamic_rtx
)
1426 new_rtx
= stack_pointer_rtx
, offset
= dynamic_offset
;
1427 else if (x
== virtual_outgoing_args_rtx
)
1428 new_rtx
= stack_pointer_rtx
, offset
= out_arg_offset
;
1429 else if (x
== virtual_cfa_rtx
)
1431 #ifdef FRAME_POINTER_CFA_OFFSET
1432 new_rtx
= frame_pointer_rtx
;
1434 new_rtx
= arg_pointer_rtx
;
1436 offset
= cfa_offset
;
1438 else if (x
== virtual_preferred_stack_boundary_rtx
)
1440 new_rtx
= GEN_INT (crtl
->preferred_stack_boundary
/ BITS_PER_UNIT
);
1450 /* A subroutine of instantiate_virtual_regs. Instantiate any virtual
1451 registers present inside of *LOC. The expression is simplified,
1452 as much as possible, but is not to be considered "valid" in any sense
1453 implied by the target. Return true if any change is made. */
1456 instantiate_virtual_regs_in_rtx (rtx
*loc
)
1460 bool changed
= false;
1461 subrtx_ptr_iterator::array_type array
;
1462 FOR_EACH_SUBRTX_PTR (iter
, array
, loc
, NONCONST
)
1468 HOST_WIDE_INT offset
;
1469 switch (GET_CODE (x
))
1472 new_rtx
= instantiate_new_reg (x
, &offset
);
1475 *loc
= plus_constant (GET_MODE (x
), new_rtx
, offset
);
1478 iter
.skip_subrtxes ();
1482 new_rtx
= instantiate_new_reg (XEXP (x
, 0), &offset
);
1485 XEXP (x
, 0) = new_rtx
;
1486 *loc
= plus_constant (GET_MODE (x
), x
, offset
, true);
1488 iter
.skip_subrtxes ();
1492 /* FIXME -- from old code */
1493 /* If we have (plus (subreg (virtual-reg)) (const_int)), we know
1494 we can commute the PLUS and SUBREG because pointers into the
1495 frame are well-behaved. */
1506 /* A subroutine of instantiate_virtual_regs_in_insn. Return true if X
1507 matches the predicate for insn CODE operand OPERAND. */
1510 safe_insn_predicate (int code
, int operand
, rtx x
)
1512 return code
< 0 || insn_operand_matches ((enum insn_code
) code
, operand
, x
);
1515 /* A subroutine of instantiate_virtual_regs. Instantiate any virtual
1516 registers present inside of insn. The result will be a valid insn. */
1519 instantiate_virtual_regs_in_insn (rtx_insn
*insn
)
1521 HOST_WIDE_INT offset
;
1523 bool any_change
= false;
1524 rtx set
, new_rtx
, x
;
1527 /* There are some special cases to be handled first. */
1528 set
= single_set (insn
);
1531 /* We're allowed to assign to a virtual register. This is interpreted
1532 to mean that the underlying register gets assigned the inverse
1533 transformation. This is used, for example, in the handling of
1535 new_rtx
= instantiate_new_reg (SET_DEST (set
), &offset
);
1540 instantiate_virtual_regs_in_rtx (&SET_SRC (set
));
1541 x
= simplify_gen_binary (PLUS
, GET_MODE (new_rtx
), SET_SRC (set
),
1542 gen_int_mode (-offset
, GET_MODE (new_rtx
)));
1543 x
= force_operand (x
, new_rtx
);
1545 emit_move_insn (new_rtx
, x
);
1550 emit_insn_before (seq
, insn
);
1555 /* Handle a straight copy from a virtual register by generating a
1556 new add insn. The difference between this and falling through
1557 to the generic case is avoiding a new pseudo and eliminating a
1558 move insn in the initial rtl stream. */
1559 new_rtx
= instantiate_new_reg (SET_SRC (set
), &offset
);
1560 if (new_rtx
&& offset
!= 0
1561 && REG_P (SET_DEST (set
))
1562 && REGNO (SET_DEST (set
)) > LAST_VIRTUAL_REGISTER
)
1566 x
= expand_simple_binop (GET_MODE (SET_DEST (set
)), PLUS
, new_rtx
,
1567 gen_int_mode (offset
,
1568 GET_MODE (SET_DEST (set
))),
1569 SET_DEST (set
), 1, OPTAB_LIB_WIDEN
);
1570 if (x
!= SET_DEST (set
))
1571 emit_move_insn (SET_DEST (set
), x
);
1576 emit_insn_before (seq
, insn
);
1581 extract_insn (insn
);
1582 insn_code
= INSN_CODE (insn
);
1584 /* Handle a plus involving a virtual register by determining if the
1585 operands remain valid if they're modified in place. */
1586 if (GET_CODE (SET_SRC (set
)) == PLUS
1587 && recog_data
.n_operands
>= 3
1588 && recog_data
.operand_loc
[1] == &XEXP (SET_SRC (set
), 0)
1589 && recog_data
.operand_loc
[2] == &XEXP (SET_SRC (set
), 1)
1590 && CONST_INT_P (recog_data
.operand
[2])
1591 && (new_rtx
= instantiate_new_reg (recog_data
.operand
[1], &offset
)))
1593 offset
+= INTVAL (recog_data
.operand
[2]);
1595 /* If the sum is zero, then replace with a plain move. */
1597 && REG_P (SET_DEST (set
))
1598 && REGNO (SET_DEST (set
)) > LAST_VIRTUAL_REGISTER
)
1601 emit_move_insn (SET_DEST (set
), new_rtx
);
1605 emit_insn_before (seq
, insn
);
1610 x
= gen_int_mode (offset
, recog_data
.operand_mode
[2]);
1612 /* Using validate_change and apply_change_group here leaves
1613 recog_data in an invalid state. Since we know exactly what
1614 we want to check, do those two by hand. */
1615 if (safe_insn_predicate (insn_code
, 1, new_rtx
)
1616 && safe_insn_predicate (insn_code
, 2, x
))
1618 *recog_data
.operand_loc
[1] = recog_data
.operand
[1] = new_rtx
;
1619 *recog_data
.operand_loc
[2] = recog_data
.operand
[2] = x
;
1622 /* Fall through into the regular operand fixup loop in
1623 order to take care of operands other than 1 and 2. */
1629 extract_insn (insn
);
1630 insn_code
= INSN_CODE (insn
);
1633 /* In the general case, we expect virtual registers to appear only in
1634 operands, and then only as either bare registers or inside memories. */
1635 for (i
= 0; i
< recog_data
.n_operands
; ++i
)
1637 x
= recog_data
.operand
[i
];
1638 switch (GET_CODE (x
))
1642 rtx addr
= XEXP (x
, 0);
1644 if (!instantiate_virtual_regs_in_rtx (&addr
))
1648 x
= replace_equiv_address (x
, addr
, true);
1649 /* It may happen that the address with the virtual reg
1650 was valid (e.g. based on the virtual stack reg, which might
1651 be acceptable to the predicates with all offsets), whereas
1652 the address now isn't anymore, for instance when the address
1653 is still offsetted, but the base reg isn't virtual-stack-reg
1654 anymore. Below we would do a force_reg on the whole operand,
1655 but this insn might actually only accept memory. Hence,
1656 before doing that last resort, try to reload the address into
1657 a register, so this operand stays a MEM. */
1658 if (!safe_insn_predicate (insn_code
, i
, x
))
1660 addr
= force_reg (GET_MODE (addr
), addr
);
1661 x
= replace_equiv_address (x
, addr
, true);
1666 emit_insn_before (seq
, insn
);
1671 new_rtx
= instantiate_new_reg (x
, &offset
);
1672 if (new_rtx
== NULL
)
1680 /* Careful, special mode predicates may have stuff in
1681 insn_data[insn_code].operand[i].mode that isn't useful
1682 to us for computing a new value. */
1683 /* ??? Recognize address_operand and/or "p" constraints
1684 to see if (plus new offset) is a valid before we put
1685 this through expand_simple_binop. */
1686 x
= expand_simple_binop (GET_MODE (x
), PLUS
, new_rtx
,
1687 gen_int_mode (offset
, GET_MODE (x
)),
1688 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
1691 emit_insn_before (seq
, insn
);
1696 new_rtx
= instantiate_new_reg (SUBREG_REG (x
), &offset
);
1697 if (new_rtx
== NULL
)
1702 new_rtx
= expand_simple_binop
1703 (GET_MODE (new_rtx
), PLUS
, new_rtx
,
1704 gen_int_mode (offset
, GET_MODE (new_rtx
)),
1705 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
1708 emit_insn_before (seq
, insn
);
1710 x
= simplify_gen_subreg (recog_data
.operand_mode
[i
], new_rtx
,
1711 GET_MODE (new_rtx
), SUBREG_BYTE (x
));
1719 /* At this point, X contains the new value for the operand.
1720 Validate the new value vs the insn predicate. Note that
1721 asm insns will have insn_code -1 here. */
1722 if (!safe_insn_predicate (insn_code
, i
, x
))
1727 gcc_assert (REGNO (x
) <= LAST_VIRTUAL_REGISTER
);
1728 x
= copy_to_reg (x
);
1731 x
= force_reg (insn_data
[insn_code
].operand
[i
].mode
, x
);
1735 emit_insn_before (seq
, insn
);
1738 *recog_data
.operand_loc
[i
] = recog_data
.operand
[i
] = x
;
1744 /* Propagate operand changes into the duplicates. */
1745 for (i
= 0; i
< recog_data
.n_dups
; ++i
)
1746 *recog_data
.dup_loc
[i
]
1747 = copy_rtx (recog_data
.operand
[(unsigned)recog_data
.dup_num
[i
]]);
1749 /* Force re-recognition of the instruction for validation. */
1750 INSN_CODE (insn
) = -1;
1753 if (asm_noperands (PATTERN (insn
)) >= 0)
1755 if (!check_asm_operands (PATTERN (insn
)))
1757 error_for_asm (insn
, "impossible constraint in %<asm%>");
1758 /* For asm goto, instead of fixing up all the edges
1759 just clear the template and clear input operands
1760 (asm goto doesn't have any output operands). */
1763 rtx asm_op
= extract_asm_operands (PATTERN (insn
));
1764 ASM_OPERANDS_TEMPLATE (asm_op
) = ggc_strdup ("");
1765 ASM_OPERANDS_INPUT_VEC (asm_op
) = rtvec_alloc (0);
1766 ASM_OPERANDS_INPUT_CONSTRAINT_VEC (asm_op
) = rtvec_alloc (0);
1774 if (recog_memoized (insn
) < 0)
1775 fatal_insn_not_found (insn
);
1779 /* Subroutine of instantiate_decls. Given RTL representing a decl,
1780 do any instantiation required. */
1783 instantiate_decl_rtl (rtx x
)
1790 /* If this is a CONCAT, recurse for the pieces. */
1791 if (GET_CODE (x
) == CONCAT
)
1793 instantiate_decl_rtl (XEXP (x
, 0));
1794 instantiate_decl_rtl (XEXP (x
, 1));
1798 /* If this is not a MEM, no need to do anything. Similarly if the
1799 address is a constant or a register that is not a virtual register. */
1804 if (CONSTANT_P (addr
)
1806 && (REGNO (addr
) < FIRST_VIRTUAL_REGISTER
1807 || REGNO (addr
) > LAST_VIRTUAL_REGISTER
)))
1810 instantiate_virtual_regs_in_rtx (&XEXP (x
, 0));
1813 /* Helper for instantiate_decls called via walk_tree: Process all decls
1814 in the given DECL_VALUE_EXPR. */
1817 instantiate_expr (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
1825 if (DECL_RTL_SET_P (t
))
1826 instantiate_decl_rtl (DECL_RTL (t
));
1827 if (TREE_CODE (t
) == PARM_DECL
&& DECL_NAMELESS (t
)
1828 && DECL_INCOMING_RTL (t
))
1829 instantiate_decl_rtl (DECL_INCOMING_RTL (t
));
1830 if ((TREE_CODE (t
) == VAR_DECL
1831 || TREE_CODE (t
) == RESULT_DECL
)
1832 && DECL_HAS_VALUE_EXPR_P (t
))
1834 tree v
= DECL_VALUE_EXPR (t
);
1835 walk_tree (&v
, instantiate_expr
, NULL
, NULL
);
1842 /* Subroutine of instantiate_decls: Process all decls in the given
1843 BLOCK node and all its subblocks. */
1846 instantiate_decls_1 (tree let
)
1850 for (t
= BLOCK_VARS (let
); t
; t
= DECL_CHAIN (t
))
1852 if (DECL_RTL_SET_P (t
))
1853 instantiate_decl_rtl (DECL_RTL (t
));
1854 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (t
))
1856 tree v
= DECL_VALUE_EXPR (t
);
1857 walk_tree (&v
, instantiate_expr
, NULL
, NULL
);
1861 /* Process all subblocks. */
1862 for (t
= BLOCK_SUBBLOCKS (let
); t
; t
= BLOCK_CHAIN (t
))
1863 instantiate_decls_1 (t
);
1866 /* Scan all decls in FNDECL (both variables and parameters) and instantiate
1867 all virtual registers in their DECL_RTL's. */
1870 instantiate_decls (tree fndecl
)
1875 /* Process all parameters of the function. */
1876 for (decl
= DECL_ARGUMENTS (fndecl
); decl
; decl
= DECL_CHAIN (decl
))
1878 instantiate_decl_rtl (DECL_RTL (decl
));
1879 instantiate_decl_rtl (DECL_INCOMING_RTL (decl
));
1880 if (DECL_HAS_VALUE_EXPR_P (decl
))
1882 tree v
= DECL_VALUE_EXPR (decl
);
1883 walk_tree (&v
, instantiate_expr
, NULL
, NULL
);
1887 if ((decl
= DECL_RESULT (fndecl
))
1888 && TREE_CODE (decl
) == RESULT_DECL
)
1890 if (DECL_RTL_SET_P (decl
))
1891 instantiate_decl_rtl (DECL_RTL (decl
));
1892 if (DECL_HAS_VALUE_EXPR_P (decl
))
1894 tree v
= DECL_VALUE_EXPR (decl
);
1895 walk_tree (&v
, instantiate_expr
, NULL
, NULL
);
1899 /* Process the saved static chain if it exists. */
1900 decl
= DECL_STRUCT_FUNCTION (fndecl
)->static_chain_decl
;
1901 if (decl
&& DECL_HAS_VALUE_EXPR_P (decl
))
1902 instantiate_decl_rtl (DECL_RTL (DECL_VALUE_EXPR (decl
)));
1904 /* Now process all variables defined in the function or its subblocks. */
1905 instantiate_decls_1 (DECL_INITIAL (fndecl
));
1907 FOR_EACH_LOCAL_DECL (cfun
, ix
, decl
)
1908 if (DECL_RTL_SET_P (decl
))
1909 instantiate_decl_rtl (DECL_RTL (decl
));
1910 vec_free (cfun
->local_decls
);
1913 /* Pass through the INSNS of function FNDECL and convert virtual register
1914 references to hard register references. */
1917 instantiate_virtual_regs (void)
1921 /* Compute the offsets to use for this function. */
1922 in_arg_offset
= FIRST_PARM_OFFSET (current_function_decl
);
1923 var_offset
= STARTING_FRAME_OFFSET
;
1924 dynamic_offset
= STACK_DYNAMIC_OFFSET (current_function_decl
);
1925 out_arg_offset
= STACK_POINTER_OFFSET
;
1926 #ifdef FRAME_POINTER_CFA_OFFSET
1927 cfa_offset
= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
1929 cfa_offset
= ARG_POINTER_CFA_OFFSET (current_function_decl
);
1932 /* Initialize recognition, indicating that volatile is OK. */
1935 /* Scan through all the insns, instantiating every virtual register still
1937 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1940 /* These patterns in the instruction stream can never be recognized.
1941 Fortunately, they shouldn't contain virtual registers either. */
1942 if (GET_CODE (PATTERN (insn
)) == USE
1943 || GET_CODE (PATTERN (insn
)) == CLOBBER
1944 || GET_CODE (PATTERN (insn
)) == ASM_INPUT
)
1946 else if (DEBUG_INSN_P (insn
))
1947 instantiate_virtual_regs_in_rtx (&INSN_VAR_LOCATION (insn
));
1949 instantiate_virtual_regs_in_insn (insn
);
1951 if (insn
->deleted ())
1954 instantiate_virtual_regs_in_rtx (®_NOTES (insn
));
1956 /* Instantiate any virtual registers in CALL_INSN_FUNCTION_USAGE. */
1958 instantiate_virtual_regs_in_rtx (&CALL_INSN_FUNCTION_USAGE (insn
));
1961 /* Instantiate the virtual registers in the DECLs for debugging purposes. */
1962 instantiate_decls (current_function_decl
);
1964 targetm
.instantiate_decls ();
1966 /* Indicate that, from now on, assign_stack_local should use
1967 frame_pointer_rtx. */
1968 virtuals_instantiated
= 1;
1975 const pass_data pass_data_instantiate_virtual_regs
=
1977 RTL_PASS
, /* type */
1979 OPTGROUP_NONE
, /* optinfo_flags */
1980 TV_NONE
, /* tv_id */
1981 0, /* properties_required */
1982 0, /* properties_provided */
1983 0, /* properties_destroyed */
1984 0, /* todo_flags_start */
1985 0, /* todo_flags_finish */
1988 class pass_instantiate_virtual_regs
: public rtl_opt_pass
1991 pass_instantiate_virtual_regs (gcc::context
*ctxt
)
1992 : rtl_opt_pass (pass_data_instantiate_virtual_regs
, ctxt
)
1995 /* opt_pass methods: */
1996 virtual unsigned int execute (function
*)
1998 return instantiate_virtual_regs ();
2001 }; // class pass_instantiate_virtual_regs
2006 make_pass_instantiate_virtual_regs (gcc::context
*ctxt
)
2008 return new pass_instantiate_virtual_regs (ctxt
);
2012 /* Return 1 if EXP is an aggregate type (or a value with aggregate type).
2013 This means a type for which function calls must pass an address to the
2014 function or get an address back from the function.
2015 EXP may be a type node or an expression (whose type is tested). */
2018 aggregate_value_p (const_tree exp
, const_tree fntype
)
2020 const_tree type
= (TYPE_P (exp
)) ? exp
: TREE_TYPE (exp
);
2021 int i
, regno
, nregs
;
2025 switch (TREE_CODE (fntype
))
2029 tree fndecl
= get_callee_fndecl (fntype
);
2031 fntype
= TREE_TYPE (fndecl
);
2032 else if (CALL_EXPR_FN (fntype
))
2033 fntype
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (fntype
)));
2035 /* For internal functions, assume nothing needs to be
2036 returned in memory. */
2041 fntype
= TREE_TYPE (fntype
);
2046 case IDENTIFIER_NODE
:
2050 /* We don't expect other tree types here. */
2054 if (VOID_TYPE_P (type
))
2057 /* If a record should be passed the same as its first (and only) member
2058 don't pass it as an aggregate. */
2059 if (TREE_CODE (type
) == RECORD_TYPE
&& TYPE_TRANSPARENT_AGGR (type
))
2060 return aggregate_value_p (first_field (type
), fntype
);
2062 /* If the front end has decided that this needs to be passed by
2063 reference, do so. */
2064 if ((TREE_CODE (exp
) == PARM_DECL
|| TREE_CODE (exp
) == RESULT_DECL
)
2065 && DECL_BY_REFERENCE (exp
))
2068 /* Function types that are TREE_ADDRESSABLE force return in memory. */
2069 if (fntype
&& TREE_ADDRESSABLE (fntype
))
2072 /* Types that are TREE_ADDRESSABLE must be constructed in memory,
2073 and thus can't be returned in registers. */
2074 if (TREE_ADDRESSABLE (type
))
2077 if (flag_pcc_struct_return
&& AGGREGATE_TYPE_P (type
))
2080 if (targetm
.calls
.return_in_memory (type
, fntype
))
2083 /* Make sure we have suitable call-clobbered regs to return
2084 the value in; if not, we must return it in memory. */
2085 reg
= hard_function_value (type
, 0, fntype
, 0);
2087 /* If we have something other than a REG (e.g. a PARALLEL), then assume
2092 regno
= REGNO (reg
);
2093 nregs
= hard_regno_nregs
[regno
][TYPE_MODE (type
)];
2094 for (i
= 0; i
< nregs
; i
++)
2095 if (! call_used_regs
[regno
+ i
])
2101 /* Return true if we should assign DECL a pseudo register; false if it
2102 should live on the local stack. */
2105 use_register_for_decl (const_tree decl
)
2107 if (!targetm
.calls
.allocate_stack_slots_for_args ())
2110 /* Honor volatile. */
2111 if (TREE_SIDE_EFFECTS (decl
))
2114 /* Honor addressability. */
2115 if (TREE_ADDRESSABLE (decl
))
2118 /* Decl is implicitly addressible by bound stores and loads
2119 if it is an aggregate holding bounds. */
2120 if (chkp_function_instrumented_p (current_function_decl
)
2122 && !BOUNDED_P (decl
)
2123 && chkp_type_has_pointer (TREE_TYPE (decl
)))
2126 /* Only register-like things go in registers. */
2127 if (DECL_MODE (decl
) == BLKmode
)
2130 /* If -ffloat-store specified, don't put explicit float variables
2132 /* ??? This should be checked after DECL_ARTIFICIAL, but tree-ssa
2133 propagates values across these stores, and it probably shouldn't. */
2134 if (flag_float_store
&& FLOAT_TYPE_P (TREE_TYPE (decl
)))
2137 /* If we're not interested in tracking debugging information for
2138 this decl, then we can certainly put it in a register. */
2139 if (DECL_IGNORED_P (decl
))
2145 if (!DECL_REGISTER (decl
))
2148 switch (TREE_CODE (TREE_TYPE (decl
)))
2152 case QUAL_UNION_TYPE
:
2153 /* When not optimizing, disregard register keyword for variables with
2154 types containing methods, otherwise the methods won't be callable
2155 from the debugger. */
2156 if (TYPE_METHODS (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))))
2166 /* Structures to communicate between the subroutines of assign_parms.
2167 The first holds data persistent across all parameters, the second
2168 is cleared out for each parameter. */
2170 struct assign_parm_data_all
2172 /* When INIT_CUMULATIVE_ARGS gets revamped, allocating CUMULATIVE_ARGS
2173 should become a job of the target or otherwise encapsulated. */
2174 CUMULATIVE_ARGS args_so_far_v
;
2175 cumulative_args_t args_so_far
;
2176 struct args_size stack_args_size
;
2177 tree function_result_decl
;
2179 rtx_insn
*first_conversion_insn
;
2180 rtx_insn
*last_conversion_insn
;
2181 HOST_WIDE_INT pretend_args_size
;
2182 HOST_WIDE_INT extra_pretend_bytes
;
2183 int reg_parm_stack_space
;
2186 struct assign_parm_data_one
2192 machine_mode nominal_mode
;
2193 machine_mode passed_mode
;
2194 machine_mode promoted_mode
;
2195 struct locate_and_pad_arg_data locate
;
2197 BOOL_BITFIELD named_arg
: 1;
2198 BOOL_BITFIELD passed_pointer
: 1;
2199 BOOL_BITFIELD on_stack
: 1;
2200 BOOL_BITFIELD loaded_in_reg
: 1;
2203 struct bounds_parm_data
2205 assign_parm_data_one parm_data
;
2212 /* A subroutine of assign_parms. Initialize ALL. */
2215 assign_parms_initialize_all (struct assign_parm_data_all
*all
)
2217 tree fntype ATTRIBUTE_UNUSED
;
2219 memset (all
, 0, sizeof (*all
));
2221 fntype
= TREE_TYPE (current_function_decl
);
2223 #ifdef INIT_CUMULATIVE_INCOMING_ARGS
2224 INIT_CUMULATIVE_INCOMING_ARGS (all
->args_so_far_v
, fntype
, NULL_RTX
);
2226 INIT_CUMULATIVE_ARGS (all
->args_so_far_v
, fntype
, NULL_RTX
,
2227 current_function_decl
, -1);
2229 all
->args_so_far
= pack_cumulative_args (&all
->args_so_far_v
);
2231 #ifdef INCOMING_REG_PARM_STACK_SPACE
2232 all
->reg_parm_stack_space
2233 = INCOMING_REG_PARM_STACK_SPACE (current_function_decl
);
2237 /* If ARGS contains entries with complex types, split the entry into two
2238 entries of the component type. Return a new list of substitutions are
2239 needed, else the old list. */
2242 split_complex_args (vec
<tree
> *args
)
2247 FOR_EACH_VEC_ELT (*args
, i
, p
)
2249 tree type
= TREE_TYPE (p
);
2250 if (TREE_CODE (type
) == COMPLEX_TYPE
2251 && targetm
.calls
.split_complex_arg (type
))
2254 tree subtype
= TREE_TYPE (type
);
2255 bool addressable
= TREE_ADDRESSABLE (p
);
2257 /* Rewrite the PARM_DECL's type with its component. */
2259 TREE_TYPE (p
) = subtype
;
2260 DECL_ARG_TYPE (p
) = TREE_TYPE (DECL_ARG_TYPE (p
));
2261 DECL_MODE (p
) = VOIDmode
;
2262 DECL_SIZE (p
) = NULL
;
2263 DECL_SIZE_UNIT (p
) = NULL
;
2264 /* If this arg must go in memory, put it in a pseudo here.
2265 We can't allow it to go in memory as per normal parms,
2266 because the usual place might not have the imag part
2267 adjacent to the real part. */
2268 DECL_ARTIFICIAL (p
) = addressable
;
2269 DECL_IGNORED_P (p
) = addressable
;
2270 TREE_ADDRESSABLE (p
) = 0;
2274 /* Build a second synthetic decl. */
2275 decl
= build_decl (EXPR_LOCATION (p
),
2276 PARM_DECL
, NULL_TREE
, subtype
);
2277 DECL_ARG_TYPE (decl
) = DECL_ARG_TYPE (p
);
2278 DECL_ARTIFICIAL (decl
) = addressable
;
2279 DECL_IGNORED_P (decl
) = addressable
;
2280 layout_decl (decl
, 0);
2281 args
->safe_insert (++i
, decl
);
2286 /* A subroutine of assign_parms. Adjust the parameter list to incorporate
2287 the hidden struct return argument, and (abi willing) complex args.
2288 Return the new parameter list. */
2291 assign_parms_augmented_arg_list (struct assign_parm_data_all
*all
)
2293 tree fndecl
= current_function_decl
;
2294 tree fntype
= TREE_TYPE (fndecl
);
2295 vec
<tree
> fnargs
= vNULL
;
2298 for (arg
= DECL_ARGUMENTS (fndecl
); arg
; arg
= DECL_CHAIN (arg
))
2299 fnargs
.safe_push (arg
);
2301 all
->orig_fnargs
= DECL_ARGUMENTS (fndecl
);
2303 /* If struct value address is treated as the first argument, make it so. */
2304 if (aggregate_value_p (DECL_RESULT (fndecl
), fndecl
)
2305 && ! cfun
->returns_pcc_struct
2306 && targetm
.calls
.struct_value_rtx (TREE_TYPE (fndecl
), 1) == 0)
2308 tree type
= build_pointer_type (TREE_TYPE (fntype
));
2311 decl
= build_decl (DECL_SOURCE_LOCATION (fndecl
),
2312 PARM_DECL
, get_identifier (".result_ptr"), type
);
2313 DECL_ARG_TYPE (decl
) = type
;
2314 DECL_ARTIFICIAL (decl
) = 1;
2315 DECL_NAMELESS (decl
) = 1;
2316 TREE_CONSTANT (decl
) = 1;
2318 DECL_CHAIN (decl
) = all
->orig_fnargs
;
2319 all
->orig_fnargs
= decl
;
2320 fnargs
.safe_insert (0, decl
);
2322 all
->function_result_decl
= decl
;
2324 /* If function is instrumented then bounds of the
2325 passed structure address is the second argument. */
2326 if (chkp_function_instrumented_p (fndecl
))
2328 decl
= build_decl (DECL_SOURCE_LOCATION (fndecl
),
2329 PARM_DECL
, get_identifier (".result_bnd"),
2330 pointer_bounds_type_node
);
2331 DECL_ARG_TYPE (decl
) = pointer_bounds_type_node
;
2332 DECL_ARTIFICIAL (decl
) = 1;
2333 DECL_NAMELESS (decl
) = 1;
2334 TREE_CONSTANT (decl
) = 1;
2336 DECL_CHAIN (decl
) = DECL_CHAIN (all
->orig_fnargs
);
2337 DECL_CHAIN (all
->orig_fnargs
) = decl
;
2338 fnargs
.safe_insert (1, decl
);
2342 /* If the target wants to split complex arguments into scalars, do so. */
2343 if (targetm
.calls
.split_complex_arg
)
2344 split_complex_args (&fnargs
);
2349 /* A subroutine of assign_parms. Examine PARM and pull out type and mode
2350 data for the parameter. Incorporate ABI specifics such as pass-by-
2351 reference and type promotion. */
2354 assign_parm_find_data_types (struct assign_parm_data_all
*all
, tree parm
,
2355 struct assign_parm_data_one
*data
)
2357 tree nominal_type
, passed_type
;
2358 machine_mode nominal_mode
, passed_mode
, promoted_mode
;
2361 memset (data
, 0, sizeof (*data
));
2363 /* NAMED_ARG is a misnomer. We really mean 'non-variadic'. */
2365 data
->named_arg
= 1; /* No variadic parms. */
2366 else if (DECL_CHAIN (parm
))
2367 data
->named_arg
= 1; /* Not the last non-variadic parm. */
2368 else if (targetm
.calls
.strict_argument_naming (all
->args_so_far
))
2369 data
->named_arg
= 1; /* Only variadic ones are unnamed. */
2371 data
->named_arg
= 0; /* Treat as variadic. */
2373 nominal_type
= TREE_TYPE (parm
);
2374 passed_type
= DECL_ARG_TYPE (parm
);
2376 /* Look out for errors propagating this far. Also, if the parameter's
2377 type is void then its value doesn't matter. */
2378 if (TREE_TYPE (parm
) == error_mark_node
2379 /* This can happen after weird syntax errors
2380 or if an enum type is defined among the parms. */
2381 || TREE_CODE (parm
) != PARM_DECL
2382 || passed_type
== NULL
2383 || VOID_TYPE_P (nominal_type
))
2385 nominal_type
= passed_type
= void_type_node
;
2386 nominal_mode
= passed_mode
= promoted_mode
= VOIDmode
;
2390 /* Find mode of arg as it is passed, and mode of arg as it should be
2391 during execution of this function. */
2392 passed_mode
= TYPE_MODE (passed_type
);
2393 nominal_mode
= TYPE_MODE (nominal_type
);
2395 /* If the parm is to be passed as a transparent union or record, use the
2396 type of the first field for the tests below. We have already verified
2397 that the modes are the same. */
2398 if ((TREE_CODE (passed_type
) == UNION_TYPE
2399 || TREE_CODE (passed_type
) == RECORD_TYPE
)
2400 && TYPE_TRANSPARENT_AGGR (passed_type
))
2401 passed_type
= TREE_TYPE (first_field (passed_type
));
2403 /* See if this arg was passed by invisible reference. */
2404 if (pass_by_reference (&all
->args_so_far_v
, passed_mode
,
2405 passed_type
, data
->named_arg
))
2407 passed_type
= nominal_type
= build_pointer_type (passed_type
);
2408 data
->passed_pointer
= true;
2409 passed_mode
= nominal_mode
= TYPE_MODE (nominal_type
);
2412 /* Find mode as it is passed by the ABI. */
2413 unsignedp
= TYPE_UNSIGNED (passed_type
);
2414 promoted_mode
= promote_function_mode (passed_type
, passed_mode
, &unsignedp
,
2415 TREE_TYPE (current_function_decl
), 0);
2418 data
->nominal_type
= nominal_type
;
2419 data
->passed_type
= passed_type
;
2420 data
->nominal_mode
= nominal_mode
;
2421 data
->passed_mode
= passed_mode
;
2422 data
->promoted_mode
= promoted_mode
;
2425 /* A subroutine of assign_parms. Invoke setup_incoming_varargs. */
2428 assign_parms_setup_varargs (struct assign_parm_data_all
*all
,
2429 struct assign_parm_data_one
*data
, bool no_rtl
)
2431 int varargs_pretend_bytes
= 0;
2433 targetm
.calls
.setup_incoming_varargs (all
->args_so_far
,
2434 data
->promoted_mode
,
2436 &varargs_pretend_bytes
, no_rtl
);
2438 /* If the back-end has requested extra stack space, record how much is
2439 needed. Do not change pretend_args_size otherwise since it may be
2440 nonzero from an earlier partial argument. */
2441 if (varargs_pretend_bytes
> 0)
2442 all
->pretend_args_size
= varargs_pretend_bytes
;
2445 /* A subroutine of assign_parms. Set DATA->ENTRY_PARM corresponding to
2446 the incoming location of the current parameter. */
2449 assign_parm_find_entry_rtl (struct assign_parm_data_all
*all
,
2450 struct assign_parm_data_one
*data
)
2452 HOST_WIDE_INT pretend_bytes
= 0;
2456 if (data
->promoted_mode
== VOIDmode
)
2458 data
->entry_parm
= data
->stack_parm
= const0_rtx
;
2462 entry_parm
= targetm
.calls
.function_incoming_arg (all
->args_so_far
,
2463 data
->promoted_mode
,
2467 if (entry_parm
== 0)
2468 data
->promoted_mode
= data
->passed_mode
;
2470 /* Determine parm's home in the stack, in case it arrives in the stack
2471 or we should pretend it did. Compute the stack position and rtx where
2472 the argument arrives and its size.
2474 There is one complexity here: If this was a parameter that would
2475 have been passed in registers, but wasn't only because it is
2476 __builtin_va_alist, we want locate_and_pad_parm to treat it as if
2477 it came in a register so that REG_PARM_STACK_SPACE isn't skipped.
2478 In this case, we call FUNCTION_ARG with NAMED set to 1 instead of 0
2479 as it was the previous time. */
2480 in_regs
= (entry_parm
!= 0) || POINTER_BOUNDS_TYPE_P (data
->passed_type
);
2481 #ifdef STACK_PARMS_IN_REG_PARM_AREA
2484 if (!in_regs
&& !data
->named_arg
)
2486 if (targetm
.calls
.pretend_outgoing_varargs_named (all
->args_so_far
))
2489 tem
= targetm
.calls
.function_incoming_arg (all
->args_so_far
,
2490 data
->promoted_mode
,
2491 data
->passed_type
, true);
2492 in_regs
= tem
!= NULL
;
2496 /* If this parameter was passed both in registers and in the stack, use
2497 the copy on the stack. */
2498 if (targetm
.calls
.must_pass_in_stack (data
->promoted_mode
,
2506 partial
= targetm
.calls
.arg_partial_bytes (all
->args_so_far
,
2507 data
->promoted_mode
,
2510 data
->partial
= partial
;
2512 /* The caller might already have allocated stack space for the
2513 register parameters. */
2514 if (partial
!= 0 && all
->reg_parm_stack_space
== 0)
2516 /* Part of this argument is passed in registers and part
2517 is passed on the stack. Ask the prologue code to extend
2518 the stack part so that we can recreate the full value.
2520 PRETEND_BYTES is the size of the registers we need to store.
2521 CURRENT_FUNCTION_PRETEND_ARGS_SIZE is the amount of extra
2522 stack space that the prologue should allocate.
2524 Internally, gcc assumes that the argument pointer is aligned
2525 to STACK_BOUNDARY bits. This is used both for alignment
2526 optimizations (see init_emit) and to locate arguments that are
2527 aligned to more than PARM_BOUNDARY bits. We must preserve this
2528 invariant by rounding CURRENT_FUNCTION_PRETEND_ARGS_SIZE up to
2529 a stack boundary. */
2531 /* We assume at most one partial arg, and it must be the first
2532 argument on the stack. */
2533 gcc_assert (!all
->extra_pretend_bytes
&& !all
->pretend_args_size
);
2535 pretend_bytes
= partial
;
2536 all
->pretend_args_size
= CEIL_ROUND (pretend_bytes
, STACK_BYTES
);
2538 /* We want to align relative to the actual stack pointer, so
2539 don't include this in the stack size until later. */
2540 all
->extra_pretend_bytes
= all
->pretend_args_size
;
2544 locate_and_pad_parm (data
->promoted_mode
, data
->passed_type
, in_regs
,
2545 all
->reg_parm_stack_space
,
2546 entry_parm
? data
->partial
: 0, current_function_decl
,
2547 &all
->stack_args_size
, &data
->locate
);
2549 /* Update parm_stack_boundary if this parameter is passed in the
2551 if (!in_regs
&& crtl
->parm_stack_boundary
< data
->locate
.boundary
)
2552 crtl
->parm_stack_boundary
= data
->locate
.boundary
;
2554 /* Adjust offsets to include the pretend args. */
2555 pretend_bytes
= all
->extra_pretend_bytes
- pretend_bytes
;
2556 data
->locate
.slot_offset
.constant
+= pretend_bytes
;
2557 data
->locate
.offset
.constant
+= pretend_bytes
;
2559 data
->entry_parm
= entry_parm
;
2562 /* A subroutine of assign_parms. If there is actually space on the stack
2563 for this parm, count it in stack_args_size and return true. */
2566 assign_parm_is_stack_parm (struct assign_parm_data_all
*all
,
2567 struct assign_parm_data_one
*data
)
2569 /* Bounds are never passed on the stack to keep compatibility
2570 with not instrumented code. */
2571 if (POINTER_BOUNDS_TYPE_P (data
->passed_type
))
2573 /* Trivially true if we've no incoming register. */
2574 else if (data
->entry_parm
== NULL
)
2576 /* Also true if we're partially in registers and partially not,
2577 since we've arranged to drop the entire argument on the stack. */
2578 else if (data
->partial
!= 0)
2580 /* Also true if the target says that it's passed in both registers
2581 and on the stack. */
2582 else if (GET_CODE (data
->entry_parm
) == PARALLEL
2583 && XEXP (XVECEXP (data
->entry_parm
, 0, 0), 0) == NULL_RTX
)
2585 /* Also true if the target says that there's stack allocated for
2586 all register parameters. */
2587 else if (all
->reg_parm_stack_space
> 0)
2589 /* Otherwise, no, this parameter has no ABI defined stack slot. */
2593 all
->stack_args_size
.constant
+= data
->locate
.size
.constant
;
2594 if (data
->locate
.size
.var
)
2595 ADD_PARM_SIZE (all
->stack_args_size
, data
->locate
.size
.var
);
2600 /* A subroutine of assign_parms. Given that this parameter is allocated
2601 stack space by the ABI, find it. */
2604 assign_parm_find_stack_rtl (tree parm
, struct assign_parm_data_one
*data
)
2606 rtx offset_rtx
, stack_parm
;
2607 unsigned int align
, boundary
;
2609 /* If we're passing this arg using a reg, make its stack home the
2610 aligned stack slot. */
2611 if (data
->entry_parm
)
2612 offset_rtx
= ARGS_SIZE_RTX (data
->locate
.slot_offset
);
2614 offset_rtx
= ARGS_SIZE_RTX (data
->locate
.offset
);
2616 stack_parm
= crtl
->args
.internal_arg_pointer
;
2617 if (offset_rtx
!= const0_rtx
)
2618 stack_parm
= gen_rtx_PLUS (Pmode
, stack_parm
, offset_rtx
);
2619 stack_parm
= gen_rtx_MEM (data
->promoted_mode
, stack_parm
);
2621 if (!data
->passed_pointer
)
2623 set_mem_attributes (stack_parm
, parm
, 1);
2624 /* set_mem_attributes could set MEM_SIZE to the passed mode's size,
2625 while promoted mode's size is needed. */
2626 if (data
->promoted_mode
!= BLKmode
2627 && data
->promoted_mode
!= DECL_MODE (parm
))
2629 set_mem_size (stack_parm
, GET_MODE_SIZE (data
->promoted_mode
));
2630 if (MEM_EXPR (stack_parm
) && MEM_OFFSET_KNOWN_P (stack_parm
))
2632 int offset
= subreg_lowpart_offset (DECL_MODE (parm
),
2633 data
->promoted_mode
);
2635 set_mem_offset (stack_parm
, MEM_OFFSET (stack_parm
) - offset
);
2640 boundary
= data
->locate
.boundary
;
2641 align
= BITS_PER_UNIT
;
2643 /* If we're padding upward, we know that the alignment of the slot
2644 is TARGET_FUNCTION_ARG_BOUNDARY. If we're using slot_offset, we're
2645 intentionally forcing upward padding. Otherwise we have to come
2646 up with a guess at the alignment based on OFFSET_RTX. */
2647 if (data
->locate
.where_pad
!= downward
|| data
->entry_parm
)
2649 else if (CONST_INT_P (offset_rtx
))
2651 align
= INTVAL (offset_rtx
) * BITS_PER_UNIT
| boundary
;
2652 align
= align
& -align
;
2654 set_mem_align (stack_parm
, align
);
2656 if (data
->entry_parm
)
2657 set_reg_attrs_for_parm (data
->entry_parm
, stack_parm
);
2659 data
->stack_parm
= stack_parm
;
2662 /* A subroutine of assign_parms. Adjust DATA->ENTRY_RTL such that it's
2663 always valid and contiguous. */
2666 assign_parm_adjust_entry_rtl (struct assign_parm_data_one
*data
)
2668 rtx entry_parm
= data
->entry_parm
;
2669 rtx stack_parm
= data
->stack_parm
;
2671 /* If this parm was passed part in regs and part in memory, pretend it
2672 arrived entirely in memory by pushing the register-part onto the stack.
2673 In the special case of a DImode or DFmode that is split, we could put
2674 it together in a pseudoreg directly, but for now that's not worth
2676 if (data
->partial
!= 0)
2678 /* Handle calls that pass values in multiple non-contiguous
2679 locations. The Irix 6 ABI has examples of this. */
2680 if (GET_CODE (entry_parm
) == PARALLEL
)
2681 emit_group_store (validize_mem (copy_rtx (stack_parm
)), entry_parm
,
2683 int_size_in_bytes (data
->passed_type
));
2686 gcc_assert (data
->partial
% UNITS_PER_WORD
== 0);
2687 move_block_from_reg (REGNO (entry_parm
),
2688 validize_mem (copy_rtx (stack_parm
)),
2689 data
->partial
/ UNITS_PER_WORD
);
2692 entry_parm
= stack_parm
;
2695 /* If we didn't decide this parm came in a register, by default it came
2697 else if (entry_parm
== NULL
)
2698 entry_parm
= stack_parm
;
2700 /* When an argument is passed in multiple locations, we can't make use
2701 of this information, but we can save some copying if the whole argument
2702 is passed in a single register. */
2703 else if (GET_CODE (entry_parm
) == PARALLEL
2704 && data
->nominal_mode
!= BLKmode
2705 && data
->passed_mode
!= BLKmode
)
2707 size_t i
, len
= XVECLEN (entry_parm
, 0);
2709 for (i
= 0; i
< len
; i
++)
2710 if (XEXP (XVECEXP (entry_parm
, 0, i
), 0) != NULL_RTX
2711 && REG_P (XEXP (XVECEXP (entry_parm
, 0, i
), 0))
2712 && (GET_MODE (XEXP (XVECEXP (entry_parm
, 0, i
), 0))
2713 == data
->passed_mode
)
2714 && INTVAL (XEXP (XVECEXP (entry_parm
, 0, i
), 1)) == 0)
2716 entry_parm
= XEXP (XVECEXP (entry_parm
, 0, i
), 0);
2721 data
->entry_parm
= entry_parm
;
2724 /* A subroutine of assign_parms. Reconstitute any values which were
2725 passed in multiple registers and would fit in a single register. */
2728 assign_parm_remove_parallels (struct assign_parm_data_one
*data
)
2730 rtx entry_parm
= data
->entry_parm
;
2732 /* Convert the PARALLEL to a REG of the same mode as the parallel.
2733 This can be done with register operations rather than on the
2734 stack, even if we will store the reconstituted parameter on the
2736 if (GET_CODE (entry_parm
) == PARALLEL
&& GET_MODE (entry_parm
) != BLKmode
)
2738 rtx parmreg
= gen_reg_rtx (GET_MODE (entry_parm
));
2739 emit_group_store (parmreg
, entry_parm
, data
->passed_type
,
2740 GET_MODE_SIZE (GET_MODE (entry_parm
)));
2741 entry_parm
= parmreg
;
2744 data
->entry_parm
= entry_parm
;
2747 /* A subroutine of assign_parms. Adjust DATA->STACK_RTL such that it's
2748 always valid and properly aligned. */
2751 assign_parm_adjust_stack_rtl (struct assign_parm_data_one
*data
)
2753 rtx stack_parm
= data
->stack_parm
;
2755 /* If we can't trust the parm stack slot to be aligned enough for its
2756 ultimate type, don't use that slot after entry. We'll make another
2757 stack slot, if we need one. */
2759 && ((STRICT_ALIGNMENT
2760 && GET_MODE_ALIGNMENT (data
->nominal_mode
) > MEM_ALIGN (stack_parm
))
2761 || (data
->nominal_type
2762 && TYPE_ALIGN (data
->nominal_type
) > MEM_ALIGN (stack_parm
)
2763 && MEM_ALIGN (stack_parm
) < PREFERRED_STACK_BOUNDARY
)))
2766 /* If parm was passed in memory, and we need to convert it on entry,
2767 don't store it back in that same slot. */
2768 else if (data
->entry_parm
== stack_parm
2769 && data
->nominal_mode
!= BLKmode
2770 && data
->nominal_mode
!= data
->passed_mode
)
2773 /* If stack protection is in effect for this function, don't leave any
2774 pointers in their passed stack slots. */
2775 else if (crtl
->stack_protect_guard
2776 && (flag_stack_protect
== 2
2777 || data
->passed_pointer
2778 || POINTER_TYPE_P (data
->nominal_type
)))
2781 data
->stack_parm
= stack_parm
;
2784 /* A subroutine of assign_parms. Return true if the current parameter
2785 should be stored as a BLKmode in the current frame. */
2788 assign_parm_setup_block_p (struct assign_parm_data_one
*data
)
2790 if (data
->nominal_mode
== BLKmode
)
2792 if (GET_MODE (data
->entry_parm
) == BLKmode
)
2795 #ifdef BLOCK_REG_PADDING
2796 /* Only assign_parm_setup_block knows how to deal with register arguments
2797 that are padded at the least significant end. */
2798 if (REG_P (data
->entry_parm
)
2799 && GET_MODE_SIZE (data
->promoted_mode
) < UNITS_PER_WORD
2800 && (BLOCK_REG_PADDING (data
->passed_mode
, data
->passed_type
, 1)
2801 == (BYTES_BIG_ENDIAN
? upward
: downward
)))
2808 /* A subroutine of assign_parms. Arrange for the parameter to be
2809 present and valid in DATA->STACK_RTL. */
2812 assign_parm_setup_block (struct assign_parm_data_all
*all
,
2813 tree parm
, struct assign_parm_data_one
*data
)
2815 rtx entry_parm
= data
->entry_parm
;
2816 rtx stack_parm
= data
->stack_parm
;
2818 HOST_WIDE_INT size_stored
;
2820 if (GET_CODE (entry_parm
) == PARALLEL
)
2821 entry_parm
= emit_group_move_into_temps (entry_parm
);
2823 size
= int_size_in_bytes (data
->passed_type
);
2824 size_stored
= CEIL_ROUND (size
, UNITS_PER_WORD
);
2825 if (stack_parm
== 0)
2827 DECL_ALIGN (parm
) = MAX (DECL_ALIGN (parm
), BITS_PER_WORD
);
2828 stack_parm
= assign_stack_local (BLKmode
, size_stored
,
2830 if (GET_MODE_SIZE (GET_MODE (entry_parm
)) == size
)
2831 PUT_MODE (stack_parm
, GET_MODE (entry_parm
));
2832 set_mem_attributes (stack_parm
, parm
, 1);
2835 /* If a BLKmode arrives in registers, copy it to a stack slot. Handle
2836 calls that pass values in multiple non-contiguous locations. */
2837 if (REG_P (entry_parm
) || GET_CODE (entry_parm
) == PARALLEL
)
2841 /* Note that we will be storing an integral number of words.
2842 So we have to be careful to ensure that we allocate an
2843 integral number of words. We do this above when we call
2844 assign_stack_local if space was not allocated in the argument
2845 list. If it was, this will not work if PARM_BOUNDARY is not
2846 a multiple of BITS_PER_WORD. It isn't clear how to fix this
2847 if it becomes a problem. Exception is when BLKmode arrives
2848 with arguments not conforming to word_mode. */
2850 if (data
->stack_parm
== 0)
2852 else if (GET_CODE (entry_parm
) == PARALLEL
)
2855 gcc_assert (!size
|| !(PARM_BOUNDARY
% BITS_PER_WORD
));
2857 mem
= validize_mem (copy_rtx (stack_parm
));
2859 /* Handle values in multiple non-contiguous locations. */
2860 if (GET_CODE (entry_parm
) == PARALLEL
)
2862 push_to_sequence2 (all
->first_conversion_insn
,
2863 all
->last_conversion_insn
);
2864 emit_group_store (mem
, entry_parm
, data
->passed_type
, size
);
2865 all
->first_conversion_insn
= get_insns ();
2866 all
->last_conversion_insn
= get_last_insn ();
2873 /* If SIZE is that of a mode no bigger than a word, just use
2874 that mode's store operation. */
2875 else if (size
<= UNITS_PER_WORD
)
2878 = mode_for_size (size
* BITS_PER_UNIT
, MODE_INT
, 0);
2881 #ifdef BLOCK_REG_PADDING
2882 && (size
== UNITS_PER_WORD
2883 || (BLOCK_REG_PADDING (mode
, data
->passed_type
, 1)
2884 != (BYTES_BIG_ENDIAN
? upward
: downward
)))
2890 /* We are really truncating a word_mode value containing
2891 SIZE bytes into a value of mode MODE. If such an
2892 operation requires no actual instructions, we can refer
2893 to the value directly in mode MODE, otherwise we must
2894 start with the register in word_mode and explicitly
2896 if (TRULY_NOOP_TRUNCATION (size
* BITS_PER_UNIT
, BITS_PER_WORD
))
2897 reg
= gen_rtx_REG (mode
, REGNO (entry_parm
));
2900 reg
= gen_rtx_REG (word_mode
, REGNO (entry_parm
));
2901 reg
= convert_to_mode (mode
, copy_to_reg (reg
), 1);
2903 emit_move_insn (change_address (mem
, mode
, 0), reg
);
2906 /* Blocks smaller than a word on a BYTES_BIG_ENDIAN
2907 machine must be aligned to the left before storing
2908 to memory. Note that the previous test doesn't
2909 handle all cases (e.g. SIZE == 3). */
2910 else if (size
!= UNITS_PER_WORD
2911 #ifdef BLOCK_REG_PADDING
2912 && (BLOCK_REG_PADDING (mode
, data
->passed_type
, 1)
2920 int by
= (UNITS_PER_WORD
- size
) * BITS_PER_UNIT
;
2921 rtx reg
= gen_rtx_REG (word_mode
, REGNO (entry_parm
));
2923 x
= expand_shift (LSHIFT_EXPR
, word_mode
, reg
, by
, NULL_RTX
, 1);
2924 tem
= change_address (mem
, word_mode
, 0);
2925 emit_move_insn (tem
, x
);
2928 move_block_from_reg (REGNO (entry_parm
), mem
,
2929 size_stored
/ UNITS_PER_WORD
);
2932 move_block_from_reg (REGNO (entry_parm
), mem
,
2933 size_stored
/ UNITS_PER_WORD
);
2935 else if (data
->stack_parm
== 0)
2937 push_to_sequence2 (all
->first_conversion_insn
, all
->last_conversion_insn
);
2938 emit_block_move (stack_parm
, data
->entry_parm
, GEN_INT (size
),
2940 all
->first_conversion_insn
= get_insns ();
2941 all
->last_conversion_insn
= get_last_insn ();
2945 data
->stack_parm
= stack_parm
;
2946 SET_DECL_RTL (parm
, stack_parm
);
2949 /* A subroutine of assign_parms. Allocate a pseudo to hold the current
2950 parameter. Get it there. Perform all ABI specified conversions. */
2953 assign_parm_setup_reg (struct assign_parm_data_all
*all
, tree parm
,
2954 struct assign_parm_data_one
*data
)
2956 rtx parmreg
, validated_mem
;
2957 rtx equiv_stack_parm
;
2958 machine_mode promoted_nominal_mode
;
2959 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (parm
));
2960 bool did_conversion
= false;
2961 bool need_conversion
, moved
;
2963 /* Store the parm in a pseudoregister during the function, but we may
2964 need to do it in a wider mode. Using 2 here makes the result
2965 consistent with promote_decl_mode and thus expand_expr_real_1. */
2966 promoted_nominal_mode
2967 = promote_function_mode (data
->nominal_type
, data
->nominal_mode
, &unsignedp
,
2968 TREE_TYPE (current_function_decl
), 2);
2970 parmreg
= gen_reg_rtx (promoted_nominal_mode
);
2972 if (!DECL_ARTIFICIAL (parm
))
2973 mark_user_reg (parmreg
);
2975 /* If this was an item that we received a pointer to,
2976 set DECL_RTL appropriately. */
2977 if (data
->passed_pointer
)
2979 rtx x
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data
->passed_type
)), parmreg
);
2980 set_mem_attributes (x
, parm
, 1);
2981 SET_DECL_RTL (parm
, x
);
2984 SET_DECL_RTL (parm
, parmreg
);
2986 assign_parm_remove_parallels (data
);
2988 /* Copy the value into the register, thus bridging between
2989 assign_parm_find_data_types and expand_expr_real_1. */
2991 equiv_stack_parm
= data
->stack_parm
;
2992 validated_mem
= validize_mem (copy_rtx (data
->entry_parm
));
2994 need_conversion
= (data
->nominal_mode
!= data
->passed_mode
2995 || promoted_nominal_mode
!= data
->promoted_mode
);
2999 && GET_MODE_CLASS (data
->nominal_mode
) == MODE_INT
3000 && data
->nominal_mode
== data
->passed_mode
3001 && data
->nominal_mode
== GET_MODE (data
->entry_parm
))
3003 /* ENTRY_PARM has been converted to PROMOTED_MODE, its
3004 mode, by the caller. We now have to convert it to
3005 NOMINAL_MODE, if different. However, PARMREG may be in
3006 a different mode than NOMINAL_MODE if it is being stored
3009 If ENTRY_PARM is a hard register, it might be in a register
3010 not valid for operating in its mode (e.g., an odd-numbered
3011 register for a DFmode). In that case, moves are the only
3012 thing valid, so we can't do a convert from there. This
3013 occurs when the calling sequence allow such misaligned
3016 In addition, the conversion may involve a call, which could
3017 clobber parameters which haven't been copied to pseudo
3020 First, we try to emit an insn which performs the necessary
3021 conversion. We verify that this insn does not clobber any
3024 enum insn_code icode
;
3027 icode
= can_extend_p (promoted_nominal_mode
, data
->passed_mode
,
3031 op1
= validated_mem
;
3032 if (icode
!= CODE_FOR_nothing
3033 && insn_operand_matches (icode
, 0, op0
)
3034 && insn_operand_matches (icode
, 1, op1
))
3036 enum rtx_code code
= unsignedp
? ZERO_EXTEND
: SIGN_EXTEND
;
3037 rtx_insn
*insn
, *insns
;
3039 HARD_REG_SET hardregs
;
3042 /* If op1 is a hard register that is likely spilled, first
3043 force it into a pseudo, otherwise combiner might extend
3044 its lifetime too much. */
3045 if (GET_CODE (t
) == SUBREG
)
3048 && HARD_REGISTER_P (t
)
3049 && ! TEST_HARD_REG_BIT (fixed_reg_set
, REGNO (t
))
3050 && targetm
.class_likely_spilled_p (REGNO_REG_CLASS (REGNO (t
))))
3052 t
= gen_reg_rtx (GET_MODE (op1
));
3053 emit_move_insn (t
, op1
);
3057 rtx_insn
*pat
= gen_extend_insn (op0
, t
, promoted_nominal_mode
,
3058 data
->passed_mode
, unsignedp
);
3060 insns
= get_insns ();
3063 CLEAR_HARD_REG_SET (hardregs
);
3064 for (insn
= insns
; insn
&& moved
; insn
= NEXT_INSN (insn
))
3067 note_stores (PATTERN (insn
), record_hard_reg_sets
,
3069 if (!hard_reg_set_empty_p (hardregs
))
3078 if (equiv_stack_parm
!= NULL_RTX
)
3079 equiv_stack_parm
= gen_rtx_fmt_e (code
, GET_MODE (parmreg
),
3086 /* Nothing to do. */
3088 else if (need_conversion
)
3090 /* We did not have an insn to convert directly, or the sequence
3091 generated appeared unsafe. We must first copy the parm to a
3092 pseudo reg, and save the conversion until after all
3093 parameters have been moved. */
3096 rtx tempreg
= gen_reg_rtx (GET_MODE (data
->entry_parm
));
3098 emit_move_insn (tempreg
, validated_mem
);
3100 push_to_sequence2 (all
->first_conversion_insn
, all
->last_conversion_insn
);
3101 tempreg
= convert_to_mode (data
->nominal_mode
, tempreg
, unsignedp
);
3103 if (GET_CODE (tempreg
) == SUBREG
3104 && GET_MODE (tempreg
) == data
->nominal_mode
3105 && REG_P (SUBREG_REG (tempreg
))
3106 && data
->nominal_mode
== data
->passed_mode
3107 && GET_MODE (SUBREG_REG (tempreg
)) == GET_MODE (data
->entry_parm
)
3108 && GET_MODE_SIZE (GET_MODE (tempreg
))
3109 < GET_MODE_SIZE (GET_MODE (data
->entry_parm
)))
3111 /* The argument is already sign/zero extended, so note it
3113 SUBREG_PROMOTED_VAR_P (tempreg
) = 1;
3114 SUBREG_PROMOTED_SET (tempreg
, unsignedp
);
3117 /* TREE_USED gets set erroneously during expand_assignment. */
3118 save_tree_used
= TREE_USED (parm
);
3119 expand_assignment (parm
, make_tree (data
->nominal_type
, tempreg
), false);
3120 TREE_USED (parm
) = save_tree_used
;
3121 all
->first_conversion_insn
= get_insns ();
3122 all
->last_conversion_insn
= get_last_insn ();
3125 did_conversion
= true;
3128 emit_move_insn (parmreg
, validated_mem
);
3130 /* If we were passed a pointer but the actual value can safely live
3131 in a register, retrieve it and use it directly. */
3132 if (data
->passed_pointer
&& TYPE_MODE (TREE_TYPE (parm
)) != BLKmode
)
3134 /* We can't use nominal_mode, because it will have been set to
3135 Pmode above. We must use the actual mode of the parm. */
3136 if (use_register_for_decl (parm
))
3138 parmreg
= gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm
)));
3139 mark_user_reg (parmreg
);
3143 int align
= STACK_SLOT_ALIGNMENT (TREE_TYPE (parm
),
3144 TYPE_MODE (TREE_TYPE (parm
)),
3145 TYPE_ALIGN (TREE_TYPE (parm
)));
3147 = assign_stack_local (TYPE_MODE (TREE_TYPE (parm
)),
3148 GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parm
))),
3150 set_mem_attributes (parmreg
, parm
, 1);
3153 if (GET_MODE (parmreg
) != GET_MODE (DECL_RTL (parm
)))
3155 rtx tempreg
= gen_reg_rtx (GET_MODE (DECL_RTL (parm
)));
3156 int unsigned_p
= TYPE_UNSIGNED (TREE_TYPE (parm
));
3158 push_to_sequence2 (all
->first_conversion_insn
,
3159 all
->last_conversion_insn
);
3160 emit_move_insn (tempreg
, DECL_RTL (parm
));
3161 tempreg
= convert_to_mode (GET_MODE (parmreg
), tempreg
, unsigned_p
);
3162 emit_move_insn (parmreg
, tempreg
);
3163 all
->first_conversion_insn
= get_insns ();
3164 all
->last_conversion_insn
= get_last_insn ();
3167 did_conversion
= true;
3170 emit_move_insn (parmreg
, DECL_RTL (parm
));
3172 SET_DECL_RTL (parm
, parmreg
);
3174 /* STACK_PARM is the pointer, not the parm, and PARMREG is
3176 data
->stack_parm
= NULL
;
3179 /* Mark the register as eliminable if we did no conversion and it was
3180 copied from memory at a fixed offset, and the arg pointer was not
3181 copied to a pseudo-reg. If the arg pointer is a pseudo reg or the
3182 offset formed an invalid address, such memory-equivalences as we
3183 make here would screw up life analysis for it. */
3184 if (data
->nominal_mode
== data
->passed_mode
3186 && data
->stack_parm
!= 0
3187 && MEM_P (data
->stack_parm
)
3188 && data
->locate
.offset
.var
== 0
3189 && reg_mentioned_p (virtual_incoming_args_rtx
,
3190 XEXP (data
->stack_parm
, 0)))
3192 rtx_insn
*linsn
= get_last_insn ();
3196 /* Mark complex types separately. */
3197 if (GET_CODE (parmreg
) == CONCAT
)
3199 machine_mode submode
3200 = GET_MODE_INNER (GET_MODE (parmreg
));
3201 int regnor
= REGNO (XEXP (parmreg
, 0));
3202 int regnoi
= REGNO (XEXP (parmreg
, 1));
3203 rtx stackr
= adjust_address_nv (data
->stack_parm
, submode
, 0);
3204 rtx stacki
= adjust_address_nv (data
->stack_parm
, submode
,
3205 GET_MODE_SIZE (submode
));
3207 /* Scan backwards for the set of the real and
3209 for (sinsn
= linsn
; sinsn
!= 0;
3210 sinsn
= prev_nonnote_insn (sinsn
))
3212 set
= single_set (sinsn
);
3216 if (SET_DEST (set
) == regno_reg_rtx
[regnoi
])
3217 set_unique_reg_note (sinsn
, REG_EQUIV
, stacki
);
3218 else if (SET_DEST (set
) == regno_reg_rtx
[regnor
])
3219 set_unique_reg_note (sinsn
, REG_EQUIV
, stackr
);
3223 set_dst_reg_note (linsn
, REG_EQUIV
, equiv_stack_parm
, parmreg
);
3226 /* For pointer data type, suggest pointer register. */
3227 if (POINTER_TYPE_P (TREE_TYPE (parm
)))
3228 mark_reg_pointer (parmreg
,
3229 TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm
))));
3232 /* A subroutine of assign_parms. Allocate stack space to hold the current
3233 parameter. Get it there. Perform all ABI specified conversions. */
3236 assign_parm_setup_stack (struct assign_parm_data_all
*all
, tree parm
,
3237 struct assign_parm_data_one
*data
)
3239 /* Value must be stored in the stack slot STACK_PARM during function
3241 bool to_conversion
= false;
3243 assign_parm_remove_parallels (data
);
3245 if (data
->promoted_mode
!= data
->nominal_mode
)
3247 /* Conversion is required. */
3248 rtx tempreg
= gen_reg_rtx (GET_MODE (data
->entry_parm
));
3250 emit_move_insn (tempreg
, validize_mem (copy_rtx (data
->entry_parm
)));
3252 push_to_sequence2 (all
->first_conversion_insn
, all
->last_conversion_insn
);
3253 to_conversion
= true;
3255 data
->entry_parm
= convert_to_mode (data
->nominal_mode
, tempreg
,
3256 TYPE_UNSIGNED (TREE_TYPE (parm
)));
3258 if (data
->stack_parm
)
3260 int offset
= subreg_lowpart_offset (data
->nominal_mode
,
3261 GET_MODE (data
->stack_parm
));
3262 /* ??? This may need a big-endian conversion on sparc64. */
3264 = adjust_address (data
->stack_parm
, data
->nominal_mode
, 0);
3265 if (offset
&& MEM_OFFSET_KNOWN_P (data
->stack_parm
))
3266 set_mem_offset (data
->stack_parm
,
3267 MEM_OFFSET (data
->stack_parm
) + offset
);
3271 if (data
->entry_parm
!= data
->stack_parm
)
3275 if (data
->stack_parm
== 0)
3277 int align
= STACK_SLOT_ALIGNMENT (data
->passed_type
,
3278 GET_MODE (data
->entry_parm
),
3279 TYPE_ALIGN (data
->passed_type
));
3281 = assign_stack_local (GET_MODE (data
->entry_parm
),
3282 GET_MODE_SIZE (GET_MODE (data
->entry_parm
)),
3284 set_mem_attributes (data
->stack_parm
, parm
, 1);
3287 dest
= validize_mem (copy_rtx (data
->stack_parm
));
3288 src
= validize_mem (copy_rtx (data
->entry_parm
));
3292 /* Use a block move to handle potentially misaligned entry_parm. */
3294 push_to_sequence2 (all
->first_conversion_insn
,
3295 all
->last_conversion_insn
);
3296 to_conversion
= true;
3298 emit_block_move (dest
, src
,
3299 GEN_INT (int_size_in_bytes (data
->passed_type
)),
3303 emit_move_insn (dest
, src
);
3308 all
->first_conversion_insn
= get_insns ();
3309 all
->last_conversion_insn
= get_last_insn ();
3313 SET_DECL_RTL (parm
, data
->stack_parm
);
3316 /* A subroutine of assign_parms. If the ABI splits complex arguments, then
3317 undo the frobbing that we did in assign_parms_augmented_arg_list. */
3320 assign_parms_unsplit_complex (struct assign_parm_data_all
*all
,
3324 tree orig_fnargs
= all
->orig_fnargs
;
3327 for (parm
= orig_fnargs
; parm
; parm
= TREE_CHAIN (parm
), ++i
)
3329 if (TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
3330 && targetm
.calls
.split_complex_arg (TREE_TYPE (parm
)))
3332 rtx tmp
, real
, imag
;
3333 machine_mode inner
= GET_MODE_INNER (DECL_MODE (parm
));
3335 real
= DECL_RTL (fnargs
[i
]);
3336 imag
= DECL_RTL (fnargs
[i
+ 1]);
3337 if (inner
!= GET_MODE (real
))
3339 real
= gen_lowpart_SUBREG (inner
, real
);
3340 imag
= gen_lowpart_SUBREG (inner
, imag
);
3343 if (TREE_ADDRESSABLE (parm
))
3346 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (parm
));
3347 int align
= STACK_SLOT_ALIGNMENT (TREE_TYPE (parm
),
3349 TYPE_ALIGN (TREE_TYPE (parm
)));
3351 /* split_complex_arg put the real and imag parts in
3352 pseudos. Move them to memory. */
3353 tmp
= assign_stack_local (DECL_MODE (parm
), size
, align
);
3354 set_mem_attributes (tmp
, parm
, 1);
3355 rmem
= adjust_address_nv (tmp
, inner
, 0);
3356 imem
= adjust_address_nv (tmp
, inner
, GET_MODE_SIZE (inner
));
3357 push_to_sequence2 (all
->first_conversion_insn
,
3358 all
->last_conversion_insn
);
3359 emit_move_insn (rmem
, real
);
3360 emit_move_insn (imem
, imag
);
3361 all
->first_conversion_insn
= get_insns ();
3362 all
->last_conversion_insn
= get_last_insn ();
3366 tmp
= gen_rtx_CONCAT (DECL_MODE (parm
), real
, imag
);
3367 SET_DECL_RTL (parm
, tmp
);
3369 real
= DECL_INCOMING_RTL (fnargs
[i
]);
3370 imag
= DECL_INCOMING_RTL (fnargs
[i
+ 1]);
3371 if (inner
!= GET_MODE (real
))
3373 real
= gen_lowpart_SUBREG (inner
, real
);
3374 imag
= gen_lowpart_SUBREG (inner
, imag
);
3376 tmp
= gen_rtx_CONCAT (DECL_MODE (parm
), real
, imag
);
3377 set_decl_incoming_rtl (parm
, tmp
, false);
3383 /* Load bounds of PARM from bounds table. */
3385 assign_parm_load_bounds (struct assign_parm_data_one
*data
,
3391 unsigned i
, offs
= 0;
3393 rtx slot
= NULL
, ptr
= NULL
;
3398 bitmap_obstack_initialize (NULL
);
3399 slots
= BITMAP_ALLOC (NULL
);
3400 chkp_find_bound_slots (TREE_TYPE (parm
), slots
);
3401 EXECUTE_IF_SET_IN_BITMAP (slots
, 0, i
, bi
)
3411 BITMAP_FREE (slots
);
3412 bitmap_obstack_release (NULL
);
3415 /* We may have bounds not associated with any pointer. */
3417 offs
= bnd_no
* POINTER_SIZE
/ BITS_PER_UNIT
;
3419 /* Find associated pointer. */
3422 /* If bounds are not associated with any bounds,
3423 then it is passed in a register or special slot. */
3424 gcc_assert (data
->entry_parm
);
3427 else if (MEM_P (entry
))
3428 slot
= adjust_address (entry
, Pmode
, offs
);
3429 else if (REG_P (entry
))
3430 ptr
= gen_rtx_REG (Pmode
, REGNO (entry
) + bnd_no
);
3431 else if (GET_CODE (entry
) == PARALLEL
)
3432 ptr
= chkp_get_value_with_offs (entry
, GEN_INT (offs
));
3435 data
->entry_parm
= targetm
.calls
.load_bounds_for_arg (slot
, ptr
,
3439 /* Assign RTL expressions to the function's bounds parameters BNDARGS. */
3442 assign_bounds (vec
<bounds_parm_data
> &bndargs
,
3443 struct assign_parm_data_all
&all
,
3444 bool assign_regs
, bool assign_special
,
3448 bounds_parm_data
*pbdata
;
3450 if (!bndargs
.exists ())
3453 /* We make few passes to store input bounds. Firstly handle bounds
3454 passed in registers. After that we load bounds passed in special
3455 slots. Finally we load bounds from Bounds Table. */
3456 for (pass
= 0; pass
< 3; pass
++)
3457 FOR_EACH_VEC_ELT (bndargs
, i
, pbdata
)
3459 /* Pass 0 => regs only. */
3462 ||(!pbdata
->parm_data
.entry_parm
3463 || GET_CODE (pbdata
->parm_data
.entry_parm
) != REG
)))
3465 /* Pass 1 => slots only. */
3468 || (!pbdata
->parm_data
.entry_parm
3469 || GET_CODE (pbdata
->parm_data
.entry_parm
) == REG
)))
3471 /* Pass 2 => BT only. */
3474 || pbdata
->parm_data
.entry_parm
))
3477 if (!pbdata
->parm_data
.entry_parm
3478 || GET_CODE (pbdata
->parm_data
.entry_parm
) != REG
)
3479 assign_parm_load_bounds (&pbdata
->parm_data
, pbdata
->ptr_parm
,
3480 pbdata
->ptr_entry
, pbdata
->bound_no
);
3482 set_decl_incoming_rtl (pbdata
->bounds_parm
,
3483 pbdata
->parm_data
.entry_parm
, false);
3485 if (assign_parm_setup_block_p (&pbdata
->parm_data
))
3486 assign_parm_setup_block (&all
, pbdata
->bounds_parm
,
3487 &pbdata
->parm_data
);
3488 else if (pbdata
->parm_data
.passed_pointer
3489 || use_register_for_decl (pbdata
->bounds_parm
))
3490 assign_parm_setup_reg (&all
, pbdata
->bounds_parm
,
3491 &pbdata
->parm_data
);
3493 assign_parm_setup_stack (&all
, pbdata
->bounds_parm
,
3494 &pbdata
->parm_data
);
3498 /* Assign RTL expressions to the function's parameters. This may involve
3499 copying them into registers and using those registers as the DECL_RTL. */
3502 assign_parms (tree fndecl
)
3504 struct assign_parm_data_all all
;
3507 unsigned i
, bound_no
= 0;
3508 tree last_arg
= NULL
;
3509 rtx last_arg_entry
= NULL
;
3510 vec
<bounds_parm_data
> bndargs
= vNULL
;
3511 bounds_parm_data bdata
;
3513 crtl
->args
.internal_arg_pointer
3514 = targetm
.calls
.internal_arg_pointer ();
3516 assign_parms_initialize_all (&all
);
3517 fnargs
= assign_parms_augmented_arg_list (&all
);
3519 FOR_EACH_VEC_ELT (fnargs
, i
, parm
)
3521 struct assign_parm_data_one data
;
3523 /* Extract the type of PARM; adjust it according to ABI. */
3524 assign_parm_find_data_types (&all
, parm
, &data
);
3526 /* Early out for errors and void parameters. */
3527 if (data
.passed_mode
== VOIDmode
)
3529 SET_DECL_RTL (parm
, const0_rtx
);
3530 DECL_INCOMING_RTL (parm
) = DECL_RTL (parm
);
3534 /* Estimate stack alignment from parameter alignment. */
3535 if (SUPPORTS_STACK_ALIGNMENT
)
3538 = targetm
.calls
.function_arg_boundary (data
.promoted_mode
,
3540 align
= MINIMUM_ALIGNMENT (data
.passed_type
, data
.promoted_mode
,
3542 if (TYPE_ALIGN (data
.nominal_type
) > align
)
3543 align
= MINIMUM_ALIGNMENT (data
.nominal_type
,
3544 TYPE_MODE (data
.nominal_type
),
3545 TYPE_ALIGN (data
.nominal_type
));
3546 if (crtl
->stack_alignment_estimated
< align
)
3548 gcc_assert (!crtl
->stack_realign_processed
);
3549 crtl
->stack_alignment_estimated
= align
;
3553 /* Find out where the parameter arrives in this function. */
3554 assign_parm_find_entry_rtl (&all
, &data
);
3556 /* Find out where stack space for this parameter might be. */
3557 if (assign_parm_is_stack_parm (&all
, &data
))
3559 assign_parm_find_stack_rtl (parm
, &data
);
3560 assign_parm_adjust_entry_rtl (&data
);
3562 if (!POINTER_BOUNDS_TYPE_P (data
.passed_type
))
3564 /* Remember where last non bounds arg was passed in case
3565 we have to load associated bounds for it from Bounds
3568 last_arg_entry
= data
.entry_parm
;
3571 /* Record permanently how this parm was passed. */
3572 if (data
.passed_pointer
)
3575 = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data
.passed_type
)),
3577 set_decl_incoming_rtl (parm
, incoming_rtl
, true);
3580 set_decl_incoming_rtl (parm
, data
.entry_parm
, false);
3582 /* Boudns should be loaded in the particular order to
3583 have registers allocated correctly. Collect info about
3584 input bounds and load them later. */
3585 if (POINTER_BOUNDS_TYPE_P (data
.passed_type
))
3587 /* Expect bounds in instrumented functions only. */
3588 gcc_assert (chkp_function_instrumented_p (fndecl
));
3590 bdata
.parm_data
= data
;
3591 bdata
.bounds_parm
= parm
;
3592 bdata
.ptr_parm
= last_arg
;
3593 bdata
.ptr_entry
= last_arg_entry
;
3594 bdata
.bound_no
= bound_no
;
3595 bndargs
.safe_push (bdata
);
3599 assign_parm_adjust_stack_rtl (&data
);
3601 if (assign_parm_setup_block_p (&data
))
3602 assign_parm_setup_block (&all
, parm
, &data
);
3603 else if (data
.passed_pointer
|| use_register_for_decl (parm
))
3604 assign_parm_setup_reg (&all
, parm
, &data
);
3606 assign_parm_setup_stack (&all
, parm
, &data
);
3609 if (cfun
->stdarg
&& !DECL_CHAIN (parm
))
3611 int pretend_bytes
= 0;
3613 assign_parms_setup_varargs (&all
, &data
, false);
3615 if (chkp_function_instrumented_p (fndecl
))
3617 /* We expect this is the last parm. Otherwise it is wrong
3618 to assign bounds right now. */
3619 gcc_assert (i
== (fnargs
.length () - 1));
3620 assign_bounds (bndargs
, all
, true, false, false);
3621 targetm
.calls
.setup_incoming_vararg_bounds (all
.args_so_far
,
3626 assign_bounds (bndargs
, all
, false, true, true);
3631 /* Update info on where next arg arrives in registers. */
3632 targetm
.calls
.function_arg_advance (all
.args_so_far
, data
.promoted_mode
,
3633 data
.passed_type
, data
.named_arg
);
3635 if (POINTER_BOUNDS_TYPE_P (data
.passed_type
))
3639 assign_bounds (bndargs
, all
, true, true, true);
3642 if (targetm
.calls
.split_complex_arg
)
3643 assign_parms_unsplit_complex (&all
, fnargs
);
3647 /* Output all parameter conversion instructions (possibly including calls)
3648 now that all parameters have been copied out of hard registers. */
3649 emit_insn (all
.first_conversion_insn
);
3651 /* Estimate reload stack alignment from scalar return mode. */
3652 if (SUPPORTS_STACK_ALIGNMENT
)
3654 if (DECL_RESULT (fndecl
))
3656 tree type
= TREE_TYPE (DECL_RESULT (fndecl
));
3657 machine_mode mode
= TYPE_MODE (type
);
3661 && !AGGREGATE_TYPE_P (type
))
3663 unsigned int align
= GET_MODE_ALIGNMENT (mode
);
3664 if (crtl
->stack_alignment_estimated
< align
)
3666 gcc_assert (!crtl
->stack_realign_processed
);
3667 crtl
->stack_alignment_estimated
= align
;
3673 /* If we are receiving a struct value address as the first argument, set up
3674 the RTL for the function result. As this might require code to convert
3675 the transmitted address to Pmode, we do this here to ensure that possible
3676 preliminary conversions of the address have been emitted already. */
3677 if (all
.function_result_decl
)
3679 tree result
= DECL_RESULT (current_function_decl
);
3680 rtx addr
= DECL_RTL (all
.function_result_decl
);
3683 if (DECL_BY_REFERENCE (result
))
3685 SET_DECL_VALUE_EXPR (result
, all
.function_result_decl
);
3690 SET_DECL_VALUE_EXPR (result
,
3691 build1 (INDIRECT_REF
, TREE_TYPE (result
),
3692 all
.function_result_decl
));
3693 addr
= convert_memory_address (Pmode
, addr
);
3694 x
= gen_rtx_MEM (DECL_MODE (result
), addr
);
3695 set_mem_attributes (x
, result
, 1);
3698 DECL_HAS_VALUE_EXPR_P (result
) = 1;
3700 SET_DECL_RTL (result
, x
);
3703 /* We have aligned all the args, so add space for the pretend args. */
3704 crtl
->args
.pretend_args_size
= all
.pretend_args_size
;
3705 all
.stack_args_size
.constant
+= all
.extra_pretend_bytes
;
3706 crtl
->args
.size
= all
.stack_args_size
.constant
;
3708 /* Adjust function incoming argument size for alignment and
3711 crtl
->args
.size
= MAX (crtl
->args
.size
, all
.reg_parm_stack_space
);
3712 crtl
->args
.size
= CEIL_ROUND (crtl
->args
.size
,
3713 PARM_BOUNDARY
/ BITS_PER_UNIT
);
3715 if (ARGS_GROW_DOWNWARD
)
3717 crtl
->args
.arg_offset_rtx
3718 = (all
.stack_args_size
.var
== 0 ? GEN_INT (-all
.stack_args_size
.constant
)
3719 : expand_expr (size_diffop (all
.stack_args_size
.var
,
3720 size_int (-all
.stack_args_size
.constant
)),
3721 NULL_RTX
, VOIDmode
, EXPAND_NORMAL
));
3724 crtl
->args
.arg_offset_rtx
= ARGS_SIZE_RTX (all
.stack_args_size
);
3726 /* See how many bytes, if any, of its args a function should try to pop
3729 crtl
->args
.pops_args
= targetm
.calls
.return_pops_args (fndecl
,
3733 /* For stdarg.h function, save info about
3734 regs and stack space used by the named args. */
3736 crtl
->args
.info
= all
.args_so_far_v
;
3738 /* Set the rtx used for the function return value. Put this in its
3739 own variable so any optimizers that need this information don't have
3740 to include tree.h. Do this here so it gets done when an inlined
3741 function gets output. */
3744 = (DECL_RTL_SET_P (DECL_RESULT (fndecl
))
3745 ? DECL_RTL (DECL_RESULT (fndecl
)) : NULL_RTX
);
3747 /* If scalar return value was computed in a pseudo-reg, or was a named
3748 return value that got dumped to the stack, copy that to the hard
3750 if (DECL_RTL_SET_P (DECL_RESULT (fndecl
)))
3752 tree decl_result
= DECL_RESULT (fndecl
);
3753 rtx decl_rtl
= DECL_RTL (decl_result
);
3755 if (REG_P (decl_rtl
)
3756 ? REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
3757 : DECL_REGISTER (decl_result
))
3761 real_decl_rtl
= targetm
.calls
.function_value (TREE_TYPE (decl_result
),
3763 if (chkp_function_instrumented_p (fndecl
))
3765 = targetm
.calls
.chkp_function_value_bounds (TREE_TYPE (decl_result
),
3767 REG_FUNCTION_VALUE_P (real_decl_rtl
) = 1;
3768 /* The delay slot scheduler assumes that crtl->return_rtx
3769 holds the hard register containing the return value, not a
3770 temporary pseudo. */
3771 crtl
->return_rtx
= real_decl_rtl
;
3776 /* A subroutine of gimplify_parameters, invoked via walk_tree.
3777 For all seen types, gimplify their sizes. */
3780 gimplify_parm_type (tree
*tp
, int *walk_subtrees
, void *data
)
3787 if (POINTER_TYPE_P (t
))
3789 else if (TYPE_SIZE (t
) && !TREE_CONSTANT (TYPE_SIZE (t
))
3790 && !TYPE_SIZES_GIMPLIFIED (t
))
3792 gimplify_type_sizes (t
, (gimple_seq
*) data
);
3800 /* Gimplify the parameter list for current_function_decl. This involves
3801 evaluating SAVE_EXPRs of variable sized parameters and generating code
3802 to implement callee-copies reference parameters. Returns a sequence of
3803 statements to add to the beginning of the function. */
3806 gimplify_parameters (void)
3808 struct assign_parm_data_all all
;
3810 gimple_seq stmts
= NULL
;
3814 assign_parms_initialize_all (&all
);
3815 fnargs
= assign_parms_augmented_arg_list (&all
);
3817 FOR_EACH_VEC_ELT (fnargs
, i
, parm
)
3819 struct assign_parm_data_one data
;
3821 /* Extract the type of PARM; adjust it according to ABI. */
3822 assign_parm_find_data_types (&all
, parm
, &data
);
3824 /* Early out for errors and void parameters. */
3825 if (data
.passed_mode
== VOIDmode
|| DECL_SIZE (parm
) == NULL
)
3828 /* Update info on where next arg arrives in registers. */
3829 targetm
.calls
.function_arg_advance (all
.args_so_far
, data
.promoted_mode
,
3830 data
.passed_type
, data
.named_arg
);
3832 /* ??? Once upon a time variable_size stuffed parameter list
3833 SAVE_EXPRs (amongst others) onto a pending sizes list. This
3834 turned out to be less than manageable in the gimple world.
3835 Now we have to hunt them down ourselves. */
3836 walk_tree_without_duplicates (&data
.passed_type
,
3837 gimplify_parm_type
, &stmts
);
3839 if (TREE_CODE (DECL_SIZE_UNIT (parm
)) != INTEGER_CST
)
3841 gimplify_one_sizepos (&DECL_SIZE (parm
), &stmts
);
3842 gimplify_one_sizepos (&DECL_SIZE_UNIT (parm
), &stmts
);
3845 if (data
.passed_pointer
)
3847 tree type
= TREE_TYPE (data
.passed_type
);
3848 if (reference_callee_copied (&all
.args_so_far_v
, TYPE_MODE (type
),
3849 type
, data
.named_arg
))
3853 /* For constant-sized objects, this is trivial; for
3854 variable-sized objects, we have to play games. */
3855 if (TREE_CODE (DECL_SIZE_UNIT (parm
)) == INTEGER_CST
3856 && !(flag_stack_check
== GENERIC_STACK_CHECK
3857 && compare_tree_int (DECL_SIZE_UNIT (parm
),
3858 STACK_CHECK_MAX_VAR_SIZE
) > 0))
3860 local
= create_tmp_var (type
, get_name (parm
));
3861 DECL_IGNORED_P (local
) = 0;
3862 /* If PARM was addressable, move that flag over
3863 to the local copy, as its address will be taken,
3864 not the PARMs. Keep the parms address taken
3865 as we'll query that flag during gimplification. */
3866 if (TREE_ADDRESSABLE (parm
))
3867 TREE_ADDRESSABLE (local
) = 1;
3868 else if (TREE_CODE (type
) == COMPLEX_TYPE
3869 || TREE_CODE (type
) == VECTOR_TYPE
)
3870 DECL_GIMPLE_REG_P (local
) = 1;
3874 tree ptr_type
, addr
;
3876 ptr_type
= build_pointer_type (type
);
3877 addr
= create_tmp_reg (ptr_type
, get_name (parm
));
3878 DECL_IGNORED_P (addr
) = 0;
3879 local
= build_fold_indirect_ref (addr
);
3881 t
= builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN
);
3882 t
= build_call_expr (t
, 2, DECL_SIZE_UNIT (parm
),
3883 size_int (DECL_ALIGN (parm
)));
3885 /* The call has been built for a variable-sized object. */
3886 CALL_ALLOCA_FOR_VAR_P (t
) = 1;
3887 t
= fold_convert (ptr_type
, t
);
3888 t
= build2 (MODIFY_EXPR
, TREE_TYPE (addr
), addr
, t
);
3889 gimplify_and_add (t
, &stmts
);
3892 gimplify_assign (local
, parm
, &stmts
);
3894 SET_DECL_VALUE_EXPR (parm
, local
);
3895 DECL_HAS_VALUE_EXPR_P (parm
) = 1;
3905 /* Compute the size and offset from the start of the stacked arguments for a
3906 parm passed in mode PASSED_MODE and with type TYPE.
3908 INITIAL_OFFSET_PTR points to the current offset into the stacked
3911 The starting offset and size for this parm are returned in
3912 LOCATE->OFFSET and LOCATE->SIZE, respectively. When IN_REGS is
3913 nonzero, the offset is that of stack slot, which is returned in
3914 LOCATE->SLOT_OFFSET. LOCATE->ALIGNMENT_PAD is the amount of
3915 padding required from the initial offset ptr to the stack slot.
3917 IN_REGS is nonzero if the argument will be passed in registers. It will
3918 never be set if REG_PARM_STACK_SPACE is not defined.
3920 REG_PARM_STACK_SPACE is the number of bytes of stack space reserved
3921 for arguments which are passed in registers.
3923 FNDECL is the function in which the argument was defined.
3925 There are two types of rounding that are done. The first, controlled by
3926 TARGET_FUNCTION_ARG_BOUNDARY, forces the offset from the start of the
3927 argument list to be aligned to the specific boundary (in bits). This
3928 rounding affects the initial and starting offsets, but not the argument
3931 The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY,
3932 optionally rounds the size of the parm to PARM_BOUNDARY. The
3933 initial offset is not affected by this rounding, while the size always
3934 is and the starting offset may be. */
3936 /* LOCATE->OFFSET will be negative for ARGS_GROW_DOWNWARD case;
3937 INITIAL_OFFSET_PTR is positive because locate_and_pad_parm's
3938 callers pass in the total size of args so far as
3939 INITIAL_OFFSET_PTR. LOCATE->SIZE is always positive. */
3942 locate_and_pad_parm (machine_mode passed_mode
, tree type
, int in_regs
,
3943 int reg_parm_stack_space
, int partial
,
3944 tree fndecl ATTRIBUTE_UNUSED
,
3945 struct args_size
*initial_offset_ptr
,
3946 struct locate_and_pad_arg_data
*locate
)
3949 enum direction where_pad
;
3950 unsigned int boundary
, round_boundary
;
3951 int part_size_in_regs
;
3953 /* If we have found a stack parm before we reach the end of the
3954 area reserved for registers, skip that area. */
3957 if (reg_parm_stack_space
> 0)
3959 if (initial_offset_ptr
->var
)
3961 initial_offset_ptr
->var
3962 = size_binop (MAX_EXPR
, ARGS_SIZE_TREE (*initial_offset_ptr
),
3963 ssize_int (reg_parm_stack_space
));
3964 initial_offset_ptr
->constant
= 0;
3966 else if (initial_offset_ptr
->constant
< reg_parm_stack_space
)
3967 initial_offset_ptr
->constant
= reg_parm_stack_space
;
3971 part_size_in_regs
= (reg_parm_stack_space
== 0 ? partial
: 0);
3974 = type
? size_in_bytes (type
) : size_int (GET_MODE_SIZE (passed_mode
));
3975 where_pad
= FUNCTION_ARG_PADDING (passed_mode
, type
);
3976 boundary
= targetm
.calls
.function_arg_boundary (passed_mode
, type
);
3977 round_boundary
= targetm
.calls
.function_arg_round_boundary (passed_mode
,
3979 locate
->where_pad
= where_pad
;
3981 /* Alignment can't exceed MAX_SUPPORTED_STACK_ALIGNMENT. */
3982 if (boundary
> MAX_SUPPORTED_STACK_ALIGNMENT
)
3983 boundary
= MAX_SUPPORTED_STACK_ALIGNMENT
;
3985 locate
->boundary
= boundary
;
3987 if (SUPPORTS_STACK_ALIGNMENT
)
3989 /* stack_alignment_estimated can't change after stack has been
3991 if (crtl
->stack_alignment_estimated
< boundary
)
3993 if (!crtl
->stack_realign_processed
)
3994 crtl
->stack_alignment_estimated
= boundary
;
3997 /* If stack is realigned and stack alignment value
3998 hasn't been finalized, it is OK not to increase
3999 stack_alignment_estimated. The bigger alignment
4000 requirement is recorded in stack_alignment_needed
4002 gcc_assert (!crtl
->stack_realign_finalized
4003 && crtl
->stack_realign_needed
);
4008 /* Remember if the outgoing parameter requires extra alignment on the
4009 calling function side. */
4010 if (crtl
->stack_alignment_needed
< boundary
)
4011 crtl
->stack_alignment_needed
= boundary
;
4012 if (crtl
->preferred_stack_boundary
< boundary
)
4013 crtl
->preferred_stack_boundary
= boundary
;
4015 if (ARGS_GROW_DOWNWARD
)
4017 locate
->slot_offset
.constant
= -initial_offset_ptr
->constant
;
4018 if (initial_offset_ptr
->var
)
4019 locate
->slot_offset
.var
= size_binop (MINUS_EXPR
, ssize_int (0),
4020 initial_offset_ptr
->var
);
4024 if (where_pad
!= none
4025 && (!tree_fits_uhwi_p (sizetree
)
4026 || (tree_to_uhwi (sizetree
) * BITS_PER_UNIT
) % round_boundary
))
4027 s2
= round_up (s2
, round_boundary
/ BITS_PER_UNIT
);
4028 SUB_PARM_SIZE (locate
->slot_offset
, s2
);
4031 locate
->slot_offset
.constant
+= part_size_in_regs
;
4033 if (!in_regs
|| reg_parm_stack_space
> 0)
4034 pad_to_arg_alignment (&locate
->slot_offset
, boundary
,
4035 &locate
->alignment_pad
);
4037 locate
->size
.constant
= (-initial_offset_ptr
->constant
4038 - locate
->slot_offset
.constant
);
4039 if (initial_offset_ptr
->var
)
4040 locate
->size
.var
= size_binop (MINUS_EXPR
,
4041 size_binop (MINUS_EXPR
,
4043 initial_offset_ptr
->var
),
4044 locate
->slot_offset
.var
);
4046 /* Pad_below needs the pre-rounded size to know how much to pad
4048 locate
->offset
= locate
->slot_offset
;
4049 if (where_pad
== downward
)
4050 pad_below (&locate
->offset
, passed_mode
, sizetree
);
4055 if (!in_regs
|| reg_parm_stack_space
> 0)
4056 pad_to_arg_alignment (initial_offset_ptr
, boundary
,
4057 &locate
->alignment_pad
);
4058 locate
->slot_offset
= *initial_offset_ptr
;
4060 #ifdef PUSH_ROUNDING
4061 if (passed_mode
!= BLKmode
)
4062 sizetree
= size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree
)));
4065 /* Pad_below needs the pre-rounded size to know how much to pad below
4066 so this must be done before rounding up. */
4067 locate
->offset
= locate
->slot_offset
;
4068 if (where_pad
== downward
)
4069 pad_below (&locate
->offset
, passed_mode
, sizetree
);
4071 if (where_pad
!= none
4072 && (!tree_fits_uhwi_p (sizetree
)
4073 || (tree_to_uhwi (sizetree
) * BITS_PER_UNIT
) % round_boundary
))
4074 sizetree
= round_up (sizetree
, round_boundary
/ BITS_PER_UNIT
);
4076 ADD_PARM_SIZE (locate
->size
, sizetree
);
4078 locate
->size
.constant
-= part_size_in_regs
;
4081 #ifdef FUNCTION_ARG_OFFSET
4082 locate
->offset
.constant
+= FUNCTION_ARG_OFFSET (passed_mode
, type
);
4086 /* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY.
4087 BOUNDARY is measured in bits, but must be a multiple of a storage unit. */
4090 pad_to_arg_alignment (struct args_size
*offset_ptr
, int boundary
,
4091 struct args_size
*alignment_pad
)
4093 tree save_var
= NULL_TREE
;
4094 HOST_WIDE_INT save_constant
= 0;
4095 int boundary_in_bytes
= boundary
/ BITS_PER_UNIT
;
4096 HOST_WIDE_INT sp_offset
= STACK_POINTER_OFFSET
;
4098 #ifdef SPARC_STACK_BOUNDARY_HACK
4099 /* ??? The SPARC port may claim a STACK_BOUNDARY higher than
4100 the real alignment of %sp. However, when it does this, the
4101 alignment of %sp+STACK_POINTER_OFFSET is STACK_BOUNDARY. */
4102 if (SPARC_STACK_BOUNDARY_HACK
)
4106 if (boundary
> PARM_BOUNDARY
)
4108 save_var
= offset_ptr
->var
;
4109 save_constant
= offset_ptr
->constant
;
4112 alignment_pad
->var
= NULL_TREE
;
4113 alignment_pad
->constant
= 0;
4115 if (boundary
> BITS_PER_UNIT
)
4117 if (offset_ptr
->var
)
4119 tree sp_offset_tree
= ssize_int (sp_offset
);
4120 tree offset
= size_binop (PLUS_EXPR
,
4121 ARGS_SIZE_TREE (*offset_ptr
),
4124 if (ARGS_GROW_DOWNWARD
)
4125 rounded
= round_down (offset
, boundary
/ BITS_PER_UNIT
);
4127 rounded
= round_up (offset
, boundary
/ BITS_PER_UNIT
);
4129 offset_ptr
->var
= size_binop (MINUS_EXPR
, rounded
, sp_offset_tree
);
4130 /* ARGS_SIZE_TREE includes constant term. */
4131 offset_ptr
->constant
= 0;
4132 if (boundary
> PARM_BOUNDARY
)
4133 alignment_pad
->var
= size_binop (MINUS_EXPR
, offset_ptr
->var
,
4138 offset_ptr
->constant
= -sp_offset
+
4140 ? FLOOR_ROUND (offset_ptr
->constant
+ sp_offset
, boundary_in_bytes
)
4141 : CEIL_ROUND (offset_ptr
->constant
+ sp_offset
, boundary_in_bytes
));
4143 if (boundary
> PARM_BOUNDARY
)
4144 alignment_pad
->constant
= offset_ptr
->constant
- save_constant
;
4150 pad_below (struct args_size
*offset_ptr
, machine_mode passed_mode
, tree sizetree
)
4152 if (passed_mode
!= BLKmode
)
4154 if (GET_MODE_BITSIZE (passed_mode
) % PARM_BOUNDARY
)
4155 offset_ptr
->constant
4156 += (((GET_MODE_BITSIZE (passed_mode
) + PARM_BOUNDARY
- 1)
4157 / PARM_BOUNDARY
* PARM_BOUNDARY
/ BITS_PER_UNIT
)
4158 - GET_MODE_SIZE (passed_mode
));
4162 if (TREE_CODE (sizetree
) != INTEGER_CST
4163 || (TREE_INT_CST_LOW (sizetree
) * BITS_PER_UNIT
) % PARM_BOUNDARY
)
4165 /* Round the size up to multiple of PARM_BOUNDARY bits. */
4166 tree s2
= round_up (sizetree
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
4168 ADD_PARM_SIZE (*offset_ptr
, s2
);
4169 SUB_PARM_SIZE (*offset_ptr
, sizetree
);
4175 /* True if register REGNO was alive at a place where `setjmp' was
4176 called and was set more than once or is an argument. Such regs may
4177 be clobbered by `longjmp'. */
4180 regno_clobbered_at_setjmp (bitmap setjmp_crosses
, int regno
)
4182 /* There appear to be cases where some local vars never reach the
4183 backend but have bogus regnos. */
4184 if (regno
>= max_reg_num ())
4187 return ((REG_N_SETS (regno
) > 1
4188 || REGNO_REG_SET_P (df_get_live_out (ENTRY_BLOCK_PTR_FOR_FN (cfun
)),
4190 && REGNO_REG_SET_P (setjmp_crosses
, regno
));
4193 /* Walk the tree of blocks describing the binding levels within a
4194 function and warn about variables the might be killed by setjmp or
4195 vfork. This is done after calling flow_analysis before register
4196 allocation since that will clobber the pseudo-regs to hard
4200 setjmp_vars_warning (bitmap setjmp_crosses
, tree block
)
4204 for (decl
= BLOCK_VARS (block
); decl
; decl
= DECL_CHAIN (decl
))
4206 if (TREE_CODE (decl
) == VAR_DECL
4207 && DECL_RTL_SET_P (decl
)
4208 && REG_P (DECL_RTL (decl
))
4209 && regno_clobbered_at_setjmp (setjmp_crosses
, REGNO (DECL_RTL (decl
))))
4210 warning (OPT_Wclobbered
, "variable %q+D might be clobbered by"
4211 " %<longjmp%> or %<vfork%>", decl
);
4214 for (sub
= BLOCK_SUBBLOCKS (block
); sub
; sub
= BLOCK_CHAIN (sub
))
4215 setjmp_vars_warning (setjmp_crosses
, sub
);
4218 /* Do the appropriate part of setjmp_vars_warning
4219 but for arguments instead of local variables. */
4222 setjmp_args_warning (bitmap setjmp_crosses
)
4225 for (decl
= DECL_ARGUMENTS (current_function_decl
);
4226 decl
; decl
= DECL_CHAIN (decl
))
4227 if (DECL_RTL (decl
) != 0
4228 && REG_P (DECL_RTL (decl
))
4229 && regno_clobbered_at_setjmp (setjmp_crosses
, REGNO (DECL_RTL (decl
))))
4230 warning (OPT_Wclobbered
,
4231 "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>",
4235 /* Generate warning messages for variables live across setjmp. */
4238 generate_setjmp_warnings (void)
4240 bitmap setjmp_crosses
= regstat_get_setjmp_crosses ();
4242 if (n_basic_blocks_for_fn (cfun
) == NUM_FIXED_BLOCKS
4243 || bitmap_empty_p (setjmp_crosses
))
4246 setjmp_vars_warning (setjmp_crosses
, DECL_INITIAL (current_function_decl
));
4247 setjmp_args_warning (setjmp_crosses
);
4251 /* Reverse the order of elements in the fragment chain T of blocks,
4252 and return the new head of the chain (old last element).
4253 In addition to that clear BLOCK_SAME_RANGE flags when needed
4254 and adjust BLOCK_SUPERCONTEXT from the super fragment to
4255 its super fragment origin. */
4258 block_fragments_nreverse (tree t
)
4260 tree prev
= 0, block
, next
, prev_super
= 0;
4261 tree super
= BLOCK_SUPERCONTEXT (t
);
4262 if (BLOCK_FRAGMENT_ORIGIN (super
))
4263 super
= BLOCK_FRAGMENT_ORIGIN (super
);
4264 for (block
= t
; block
; block
= next
)
4266 next
= BLOCK_FRAGMENT_CHAIN (block
);
4267 BLOCK_FRAGMENT_CHAIN (block
) = prev
;
4268 if ((prev
&& !BLOCK_SAME_RANGE (prev
))
4269 || (BLOCK_FRAGMENT_CHAIN (BLOCK_SUPERCONTEXT (block
))
4271 BLOCK_SAME_RANGE (block
) = 0;
4272 prev_super
= BLOCK_SUPERCONTEXT (block
);
4273 BLOCK_SUPERCONTEXT (block
) = super
;
4276 t
= BLOCK_FRAGMENT_ORIGIN (t
);
4277 if (BLOCK_FRAGMENT_CHAIN (BLOCK_SUPERCONTEXT (t
))
4279 BLOCK_SAME_RANGE (t
) = 0;
4280 BLOCK_SUPERCONTEXT (t
) = super
;
4284 /* Reverse the order of elements in the chain T of blocks,
4285 and return the new head of the chain (old last element).
4286 Also do the same on subblocks and reverse the order of elements
4287 in BLOCK_FRAGMENT_CHAIN as well. */
4290 blocks_nreverse_all (tree t
)
4292 tree prev
= 0, block
, next
;
4293 for (block
= t
; block
; block
= next
)
4295 next
= BLOCK_CHAIN (block
);
4296 BLOCK_CHAIN (block
) = prev
;
4297 if (BLOCK_FRAGMENT_CHAIN (block
)
4298 && BLOCK_FRAGMENT_ORIGIN (block
) == NULL_TREE
)
4300 BLOCK_FRAGMENT_CHAIN (block
)
4301 = block_fragments_nreverse (BLOCK_FRAGMENT_CHAIN (block
));
4302 if (!BLOCK_SAME_RANGE (BLOCK_FRAGMENT_CHAIN (block
)))
4303 BLOCK_SAME_RANGE (block
) = 0;
4305 BLOCK_SUBBLOCKS (block
) = blocks_nreverse_all (BLOCK_SUBBLOCKS (block
));
4312 /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
4313 and create duplicate blocks. */
4314 /* ??? Need an option to either create block fragments or to create
4315 abstract origin duplicates of a source block. It really depends
4316 on what optimization has been performed. */
4319 reorder_blocks (void)
4321 tree block
= DECL_INITIAL (current_function_decl
);
4323 if (block
== NULL_TREE
)
4326 auto_vec
<tree
, 10> block_stack
;
4328 /* Reset the TREE_ASM_WRITTEN bit for all blocks. */
4329 clear_block_marks (block
);
4331 /* Prune the old trees away, so that they don't get in the way. */
4332 BLOCK_SUBBLOCKS (block
) = NULL_TREE
;
4333 BLOCK_CHAIN (block
) = NULL_TREE
;
4335 /* Recreate the block tree from the note nesting. */
4336 reorder_blocks_1 (get_insns (), block
, &block_stack
);
4337 BLOCK_SUBBLOCKS (block
) = blocks_nreverse_all (BLOCK_SUBBLOCKS (block
));
4340 /* Helper function for reorder_blocks. Reset TREE_ASM_WRITTEN. */
4343 clear_block_marks (tree block
)
4347 TREE_ASM_WRITTEN (block
) = 0;
4348 clear_block_marks (BLOCK_SUBBLOCKS (block
));
4349 block
= BLOCK_CHAIN (block
);
4354 reorder_blocks_1 (rtx_insn
*insns
, tree current_block
,
4355 vec
<tree
> *p_block_stack
)
4358 tree prev_beg
= NULL_TREE
, prev_end
= NULL_TREE
;
4360 for (insn
= insns
; insn
; insn
= NEXT_INSN (insn
))
4364 if (NOTE_KIND (insn
) == NOTE_INSN_BLOCK_BEG
)
4366 tree block
= NOTE_BLOCK (insn
);
4369 gcc_assert (BLOCK_FRAGMENT_ORIGIN (block
) == NULL_TREE
);
4373 BLOCK_SAME_RANGE (prev_end
) = 0;
4374 prev_end
= NULL_TREE
;
4376 /* If we have seen this block before, that means it now
4377 spans multiple address regions. Create a new fragment. */
4378 if (TREE_ASM_WRITTEN (block
))
4380 tree new_block
= copy_node (block
);
4382 BLOCK_SAME_RANGE (new_block
) = 0;
4383 BLOCK_FRAGMENT_ORIGIN (new_block
) = origin
;
4384 BLOCK_FRAGMENT_CHAIN (new_block
)
4385 = BLOCK_FRAGMENT_CHAIN (origin
);
4386 BLOCK_FRAGMENT_CHAIN (origin
) = new_block
;
4388 NOTE_BLOCK (insn
) = new_block
;
4392 if (prev_beg
== current_block
&& prev_beg
)
4393 BLOCK_SAME_RANGE (block
) = 1;
4397 BLOCK_SUBBLOCKS (block
) = 0;
4398 TREE_ASM_WRITTEN (block
) = 1;
4399 /* When there's only one block for the entire function,
4400 current_block == block and we mustn't do this, it
4401 will cause infinite recursion. */
4402 if (block
!= current_block
)
4405 if (block
!= origin
)
4406 gcc_assert (BLOCK_SUPERCONTEXT (origin
) == current_block
4407 || BLOCK_FRAGMENT_ORIGIN (BLOCK_SUPERCONTEXT
4410 if (p_block_stack
->is_empty ())
4411 super
= current_block
;
4414 super
= p_block_stack
->last ();
4415 gcc_assert (super
== current_block
4416 || BLOCK_FRAGMENT_ORIGIN (super
)
4419 BLOCK_SUPERCONTEXT (block
) = super
;
4420 BLOCK_CHAIN (block
) = BLOCK_SUBBLOCKS (current_block
);
4421 BLOCK_SUBBLOCKS (current_block
) = block
;
4422 current_block
= origin
;
4424 p_block_stack
->safe_push (block
);
4426 else if (NOTE_KIND (insn
) == NOTE_INSN_BLOCK_END
)
4428 NOTE_BLOCK (insn
) = p_block_stack
->pop ();
4429 current_block
= BLOCK_SUPERCONTEXT (current_block
);
4430 if (BLOCK_FRAGMENT_ORIGIN (current_block
))
4431 current_block
= BLOCK_FRAGMENT_ORIGIN (current_block
);
4432 prev_beg
= NULL_TREE
;
4433 prev_end
= BLOCK_SAME_RANGE (NOTE_BLOCK (insn
))
4434 ? NOTE_BLOCK (insn
) : NULL_TREE
;
4439 prev_beg
= NULL_TREE
;
4441 BLOCK_SAME_RANGE (prev_end
) = 0;
4442 prev_end
= NULL_TREE
;
4447 /* Reverse the order of elements in the chain T of blocks,
4448 and return the new head of the chain (old last element). */
4451 blocks_nreverse (tree t
)
4453 tree prev
= 0, block
, next
;
4454 for (block
= t
; block
; block
= next
)
4456 next
= BLOCK_CHAIN (block
);
4457 BLOCK_CHAIN (block
) = prev
;
4463 /* Concatenate two chains of blocks (chained through BLOCK_CHAIN)
4464 by modifying the last node in chain 1 to point to chain 2. */
4467 block_chainon (tree op1
, tree op2
)
4476 for (t1
= op1
; BLOCK_CHAIN (t1
); t1
= BLOCK_CHAIN (t1
))
4478 BLOCK_CHAIN (t1
) = op2
;
4480 #ifdef ENABLE_TREE_CHECKING
4483 for (t2
= op2
; t2
; t2
= BLOCK_CHAIN (t2
))
4484 gcc_assert (t2
!= t1
);
4491 /* Count the subblocks of the list starting with BLOCK. If VECTOR is
4492 non-NULL, list them all into VECTOR, in a depth-first preorder
4493 traversal of the block tree. Also clear TREE_ASM_WRITTEN in all
4497 all_blocks (tree block
, tree
*vector
)
4503 TREE_ASM_WRITTEN (block
) = 0;
4505 /* Record this block. */
4507 vector
[n_blocks
] = block
;
4511 /* Record the subblocks, and their subblocks... */
4512 n_blocks
+= all_blocks (BLOCK_SUBBLOCKS (block
),
4513 vector
? vector
+ n_blocks
: 0);
4514 block
= BLOCK_CHAIN (block
);
4520 /* Return a vector containing all the blocks rooted at BLOCK. The
4521 number of elements in the vector is stored in N_BLOCKS_P. The
4522 vector is dynamically allocated; it is the caller's responsibility
4523 to call `free' on the pointer returned. */
4526 get_block_vector (tree block
, int *n_blocks_p
)
4530 *n_blocks_p
= all_blocks (block
, NULL
);
4531 block_vector
= XNEWVEC (tree
, *n_blocks_p
);
4532 all_blocks (block
, block_vector
);
4534 return block_vector
;
4537 static GTY(()) int next_block_index
= 2;
4539 /* Set BLOCK_NUMBER for all the blocks in FN. */
4542 number_blocks (tree fn
)
4548 /* For SDB and XCOFF debugging output, we start numbering the blocks
4549 from 1 within each function, rather than keeping a running
4551 #if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
4552 if (write_symbols
== SDB_DEBUG
|| write_symbols
== XCOFF_DEBUG
)
4553 next_block_index
= 1;
4556 block_vector
= get_block_vector (DECL_INITIAL (fn
), &n_blocks
);
4558 /* The top-level BLOCK isn't numbered at all. */
4559 for (i
= 1; i
< n_blocks
; ++i
)
4560 /* We number the blocks from two. */
4561 BLOCK_NUMBER (block_vector
[i
]) = next_block_index
++;
4563 free (block_vector
);
4568 /* If VAR is present in a subblock of BLOCK, return the subblock. */
4571 debug_find_var_in_block_tree (tree var
, tree block
)
4575 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
4579 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= TREE_CHAIN (t
))
4581 tree ret
= debug_find_var_in_block_tree (var
, t
);
4589 /* Keep track of whether we're in a dummy function context. If we are,
4590 we don't want to invoke the set_current_function hook, because we'll
4591 get into trouble if the hook calls target_reinit () recursively or
4592 when the initial initialization is not yet complete. */
4594 static bool in_dummy_function
;
4596 /* Invoke the target hook when setting cfun. Update the optimization options
4597 if the function uses different options than the default. */
4600 invoke_set_current_function_hook (tree fndecl
)
4602 if (!in_dummy_function
)
4604 tree opts
= ((fndecl
)
4605 ? DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl
)
4606 : optimization_default_node
);
4609 opts
= optimization_default_node
;
4611 /* Change optimization options if needed. */
4612 if (optimization_current_node
!= opts
)
4614 optimization_current_node
= opts
;
4615 cl_optimization_restore (&global_options
, TREE_OPTIMIZATION (opts
));
4618 targetm
.set_current_function (fndecl
);
4619 this_fn_optabs
= this_target_optabs
;
4621 if (opts
!= optimization_default_node
)
4623 init_tree_optimization_optabs (opts
);
4624 if (TREE_OPTIMIZATION_OPTABS (opts
))
4625 this_fn_optabs
= (struct target_optabs
*)
4626 TREE_OPTIMIZATION_OPTABS (opts
);
4631 /* cfun should never be set directly; use this function. */
4634 set_cfun (struct function
*new_cfun
)
4636 if (cfun
!= new_cfun
)
4639 invoke_set_current_function_hook (new_cfun
? new_cfun
->decl
: NULL_TREE
);
4643 /* Initialized with NOGC, making this poisonous to the garbage collector. */
4645 static vec
<function_p
> cfun_stack
;
4647 /* Push the current cfun onto the stack, and set cfun to new_cfun. Also set
4648 current_function_decl accordingly. */
4651 push_cfun (struct function
*new_cfun
)
4653 gcc_assert ((!cfun
&& !current_function_decl
)
4654 || (cfun
&& current_function_decl
== cfun
->decl
));
4655 cfun_stack
.safe_push (cfun
);
4656 current_function_decl
= new_cfun
? new_cfun
->decl
: NULL_TREE
;
4657 set_cfun (new_cfun
);
4660 /* Pop cfun from the stack. Also set current_function_decl accordingly. */
4665 struct function
*new_cfun
= cfun_stack
.pop ();
4666 /* When in_dummy_function, we do have a cfun but current_function_decl is
4667 NULL. We also allow pushing NULL cfun and subsequently changing
4668 current_function_decl to something else and have both restored by
4670 gcc_checking_assert (in_dummy_function
4672 || current_function_decl
== cfun
->decl
);
4673 set_cfun (new_cfun
);
4674 current_function_decl
= new_cfun
? new_cfun
->decl
: NULL_TREE
;
4677 /* Return value of funcdef and increase it. */
4679 get_next_funcdef_no (void)
4681 return funcdef_no
++;
4684 /* Return value of funcdef. */
4686 get_last_funcdef_no (void)
4691 /* Allocate a function structure for FNDECL and set its contents
4692 to the defaults. Set cfun to the newly-allocated object.
4693 Some of the helper functions invoked during initialization assume
4694 that cfun has already been set. Therefore, assign the new object
4695 directly into cfun and invoke the back end hook explicitly at the
4696 very end, rather than initializing a temporary and calling set_cfun
4699 ABSTRACT_P is true if this is a function that will never be seen by
4700 the middle-end. Such functions are front-end concepts (like C++
4701 function templates) that do not correspond directly to functions
4702 placed in object files. */
4705 allocate_struct_function (tree fndecl
, bool abstract_p
)
4707 tree fntype
= fndecl
? TREE_TYPE (fndecl
) : NULL_TREE
;
4709 cfun
= ggc_cleared_alloc
<function
> ();
4711 init_eh_for_function ();
4713 if (init_machine_status
)
4714 cfun
->machine
= (*init_machine_status
) ();
4716 #ifdef OVERRIDE_ABI_FORMAT
4717 OVERRIDE_ABI_FORMAT (fndecl
);
4720 if (fndecl
!= NULL_TREE
)
4722 DECL_STRUCT_FUNCTION (fndecl
) = cfun
;
4723 cfun
->decl
= fndecl
;
4724 current_function_funcdef_no
= get_next_funcdef_no ();
4727 invoke_set_current_function_hook (fndecl
);
4729 if (fndecl
!= NULL_TREE
)
4731 tree result
= DECL_RESULT (fndecl
);
4732 if (!abstract_p
&& aggregate_value_p (result
, fndecl
))
4734 #ifdef PCC_STATIC_STRUCT_RETURN
4735 cfun
->returns_pcc_struct
= 1;
4737 cfun
->returns_struct
= 1;
4740 cfun
->stdarg
= stdarg_p (fntype
);
4742 /* Assume all registers in stdarg functions need to be saved. */
4743 cfun
->va_list_gpr_size
= VA_LIST_MAX_GPR_SIZE
;
4744 cfun
->va_list_fpr_size
= VA_LIST_MAX_FPR_SIZE
;
4746 /* ??? This could be set on a per-function basis by the front-end
4747 but is this worth the hassle? */
4748 cfun
->can_throw_non_call_exceptions
= flag_non_call_exceptions
;
4749 cfun
->can_delete_dead_exceptions
= flag_delete_dead_exceptions
;
4751 if (!profile_flag
&& !flag_instrument_function_entry_exit
)
4752 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl
) = 1;
4756 /* This is like allocate_struct_function, but pushes a new cfun for FNDECL
4757 instead of just setting it. */
4760 push_struct_function (tree fndecl
)
4762 /* When in_dummy_function we might be in the middle of a pop_cfun and
4763 current_function_decl and cfun may not match. */
4764 gcc_assert (in_dummy_function
4765 || (!cfun
&& !current_function_decl
)
4766 || (cfun
&& current_function_decl
== cfun
->decl
));
4767 cfun_stack
.safe_push (cfun
);
4768 current_function_decl
= fndecl
;
4769 allocate_struct_function (fndecl
, false);
4772 /* Reset crtl and other non-struct-function variables to defaults as
4773 appropriate for emitting rtl at the start of a function. */
4776 prepare_function_start (void)
4778 gcc_assert (!get_last_insn ());
4781 init_varasm_status ();
4783 default_rtl_profile ();
4785 if (flag_stack_usage_info
)
4787 cfun
->su
= ggc_cleared_alloc
<stack_usage
> ();
4788 cfun
->su
->static_stack_size
= -1;
4791 cse_not_expected
= ! optimize
;
4793 /* Caller save not needed yet. */
4794 caller_save_needed
= 0;
4796 /* We haven't done register allocation yet. */
4799 /* Indicate that we have not instantiated virtual registers yet. */
4800 virtuals_instantiated
= 0;
4802 /* Indicate that we want CONCATs now. */
4803 generating_concat_p
= 1;
4805 /* Indicate we have no need of a frame pointer yet. */
4806 frame_pointer_needed
= 0;
4810 push_dummy_function (bool with_decl
)
4812 tree fn_decl
, fn_type
, fn_result_decl
;
4814 gcc_assert (!in_dummy_function
);
4815 in_dummy_function
= true;
4819 fn_type
= build_function_type_list (void_type_node
, NULL_TREE
);
4820 fn_decl
= build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
, NULL_TREE
,
4822 fn_result_decl
= build_decl (UNKNOWN_LOCATION
, RESULT_DECL
,
4823 NULL_TREE
, void_type_node
);
4824 DECL_RESULT (fn_decl
) = fn_result_decl
;
4827 fn_decl
= NULL_TREE
;
4829 push_struct_function (fn_decl
);
4832 /* Initialize the rtl expansion mechanism so that we can do simple things
4833 like generate sequences. This is used to provide a context during global
4834 initialization of some passes. You must call expand_dummy_function_end
4835 to exit this context. */
4838 init_dummy_function_start (void)
4840 push_dummy_function (false);
4841 prepare_function_start ();
4844 /* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node)
4845 and initialize static variables for generating RTL for the statements
4849 init_function_start (tree subr
)
4851 if (subr
&& DECL_STRUCT_FUNCTION (subr
))
4852 set_cfun (DECL_STRUCT_FUNCTION (subr
));
4854 allocate_struct_function (subr
, false);
4856 /* Initialize backend, if needed. */
4859 prepare_function_start ();
4860 decide_function_section (subr
);
4862 /* Warn if this value is an aggregate type,
4863 regardless of which calling convention we are using for it. */
4864 if (AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr
))))
4865 warning (OPT_Waggregate_return
, "function returns an aggregate");
4868 /* Expand code to verify the stack_protect_guard. This is invoked at
4869 the end of a function to be protected. */
4872 stack_protect_epilogue (void)
4874 tree guard_decl
= targetm
.stack_protect_guard ();
4875 rtx_code_label
*label
= gen_label_rtx ();
4878 x
= expand_normal (crtl
->stack_protect_guard
);
4879 y
= expand_normal (guard_decl
);
4881 /* Allow the target to compare Y with X without leaking either into
4883 switch (targetm
.have_stack_protect_test ())
4886 if (rtx_insn
*seq
= targetm
.gen_stack_protect_test (x
, y
, label
))
4894 emit_cmp_and_jump_insns (x
, y
, EQ
, NULL_RTX
, ptr_mode
, 1, label
);
4898 /* The noreturn predictor has been moved to the tree level. The rtl-level
4899 predictors estimate this branch about 20%, which isn't enough to get
4900 things moved out of line. Since this is the only extant case of adding
4901 a noreturn function at the rtl level, it doesn't seem worth doing ought
4902 except adding the prediction by hand. */
4903 tmp
= get_last_insn ();
4905 predict_insn_def (as_a
<rtx_insn
*> (tmp
), PRED_NORETURN
, TAKEN
);
4907 expand_call (targetm
.stack_protect_fail (), NULL_RTX
, /*ignore=*/true);
4912 /* Start the RTL for a new function, and set variables used for
4914 SUBR is the FUNCTION_DECL node.
4915 PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with
4916 the function's parameters, which must be run at any return statement. */
4919 expand_function_start (tree subr
)
4921 /* Make sure volatile mem refs aren't considered
4922 valid operands of arithmetic insns. */
4923 init_recog_no_volatile ();
4927 && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr
));
4930 = (stack_limit_rtx
!= NULL_RTX
&& ! DECL_NO_LIMIT_STACK (subr
));
4932 /* Make the label for return statements to jump to. Do not special
4933 case machines with special return instructions -- they will be
4934 handled later during jump, ifcvt, or epilogue creation. */
4935 return_label
= gen_label_rtx ();
4937 /* Initialize rtx used to return the value. */
4938 /* Do this before assign_parms so that we copy the struct value address
4939 before any library calls that assign parms might generate. */
4941 /* Decide whether to return the value in memory or in a register. */
4942 if (aggregate_value_p (DECL_RESULT (subr
), subr
))
4944 /* Returning something that won't go in a register. */
4945 rtx value_address
= 0;
4947 #ifdef PCC_STATIC_STRUCT_RETURN
4948 if (cfun
->returns_pcc_struct
)
4950 int size
= int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr
)));
4951 value_address
= assemble_static_space (size
);
4956 rtx sv
= targetm
.calls
.struct_value_rtx (TREE_TYPE (subr
), 2);
4957 /* Expect to be passed the address of a place to store the value.
4958 If it is passed as an argument, assign_parms will take care of
4962 value_address
= gen_reg_rtx (Pmode
);
4963 emit_move_insn (value_address
, sv
);
4968 rtx x
= value_address
;
4969 if (!DECL_BY_REFERENCE (DECL_RESULT (subr
)))
4971 x
= gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr
)), x
);
4972 set_mem_attributes (x
, DECL_RESULT (subr
), 1);
4974 SET_DECL_RTL (DECL_RESULT (subr
), x
);
4977 else if (DECL_MODE (DECL_RESULT (subr
)) == VOIDmode
)
4978 /* If return mode is void, this decl rtl should not be used. */
4979 SET_DECL_RTL (DECL_RESULT (subr
), NULL_RTX
);
4982 /* Compute the return values into a pseudo reg, which we will copy
4983 into the true return register after the cleanups are done. */
4984 tree return_type
= TREE_TYPE (DECL_RESULT (subr
));
4985 if (TYPE_MODE (return_type
) != BLKmode
4986 && targetm
.calls
.return_in_msb (return_type
))
4987 /* expand_function_end will insert the appropriate padding in
4988 this case. Use the return value's natural (unpadded) mode
4989 within the function proper. */
4990 SET_DECL_RTL (DECL_RESULT (subr
),
4991 gen_reg_rtx (TYPE_MODE (return_type
)));
4994 /* In order to figure out what mode to use for the pseudo, we
4995 figure out what the mode of the eventual return register will
4996 actually be, and use that. */
4997 rtx hard_reg
= hard_function_value (return_type
, subr
, 0, 1);
4999 /* Structures that are returned in registers are not
5000 aggregate_value_p, so we may see a PARALLEL or a REG. */
5001 if (REG_P (hard_reg
))
5002 SET_DECL_RTL (DECL_RESULT (subr
),
5003 gen_reg_rtx (GET_MODE (hard_reg
)));
5006 gcc_assert (GET_CODE (hard_reg
) == PARALLEL
);
5007 SET_DECL_RTL (DECL_RESULT (subr
), gen_group_rtx (hard_reg
));
5011 /* Set DECL_REGISTER flag so that expand_function_end will copy the
5012 result to the real return register(s). */
5013 DECL_REGISTER (DECL_RESULT (subr
)) = 1;
5015 if (chkp_function_instrumented_p (current_function_decl
))
5017 tree return_type
= TREE_TYPE (DECL_RESULT (subr
));
5018 rtx bounds
= targetm
.calls
.chkp_function_value_bounds (return_type
,
5020 SET_DECL_BOUNDS_RTL (DECL_RESULT (subr
), bounds
);
5024 /* Initialize rtx for parameters and local variables.
5025 In some cases this requires emitting insns. */
5026 assign_parms (subr
);
5028 /* If function gets a static chain arg, store it. */
5029 if (cfun
->static_chain_decl
)
5031 tree parm
= cfun
->static_chain_decl
;
5035 local
= gen_reg_rtx (Pmode
);
5036 chain
= targetm
.calls
.static_chain (current_function_decl
, true);
5038 set_decl_incoming_rtl (parm
, chain
, false);
5039 SET_DECL_RTL (parm
, local
);
5040 mark_reg_pointer (local
, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm
))));
5042 insn
= emit_move_insn (local
, chain
);
5044 /* Mark the register as eliminable, similar to parameters. */
5046 && reg_mentioned_p (arg_pointer_rtx
, XEXP (chain
, 0)))
5047 set_dst_reg_note (insn
, REG_EQUIV
, chain
, local
);
5049 /* If we aren't optimizing, save the static chain onto the stack. */
5052 tree saved_static_chain_decl
5053 = build_decl (DECL_SOURCE_LOCATION (parm
), VAR_DECL
,
5054 DECL_NAME (parm
), TREE_TYPE (parm
));
5055 rtx saved_static_chain_rtx
5056 = assign_stack_local (Pmode
, GET_MODE_SIZE (Pmode
), 0);
5057 SET_DECL_RTL (saved_static_chain_decl
, saved_static_chain_rtx
);
5058 emit_move_insn (saved_static_chain_rtx
, chain
);
5059 SET_DECL_VALUE_EXPR (parm
, saved_static_chain_decl
);
5060 DECL_HAS_VALUE_EXPR_P (parm
) = 1;
5064 /* If the function receives a non-local goto, then store the
5065 bits we need to restore the frame pointer. */
5066 if (cfun
->nonlocal_goto_save_area
)
5071 tree var
= TREE_OPERAND (cfun
->nonlocal_goto_save_area
, 0);
5072 gcc_assert (DECL_RTL_SET_P (var
));
5074 t_save
= build4 (ARRAY_REF
,
5075 TREE_TYPE (TREE_TYPE (cfun
->nonlocal_goto_save_area
)),
5076 cfun
->nonlocal_goto_save_area
,
5077 integer_zero_node
, NULL_TREE
, NULL_TREE
);
5078 r_save
= expand_expr (t_save
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
5079 gcc_assert (GET_MODE (r_save
) == Pmode
);
5081 emit_move_insn (r_save
, targetm
.builtin_setjmp_frame_value ());
5082 update_nonlocal_goto_save_area ();
5085 /* The following was moved from init_function_start.
5086 The move is supposed to make sdb output more accurate. */
5087 /* Indicate the beginning of the function body,
5088 as opposed to parm setup. */
5089 emit_note (NOTE_INSN_FUNCTION_BEG
);
5091 gcc_assert (NOTE_P (get_last_insn ()));
5093 parm_birth_insn
= get_last_insn ();
5098 PROFILE_HOOK (current_function_funcdef_no
);
5102 /* If we are doing generic stack checking, the probe should go here. */
5103 if (flag_stack_check
== GENERIC_STACK_CHECK
)
5104 stack_check_probe_note
= emit_note (NOTE_INSN_DELETED
);
5108 pop_dummy_function (void)
5111 in_dummy_function
= false;
5114 /* Undo the effects of init_dummy_function_start. */
5116 expand_dummy_function_end (void)
5118 gcc_assert (in_dummy_function
);
5120 /* End any sequences that failed to be closed due to syntax errors. */
5121 while (in_sequence_p ())
5124 /* Outside function body, can't compute type's actual size
5125 until next function's body starts. */
5127 free_after_parsing (cfun
);
5128 free_after_compilation (cfun
);
5129 pop_dummy_function ();
5132 /* Helper for diddle_return_value. */
5135 diddle_return_value_1 (void (*doit
) (rtx
, void *), void *arg
, rtx outgoing
)
5140 if (REG_P (outgoing
))
5141 (*doit
) (outgoing
, arg
);
5142 else if (GET_CODE (outgoing
) == PARALLEL
)
5146 for (i
= 0; i
< XVECLEN (outgoing
, 0); i
++)
5148 rtx x
= XEXP (XVECEXP (outgoing
, 0, i
), 0);
5150 if (REG_P (x
) && REGNO (x
) < FIRST_PSEUDO_REGISTER
)
5156 /* Call DOIT for each hard register used as a return value from
5157 the current function. */
5160 diddle_return_value (void (*doit
) (rtx
, void *), void *arg
)
5162 diddle_return_value_1 (doit
, arg
, crtl
->return_bnd
);
5163 diddle_return_value_1 (doit
, arg
, crtl
->return_rtx
);
5167 do_clobber_return_reg (rtx reg
, void *arg ATTRIBUTE_UNUSED
)
5173 clobber_return_register (void)
5175 diddle_return_value (do_clobber_return_reg
, NULL
);
5177 /* In case we do use pseudo to return value, clobber it too. */
5178 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl
)))
5180 tree decl_result
= DECL_RESULT (current_function_decl
);
5181 rtx decl_rtl
= DECL_RTL (decl_result
);
5182 if (REG_P (decl_rtl
) && REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
)
5184 do_clobber_return_reg (decl_rtl
, NULL
);
5190 do_use_return_reg (rtx reg
, void *arg ATTRIBUTE_UNUSED
)
5196 use_return_register (void)
5198 diddle_return_value (do_use_return_reg
, NULL
);
5201 /* Set the location of the insn chain starting at INSN to LOC. */
5204 set_insn_locations (rtx_insn
*insn
, int loc
)
5206 while (insn
!= NULL
)
5209 INSN_LOCATION (insn
) = loc
;
5210 insn
= NEXT_INSN (insn
);
5214 /* Generate RTL for the end of the current function. */
5217 expand_function_end (void)
5219 /* If arg_pointer_save_area was referenced only from a nested
5220 function, we will not have initialized it yet. Do that now. */
5221 if (arg_pointer_save_area
&& ! crtl
->arg_pointer_save_area_init
)
5222 get_arg_pointer_save_area ();
5224 /* If we are doing generic stack checking and this function makes calls,
5225 do a stack probe at the start of the function to ensure we have enough
5226 space for another stack frame. */
5227 if (flag_stack_check
== GENERIC_STACK_CHECK
)
5229 rtx_insn
*insn
, *seq
;
5231 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
5234 rtx max_frame_size
= GEN_INT (STACK_CHECK_MAX_FRAME_SIZE
);
5236 if (STACK_CHECK_MOVING_SP
)
5237 anti_adjust_stack_and_probe (max_frame_size
, true);
5239 probe_stack_range (STACK_OLD_CHECK_PROTECT
, max_frame_size
);
5242 set_insn_locations (seq
, prologue_location
);
5243 emit_insn_before (seq
, stack_check_probe_note
);
5248 /* End any sequences that failed to be closed due to syntax errors. */
5249 while (in_sequence_p ())
5252 clear_pending_stack_adjust ();
5253 do_pending_stack_adjust ();
5255 /* Output a linenumber for the end of the function.
5256 SDB depends on this. */
5257 set_curr_insn_location (input_location
);
5259 /* Before the return label (if any), clobber the return
5260 registers so that they are not propagated live to the rest of
5261 the function. This can only happen with functions that drop
5262 through; if there had been a return statement, there would
5263 have either been a return rtx, or a jump to the return label.
5265 We delay actual code generation after the current_function_value_rtx
5267 rtx_insn
*clobber_after
= get_last_insn ();
5269 /* Output the label for the actual return from the function. */
5270 emit_label (return_label
);
5272 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
5274 /* Let except.c know where it should emit the call to unregister
5275 the function context for sjlj exceptions. */
5276 if (flag_exceptions
)
5277 sjlj_emit_function_exit_after (get_last_insn ());
5281 /* We want to ensure that instructions that may trap are not
5282 moved into the epilogue by scheduling, because we don't
5283 always emit unwind information for the epilogue. */
5284 if (cfun
->can_throw_non_call_exceptions
)
5285 emit_insn (gen_blockage ());
5288 /* If this is an implementation of throw, do what's necessary to
5289 communicate between __builtin_eh_return and the epilogue. */
5290 expand_eh_return ();
5292 /* If scalar return value was computed in a pseudo-reg, or was a named
5293 return value that got dumped to the stack, copy that to the hard
5295 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl
)))
5297 tree decl_result
= DECL_RESULT (current_function_decl
);
5298 rtx decl_rtl
= DECL_RTL (decl_result
);
5300 if (REG_P (decl_rtl
)
5301 ? REGNO (decl_rtl
) >= FIRST_PSEUDO_REGISTER
5302 : DECL_REGISTER (decl_result
))
5304 rtx real_decl_rtl
= crtl
->return_rtx
;
5306 /* This should be set in assign_parms. */
5307 gcc_assert (REG_FUNCTION_VALUE_P (real_decl_rtl
));
5309 /* If this is a BLKmode structure being returned in registers,
5310 then use the mode computed in expand_return. Note that if
5311 decl_rtl is memory, then its mode may have been changed,
5312 but that crtl->return_rtx has not. */
5313 if (GET_MODE (real_decl_rtl
) == BLKmode
)
5314 PUT_MODE (real_decl_rtl
, GET_MODE (decl_rtl
));
5316 /* If a non-BLKmode return value should be padded at the least
5317 significant end of the register, shift it left by the appropriate
5318 amount. BLKmode results are handled using the group load/store
5320 if (TYPE_MODE (TREE_TYPE (decl_result
)) != BLKmode
5321 && REG_P (real_decl_rtl
)
5322 && targetm
.calls
.return_in_msb (TREE_TYPE (decl_result
)))
5324 emit_move_insn (gen_rtx_REG (GET_MODE (decl_rtl
),
5325 REGNO (real_decl_rtl
)),
5327 shift_return_value (GET_MODE (decl_rtl
), true, real_decl_rtl
);
5329 /* If a named return value dumped decl_return to memory, then
5330 we may need to re-do the PROMOTE_MODE signed/unsigned
5332 else if (GET_MODE (real_decl_rtl
) != GET_MODE (decl_rtl
))
5334 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (decl_result
));
5335 promote_function_mode (TREE_TYPE (decl_result
),
5336 GET_MODE (decl_rtl
), &unsignedp
,
5337 TREE_TYPE (current_function_decl
), 1);
5339 convert_move (real_decl_rtl
, decl_rtl
, unsignedp
);
5341 else if (GET_CODE (real_decl_rtl
) == PARALLEL
)
5343 /* If expand_function_start has created a PARALLEL for decl_rtl,
5344 move the result to the real return registers. Otherwise, do
5345 a group load from decl_rtl for a named return. */
5346 if (GET_CODE (decl_rtl
) == PARALLEL
)
5347 emit_group_move (real_decl_rtl
, decl_rtl
);
5349 emit_group_load (real_decl_rtl
, decl_rtl
,
5350 TREE_TYPE (decl_result
),
5351 int_size_in_bytes (TREE_TYPE (decl_result
)));
5353 /* In the case of complex integer modes smaller than a word, we'll
5354 need to generate some non-trivial bitfield insertions. Do that
5355 on a pseudo and not the hard register. */
5356 else if (GET_CODE (decl_rtl
) == CONCAT
5357 && GET_MODE_CLASS (GET_MODE (decl_rtl
)) == MODE_COMPLEX_INT
5358 && GET_MODE_BITSIZE (GET_MODE (decl_rtl
)) <= BITS_PER_WORD
)
5360 int old_generating_concat_p
;
5363 old_generating_concat_p
= generating_concat_p
;
5364 generating_concat_p
= 0;
5365 tmp
= gen_reg_rtx (GET_MODE (decl_rtl
));
5366 generating_concat_p
= old_generating_concat_p
;
5368 emit_move_insn (tmp
, decl_rtl
);
5369 emit_move_insn (real_decl_rtl
, tmp
);
5372 emit_move_insn (real_decl_rtl
, decl_rtl
);
5376 /* If returning a structure, arrange to return the address of the value
5377 in a place where debuggers expect to find it.
5379 If returning a structure PCC style,
5380 the caller also depends on this value.
5381 And cfun->returns_pcc_struct is not necessarily set. */
5382 if ((cfun
->returns_struct
|| cfun
->returns_pcc_struct
)
5383 && !targetm
.calls
.omit_struct_return_reg
)
5385 rtx value_address
= DECL_RTL (DECL_RESULT (current_function_decl
));
5386 tree type
= TREE_TYPE (DECL_RESULT (current_function_decl
));
5389 if (DECL_BY_REFERENCE (DECL_RESULT (current_function_decl
)))
5390 type
= TREE_TYPE (type
);
5392 value_address
= XEXP (value_address
, 0);
5394 outgoing
= targetm
.calls
.function_value (build_pointer_type (type
),
5395 current_function_decl
, true);
5397 /* Mark this as a function return value so integrate will delete the
5398 assignment and USE below when inlining this function. */
5399 REG_FUNCTION_VALUE_P (outgoing
) = 1;
5401 /* The address may be ptr_mode and OUTGOING may be Pmode. */
5402 value_address
= convert_memory_address (GET_MODE (outgoing
),
5405 emit_move_insn (outgoing
, value_address
);
5407 /* Show return register used to hold result (in this case the address
5409 crtl
->return_rtx
= outgoing
;
5412 /* Emit the actual code to clobber return register. Don't emit
5413 it if clobber_after is a barrier, then the previous basic block
5414 certainly doesn't fall thru into the exit block. */
5415 if (!BARRIER_P (clobber_after
))
5418 clobber_return_register ();
5419 rtx_insn
*seq
= get_insns ();
5422 emit_insn_after (seq
, clobber_after
);
5425 /* Output the label for the naked return from the function. */
5426 if (naked_return_label
)
5427 emit_label (naked_return_label
);
5429 /* @@@ This is a kludge. We want to ensure that instructions that
5430 may trap are not moved into the epilogue by scheduling, because
5431 we don't always emit unwind information for the epilogue. */
5432 if (cfun
->can_throw_non_call_exceptions
5433 && targetm_common
.except_unwind_info (&global_options
) != UI_SJLJ
)
5434 emit_insn (gen_blockage ());
5436 /* If stack protection is enabled for this function, check the guard. */
5437 if (crtl
->stack_protect_guard
)
5438 stack_protect_epilogue ();
5440 /* If we had calls to alloca, and this machine needs
5441 an accurate stack pointer to exit the function,
5442 insert some code to save and restore the stack pointer. */
5443 if (! EXIT_IGNORE_STACK
5444 && cfun
->calls_alloca
)
5449 emit_stack_save (SAVE_FUNCTION
, &tem
);
5450 rtx_insn
*seq
= get_insns ();
5452 emit_insn_before (seq
, parm_birth_insn
);
5454 emit_stack_restore (SAVE_FUNCTION
, tem
);
5457 /* ??? This should no longer be necessary since stupid is no longer with
5458 us, but there are some parts of the compiler (eg reload_combine, and
5459 sh mach_dep_reorg) that still try and compute their own lifetime info
5460 instead of using the general framework. */
5461 use_return_register ();
5465 get_arg_pointer_save_area (void)
5467 rtx ret
= arg_pointer_save_area
;
5471 ret
= assign_stack_local (Pmode
, GET_MODE_SIZE (Pmode
), 0);
5472 arg_pointer_save_area
= ret
;
5475 if (! crtl
->arg_pointer_save_area_init
)
5477 /* Save the arg pointer at the beginning of the function. The
5478 generated stack slot may not be a valid memory address, so we
5479 have to check it and fix it if necessary. */
5481 emit_move_insn (validize_mem (copy_rtx (ret
)),
5482 crtl
->args
.internal_arg_pointer
);
5483 rtx_insn
*seq
= get_insns ();
5486 push_topmost_sequence ();
5487 emit_insn_after (seq
, entry_of_function ());
5488 pop_topmost_sequence ();
5490 crtl
->arg_pointer_save_area_init
= true;
5496 /* Add a list of INSNS to the hash HASHP, possibly allocating HASHP
5497 for the first time. */
5500 record_insns (rtx_insn
*insns
, rtx end
, hash_table
<insn_cache_hasher
> **hashp
)
5503 hash_table
<insn_cache_hasher
> *hash
= *hashp
;
5506 *hashp
= hash
= hash_table
<insn_cache_hasher
>::create_ggc (17);
5508 for (tmp
= insns
; tmp
!= end
; tmp
= NEXT_INSN (tmp
))
5510 rtx
*slot
= hash
->find_slot (tmp
, INSERT
);
5511 gcc_assert (*slot
== NULL
);
5516 /* INSN has been duplicated or replaced by as COPY, perhaps by duplicating a
5517 basic block, splitting or peepholes. If INSN is a prologue or epilogue
5518 insn, then record COPY as well. */
5521 maybe_copy_prologue_epilogue_insn (rtx insn
, rtx copy
)
5523 hash_table
<insn_cache_hasher
> *hash
;
5526 hash
= epilogue_insn_hash
;
5527 if (!hash
|| !hash
->find (insn
))
5529 hash
= prologue_insn_hash
;
5530 if (!hash
|| !hash
->find (insn
))
5534 slot
= hash
->find_slot (copy
, INSERT
);
5535 gcc_assert (*slot
== NULL
);
5539 /* Determine if any INSNs in HASH are, or are part of, INSN. Because
5540 we can be running after reorg, SEQUENCE rtl is possible. */
5543 contains (const_rtx insn
, hash_table
<insn_cache_hasher
> *hash
)
5548 if (NONJUMP_INSN_P (insn
) && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
5550 rtx_sequence
*seq
= as_a
<rtx_sequence
*> (PATTERN (insn
));
5552 for (i
= seq
->len () - 1; i
>= 0; i
--)
5553 if (hash
->find (seq
->element (i
)))
5558 return hash
->find (const_cast<rtx
> (insn
)) != NULL
;
5562 prologue_epilogue_contains (const_rtx insn
)
5564 if (contains (insn
, prologue_insn_hash
))
5566 if (contains (insn
, epilogue_insn_hash
))
5571 /* Insert use of return register before the end of BB. */
5574 emit_use_return_register_into_block (basic_block bb
)
5577 use_return_register ();
5578 rtx_insn
*seq
= get_insns ();
5580 rtx_insn
*insn
= BB_END (bb
);
5581 if (HAVE_cc0
&& reg_mentioned_p (cc0_rtx
, PATTERN (insn
)))
5582 insn
= prev_cc0_setter (insn
);
5584 emit_insn_before (seq
, insn
);
5588 /* Create a return pattern, either simple_return or return, depending on
5592 gen_return_pattern (bool simple_p
)
5595 ? targetm
.gen_simple_return ()
5596 : targetm
.gen_return ());
5599 /* Insert an appropriate return pattern at the end of block BB. This
5600 also means updating block_for_insn appropriately. SIMPLE_P is
5601 the same as in gen_return_pattern and passed to it. */
5604 emit_return_into_block (bool simple_p
, basic_block bb
)
5606 rtx_jump_insn
*jump
= emit_jump_insn_after (gen_return_pattern (simple_p
),
5608 rtx pat
= PATTERN (jump
);
5609 if (GET_CODE (pat
) == PARALLEL
)
5610 pat
= XVECEXP (pat
, 0, 0);
5611 gcc_assert (ANY_RETURN_P (pat
));
5612 JUMP_LABEL (jump
) = pat
;
5615 /* Set JUMP_LABEL for a return insn. */
5618 set_return_jump_label (rtx_insn
*returnjump
)
5620 rtx pat
= PATTERN (returnjump
);
5621 if (GET_CODE (pat
) == PARALLEL
)
5622 pat
= XVECEXP (pat
, 0, 0);
5623 if (ANY_RETURN_P (pat
))
5624 JUMP_LABEL (returnjump
) = pat
;
5626 JUMP_LABEL (returnjump
) = ret_rtx
;
5629 /* Return true if there are any active insns between HEAD and TAIL. */
5631 active_insn_between (rtx_insn
*head
, rtx_insn
*tail
)
5635 if (active_insn_p (tail
))
5639 tail
= PREV_INSN (tail
);
5644 /* LAST_BB is a block that exits, and empty of active instructions.
5645 Examine its predecessors for jumps that can be converted to
5646 (conditional) returns. */
5648 convert_jumps_to_returns (basic_block last_bb
, bool simple_p
,
5649 vec
<edge
> unconverted ATTRIBUTE_UNUSED
)
5655 auto_vec
<basic_block
> src_bbs (EDGE_COUNT (last_bb
->preds
));
5657 FOR_EACH_EDGE (e
, ei
, last_bb
->preds
)
5658 if (e
->src
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
))
5659 src_bbs
.quick_push (e
->src
);
5661 rtx_insn
*label
= BB_HEAD (last_bb
);
5663 FOR_EACH_VEC_ELT (src_bbs
, i
, bb
)
5665 rtx_insn
*jump
= BB_END (bb
);
5667 if (!JUMP_P (jump
) || JUMP_LABEL (jump
) != label
)
5670 e
= find_edge (bb
, last_bb
);
5672 /* If we have an unconditional jump, we can replace that
5673 with a simple return instruction. */
5674 if (simplejump_p (jump
))
5676 /* The use of the return register might be present in the exit
5677 fallthru block. Either:
5678 - removing the use is safe, and we should remove the use in
5679 the exit fallthru block, or
5680 - removing the use is not safe, and we should add it here.
5681 For now, we conservatively choose the latter. Either of the
5682 2 helps in crossjumping. */
5683 emit_use_return_register_into_block (bb
);
5685 emit_return_into_block (simple_p
, bb
);
5689 /* If we have a conditional jump branching to the last
5690 block, we can try to replace that with a conditional
5691 return instruction. */
5692 else if (condjump_p (jump
))
5697 dest
= simple_return_rtx
;
5700 if (!redirect_jump (as_a
<rtx_jump_insn
*> (jump
), dest
, 0))
5702 if (targetm
.have_simple_return () && simple_p
)
5706 "Failed to redirect bb %d branch.\n", bb
->index
);
5707 unconverted
.safe_push (e
);
5712 /* See comment in simplejump_p case above. */
5713 emit_use_return_register_into_block (bb
);
5715 /* If this block has only one successor, it both jumps
5716 and falls through to the fallthru block, so we can't
5718 if (single_succ_p (bb
))
5723 if (targetm
.have_simple_return () && simple_p
)
5727 "Failed to redirect bb %d branch.\n", bb
->index
);
5728 unconverted
.safe_push (e
);
5733 /* Fix up the CFG for the successful change we just made. */
5734 redirect_edge_succ (e
, EXIT_BLOCK_PTR_FOR_FN (cfun
));
5735 e
->flags
&= ~EDGE_CROSSING
;
5741 /* Emit a return insn for the exit fallthru block. */
5743 emit_return_for_exit (edge exit_fallthru_edge
, bool simple_p
)
5745 basic_block last_bb
= exit_fallthru_edge
->src
;
5747 if (JUMP_P (BB_END (last_bb
)))
5749 last_bb
= split_edge (exit_fallthru_edge
);
5750 exit_fallthru_edge
= single_succ_edge (last_bb
);
5752 emit_barrier_after (BB_END (last_bb
));
5753 emit_return_into_block (simple_p
, last_bb
);
5754 exit_fallthru_edge
->flags
&= ~EDGE_FALLTHRU
;
5759 /* Generate the prologue and epilogue RTL if the machine supports it. Thread
5760 this into place with notes indicating where the prologue ends and where
5761 the epilogue begins. Update the basic block information when possible.
5763 Notes on epilogue placement:
5764 There are several kinds of edges to the exit block:
5765 * a single fallthru edge from LAST_BB
5766 * possibly, edges from blocks containing sibcalls
5767 * possibly, fake edges from infinite loops
5769 The epilogue is always emitted on the fallthru edge from the last basic
5770 block in the function, LAST_BB, into the exit block.
5772 If LAST_BB is empty except for a label, it is the target of every
5773 other basic block in the function that ends in a return. If a
5774 target has a return or simple_return pattern (possibly with
5775 conditional variants), these basic blocks can be changed so that a
5776 return insn is emitted into them, and their target is adjusted to
5777 the real exit block.
5779 Notes on shrink wrapping: We implement a fairly conservative
5780 version of shrink-wrapping rather than the textbook one. We only
5781 generate a single prologue and a single epilogue. This is
5782 sufficient to catch a number of interesting cases involving early
5785 First, we identify the blocks that require the prologue to occur before
5786 them. These are the ones that modify a call-saved register, or reference
5787 any of the stack or frame pointer registers. To simplify things, we then
5788 mark everything reachable from these blocks as also requiring a prologue.
5789 This takes care of loops automatically, and avoids the need to examine
5790 whether MEMs reference the frame, since it is sufficient to check for
5791 occurrences of the stack or frame pointer.
5793 We then compute the set of blocks for which the need for a prologue
5794 is anticipatable (borrowing terminology from the shrink-wrapping
5795 description in Muchnick's book). These are the blocks which either
5796 require a prologue themselves, or those that have only successors
5797 where the prologue is anticipatable. The prologue needs to be
5798 inserted on all edges from BB1->BB2 where BB2 is in ANTIC and BB1
5799 is not. For the moment, we ensure that only one such edge exists.
5801 The epilogue is placed as described above, but we make a
5802 distinction between inserting return and simple_return patterns
5803 when modifying other blocks that end in a return. Blocks that end
5804 in a sibcall omit the sibcall_epilogue if the block is not in
5808 thread_prologue_and_epilogue_insns (void)
5811 vec
<edge
> unconverted_simple_returns
= vNULL
;
5812 bitmap_head bb_flags
;
5813 rtx_insn
*returnjump
;
5814 rtx_insn
*epilogue_end ATTRIBUTE_UNUSED
;
5815 rtx_insn
*prologue_seq ATTRIBUTE_UNUSED
, *split_prologue_seq ATTRIBUTE_UNUSED
;
5816 edge e
, entry_edge
, orig_entry_edge
, exit_fallthru_edge
;
5821 rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5824 epilogue_end
= NULL
;
5827 /* Can't deal with multiple successors of the entry block at the
5828 moment. Function should always have at least one entry
5830 gcc_assert (single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
5831 entry_edge
= single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5832 orig_entry_edge
= entry_edge
;
5834 split_prologue_seq
= NULL
;
5835 if (flag_split_stack
5836 && (lookup_attribute ("no_split_stack", DECL_ATTRIBUTES (cfun
->decl
))
5840 emit_insn (targetm
.gen_split_stack_prologue ());
5841 split_prologue_seq
= get_insns ();
5844 record_insns (split_prologue_seq
, NULL
, &prologue_insn_hash
);
5845 set_insn_locations (split_prologue_seq
, prologue_location
);
5848 prologue_seq
= NULL
;
5849 if (targetm
.have_prologue ())
5852 rtx_insn
*seq
= targetm
.gen_prologue ();
5855 /* Insert an explicit USE for the frame pointer
5856 if the profiling is on and the frame pointer is required. */
5857 if (crtl
->profile
&& frame_pointer_needed
)
5858 emit_use (hard_frame_pointer_rtx
);
5860 /* Retain a map of the prologue insns. */
5861 record_insns (seq
, NULL
, &prologue_insn_hash
);
5862 emit_note (NOTE_INSN_PROLOGUE_END
);
5864 /* Ensure that instructions are not moved into the prologue when
5865 profiling is on. The call to the profiling routine can be
5866 emitted within the live range of a call-clobbered register. */
5867 if (!targetm
.profile_before_prologue () && crtl
->profile
)
5868 emit_insn (gen_blockage ());
5870 prologue_seq
= get_insns ();
5872 set_insn_locations (prologue_seq
, prologue_location
);
5875 bitmap_initialize (&bb_flags
, &bitmap_default_obstack
);
5877 /* Try to perform a kind of shrink-wrapping, making sure the
5878 prologue/epilogue is emitted only around those parts of the
5879 function that require it. */
5881 try_shrink_wrapping (&entry_edge
, orig_entry_edge
, &bb_flags
, prologue_seq
);
5883 if (split_prologue_seq
!= NULL_RTX
)
5885 insert_insn_on_edge (split_prologue_seq
, orig_entry_edge
);
5888 if (prologue_seq
!= NULL_RTX
)
5890 insert_insn_on_edge (prologue_seq
, entry_edge
);
5894 /* If the exit block has no non-fake predecessors, we don't need
5896 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
5897 if ((e
->flags
& EDGE_FAKE
) == 0)
5902 rtl_profile_for_bb (EXIT_BLOCK_PTR_FOR_FN (cfun
));
5904 exit_fallthru_edge
= find_fallthru_edge (EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
);
5906 if (targetm
.have_simple_return () && entry_edge
!= orig_entry_edge
)
5908 = get_unconverted_simple_return (exit_fallthru_edge
, bb_flags
,
5909 &unconverted_simple_returns
,
5911 if (targetm
.have_return ())
5913 if (exit_fallthru_edge
== NULL
)
5918 basic_block last_bb
= exit_fallthru_edge
->src
;
5920 if (LABEL_P (BB_HEAD (last_bb
))
5921 && !active_insn_between (BB_HEAD (last_bb
), BB_END (last_bb
)))
5922 convert_jumps_to_returns (last_bb
, false, vNULL
);
5924 if (EDGE_COUNT (last_bb
->preds
) != 0
5925 && single_succ_p (last_bb
))
5927 last_bb
= emit_return_for_exit (exit_fallthru_edge
, false);
5928 epilogue_end
= returnjump
= BB_END (last_bb
);
5930 /* Emitting the return may add a basic block.
5931 Fix bb_flags for the added block. */
5932 if (targetm
.have_simple_return ()
5933 && last_bb
!= exit_fallthru_edge
->src
)
5934 bitmap_set_bit (&bb_flags
, last_bb
->index
);
5941 /* A small fib -- epilogue is not yet completed, but we wish to re-use
5942 this marker for the splits of EH_RETURN patterns, and nothing else
5943 uses the flag in the meantime. */
5944 epilogue_completed
= 1;
5946 #ifdef HAVE_eh_return
5947 /* Find non-fallthru edges that end with EH_RETURN instructions. On
5948 some targets, these get split to a special version of the epilogue
5949 code. In order to be able to properly annotate these with unwind
5950 info, try to split them now. If we get a valid split, drop an
5951 EPILOGUE_BEG note and mark the insns as epilogue insns. */
5952 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
5954 rtx_insn
*prev
, *last
, *trial
;
5956 if (e
->flags
& EDGE_FALLTHRU
)
5958 last
= BB_END (e
->src
);
5959 if (!eh_returnjump_p (last
))
5962 prev
= PREV_INSN (last
);
5963 trial
= try_split (PATTERN (last
), last
, 1);
5967 record_insns (NEXT_INSN (prev
), NEXT_INSN (trial
), &epilogue_insn_hash
);
5968 emit_note_after (NOTE_INSN_EPILOGUE_BEG
, prev
);
5972 /* If nothing falls through into the exit block, we don't need an
5975 if (exit_fallthru_edge
== NULL
)
5978 if (targetm
.have_epilogue ())
5981 epilogue_end
= emit_note (NOTE_INSN_EPILOGUE_BEG
);
5982 rtx_insn
*seq
= targetm
.gen_epilogue ();
5984 emit_jump_insn (seq
);
5986 /* Retain a map of the epilogue insns. */
5987 record_insns (seq
, NULL
, &epilogue_insn_hash
);
5988 set_insn_locations (seq
, epilogue_location
);
5991 returnjump
= get_last_insn ();
5994 insert_insn_on_edge (seq
, exit_fallthru_edge
);
5997 if (JUMP_P (returnjump
))
5998 set_return_jump_label (returnjump
);
6004 if (! next_active_insn (BB_END (exit_fallthru_edge
->src
)))
6006 /* We have a fall-through edge to the exit block, the source is not
6007 at the end of the function, and there will be an assembler epilogue
6008 at the end of the function.
6009 We can't use force_nonfallthru here, because that would try to
6010 use return. Inserting a jump 'by hand' is extremely messy, so
6011 we take advantage of cfg_layout_finalize using
6012 fixup_fallthru_exit_predecessor. */
6013 cfg_layout_initialize (0);
6014 FOR_EACH_BB_FN (cur_bb
, cfun
)
6015 if (cur_bb
->index
>= NUM_FIXED_BLOCKS
6016 && cur_bb
->next_bb
->index
>= NUM_FIXED_BLOCKS
)
6017 cur_bb
->aux
= cur_bb
->next_bb
;
6018 cfg_layout_finalize ();
6023 default_rtl_profile ();
6029 commit_edge_insertions ();
6031 /* Look for basic blocks within the prologue insns. */
6032 blocks
= sbitmap_alloc (last_basic_block_for_fn (cfun
));
6033 bitmap_clear (blocks
);
6034 bitmap_set_bit (blocks
, entry_edge
->dest
->index
);
6035 bitmap_set_bit (blocks
, orig_entry_edge
->dest
->index
);
6036 find_many_sub_basic_blocks (blocks
);
6037 sbitmap_free (blocks
);
6039 /* The epilogue insns we inserted may cause the exit edge to no longer
6041 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
6043 if (((e
->flags
& EDGE_FALLTHRU
) != 0)
6044 && returnjump_p (BB_END (e
->src
)))
6045 e
->flags
&= ~EDGE_FALLTHRU
;
6049 if (targetm
.have_simple_return ())
6050 convert_to_simple_return (entry_edge
, orig_entry_edge
, bb_flags
,
6051 returnjump
, unconverted_simple_returns
);
6053 /* Emit sibling epilogues before any sibling call sites. */
6054 for (ei
= ei_start (EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
); (e
=
6058 basic_block bb
= e
->src
;
6059 rtx_insn
*insn
= BB_END (bb
);
6062 || ! SIBLING_CALL_P (insn
)
6063 || (targetm
.have_simple_return ()
6064 && entry_edge
!= orig_entry_edge
6065 && !bitmap_bit_p (&bb_flags
, bb
->index
)))
6071 if (rtx_insn
*ep_seq
= targetm
.gen_sibcall_epilogue ())
6074 emit_note (NOTE_INSN_EPILOGUE_BEG
);
6076 rtx_insn
*seq
= get_insns ();
6079 /* Retain a map of the epilogue insns. Used in life analysis to
6080 avoid getting rid of sibcall epilogue insns. Do this before we
6081 actually emit the sequence. */
6082 record_insns (seq
, NULL
, &epilogue_insn_hash
);
6083 set_insn_locations (seq
, epilogue_location
);
6085 emit_insn_before (seq
, insn
);
6092 rtx_insn
*insn
, *next
;
6094 /* Similarly, move any line notes that appear after the epilogue.
6095 There is no need, however, to be quite so anal about the existence
6096 of such a note. Also possibly move
6097 NOTE_INSN_FUNCTION_BEG notes, as those can be relevant for debug
6099 for (insn
= epilogue_end
; insn
; insn
= next
)
6101 next
= NEXT_INSN (insn
);
6103 && (NOTE_KIND (insn
) == NOTE_INSN_FUNCTION_BEG
))
6104 reorder_insns (insn
, insn
, PREV_INSN (epilogue_end
));
6108 bitmap_clear (&bb_flags
);
6110 /* Threading the prologue and epilogue changes the artificial refs
6111 in the entry and exit blocks. */
6112 epilogue_completed
= 1;
6113 df_update_entry_exit_and_calls ();
6116 /* Reposition the prologue-end and epilogue-begin notes after
6117 instruction scheduling. */
6120 reposition_prologue_and_epilogue_notes (void)
6122 if (!targetm
.have_prologue ()
6123 && !targetm
.have_epilogue ()
6124 && !targetm
.have_sibcall_epilogue ())
6127 /* Since the hash table is created on demand, the fact that it is
6128 non-null is a signal that it is non-empty. */
6129 if (prologue_insn_hash
!= NULL
)
6131 size_t len
= prologue_insn_hash
->elements ();
6132 rtx_insn
*insn
, *last
= NULL
, *note
= NULL
;
6134 /* Scan from the beginning until we reach the last prologue insn. */
6135 /* ??? While we do have the CFG intact, there are two problems:
6136 (1) The prologue can contain loops (typically probing the stack),
6137 which means that the end of the prologue isn't in the first bb.
6138 (2) Sometimes the PROLOGUE_END note gets pushed into the next bb. */
6139 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
6143 if (NOTE_KIND (insn
) == NOTE_INSN_PROLOGUE_END
)
6146 else if (contains (insn
, prologue_insn_hash
))
6158 /* Scan forward looking for the PROLOGUE_END note. It should
6159 be right at the beginning of the block, possibly with other
6160 insn notes that got moved there. */
6161 for (note
= NEXT_INSN (last
); ; note
= NEXT_INSN (note
))
6164 && NOTE_KIND (note
) == NOTE_INSN_PROLOGUE_END
)
6169 /* Avoid placing note between CODE_LABEL and BASIC_BLOCK note. */
6171 last
= NEXT_INSN (last
);
6172 reorder_insns (note
, note
, last
);
6176 if (epilogue_insn_hash
!= NULL
)
6181 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
6183 rtx_insn
*insn
, *first
= NULL
, *note
= NULL
;
6184 basic_block bb
= e
->src
;
6186 /* Scan from the beginning until we reach the first epilogue insn. */
6187 FOR_BB_INSNS (bb
, insn
)
6191 if (NOTE_KIND (insn
) == NOTE_INSN_EPILOGUE_BEG
)
6198 else if (first
== NULL
&& contains (insn
, epilogue_insn_hash
))
6208 /* If the function has a single basic block, and no real
6209 epilogue insns (e.g. sibcall with no cleanup), the
6210 epilogue note can get scheduled before the prologue
6211 note. If we have frame related prologue insns, having
6212 them scanned during the epilogue will result in a crash.
6213 In this case re-order the epilogue note to just before
6214 the last insn in the block. */
6216 first
= BB_END (bb
);
6218 if (PREV_INSN (first
) != note
)
6219 reorder_insns (note
, note
, PREV_INSN (first
));
6225 /* Returns the name of function declared by FNDECL. */
6227 fndecl_name (tree fndecl
)
6231 return lang_hooks
.decl_printable_name (fndecl
, 2);
6234 /* Returns the name of function FN. */
6236 function_name (struct function
*fn
)
6238 tree fndecl
= (fn
== NULL
) ? NULL
: fn
->decl
;
6239 return fndecl_name (fndecl
);
6242 /* Returns the name of the current function. */
6244 current_function_name (void)
6246 return function_name (cfun
);
6251 rest_of_handle_check_leaf_regs (void)
6253 #ifdef LEAF_REGISTERS
6254 crtl
->uses_only_leaf_regs
6255 = optimize
> 0 && only_leaf_regs_used () && leaf_function_p ();
6260 /* Insert a TYPE into the used types hash table of CFUN. */
6263 used_types_insert_helper (tree type
, struct function
*func
)
6265 if (type
!= NULL
&& func
!= NULL
)
6267 if (func
->used_types_hash
== NULL
)
6268 func
->used_types_hash
= hash_set
<tree
>::create_ggc (37);
6270 func
->used_types_hash
->add (type
);
6274 /* Given a type, insert it into the used hash table in cfun. */
6276 used_types_insert (tree t
)
6278 while (POINTER_TYPE_P (t
) || TREE_CODE (t
) == ARRAY_TYPE
)
6283 if (TREE_CODE (t
) == ERROR_MARK
)
6285 if (TYPE_NAME (t
) == NULL_TREE
6286 || TYPE_NAME (t
) == TYPE_NAME (TYPE_MAIN_VARIANT (t
)))
6287 t
= TYPE_MAIN_VARIANT (t
);
6288 if (debug_info_level
> DINFO_LEVEL_NONE
)
6291 used_types_insert_helper (t
, cfun
);
6294 /* So this might be a type referenced by a global variable.
6295 Record that type so that we can later decide to emit its
6296 debug information. */
6297 vec_safe_push (types_used_by_cur_var_decl
, t
);
6302 /* Helper to Hash a struct types_used_by_vars_entry. */
6305 hash_types_used_by_vars_entry (const struct types_used_by_vars_entry
*entry
)
6307 gcc_assert (entry
&& entry
->var_decl
&& entry
->type
);
6309 return iterative_hash_object (entry
->type
,
6310 iterative_hash_object (entry
->var_decl
, 0));
6313 /* Hash function of the types_used_by_vars_entry hash table. */
6316 used_type_hasher::hash (types_used_by_vars_entry
*entry
)
6318 return hash_types_used_by_vars_entry (entry
);
6321 /*Equality function of the types_used_by_vars_entry hash table. */
6324 used_type_hasher::equal (types_used_by_vars_entry
*e1
,
6325 types_used_by_vars_entry
*e2
)
6327 return (e1
->var_decl
== e2
->var_decl
&& e1
->type
== e2
->type
);
6330 /* Inserts an entry into the types_used_by_vars_hash hash table. */
6333 types_used_by_var_decl_insert (tree type
, tree var_decl
)
6335 if (type
!= NULL
&& var_decl
!= NULL
)
6337 types_used_by_vars_entry
**slot
;
6338 struct types_used_by_vars_entry e
;
6339 e
.var_decl
= var_decl
;
6341 if (types_used_by_vars_hash
== NULL
)
6342 types_used_by_vars_hash
6343 = hash_table
<used_type_hasher
>::create_ggc (37);
6345 slot
= types_used_by_vars_hash
->find_slot (&e
, INSERT
);
6348 struct types_used_by_vars_entry
*entry
;
6349 entry
= ggc_alloc
<types_used_by_vars_entry
> ();
6351 entry
->var_decl
= var_decl
;
6359 const pass_data pass_data_leaf_regs
=
6361 RTL_PASS
, /* type */
6362 "*leaf_regs", /* name */
6363 OPTGROUP_NONE
, /* optinfo_flags */
6364 TV_NONE
, /* tv_id */
6365 0, /* properties_required */
6366 0, /* properties_provided */
6367 0, /* properties_destroyed */
6368 0, /* todo_flags_start */
6369 0, /* todo_flags_finish */
6372 class pass_leaf_regs
: public rtl_opt_pass
6375 pass_leaf_regs (gcc::context
*ctxt
)
6376 : rtl_opt_pass (pass_data_leaf_regs
, ctxt
)
6379 /* opt_pass methods: */
6380 virtual unsigned int execute (function
*)
6382 return rest_of_handle_check_leaf_regs ();
6385 }; // class pass_leaf_regs
6390 make_pass_leaf_regs (gcc::context
*ctxt
)
6392 return new pass_leaf_regs (ctxt
);
6396 rest_of_handle_thread_prologue_and_epilogue (void)
6399 cleanup_cfg (CLEANUP_EXPENSIVE
);
6401 /* On some machines, the prologue and epilogue code, or parts thereof,
6402 can be represented as RTL. Doing so lets us schedule insns between
6403 it and the rest of the code and also allows delayed branch
6404 scheduling to operate in the epilogue. */
6405 thread_prologue_and_epilogue_insns ();
6407 /* Shrink-wrapping can result in unreachable edges in the epilogue,
6411 /* The stack usage info is finalized during prologue expansion. */
6412 if (flag_stack_usage_info
)
6413 output_stack_usage ();
6420 const pass_data pass_data_thread_prologue_and_epilogue
=
6422 RTL_PASS
, /* type */
6423 "pro_and_epilogue", /* name */
6424 OPTGROUP_NONE
, /* optinfo_flags */
6425 TV_THREAD_PROLOGUE_AND_EPILOGUE
, /* tv_id */
6426 0, /* properties_required */
6427 0, /* properties_provided */
6428 0, /* properties_destroyed */
6429 0, /* todo_flags_start */
6430 ( TODO_df_verify
| TODO_df_finish
), /* todo_flags_finish */
6433 class pass_thread_prologue_and_epilogue
: public rtl_opt_pass
6436 pass_thread_prologue_and_epilogue (gcc::context
*ctxt
)
6437 : rtl_opt_pass (pass_data_thread_prologue_and_epilogue
, ctxt
)
6440 /* opt_pass methods: */
6441 virtual unsigned int execute (function
*)
6443 return rest_of_handle_thread_prologue_and_epilogue ();
6446 }; // class pass_thread_prologue_and_epilogue
6451 make_pass_thread_prologue_and_epilogue (gcc::context
*ctxt
)
6453 return new pass_thread_prologue_and_epilogue (ctxt
);
6457 /* This mini-pass fixes fall-out from SSA in asm statements that have
6458 in-out constraints. Say you start with
6461 asm ("": "+mr" (inout));
6464 which is transformed very early to use explicit output and match operands:
6467 asm ("": "=mr" (inout) : "0" (inout));
6470 Or, after SSA and copyprop,
6472 asm ("": "=mr" (inout_2) : "0" (inout_1));
6475 Clearly inout_2 and inout_1 can't be coalesced easily anymore, as
6476 they represent two separate values, so they will get different pseudo
6477 registers during expansion. Then, since the two operands need to match
6478 per the constraints, but use different pseudo registers, reload can
6479 only register a reload for these operands. But reloads can only be
6480 satisfied by hardregs, not by memory, so we need a register for this
6481 reload, just because we are presented with non-matching operands.
6482 So, even though we allow memory for this operand, no memory can be
6483 used for it, just because the two operands don't match. This can
6484 cause reload failures on register-starved targets.
6486 So it's a symptom of reload not being able to use memory for reloads
6487 or, alternatively it's also a symptom of both operands not coming into
6488 reload as matching (in which case the pseudo could go to memory just
6489 fine, as the alternative allows it, and no reload would be necessary).
6490 We fix the latter problem here, by transforming
6492 asm ("": "=mr" (inout_2) : "0" (inout_1));
6497 asm ("": "=mr" (inout_2) : "0" (inout_2)); */
6500 match_asm_constraints_1 (rtx_insn
*insn
, rtx
*p_sets
, int noutputs
)
6503 bool changed
= false;
6504 rtx op
= SET_SRC (p_sets
[0]);
6505 int ninputs
= ASM_OPERANDS_INPUT_LENGTH (op
);
6506 rtvec inputs
= ASM_OPERANDS_INPUT_VEC (op
);
6507 bool *output_matched
= XALLOCAVEC (bool, noutputs
);
6509 memset (output_matched
, 0, noutputs
* sizeof (bool));
6510 for (i
= 0; i
< ninputs
; i
++)
6514 const char *constraint
= ASM_OPERANDS_INPUT_CONSTRAINT (op
, i
);
6518 if (*constraint
== '%')
6521 match
= strtoul (constraint
, &end
, 10);
6522 if (end
== constraint
)
6525 gcc_assert (match
< noutputs
);
6526 output
= SET_DEST (p_sets
[match
]);
6527 input
= RTVEC_ELT (inputs
, i
);
6528 /* Only do the transformation for pseudos. */
6529 if (! REG_P (output
)
6530 || rtx_equal_p (output
, input
)
6531 || (GET_MODE (input
) != VOIDmode
6532 && GET_MODE (input
) != GET_MODE (output
)))
6535 /* We can't do anything if the output is also used as input,
6536 as we're going to overwrite it. */
6537 for (j
= 0; j
< ninputs
; j
++)
6538 if (reg_overlap_mentioned_p (output
, RTVEC_ELT (inputs
, j
)))
6543 /* Avoid changing the same input several times. For
6544 asm ("" : "=mr" (out1), "=mr" (out2) : "0" (in), "1" (in));
6545 only change in once (to out1), rather than changing it
6546 first to out1 and afterwards to out2. */
6549 for (j
= 0; j
< noutputs
; j
++)
6550 if (output_matched
[j
] && input
== SET_DEST (p_sets
[j
]))
6555 output_matched
[match
] = true;
6558 emit_move_insn (output
, input
);
6559 insns
= get_insns ();
6561 emit_insn_before (insns
, insn
);
6563 /* Now replace all mentions of the input with output. We can't
6564 just replace the occurrence in inputs[i], as the register might
6565 also be used in some other input (or even in an address of an
6566 output), which would mean possibly increasing the number of
6567 inputs by one (namely 'output' in addition), which might pose
6568 a too complicated problem for reload to solve. E.g. this situation:
6570 asm ("" : "=r" (output), "=m" (input) : "0" (input))
6572 Here 'input' is used in two occurrences as input (once for the
6573 input operand, once for the address in the second output operand).
6574 If we would replace only the occurrence of the input operand (to
6575 make the matching) we would be left with this:
6578 asm ("" : "=r" (output), "=m" (input) : "0" (output))
6580 Now we suddenly have two different input values (containing the same
6581 value, but different pseudos) where we formerly had only one.
6582 With more complicated asms this might lead to reload failures
6583 which wouldn't have happen without this pass. So, iterate over
6584 all operands and replace all occurrences of the register used. */
6585 for (j
= 0; j
< noutputs
; j
++)
6586 if (!rtx_equal_p (SET_DEST (p_sets
[j
]), input
)
6587 && reg_overlap_mentioned_p (input
, SET_DEST (p_sets
[j
])))
6588 SET_DEST (p_sets
[j
]) = replace_rtx (SET_DEST (p_sets
[j
]),
6590 for (j
= 0; j
< ninputs
; j
++)
6591 if (reg_overlap_mentioned_p (input
, RTVEC_ELT (inputs
, j
)))
6592 RTVEC_ELT (inputs
, j
) = replace_rtx (RTVEC_ELT (inputs
, j
),
6599 df_insn_rescan (insn
);
6602 /* Add the decl D to the local_decls list of FUN. */
6605 add_local_decl (struct function
*fun
, tree d
)
6607 gcc_assert (TREE_CODE (d
) == VAR_DECL
);
6608 vec_safe_push (fun
->local_decls
, d
);
6613 const pass_data pass_data_match_asm_constraints
=
6615 RTL_PASS
, /* type */
6616 "asmcons", /* name */
6617 OPTGROUP_NONE
, /* optinfo_flags */
6618 TV_NONE
, /* tv_id */
6619 0, /* properties_required */
6620 0, /* properties_provided */
6621 0, /* properties_destroyed */
6622 0, /* todo_flags_start */
6623 0, /* todo_flags_finish */
6626 class pass_match_asm_constraints
: public rtl_opt_pass
6629 pass_match_asm_constraints (gcc::context
*ctxt
)
6630 : rtl_opt_pass (pass_data_match_asm_constraints
, ctxt
)
6633 /* opt_pass methods: */
6634 virtual unsigned int execute (function
*);
6636 }; // class pass_match_asm_constraints
6639 pass_match_asm_constraints::execute (function
*fun
)
6646 if (!crtl
->has_asm_statement
)
6649 df_set_flags (DF_DEFER_INSN_RESCAN
);
6650 FOR_EACH_BB_FN (bb
, fun
)
6652 FOR_BB_INSNS (bb
, insn
)
6657 pat
= PATTERN (insn
);
6658 if (GET_CODE (pat
) == PARALLEL
)
6659 p_sets
= &XVECEXP (pat
, 0, 0), noutputs
= XVECLEN (pat
, 0);
6660 else if (GET_CODE (pat
) == SET
)
6661 p_sets
= &PATTERN (insn
), noutputs
= 1;
6665 if (GET_CODE (*p_sets
) == SET
6666 && GET_CODE (SET_SRC (*p_sets
)) == ASM_OPERANDS
)
6667 match_asm_constraints_1 (insn
, p_sets
, noutputs
);
6671 return TODO_df_finish
;
6677 make_pass_match_asm_constraints (gcc::context
*ctxt
)
6679 return new pass_match_asm_constraints (ctxt
);
6683 #include "gt-function.h"