1 /* Expands front end tree to back end RTL for GNU C-Compiler
2 Copyright (C) 1987, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* This file handles the generation of rtl code from tree structure
24 at the level of the function as a whole.
25 It creates the rtl expressions for parameters and auto variables
26 and has full responsibility for allocating stack slots.
28 `expand_function_start' is called at the beginning of a function,
29 before the function body is parsed, and `expand_function_end' is
30 called after parsing the body.
32 Call `assign_stack_local' to allocate a stack slot for a local variable.
33 This is usually done during the RTL generation for the function body,
34 but it can also be done in the reload pass when a pseudo-register does
35 not get a hard register.
37 Call `put_var_into_stack' when you learn, belatedly, that a variable
38 previously given a pseudo-register must in fact go in the stack.
39 This function changes the DECL_RTL to be a stack slot instead of a reg
40 then scans all the RTL instructions so far generated to correct them. */
49 #include "insn-flags.h"
51 #include "insn-codes.h"
53 #include "hard-reg-set.h"
54 #include "insn-config.h"
57 #include "basic-block.h"
64 #ifndef ACCUMULATE_OUTGOING_ARGS
65 #define ACCUMULATE_OUTGOING_ARGS 0
68 #ifndef TRAMPOLINE_ALIGNMENT
69 #define TRAMPOLINE_ALIGNMENT FUNCTION_BOUNDARY
72 #ifndef LOCAL_ALIGNMENT
73 #define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT
76 #if !defined (PREFERRED_STACK_BOUNDARY) && defined (STACK_BOUNDARY)
77 #define PREFERRED_STACK_BOUNDARY STACK_BOUNDARY
80 /* Some systems use __main in a way incompatible with its use in gcc, in these
81 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
82 give the same symbol without quotes for an alternative entry point. You
83 must define both, or neither. */
85 #define NAME__MAIN "__main"
86 #define SYMBOL__MAIN __main
89 /* Round a value to the lowest integer less than it that is a multiple of
90 the required alignment. Avoid using division in case the value is
91 negative. Assume the alignment is a power of two. */
92 #define FLOOR_ROUND(VALUE,ALIGN) ((VALUE) & ~((ALIGN) - 1))
94 /* Similar, but round to the next highest integer that meets the
96 #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
98 /* NEED_SEPARATE_AP means that we cannot derive ap from the value of fp
99 during rtl generation. If they are different register numbers, this is
100 always true. It may also be true if
101 FIRST_PARM_OFFSET - STARTING_FRAME_OFFSET is not a constant during rtl
102 generation. See fix_lexical_addr for details. */
104 #if ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM
105 #define NEED_SEPARATE_AP
108 /* Nonzero if function being compiled doesn't contain any calls
109 (ignoring the prologue and epilogue). This is set prior to
110 local register allocation and is valid for the remaining
112 int current_function_is_leaf
;
114 /* Nonzero if function being compiled doesn't contain any instructions
115 that can throw an exception. This is set prior to final. */
117 int current_function_nothrow
;
119 /* Nonzero if function being compiled doesn't modify the stack pointer
120 (ignoring the prologue and epilogue). This is only valid after
121 life_analysis has run. */
122 int current_function_sp_is_unchanging
;
124 /* Nonzero if the function being compiled is a leaf function which only
125 uses leaf registers. This is valid after reload (specifically after
126 sched2) and is useful only if the port defines LEAF_REGISTERS. */
127 int current_function_uses_only_leaf_regs
;
129 /* Nonzero once virtual register instantiation has been done.
130 assign_stack_local uses frame_pointer_rtx when this is nonzero. */
131 static int virtuals_instantiated
;
133 /* These variables hold pointers to functions to
134 save and restore machine-specific data,
135 in push_function_context and pop_function_context. */
136 void (*init_machine_status
) PARAMS ((struct function
*));
137 void (*save_machine_status
) PARAMS ((struct function
*));
138 void (*restore_machine_status
) PARAMS ((struct function
*));
139 void (*mark_machine_status
) PARAMS ((struct function
*));
140 void (*free_machine_status
) PARAMS ((struct function
*));
142 /* Likewise, but for language-specific data. */
143 void (*init_lang_status
) PARAMS ((struct function
*));
144 void (*save_lang_status
) PARAMS ((struct function
*));
145 void (*restore_lang_status
) PARAMS ((struct function
*));
146 void (*mark_lang_status
) PARAMS ((struct function
*));
147 void (*free_lang_status
) PARAMS ((struct function
*));
149 /* The FUNCTION_DECL for an inline function currently being expanded. */
150 tree inline_function_decl
;
152 /* The currently compiled function. */
153 struct function
*cfun
= 0;
155 /* Global list of all compiled functions. */
156 struct function
*all_functions
= 0;
158 /* These arrays record the INSN_UIDs of the prologue and epilogue insns. */
159 static varray_type prologue
;
160 static varray_type epilogue
;
162 /* Array of INSN_UIDs to hold the INSN_UIDs for each sibcall epilogue
164 static varray_type sibcall_epilogue
;
166 /* In order to evaluate some expressions, such as function calls returning
167 structures in memory, we need to temporarily allocate stack locations.
168 We record each allocated temporary in the following structure.
170 Associated with each temporary slot is a nesting level. When we pop up
171 one level, all temporaries associated with the previous level are freed.
172 Normally, all temporaries are freed after the execution of the statement
173 in which they were created. However, if we are inside a ({...}) grouping,
174 the result may be in a temporary and hence must be preserved. If the
175 result could be in a temporary, we preserve it if we can determine which
176 one it is in. If we cannot determine which temporary may contain the
177 result, all temporaries are preserved. A temporary is preserved by
178 pretending it was allocated at the previous nesting level.
180 Automatic variables are also assigned temporary slots, at the nesting
181 level where they are defined. They are marked a "kept" so that
182 free_temp_slots will not free them. */
186 /* Points to next temporary slot. */
187 struct temp_slot
*next
;
188 /* The rtx to used to reference the slot. */
190 /* The rtx used to represent the address if not the address of the
191 slot above. May be an EXPR_LIST if multiple addresses exist. */
193 /* The alignment (in bits) of the slot. */
195 /* The size, in units, of the slot. */
197 /* The alias set for the slot. If the alias set is zero, we don't
198 know anything about the alias set of the slot. We must only
199 reuse a slot if it is assigned an object of the same alias set.
200 Otherwise, the rest of the compiler may assume that the new use
201 of the slot cannot alias the old use of the slot, which is
202 false. If the slot has alias set zero, then we can't reuse the
203 slot at all, since we have no idea what alias set may have been
204 imposed on the memory. For example, if the stack slot is the
205 call frame for an inline functioned, we have no idea what alias
206 sets will be assigned to various pieces of the call frame. */
207 HOST_WIDE_INT alias_set
;
208 /* The value of `sequence_rtl_expr' when this temporary is allocated. */
210 /* Non-zero if this temporary is currently in use. */
212 /* Non-zero if this temporary has its address taken. */
214 /* Nesting level at which this slot is being used. */
216 /* Non-zero if this should survive a call to free_temp_slots. */
218 /* The offset of the slot from the frame_pointer, including extra space
219 for alignment. This info is for combine_temp_slots. */
220 HOST_WIDE_INT base_offset
;
221 /* The size of the slot, including extra space for alignment. This
222 info is for combine_temp_slots. */
223 HOST_WIDE_INT full_size
;
226 /* This structure is used to record MEMs or pseudos used to replace VAR, any
227 SUBREGs of VAR, and any MEMs containing VAR as an address. We need to
228 maintain this list in case two operands of an insn were required to match;
229 in that case we must ensure we use the same replacement. */
231 struct fixup_replacement
235 struct fixup_replacement
*next
;
238 struct insns_for_mem_entry
{
239 /* The KEY in HE will be a MEM. */
240 struct hash_entry he
;
241 /* These are the INSNS which reference the MEM. */
245 /* Forward declarations. */
247 static rtx assign_stack_local_1
PARAMS ((enum machine_mode
, HOST_WIDE_INT
,
248 int, struct function
*));
249 static rtx assign_stack_temp_for_type
PARAMS ((enum machine_mode
,
250 HOST_WIDE_INT
, int, tree
));
251 static struct temp_slot
*find_temp_slot_from_address
PARAMS ((rtx
));
252 static void put_reg_into_stack
PARAMS ((struct function
*, rtx
, tree
,
253 enum machine_mode
, enum machine_mode
,
254 int, unsigned int, int,
255 struct hash_table
*));
256 static void fixup_var_refs
PARAMS ((rtx
, enum machine_mode
, int,
257 struct hash_table
*));
258 static struct fixup_replacement
259 *find_fixup_replacement
PARAMS ((struct fixup_replacement
**, rtx
));
260 static void fixup_var_refs_insns
PARAMS ((rtx
, enum machine_mode
, int,
261 rtx
, int, struct hash_table
*));
262 static void fixup_var_refs_1
PARAMS ((rtx
, enum machine_mode
, rtx
*, rtx
,
263 struct fixup_replacement
**));
264 static rtx fixup_memory_subreg
PARAMS ((rtx
, rtx
, int));
265 static rtx walk_fixup_memory_subreg
PARAMS ((rtx
, rtx
, int));
266 static rtx fixup_stack_1
PARAMS ((rtx
, rtx
));
267 static void optimize_bit_field
PARAMS ((rtx
, rtx
, rtx
*));
268 static void instantiate_decls
PARAMS ((tree
, int));
269 static void instantiate_decls_1
PARAMS ((tree
, int));
270 static void instantiate_decl
PARAMS ((rtx
, HOST_WIDE_INT
, int));
271 static int instantiate_virtual_regs_1
PARAMS ((rtx
*, rtx
, int));
272 static void delete_handlers
PARAMS ((void));
273 static void pad_to_arg_alignment
PARAMS ((struct args_size
*, int,
274 struct args_size
*));
275 #ifndef ARGS_GROW_DOWNWARD
276 static void pad_below
PARAMS ((struct args_size
*, enum machine_mode
,
279 static rtx round_trampoline_addr
PARAMS ((rtx
));
280 static tree
*identify_blocks_1
PARAMS ((rtx
, tree
*, tree
*, tree
*));
281 static void reorder_blocks_1
PARAMS ((rtx
, tree
, varray_type
*));
282 static tree blocks_nreverse
PARAMS ((tree
));
283 static int all_blocks
PARAMS ((tree
, tree
*));
284 static tree
*get_block_vector
PARAMS ((tree
, int *));
285 /* We always define `record_insns' even if its not used so that we
286 can always export `prologue_epilogue_contains'. */
287 static void record_insns
PARAMS ((rtx
, varray_type
*)) ATTRIBUTE_UNUSED
;
288 static int contains
PARAMS ((rtx
, varray_type
));
290 static void emit_return_into_block
PARAMS ((basic_block
, rtx
));
292 static void put_addressof_into_stack
PARAMS ((rtx
, struct hash_table
*));
293 static boolean purge_addressof_1
PARAMS ((rtx
*, rtx
, int, int,
294 struct hash_table
*));
295 static int is_addressof
PARAMS ((rtx
*, void *));
296 static struct hash_entry
*insns_for_mem_newfunc
PARAMS ((struct hash_entry
*,
299 static unsigned long insns_for_mem_hash
PARAMS ((hash_table_key
));
300 static boolean insns_for_mem_comp
PARAMS ((hash_table_key
, hash_table_key
));
301 static int insns_for_mem_walk
PARAMS ((rtx
*, void *));
302 static void compute_insns_for_mem
PARAMS ((rtx
, rtx
, struct hash_table
*));
303 static void mark_temp_slot
PARAMS ((struct temp_slot
*));
304 static void mark_function_status
PARAMS ((struct function
*));
305 static void mark_function_chain
PARAMS ((void *));
306 static void prepare_function_start
PARAMS ((void));
307 static void do_clobber_return_reg
PARAMS ((rtx
, void *));
308 static void do_use_return_reg
PARAMS ((rtx
, void *));
310 /* Pointer to chain of `struct function' for containing functions. */
311 struct function
*outer_function_chain
;
313 /* Given a function decl for a containing function,
314 return the `struct function' for it. */
317 find_function_data (decl
)
322 for (p
= outer_function_chain
; p
; p
= p
->next
)
329 /* Save the current context for compilation of a nested function.
330 This is called from language-specific code. The caller should use
331 the save_lang_status callback to save any language-specific state,
332 since this function knows only about language-independent
336 push_function_context_to (context
)
339 struct function
*p
, *context_data
;
343 context_data
= (context
== current_function_decl
345 : find_function_data (context
));
346 context_data
->contains_functions
= 1;
350 init_dummy_function_start ();
353 p
->next
= outer_function_chain
;
354 outer_function_chain
= p
;
355 p
->fixup_var_refs_queue
= 0;
357 save_tree_status (p
);
358 if (save_lang_status
)
359 (*save_lang_status
) (p
);
360 if (save_machine_status
)
361 (*save_machine_status
) (p
);
367 push_function_context ()
369 push_function_context_to (current_function_decl
);
372 /* Restore the last saved context, at the end of a nested function.
373 This function is called from language-specific code. */
376 pop_function_context_from (context
)
377 tree context ATTRIBUTE_UNUSED
;
379 struct function
*p
= outer_function_chain
;
380 struct var_refs_queue
*queue
;
381 struct var_refs_queue
*next
;
384 outer_function_chain
= p
->next
;
386 current_function_decl
= p
->decl
;
389 restore_tree_status (p
);
390 restore_emit_status (p
);
392 if (restore_machine_status
)
393 (*restore_machine_status
) (p
);
394 if (restore_lang_status
)
395 (*restore_lang_status
) (p
);
397 /* Finish doing put_var_into_stack for any of our variables
398 which became addressable during the nested function. */
399 for (queue
= p
->fixup_var_refs_queue
; queue
; queue
= next
)
402 fixup_var_refs (queue
->modified
, queue
->promoted_mode
,
403 queue
->unsignedp
, 0);
406 p
->fixup_var_refs_queue
= 0;
408 /* Reset variables that have known state during rtx generation. */
409 rtx_equal_function_value_matters
= 1;
410 virtuals_instantiated
= 0;
414 pop_function_context ()
416 pop_function_context_from (current_function_decl
);
419 /* Clear out all parts of the state in F that can safely be discarded
420 after the function has been parsed, but not compiled, to let
421 garbage collection reclaim the memory. */
424 free_after_parsing (f
)
427 /* f->expr->forced_labels is used by code generation. */
428 /* f->emit->regno_reg_rtx is used by code generation. */
429 /* f->varasm is used by code generation. */
430 /* f->eh->eh_return_stub_label is used by code generation. */
432 if (free_lang_status
)
433 (*free_lang_status
) (f
);
434 free_stmt_status (f
);
437 /* Clear out all parts of the state in F that can safely be discarded
438 after the function has been compiled, to let garbage collection
439 reclaim the memory. */
442 free_after_compilation (f
)
445 struct temp_slot
*ts
;
446 struct temp_slot
*next
;
449 free_expr_status (f
);
450 free_emit_status (f
);
451 free_varasm_status (f
);
453 if (free_machine_status
)
454 (*free_machine_status
) (f
);
456 if (f
->x_parm_reg_stack_loc
)
457 free (f
->x_parm_reg_stack_loc
);
459 for (ts
= f
->x_temp_slots
; ts
; ts
= next
)
464 f
->x_temp_slots
= NULL
;
466 f
->arg_offset_rtx
= NULL
;
467 f
->return_rtx
= NULL
;
468 f
->internal_arg_pointer
= NULL
;
469 f
->x_nonlocal_labels
= NULL
;
470 f
->x_nonlocal_goto_handler_slots
= NULL
;
471 f
->x_nonlocal_goto_handler_labels
= NULL
;
472 f
->x_nonlocal_goto_stack_level
= NULL
;
473 f
->x_cleanup_label
= NULL
;
474 f
->x_return_label
= NULL
;
475 f
->x_save_expr_regs
= NULL
;
476 f
->x_stack_slot_list
= NULL
;
477 f
->x_rtl_expr_chain
= NULL
;
478 f
->x_tail_recursion_label
= NULL
;
479 f
->x_tail_recursion_reentry
= NULL
;
480 f
->x_arg_pointer_save_area
= NULL
;
481 f
->x_context_display
= NULL
;
482 f
->x_trampoline_list
= NULL
;
483 f
->x_parm_birth_insn
= NULL
;
484 f
->x_last_parm_insn
= NULL
;
485 f
->x_parm_reg_stack_loc
= NULL
;
486 f
->fixup_var_refs_queue
= NULL
;
487 f
->original_arg_vector
= NULL
;
488 f
->original_decl_initial
= NULL
;
489 f
->inl_last_parm_insn
= NULL
;
490 f
->epilogue_delay_list
= NULL
;
494 /* Allocate fixed slots in the stack frame of the current function. */
496 /* Return size needed for stack frame based on slots so far allocated in
498 This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY;
499 the caller may have to do that. */
502 get_func_frame_size (f
)
505 #ifdef FRAME_GROWS_DOWNWARD
506 return -f
->x_frame_offset
;
508 return f
->x_frame_offset
;
512 /* Return size needed for stack frame based on slots so far allocated.
513 This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY;
514 the caller may have to do that. */
518 return get_func_frame_size (cfun
);
521 /* Allocate a stack slot of SIZE bytes and return a MEM rtx for it
522 with machine mode MODE.
524 ALIGN controls the amount of alignment for the address of the slot:
525 0 means according to MODE,
526 -1 means use BIGGEST_ALIGNMENT and round size to multiple of that,
527 positive specifies alignment boundary in bits.
529 We do not round to stack_boundary here.
531 FUNCTION specifies the function to allocate in. */
534 assign_stack_local_1 (mode
, size
, align
, function
)
535 enum machine_mode mode
;
538 struct function
*function
;
540 register rtx x
, addr
;
541 int bigend_correction
= 0;
544 /* Allocate in the memory associated with the function in whose frame
546 if (function
!= cfun
)
547 push_obstacks (function
->function_obstack
,
548 function
->function_maybepermanent_obstack
);
555 alignment
= BIGGEST_ALIGNMENT
;
557 alignment
= GET_MODE_ALIGNMENT (mode
);
559 /* Allow the target to (possibly) increase the alignment of this
561 type
= type_for_mode (mode
, 0);
563 alignment
= LOCAL_ALIGNMENT (type
, alignment
);
565 alignment
/= BITS_PER_UNIT
;
567 else if (align
== -1)
569 alignment
= BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
;
570 size
= CEIL_ROUND (size
, alignment
);
573 alignment
= align
/ BITS_PER_UNIT
;
575 #ifdef FRAME_GROWS_DOWNWARD
576 function
->x_frame_offset
-= size
;
579 /* Ignore alignment we can't do with expected alignment of the boundary. */
580 if (alignment
* BITS_PER_UNIT
> PREFERRED_STACK_BOUNDARY
)
581 alignment
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
583 if (function
->stack_alignment_needed
< alignment
* BITS_PER_UNIT
)
584 function
->stack_alignment_needed
= alignment
* BITS_PER_UNIT
;
586 /* Round frame offset to that alignment.
587 We must be careful here, since FRAME_OFFSET might be negative and
588 division with a negative dividend isn't as well defined as we might
589 like. So we instead assume that ALIGNMENT is a power of two and
590 use logical operations which are unambiguous. */
591 #ifdef FRAME_GROWS_DOWNWARD
592 function
->x_frame_offset
= FLOOR_ROUND (function
->x_frame_offset
, alignment
);
594 function
->x_frame_offset
= CEIL_ROUND (function
->x_frame_offset
, alignment
);
597 /* On a big-endian machine, if we are allocating more space than we will use,
598 use the least significant bytes of those that are allocated. */
599 if (BYTES_BIG_ENDIAN
&& mode
!= BLKmode
)
600 bigend_correction
= size
- GET_MODE_SIZE (mode
);
602 /* If we have already instantiated virtual registers, return the actual
603 address relative to the frame pointer. */
604 if (function
== cfun
&& virtuals_instantiated
)
605 addr
= plus_constant (frame_pointer_rtx
,
606 (frame_offset
+ bigend_correction
607 + STARTING_FRAME_OFFSET
));
609 addr
= plus_constant (virtual_stack_vars_rtx
,
610 function
->x_frame_offset
+ bigend_correction
);
612 #ifndef FRAME_GROWS_DOWNWARD
613 function
->x_frame_offset
+= size
;
616 x
= gen_rtx_MEM (mode
, addr
);
618 function
->x_stack_slot_list
619 = gen_rtx_EXPR_LIST (VOIDmode
, x
, function
->x_stack_slot_list
);
621 if (function
!= cfun
)
627 /* Wrapper around assign_stack_local_1; assign a local stack slot for the
631 assign_stack_local (mode
, size
, align
)
632 enum machine_mode mode
;
636 return assign_stack_local_1 (mode
, size
, align
, cfun
);
639 /* Allocate a temporary stack slot and record it for possible later
642 MODE is the machine mode to be given to the returned rtx.
644 SIZE is the size in units of the space required. We do no rounding here
645 since assign_stack_local will do any required rounding.
647 KEEP is 1 if this slot is to be retained after a call to
648 free_temp_slots. Automatic variables for a block are allocated
649 with this flag. KEEP is 2 if we allocate a longer term temporary,
650 whose lifetime is controlled by CLEANUP_POINT_EXPRs. KEEP is 3
651 if we are to allocate something at an inner level to be treated as
652 a variable in the block (e.g., a SAVE_EXPR).
654 TYPE is the type that will be used for the stack slot. */
657 assign_stack_temp_for_type (mode
, size
, keep
, type
)
658 enum machine_mode mode
;
664 HOST_WIDE_INT alias_set
;
665 struct temp_slot
*p
, *best_p
= 0;
667 /* If SIZE is -1 it means that somebody tried to allocate a temporary
668 of a variable size. */
672 /* If we know the alias set for the memory that will be used, use
673 it. If there's no TYPE, then we don't know anything about the
674 alias set for the memory. */
676 alias_set
= get_alias_set (type
);
681 align
= BIGGEST_ALIGNMENT
;
683 align
= GET_MODE_ALIGNMENT (mode
);
686 type
= type_for_mode (mode
, 0);
689 align
= LOCAL_ALIGNMENT (type
, align
);
691 /* Try to find an available, already-allocated temporary of the proper
692 mode which meets the size and alignment requirements. Choose the
693 smallest one with the closest alignment. */
694 for (p
= temp_slots
; p
; p
= p
->next
)
695 if (p
->align
>= align
&& p
->size
>= size
&& GET_MODE (p
->slot
) == mode
697 && (! flag_strict_aliasing
698 || (alias_set
&& p
->alias_set
== alias_set
))
699 && (best_p
== 0 || best_p
->size
> p
->size
700 || (best_p
->size
== p
->size
&& best_p
->align
> p
->align
)))
702 if (p
->align
== align
&& p
->size
== size
)
710 /* Make our best, if any, the one to use. */
713 /* If there are enough aligned bytes left over, make them into a new
714 temp_slot so that the extra bytes don't get wasted. Do this only
715 for BLKmode slots, so that we can be sure of the alignment. */
716 if (GET_MODE (best_p
->slot
) == BLKmode
)
718 int alignment
= best_p
->align
/ BITS_PER_UNIT
;
719 HOST_WIDE_INT rounded_size
= CEIL_ROUND (size
, alignment
);
721 if (best_p
->size
- rounded_size
>= alignment
)
723 p
= (struct temp_slot
*) xmalloc (sizeof (struct temp_slot
));
724 p
->in_use
= p
->addr_taken
= 0;
725 p
->size
= best_p
->size
- rounded_size
;
726 p
->base_offset
= best_p
->base_offset
+ rounded_size
;
727 p
->full_size
= best_p
->full_size
- rounded_size
;
728 p
->slot
= gen_rtx_MEM (BLKmode
,
729 plus_constant (XEXP (best_p
->slot
, 0),
731 p
->align
= best_p
->align
;
734 p
->alias_set
= best_p
->alias_set
;
735 p
->next
= temp_slots
;
738 stack_slot_list
= gen_rtx_EXPR_LIST (VOIDmode
, p
->slot
,
741 best_p
->size
= rounded_size
;
742 best_p
->full_size
= rounded_size
;
749 /* If we still didn't find one, make a new temporary. */
752 HOST_WIDE_INT frame_offset_old
= frame_offset
;
754 p
= (struct temp_slot
*) xmalloc (sizeof (struct temp_slot
));
756 /* We are passing an explicit alignment request to assign_stack_local.
757 One side effect of that is assign_stack_local will not round SIZE
758 to ensure the frame offset remains suitably aligned.
760 So for requests which depended on the rounding of SIZE, we go ahead
761 and round it now. We also make sure ALIGNMENT is at least
762 BIGGEST_ALIGNMENT. */
763 if (mode
== BLKmode
&& align
< BIGGEST_ALIGNMENT
)
765 p
->slot
= assign_stack_local (mode
,
767 ? CEIL_ROUND (size
, align
/ BITS_PER_UNIT
)
772 p
->alias_set
= alias_set
;
774 /* The following slot size computation is necessary because we don't
775 know the actual size of the temporary slot until assign_stack_local
776 has performed all the frame alignment and size rounding for the
777 requested temporary. Note that extra space added for alignment
778 can be either above or below this stack slot depending on which
779 way the frame grows. We include the extra space if and only if it
780 is above this slot. */
781 #ifdef FRAME_GROWS_DOWNWARD
782 p
->size
= frame_offset_old
- frame_offset
;
787 /* Now define the fields used by combine_temp_slots. */
788 #ifdef FRAME_GROWS_DOWNWARD
789 p
->base_offset
= frame_offset
;
790 p
->full_size
= frame_offset_old
- frame_offset
;
792 p
->base_offset
= frame_offset_old
;
793 p
->full_size
= frame_offset
- frame_offset_old
;
796 p
->next
= temp_slots
;
802 p
->rtl_expr
= seq_rtl_expr
;
806 p
->level
= target_temp_slot_level
;
811 p
->level
= var_temp_slot_level
;
816 p
->level
= temp_slot_level
;
820 /* We may be reusing an old slot, so clear any MEM flags that may have been
822 RTX_UNCHANGING_P (p
->slot
) = 0;
823 MEM_IN_STRUCT_P (p
->slot
) = 0;
824 MEM_SCALAR_P (p
->slot
) = 0;
825 MEM_ALIAS_SET (p
->slot
) = alias_set
;
828 MEM_SET_IN_STRUCT_P (p
->slot
, AGGREGATE_TYPE_P (type
));
833 /* Allocate a temporary stack slot and record it for possible later
834 reuse. First three arguments are same as in preceding function. */
837 assign_stack_temp (mode
, size
, keep
)
838 enum machine_mode mode
;
842 return assign_stack_temp_for_type (mode
, size
, keep
, NULL_TREE
);
845 /* Assign a temporary of given TYPE.
846 KEEP is as for assign_stack_temp.
847 MEMORY_REQUIRED is 1 if the result must be addressable stack memory;
848 it is 0 if a register is OK.
849 DONT_PROMOTE is 1 if we should not promote values in register
853 assign_temp (type
, keep
, memory_required
, dont_promote
)
857 int dont_promote ATTRIBUTE_UNUSED
;
859 enum machine_mode mode
= TYPE_MODE (type
);
860 #ifndef PROMOTE_FOR_CALL_ONLY
861 int unsignedp
= TREE_UNSIGNED (type
);
864 if (mode
== BLKmode
|| memory_required
)
866 HOST_WIDE_INT size
= int_size_in_bytes (type
);
869 /* Zero sized arrays are GNU C extension. Set size to 1 to avoid
870 problems with allocating the stack space. */
874 /* Unfortunately, we don't yet know how to allocate variable-sized
875 temporaries. However, sometimes we have a fixed upper limit on
876 the size (which is stored in TYPE_ARRAY_MAX_SIZE) and can use that
877 instead. This is the case for Chill variable-sized strings. */
878 if (size
== -1 && TREE_CODE (type
) == ARRAY_TYPE
879 && TYPE_ARRAY_MAX_SIZE (type
) != NULL_TREE
880 && host_integerp (TYPE_ARRAY_MAX_SIZE (type
), 1))
881 size
= tree_low_cst (TYPE_ARRAY_MAX_SIZE (type
), 1);
883 tmp
= assign_stack_temp_for_type (mode
, size
, keep
, type
);
887 #ifndef PROMOTE_FOR_CALL_ONLY
889 mode
= promote_mode (type
, mode
, &unsignedp
, 0);
892 return gen_reg_rtx (mode
);
895 /* Combine temporary stack slots which are adjacent on the stack.
897 This allows for better use of already allocated stack space. This is only
898 done for BLKmode slots because we can be sure that we won't have alignment
899 problems in this case. */
902 combine_temp_slots ()
904 struct temp_slot
*p
, *q
;
905 struct temp_slot
*prev_p
, *prev_q
;
908 /* We can't combine slots, because the information about which slot
909 is in which alias set will be lost. */
910 if (flag_strict_aliasing
)
913 /* If there are a lot of temp slots, don't do anything unless
914 high levels of optimizaton. */
915 if (! flag_expensive_optimizations
)
916 for (p
= temp_slots
, num_slots
= 0; p
; p
= p
->next
, num_slots
++)
917 if (num_slots
> 100 || (num_slots
> 10 && optimize
== 0))
920 for (p
= temp_slots
, prev_p
= 0; p
; p
= prev_p
? prev_p
->next
: temp_slots
)
924 if (! p
->in_use
&& GET_MODE (p
->slot
) == BLKmode
)
925 for (q
= p
->next
, prev_q
= p
; q
; q
= prev_q
->next
)
928 if (! q
->in_use
&& GET_MODE (q
->slot
) == BLKmode
)
930 if (p
->base_offset
+ p
->full_size
== q
->base_offset
)
932 /* Q comes after P; combine Q into P. */
934 p
->full_size
+= q
->full_size
;
937 else if (q
->base_offset
+ q
->full_size
== p
->base_offset
)
939 /* P comes after Q; combine P into Q. */
941 q
->full_size
+= p
->full_size
;
946 /* Either delete Q or advance past it. */
949 prev_q
->next
= q
->next
;
955 /* Either delete P or advance past it. */
959 prev_p
->next
= p
->next
;
961 temp_slots
= p
->next
;
968 /* Find the temp slot corresponding to the object at address X. */
970 static struct temp_slot
*
971 find_temp_slot_from_address (x
)
977 for (p
= temp_slots
; p
; p
= p
->next
)
982 else if (XEXP (p
->slot
, 0) == x
984 || (GET_CODE (x
) == PLUS
985 && XEXP (x
, 0) == virtual_stack_vars_rtx
986 && GET_CODE (XEXP (x
, 1)) == CONST_INT
987 && INTVAL (XEXP (x
, 1)) >= p
->base_offset
988 && INTVAL (XEXP (x
, 1)) < p
->base_offset
+ p
->full_size
))
991 else if (p
->address
!= 0 && GET_CODE (p
->address
) == EXPR_LIST
)
992 for (next
= p
->address
; next
; next
= XEXP (next
, 1))
993 if (XEXP (next
, 0) == x
)
997 /* If we have a sum involving a register, see if it points to a temp
999 if (GET_CODE (x
) == PLUS
&& GET_CODE (XEXP (x
, 0)) == REG
1000 && (p
= find_temp_slot_from_address (XEXP (x
, 0))) != 0)
1002 else if (GET_CODE (x
) == PLUS
&& GET_CODE (XEXP (x
, 1)) == REG
1003 && (p
= find_temp_slot_from_address (XEXP (x
, 1))) != 0)
1009 /* Indicate that NEW is an alternate way of referring to the temp slot
1010 that previously was known by OLD. */
1013 update_temp_slot_address (old
, new)
1016 struct temp_slot
*p
;
1018 if (rtx_equal_p (old
, new))
1021 p
= find_temp_slot_from_address (old
);
1023 /* If we didn't find one, see if both OLD is a PLUS. If so, and NEW
1024 is a register, see if one operand of the PLUS is a temporary
1025 location. If so, NEW points into it. Otherwise, if both OLD and
1026 NEW are a PLUS and if there is a register in common between them.
1027 If so, try a recursive call on those values. */
1030 if (GET_CODE (old
) != PLUS
)
1033 if (GET_CODE (new) == REG
)
1035 update_temp_slot_address (XEXP (old
, 0), new);
1036 update_temp_slot_address (XEXP (old
, 1), new);
1039 else if (GET_CODE (new) != PLUS
)
1042 if (rtx_equal_p (XEXP (old
, 0), XEXP (new, 0)))
1043 update_temp_slot_address (XEXP (old
, 1), XEXP (new, 1));
1044 else if (rtx_equal_p (XEXP (old
, 1), XEXP (new, 0)))
1045 update_temp_slot_address (XEXP (old
, 0), XEXP (new, 1));
1046 else if (rtx_equal_p (XEXP (old
, 0), XEXP (new, 1)))
1047 update_temp_slot_address (XEXP (old
, 1), XEXP (new, 0));
1048 else if (rtx_equal_p (XEXP (old
, 1), XEXP (new, 1)))
1049 update_temp_slot_address (XEXP (old
, 0), XEXP (new, 0));
1054 /* Otherwise add an alias for the temp's address. */
1055 else if (p
->address
== 0)
1059 if (GET_CODE (p
->address
) != EXPR_LIST
)
1060 p
->address
= gen_rtx_EXPR_LIST (VOIDmode
, p
->address
, NULL_RTX
);
1062 p
->address
= gen_rtx_EXPR_LIST (VOIDmode
, new, p
->address
);
1066 /* If X could be a reference to a temporary slot, mark the fact that its
1067 address was taken. */
1070 mark_temp_addr_taken (x
)
1073 struct temp_slot
*p
;
1078 /* If X is not in memory or is at a constant address, it cannot be in
1079 a temporary slot. */
1080 if (GET_CODE (x
) != MEM
|| CONSTANT_P (XEXP (x
, 0)))
1083 p
= find_temp_slot_from_address (XEXP (x
, 0));
1088 /* If X could be a reference to a temporary slot, mark that slot as
1089 belonging to the to one level higher than the current level. If X
1090 matched one of our slots, just mark that one. Otherwise, we can't
1091 easily predict which it is, so upgrade all of them. Kept slots
1092 need not be touched.
1094 This is called when an ({...}) construct occurs and a statement
1095 returns a value in memory. */
1098 preserve_temp_slots (x
)
1101 struct temp_slot
*p
= 0;
1103 /* If there is no result, we still might have some objects whose address
1104 were taken, so we need to make sure they stay around. */
1107 for (p
= temp_slots
; p
; p
= p
->next
)
1108 if (p
->in_use
&& p
->level
== temp_slot_level
&& p
->addr_taken
)
1114 /* If X is a register that is being used as a pointer, see if we have
1115 a temporary slot we know it points to. To be consistent with
1116 the code below, we really should preserve all non-kept slots
1117 if we can't find a match, but that seems to be much too costly. */
1118 if (GET_CODE (x
) == REG
&& REGNO_POINTER_FLAG (REGNO (x
)))
1119 p
= find_temp_slot_from_address (x
);
1121 /* If X is not in memory or is at a constant address, it cannot be in
1122 a temporary slot, but it can contain something whose address was
1124 if (p
== 0 && (GET_CODE (x
) != MEM
|| CONSTANT_P (XEXP (x
, 0))))
1126 for (p
= temp_slots
; p
; p
= p
->next
)
1127 if (p
->in_use
&& p
->level
== temp_slot_level
&& p
->addr_taken
)
1133 /* First see if we can find a match. */
1135 p
= find_temp_slot_from_address (XEXP (x
, 0));
1139 /* Move everything at our level whose address was taken to our new
1140 level in case we used its address. */
1141 struct temp_slot
*q
;
1143 if (p
->level
== temp_slot_level
)
1145 for (q
= temp_slots
; q
; q
= q
->next
)
1146 if (q
!= p
&& q
->addr_taken
&& q
->level
== p
->level
)
1155 /* Otherwise, preserve all non-kept slots at this level. */
1156 for (p
= temp_slots
; p
; p
= p
->next
)
1157 if (p
->in_use
&& p
->level
== temp_slot_level
&& ! p
->keep
)
1161 /* X is the result of an RTL_EXPR. If it is a temporary slot associated
1162 with that RTL_EXPR, promote it into a temporary slot at the present
1163 level so it will not be freed when we free slots made in the
1167 preserve_rtl_expr_result (x
)
1170 struct temp_slot
*p
;
1172 /* If X is not in memory or is at a constant address, it cannot be in
1173 a temporary slot. */
1174 if (x
== 0 || GET_CODE (x
) != MEM
|| CONSTANT_P (XEXP (x
, 0)))
1177 /* If we can find a match, move it to our level unless it is already at
1179 p
= find_temp_slot_from_address (XEXP (x
, 0));
1182 p
->level
= MIN (p
->level
, temp_slot_level
);
1189 /* Free all temporaries used so far. This is normally called at the end
1190 of generating code for a statement. Don't free any temporaries
1191 currently in use for an RTL_EXPR that hasn't yet been emitted.
1192 We could eventually do better than this since it can be reused while
1193 generating the same RTL_EXPR, but this is complex and probably not
1199 struct temp_slot
*p
;
1201 for (p
= temp_slots
; p
; p
= p
->next
)
1202 if (p
->in_use
&& p
->level
== temp_slot_level
&& ! p
->keep
1203 && p
->rtl_expr
== 0)
1206 combine_temp_slots ();
1209 /* Free all temporary slots used in T, an RTL_EXPR node. */
1212 free_temps_for_rtl_expr (t
)
1215 struct temp_slot
*p
;
1217 for (p
= temp_slots
; p
; p
= p
->next
)
1218 if (p
->rtl_expr
== t
)
1220 /* If this slot is below the current TEMP_SLOT_LEVEL, then it
1221 needs to be preserved. This can happen if a temporary in
1222 the RTL_EXPR was addressed; preserve_temp_slots will move
1223 the temporary into a higher level. */
1224 if (temp_slot_level
<= p
->level
)
1227 p
->rtl_expr
= NULL_TREE
;
1230 combine_temp_slots ();
1233 /* Mark all temporaries ever allocated in this function as not suitable
1234 for reuse until the current level is exited. */
1237 mark_all_temps_used ()
1239 struct temp_slot
*p
;
1241 for (p
= temp_slots
; p
; p
= p
->next
)
1243 p
->in_use
= p
->keep
= 1;
1244 p
->level
= MIN (p
->level
, temp_slot_level
);
1248 /* Push deeper into the nesting level for stack temporaries. */
1256 /* Likewise, but save the new level as the place to allocate variables
1261 push_temp_slots_for_block ()
1265 var_temp_slot_level
= temp_slot_level
;
1268 /* Likewise, but save the new level as the place to allocate temporaries
1269 for TARGET_EXPRs. */
1272 push_temp_slots_for_target ()
1276 target_temp_slot_level
= temp_slot_level
;
1279 /* Set and get the value of target_temp_slot_level. The only
1280 permitted use of these functions is to save and restore this value. */
1283 get_target_temp_slot_level ()
1285 return target_temp_slot_level
;
1289 set_target_temp_slot_level (level
)
1292 target_temp_slot_level
= level
;
1296 /* Pop a temporary nesting level. All slots in use in the current level
1302 struct temp_slot
*p
;
1304 for (p
= temp_slots
; p
; p
= p
->next
)
1305 if (p
->in_use
&& p
->level
== temp_slot_level
&& p
->rtl_expr
== 0)
1308 combine_temp_slots ();
1313 /* Initialize temporary slots. */
1318 /* We have not allocated any temporaries yet. */
1320 temp_slot_level
= 0;
1321 var_temp_slot_level
= 0;
1322 target_temp_slot_level
= 0;
1325 /* Retroactively move an auto variable from a register to a stack slot.
1326 This is done when an address-reference to the variable is seen. */
1329 put_var_into_stack (decl
)
1333 enum machine_mode promoted_mode
, decl_mode
;
1334 struct function
*function
= 0;
1336 int can_use_addressof
;
1337 int volatilep
= TREE_CODE (decl
) != SAVE_EXPR
&& TREE_THIS_VOLATILE (decl
);
1338 int usedp
= (TREE_USED (decl
)
1339 || (TREE_CODE (decl
) != SAVE_EXPR
&& DECL_INITIAL (decl
) != 0));
1341 context
= decl_function_context (decl
);
1343 /* Get the current rtl used for this object and its original mode. */
1344 reg
= TREE_CODE (decl
) == SAVE_EXPR
? SAVE_EXPR_RTL (decl
) : DECL_RTL (decl
);
1346 /* No need to do anything if decl has no rtx yet
1347 since in that case caller is setting TREE_ADDRESSABLE
1348 and a stack slot will be assigned when the rtl is made. */
1352 /* Get the declared mode for this object. */
1353 decl_mode
= (TREE_CODE (decl
) == SAVE_EXPR
? TYPE_MODE (TREE_TYPE (decl
))
1354 : DECL_MODE (decl
));
1355 /* Get the mode it's actually stored in. */
1356 promoted_mode
= GET_MODE (reg
);
1358 /* If this variable comes from an outer function,
1359 find that function's saved context. */
1360 if (context
!= current_function_decl
&& context
!= inline_function_decl
)
1361 for (function
= outer_function_chain
; function
; function
= function
->next
)
1362 if (function
->decl
== context
)
1365 /* If this is a variable-size object with a pseudo to address it,
1366 put that pseudo into the stack, if the var is nonlocal. */
1367 if (TREE_CODE (decl
) != SAVE_EXPR
&& DECL_NONLOCAL (decl
)
1368 && GET_CODE (reg
) == MEM
1369 && GET_CODE (XEXP (reg
, 0)) == REG
1370 && REGNO (XEXP (reg
, 0)) > LAST_VIRTUAL_REGISTER
)
1372 reg
= XEXP (reg
, 0);
1373 decl_mode
= promoted_mode
= GET_MODE (reg
);
1379 /* FIXME make it work for promoted modes too */
1380 && decl_mode
== promoted_mode
1381 #ifdef NON_SAVING_SETJMP
1382 && ! (NON_SAVING_SETJMP
&& current_function_calls_setjmp
)
1386 /* If we can't use ADDRESSOF, make sure we see through one we already
1388 if (! can_use_addressof
&& GET_CODE (reg
) == MEM
1389 && GET_CODE (XEXP (reg
, 0)) == ADDRESSOF
)
1390 reg
= XEXP (XEXP (reg
, 0), 0);
1392 /* Now we should have a value that resides in one or more pseudo regs. */
1394 if (GET_CODE (reg
) == REG
)
1396 /* If this variable lives in the current function and we don't need
1397 to put things in the stack for the sake of setjmp, try to keep it
1398 in a register until we know we actually need the address. */
1399 if (can_use_addressof
)
1400 gen_mem_addressof (reg
, decl
);
1402 put_reg_into_stack (function
, reg
, TREE_TYPE (decl
), promoted_mode
,
1403 decl_mode
, volatilep
, 0, usedp
, 0);
1405 else if (GET_CODE (reg
) == CONCAT
)
1407 /* A CONCAT contains two pseudos; put them both in the stack.
1408 We do it so they end up consecutive. */
1409 enum machine_mode part_mode
= GET_MODE (XEXP (reg
, 0));
1410 tree part_type
= type_for_mode (part_mode
, 0);
1411 #ifdef FRAME_GROWS_DOWNWARD
1412 /* Since part 0 should have a lower address, do it second. */
1413 put_reg_into_stack (function
, XEXP (reg
, 1), part_type
, part_mode
,
1414 part_mode
, volatilep
, 0, usedp
, 0);
1415 put_reg_into_stack (function
, XEXP (reg
, 0), part_type
, part_mode
,
1416 part_mode
, volatilep
, 0, usedp
, 0);
1418 put_reg_into_stack (function
, XEXP (reg
, 0), part_type
, part_mode
,
1419 part_mode
, volatilep
, 0, usedp
, 0);
1420 put_reg_into_stack (function
, XEXP (reg
, 1), part_type
, part_mode
,
1421 part_mode
, volatilep
, 0, usedp
, 0);
1424 /* Change the CONCAT into a combined MEM for both parts. */
1425 PUT_CODE (reg
, MEM
);
1426 set_mem_attributes (reg
, decl
, 1);
1428 /* The two parts are in memory order already.
1429 Use the lower parts address as ours. */
1430 XEXP (reg
, 0) = XEXP (XEXP (reg
, 0), 0);
1431 /* Prevent sharing of rtl that might lose. */
1432 if (GET_CODE (XEXP (reg
, 0)) == PLUS
)
1433 XEXP (reg
, 0) = copy_rtx (XEXP (reg
, 0));
1438 if (current_function_check_memory_usage
)
1439 emit_library_call (chkr_set_right_libfunc
, 1, VOIDmode
, 3,
1440 XEXP (reg
, 0), Pmode
,
1441 GEN_INT (GET_MODE_SIZE (GET_MODE (reg
))),
1442 TYPE_MODE (sizetype
),
1443 GEN_INT (MEMORY_USE_RW
),
1444 TYPE_MODE (integer_type_node
));
1447 /* Subroutine of put_var_into_stack. This puts a single pseudo reg REG
1448 into the stack frame of FUNCTION (0 means the current function).
1449 DECL_MODE is the machine mode of the user-level data type.
1450 PROMOTED_MODE is the machine mode of the register.
1451 VOLATILE_P is nonzero if this is for a "volatile" decl.
1452 USED_P is nonzero if this reg might have already been used in an insn. */
1455 put_reg_into_stack (function
, reg
, type
, promoted_mode
, decl_mode
, volatile_p
,
1456 original_regno
, used_p
, ht
)
1457 struct function
*function
;
1460 enum machine_mode promoted_mode
, decl_mode
;
1462 unsigned int original_regno
;
1464 struct hash_table
*ht
;
1466 struct function
*func
= function
? function
: cfun
;
1468 unsigned int regno
= original_regno
;
1471 regno
= REGNO (reg
);
1473 if (regno
< func
->x_max_parm_reg
)
1474 new = func
->x_parm_reg_stack_loc
[regno
];
1477 new = assign_stack_local_1 (decl_mode
, GET_MODE_SIZE (decl_mode
), 0, func
);
1479 PUT_CODE (reg
, MEM
);
1480 PUT_MODE (reg
, decl_mode
);
1481 XEXP (reg
, 0) = XEXP (new, 0);
1482 /* `volatil' bit means one thing for MEMs, another entirely for REGs. */
1483 MEM_VOLATILE_P (reg
) = volatile_p
;
1485 /* If this is a memory ref that contains aggregate components,
1486 mark it as such for cse and loop optimize. If we are reusing a
1487 previously generated stack slot, then we need to copy the bit in
1488 case it was set for other reasons. For instance, it is set for
1489 __builtin_va_alist. */
1490 MEM_SET_IN_STRUCT_P (reg
,
1491 AGGREGATE_TYPE_P (type
) || MEM_IN_STRUCT_P (new));
1492 MEM_ALIAS_SET (reg
) = get_alias_set (type
);
1494 /* Now make sure that all refs to the variable, previously made
1495 when it was a register, are fixed up to be valid again. */
1497 if (used_p
&& function
!= 0)
1499 struct var_refs_queue
*temp
;
1502 = (struct var_refs_queue
*) xmalloc (sizeof (struct var_refs_queue
));
1503 temp
->modified
= reg
;
1504 temp
->promoted_mode
= promoted_mode
;
1505 temp
->unsignedp
= TREE_UNSIGNED (type
);
1506 temp
->next
= function
->fixup_var_refs_queue
;
1507 function
->fixup_var_refs_queue
= temp
;
1510 /* Variable is local; fix it up now. */
1511 fixup_var_refs (reg
, promoted_mode
, TREE_UNSIGNED (type
), ht
);
1515 fixup_var_refs (var
, promoted_mode
, unsignedp
, ht
)
1517 enum machine_mode promoted_mode
;
1519 struct hash_table
*ht
;
1522 rtx first_insn
= get_insns ();
1523 struct sequence_stack
*stack
= seq_stack
;
1524 tree rtl_exps
= rtl_expr_chain
;
1527 /* Must scan all insns for stack-refs that exceed the limit. */
1528 fixup_var_refs_insns (var
, promoted_mode
, unsignedp
, first_insn
,
1530 /* If there's a hash table, it must record all uses of VAR. */
1534 /* Scan all pending sequences too. */
1535 for (; stack
; stack
= stack
->next
)
1537 push_to_sequence (stack
->first
);
1538 fixup_var_refs_insns (var
, promoted_mode
, unsignedp
,
1539 stack
->first
, stack
->next
!= 0, 0);
1540 /* Update remembered end of sequence
1541 in case we added an insn at the end. */
1542 stack
->last
= get_last_insn ();
1546 /* Scan all waiting RTL_EXPRs too. */
1547 for (pending
= rtl_exps
; pending
; pending
= TREE_CHAIN (pending
))
1549 rtx seq
= RTL_EXPR_SEQUENCE (TREE_VALUE (pending
));
1550 if (seq
!= const0_rtx
&& seq
!= 0)
1552 push_to_sequence (seq
);
1553 fixup_var_refs_insns (var
, promoted_mode
, unsignedp
, seq
, 0,
1559 /* Scan the catch clauses for exception handling too. */
1560 push_to_full_sequence (catch_clauses
, catch_clauses_last
);
1561 fixup_var_refs_insns (var
, promoted_mode
, unsignedp
, catch_clauses
,
1563 end_full_sequence (&catch_clauses
, &catch_clauses_last
);
1565 /* Scan sequences saved in CALL_PLACEHOLDERS too. */
1566 for (insn
= first_insn
; insn
; insn
= NEXT_INSN (insn
))
1568 if (GET_CODE (insn
) == CALL_INSN
1569 && GET_CODE (PATTERN (insn
)) == CALL_PLACEHOLDER
)
1573 /* Look at the Normal call, sibling call and tail recursion
1574 sequences attached to the CALL_PLACEHOLDER. */
1575 for (i
= 0; i
< 3; i
++)
1577 rtx seq
= XEXP (PATTERN (insn
), i
);
1580 push_to_sequence (seq
);
1581 fixup_var_refs_insns (var
, promoted_mode
, unsignedp
,
1583 XEXP (PATTERN (insn
), i
) = get_insns ();
1591 /* REPLACEMENTS is a pointer to a list of the struct fixup_replacement and X is
1592 some part of an insn. Return a struct fixup_replacement whose OLD
1593 value is equal to X. Allocate a new structure if no such entry exists. */
1595 static struct fixup_replacement
*
1596 find_fixup_replacement (replacements
, x
)
1597 struct fixup_replacement
**replacements
;
1600 struct fixup_replacement
*p
;
1602 /* See if we have already replaced this. */
1603 for (p
= *replacements
; p
!= 0 && ! rtx_equal_p (p
->old
, x
); p
= p
->next
)
1608 p
= (struct fixup_replacement
*) oballoc (sizeof (struct fixup_replacement
));
1611 p
->next
= *replacements
;
1618 /* Scan the insn-chain starting with INSN for refs to VAR
1619 and fix them up. TOPLEVEL is nonzero if this chain is the
1620 main chain of insns for the current function. */
1623 fixup_var_refs_insns (var
, promoted_mode
, unsignedp
, insn
, toplevel
, ht
)
1625 enum machine_mode promoted_mode
;
1629 struct hash_table
*ht
;
1632 rtx insn_list
= NULL_RTX
;
1634 /* If we already know which INSNs reference VAR there's no need
1635 to walk the entire instruction chain. */
1638 insn_list
= ((struct insns_for_mem_entry
*)
1639 hash_lookup (ht
, var
, /*create=*/0, /*copy=*/0))->insns
;
1640 insn
= insn_list
? XEXP (insn_list
, 0) : NULL_RTX
;
1641 insn_list
= XEXP (insn_list
, 1);
1646 rtx next
= NEXT_INSN (insn
);
1647 rtx set
, prev
, prev_set
;
1650 if (GET_RTX_CLASS (GET_CODE (insn
)) == 'i')
1652 /* Remember the notes in case we delete the insn. */
1653 note
= REG_NOTES (insn
);
1655 /* If this is a CLOBBER of VAR, delete it.
1657 If it has a REG_LIBCALL note, delete the REG_LIBCALL
1658 and REG_RETVAL notes too. */
1659 if (GET_CODE (PATTERN (insn
)) == CLOBBER
1660 && (XEXP (PATTERN (insn
), 0) == var
1661 || (GET_CODE (XEXP (PATTERN (insn
), 0)) == CONCAT
1662 && (XEXP (XEXP (PATTERN (insn
), 0), 0) == var
1663 || XEXP (XEXP (PATTERN (insn
), 0), 1) == var
))))
1665 if ((note
= find_reg_note (insn
, REG_LIBCALL
, NULL_RTX
)) != 0)
1666 /* The REG_LIBCALL note will go away since we are going to
1667 turn INSN into a NOTE, so just delete the
1668 corresponding REG_RETVAL note. */
1669 remove_note (XEXP (note
, 0),
1670 find_reg_note (XEXP (note
, 0), REG_RETVAL
,
1673 /* In unoptimized compilation, we shouldn't call delete_insn
1674 except in jump.c doing warnings. */
1675 PUT_CODE (insn
, NOTE
);
1676 NOTE_LINE_NUMBER (insn
) = NOTE_INSN_DELETED
;
1677 NOTE_SOURCE_FILE (insn
) = 0;
1680 /* The insn to load VAR from a home in the arglist
1681 is now a no-op. When we see it, just delete it.
1682 Similarly if this is storing VAR from a register from which
1683 it was loaded in the previous insn. This will occur
1684 when an ADDRESSOF was made for an arglist slot. */
1686 && (set
= single_set (insn
)) != 0
1687 && SET_DEST (set
) == var
1688 /* If this represents the result of an insn group,
1689 don't delete the insn. */
1690 && find_reg_note (insn
, REG_RETVAL
, NULL_RTX
) == 0
1691 && (rtx_equal_p (SET_SRC (set
), var
)
1692 || (GET_CODE (SET_SRC (set
)) == REG
1693 && (prev
= prev_nonnote_insn (insn
)) != 0
1694 && (prev_set
= single_set (prev
)) != 0
1695 && SET_DEST (prev_set
) == SET_SRC (set
)
1696 && rtx_equal_p (SET_SRC (prev_set
), var
))))
1698 /* In unoptimized compilation, we shouldn't call delete_insn
1699 except in jump.c doing warnings. */
1700 PUT_CODE (insn
, NOTE
);
1701 NOTE_LINE_NUMBER (insn
) = NOTE_INSN_DELETED
;
1702 NOTE_SOURCE_FILE (insn
) = 0;
1703 if (insn
== last_parm_insn
)
1704 last_parm_insn
= PREV_INSN (next
);
1708 struct fixup_replacement
*replacements
= 0;
1709 rtx next_insn
= NEXT_INSN (insn
);
1711 if (SMALL_REGISTER_CLASSES
)
1713 /* If the insn that copies the results of a CALL_INSN
1714 into a pseudo now references VAR, we have to use an
1715 intermediate pseudo since we want the life of the
1716 return value register to be only a single insn.
1718 If we don't use an intermediate pseudo, such things as
1719 address computations to make the address of VAR valid
1720 if it is not can be placed between the CALL_INSN and INSN.
1722 To make sure this doesn't happen, we record the destination
1723 of the CALL_INSN and see if the next insn uses both that
1726 if (call_dest
!= 0 && GET_CODE (insn
) == INSN
1727 && reg_mentioned_p (var
, PATTERN (insn
))
1728 && reg_mentioned_p (call_dest
, PATTERN (insn
)))
1730 rtx temp
= gen_reg_rtx (GET_MODE (call_dest
));
1732 emit_insn_before (gen_move_insn (temp
, call_dest
), insn
);
1734 PATTERN (insn
) = replace_rtx (PATTERN (insn
),
1738 if (GET_CODE (insn
) == CALL_INSN
1739 && GET_CODE (PATTERN (insn
)) == SET
)
1740 call_dest
= SET_DEST (PATTERN (insn
));
1741 else if (GET_CODE (insn
) == CALL_INSN
1742 && GET_CODE (PATTERN (insn
)) == PARALLEL
1743 && GET_CODE (XVECEXP (PATTERN (insn
), 0, 0)) == SET
)
1744 call_dest
= SET_DEST (XVECEXP (PATTERN (insn
), 0, 0));
1749 /* See if we have to do anything to INSN now that VAR is in
1750 memory. If it needs to be loaded into a pseudo, use a single
1751 pseudo for the entire insn in case there is a MATCH_DUP
1752 between two operands. We pass a pointer to the head of
1753 a list of struct fixup_replacements. If fixup_var_refs_1
1754 needs to allocate pseudos or replacement MEMs (for SUBREGs),
1755 it will record them in this list.
1757 If it allocated a pseudo for any replacement, we copy into
1760 fixup_var_refs_1 (var
, promoted_mode
, &PATTERN (insn
), insn
,
1763 /* If this is last_parm_insn, and any instructions were output
1764 after it to fix it up, then we must set last_parm_insn to
1765 the last such instruction emitted. */
1766 if (insn
== last_parm_insn
)
1767 last_parm_insn
= PREV_INSN (next_insn
);
1769 while (replacements
)
1771 if (GET_CODE (replacements
->new) == REG
)
1776 /* OLD might be a (subreg (mem)). */
1777 if (GET_CODE (replacements
->old
) == SUBREG
)
1779 = fixup_memory_subreg (replacements
->old
, insn
, 0);
1782 = fixup_stack_1 (replacements
->old
, insn
);
1784 insert_before
= insn
;
1786 /* If we are changing the mode, do a conversion.
1787 This might be wasteful, but combine.c will
1788 eliminate much of the waste. */
1790 if (GET_MODE (replacements
->new)
1791 != GET_MODE (replacements
->old
))
1794 convert_move (replacements
->new,
1795 replacements
->old
, unsignedp
);
1796 seq
= gen_sequence ();
1800 seq
= gen_move_insn (replacements
->new,
1803 emit_insn_before (seq
, insert_before
);
1806 replacements
= replacements
->next
;
1810 /* Also fix up any invalid exprs in the REG_NOTES of this insn.
1811 But don't touch other insns referred to by reg-notes;
1812 we will get them elsewhere. */
1815 if (GET_CODE (note
) != INSN_LIST
)
1817 = walk_fixup_memory_subreg (XEXP (note
, 0), insn
, 1);
1818 note
= XEXP (note
, 1);
1826 insn
= XEXP (insn_list
, 0);
1827 insn_list
= XEXP (insn_list
, 1);
1834 /* VAR is a MEM that used to be a pseudo register with mode PROMOTED_MODE.
1835 See if the rtx expression at *LOC in INSN needs to be changed.
1837 REPLACEMENTS is a pointer to a list head that starts out zero, but may
1838 contain a list of original rtx's and replacements. If we find that we need
1839 to modify this insn by replacing a memory reference with a pseudo or by
1840 making a new MEM to implement a SUBREG, we consult that list to see if
1841 we have already chosen a replacement. If none has already been allocated,
1842 we allocate it and update the list. fixup_var_refs_insns will copy VAR
1843 or the SUBREG, as appropriate, to the pseudo. */
1846 fixup_var_refs_1 (var
, promoted_mode
, loc
, insn
, replacements
)
1848 enum machine_mode promoted_mode
;
1851 struct fixup_replacement
**replacements
;
1854 register rtx x
= *loc
;
1855 RTX_CODE code
= GET_CODE (x
);
1856 register const char *fmt
;
1857 register rtx tem
, tem1
;
1858 struct fixup_replacement
*replacement
;
1863 if (XEXP (x
, 0) == var
)
1865 /* Prevent sharing of rtl that might lose. */
1866 rtx sub
= copy_rtx (XEXP (var
, 0));
1868 if (! validate_change (insn
, loc
, sub
, 0))
1870 rtx y
= gen_reg_rtx (GET_MODE (sub
));
1873 /* We should be able to replace with a register or all is lost.
1874 Note that we can't use validate_change to verify this, since
1875 we're not caring for replacing all dups simultaneously. */
1876 if (! validate_replace_rtx (*loc
, y
, insn
))
1879 /* Careful! First try to recognize a direct move of the
1880 value, mimicking how things are done in gen_reload wrt
1881 PLUS. Consider what happens when insn is a conditional
1882 move instruction and addsi3 clobbers flags. */
1885 new_insn
= emit_insn (gen_rtx_SET (VOIDmode
, y
, sub
));
1886 seq
= gen_sequence ();
1889 if (recog_memoized (new_insn
) < 0)
1891 /* That failed. Fall back on force_operand and hope. */
1894 force_operand (sub
, y
);
1895 seq
= gen_sequence ();
1900 /* Don't separate setter from user. */
1901 if (PREV_INSN (insn
) && sets_cc0_p (PREV_INSN (insn
)))
1902 insn
= PREV_INSN (insn
);
1905 emit_insn_before (seq
, insn
);
1913 /* If we already have a replacement, use it. Otherwise,
1914 try to fix up this address in case it is invalid. */
1916 replacement
= find_fixup_replacement (replacements
, var
);
1917 if (replacement
->new)
1919 *loc
= replacement
->new;
1923 *loc
= replacement
->new = x
= fixup_stack_1 (x
, insn
);
1925 /* Unless we are forcing memory to register or we changed the mode,
1926 we can leave things the way they are if the insn is valid. */
1928 INSN_CODE (insn
) = -1;
1929 if (! flag_force_mem
&& GET_MODE (x
) == promoted_mode
1930 && recog_memoized (insn
) >= 0)
1933 *loc
= replacement
->new = gen_reg_rtx (promoted_mode
);
1937 /* If X contains VAR, we need to unshare it here so that we update
1938 each occurrence separately. But all identical MEMs in one insn
1939 must be replaced with the same rtx because of the possibility of
1942 if (reg_mentioned_p (var
, x
))
1944 replacement
= find_fixup_replacement (replacements
, x
);
1945 if (replacement
->new == 0)
1946 replacement
->new = copy_most_rtx (x
, var
);
1948 *loc
= x
= replacement
->new;
1964 /* Note that in some cases those types of expressions are altered
1965 by optimize_bit_field, and do not survive to get here. */
1966 if (XEXP (x
, 0) == var
1967 || (GET_CODE (XEXP (x
, 0)) == SUBREG
1968 && SUBREG_REG (XEXP (x
, 0)) == var
))
1970 /* Get TEM as a valid MEM in the mode presently in the insn.
1972 We don't worry about the possibility of MATCH_DUP here; it
1973 is highly unlikely and would be tricky to handle. */
1976 if (GET_CODE (tem
) == SUBREG
)
1978 if (GET_MODE_BITSIZE (GET_MODE (tem
))
1979 > GET_MODE_BITSIZE (GET_MODE (var
)))
1981 replacement
= find_fixup_replacement (replacements
, var
);
1982 if (replacement
->new == 0)
1983 replacement
->new = gen_reg_rtx (GET_MODE (var
));
1984 SUBREG_REG (tem
) = replacement
->new;
1987 tem
= fixup_memory_subreg (tem
, insn
, 0);
1990 tem
= fixup_stack_1 (tem
, insn
);
1992 /* Unless we want to load from memory, get TEM into the proper mode
1993 for an extract from memory. This can only be done if the
1994 extract is at a constant position and length. */
1996 if (! flag_force_mem
&& GET_CODE (XEXP (x
, 1)) == CONST_INT
1997 && GET_CODE (XEXP (x
, 2)) == CONST_INT
1998 && ! mode_dependent_address_p (XEXP (tem
, 0))
1999 && ! MEM_VOLATILE_P (tem
))
2001 enum machine_mode wanted_mode
= VOIDmode
;
2002 enum machine_mode is_mode
= GET_MODE (tem
);
2003 HOST_WIDE_INT pos
= INTVAL (XEXP (x
, 2));
2006 if (GET_CODE (x
) == ZERO_EXTRACT
)
2009 = insn_data
[(int) CODE_FOR_extzv
].operand
[1].mode
;
2010 if (wanted_mode
== VOIDmode
)
2011 wanted_mode
= word_mode
;
2015 if (GET_CODE (x
) == SIGN_EXTRACT
)
2017 wanted_mode
= insn_data
[(int) CODE_FOR_extv
].operand
[1].mode
;
2018 if (wanted_mode
== VOIDmode
)
2019 wanted_mode
= word_mode
;
2022 /* If we have a narrower mode, we can do something. */
2023 if (wanted_mode
!= VOIDmode
2024 && GET_MODE_SIZE (wanted_mode
) < GET_MODE_SIZE (is_mode
))
2026 HOST_WIDE_INT offset
= pos
/ BITS_PER_UNIT
;
2027 rtx old_pos
= XEXP (x
, 2);
2030 /* If the bytes and bits are counted differently, we
2031 must adjust the offset. */
2032 if (BYTES_BIG_ENDIAN
!= BITS_BIG_ENDIAN
)
2033 offset
= (GET_MODE_SIZE (is_mode
)
2034 - GET_MODE_SIZE (wanted_mode
) - offset
);
2036 pos
%= GET_MODE_BITSIZE (wanted_mode
);
2038 newmem
= gen_rtx_MEM (wanted_mode
,
2039 plus_constant (XEXP (tem
, 0), offset
));
2040 MEM_COPY_ATTRIBUTES (newmem
, tem
);
2042 /* Make the change and see if the insn remains valid. */
2043 INSN_CODE (insn
) = -1;
2044 XEXP (x
, 0) = newmem
;
2045 XEXP (x
, 2) = GEN_INT (pos
);
2047 if (recog_memoized (insn
) >= 0)
2050 /* Otherwise, restore old position. XEXP (x, 0) will be
2052 XEXP (x
, 2) = old_pos
;
2056 /* If we get here, the bitfield extract insn can't accept a memory
2057 reference. Copy the input into a register. */
2059 tem1
= gen_reg_rtx (GET_MODE (tem
));
2060 emit_insn_before (gen_move_insn (tem1
, tem
), insn
);
2067 if (SUBREG_REG (x
) == var
)
2069 /* If this is a special SUBREG made because VAR was promoted
2070 from a wider mode, replace it with VAR and call ourself
2071 recursively, this time saying that the object previously
2072 had its current mode (by virtue of the SUBREG). */
2074 if (SUBREG_PROMOTED_VAR_P (x
))
2077 fixup_var_refs_1 (var
, GET_MODE (var
), loc
, insn
, replacements
);
2081 /* If this SUBREG makes VAR wider, it has become a paradoxical
2082 SUBREG with VAR in memory, but these aren't allowed at this
2083 stage of the compilation. So load VAR into a pseudo and take
2084 a SUBREG of that pseudo. */
2085 if (GET_MODE_SIZE (GET_MODE (x
)) > GET_MODE_SIZE (GET_MODE (var
)))
2087 replacement
= find_fixup_replacement (replacements
, var
);
2088 if (replacement
->new == 0)
2089 replacement
->new = gen_reg_rtx (GET_MODE (var
));
2090 SUBREG_REG (x
) = replacement
->new;
2094 /* See if we have already found a replacement for this SUBREG.
2095 If so, use it. Otherwise, make a MEM and see if the insn
2096 is recognized. If not, or if we should force MEM into a register,
2097 make a pseudo for this SUBREG. */
2098 replacement
= find_fixup_replacement (replacements
, x
);
2099 if (replacement
->new)
2101 *loc
= replacement
->new;
2105 replacement
->new = *loc
= fixup_memory_subreg (x
, insn
, 0);
2107 INSN_CODE (insn
) = -1;
2108 if (! flag_force_mem
&& recog_memoized (insn
) >= 0)
2111 *loc
= replacement
->new = gen_reg_rtx (GET_MODE (x
));
2117 /* First do special simplification of bit-field references. */
2118 if (GET_CODE (SET_DEST (x
)) == SIGN_EXTRACT
2119 || GET_CODE (SET_DEST (x
)) == ZERO_EXTRACT
)
2120 optimize_bit_field (x
, insn
, 0);
2121 if (GET_CODE (SET_SRC (x
)) == SIGN_EXTRACT
2122 || GET_CODE (SET_SRC (x
)) == ZERO_EXTRACT
)
2123 optimize_bit_field (x
, insn
, NULL_PTR
);
2125 /* For a paradoxical SUBREG inside a ZERO_EXTRACT, load the object
2126 into a register and then store it back out. */
2127 if (GET_CODE (SET_DEST (x
)) == ZERO_EXTRACT
2128 && GET_CODE (XEXP (SET_DEST (x
), 0)) == SUBREG
2129 && SUBREG_REG (XEXP (SET_DEST (x
), 0)) == var
2130 && (GET_MODE_SIZE (GET_MODE (XEXP (SET_DEST (x
), 0)))
2131 > GET_MODE_SIZE (GET_MODE (var
))))
2133 replacement
= find_fixup_replacement (replacements
, var
);
2134 if (replacement
->new == 0)
2135 replacement
->new = gen_reg_rtx (GET_MODE (var
));
2137 SUBREG_REG (XEXP (SET_DEST (x
), 0)) = replacement
->new;
2138 emit_insn_after (gen_move_insn (var
, replacement
->new), insn
);
2141 /* If SET_DEST is now a paradoxical SUBREG, put the result of this
2142 insn into a pseudo and store the low part of the pseudo into VAR. */
2143 if (GET_CODE (SET_DEST (x
)) == SUBREG
2144 && SUBREG_REG (SET_DEST (x
)) == var
2145 && (GET_MODE_SIZE (GET_MODE (SET_DEST (x
)))
2146 > GET_MODE_SIZE (GET_MODE (var
))))
2148 SET_DEST (x
) = tem
= gen_reg_rtx (GET_MODE (SET_DEST (x
)));
2149 emit_insn_after (gen_move_insn (var
, gen_lowpart (GET_MODE (var
),
2156 rtx dest
= SET_DEST (x
);
2157 rtx src
= SET_SRC (x
);
2159 rtx outerdest
= dest
;
2162 while (GET_CODE (dest
) == SUBREG
|| GET_CODE (dest
) == STRICT_LOW_PART
2163 || GET_CODE (dest
) == SIGN_EXTRACT
2164 || GET_CODE (dest
) == ZERO_EXTRACT
)
2165 dest
= XEXP (dest
, 0);
2167 if (GET_CODE (src
) == SUBREG
)
2168 src
= XEXP (src
, 0);
2170 /* If VAR does not appear at the top level of the SET
2171 just scan the lower levels of the tree. */
2173 if (src
!= var
&& dest
!= var
)
2176 /* We will need to rerecognize this insn. */
2177 INSN_CODE (insn
) = -1;
2180 if (GET_CODE (outerdest
) == ZERO_EXTRACT
&& dest
== var
)
2182 /* Since this case will return, ensure we fixup all the
2184 fixup_var_refs_1 (var
, promoted_mode
, &XEXP (outerdest
, 1),
2185 insn
, replacements
);
2186 fixup_var_refs_1 (var
, promoted_mode
, &XEXP (outerdest
, 2),
2187 insn
, replacements
);
2188 fixup_var_refs_1 (var
, promoted_mode
, &SET_SRC (x
),
2189 insn
, replacements
);
2191 tem
= XEXP (outerdest
, 0);
2193 /* Clean up (SUBREG:SI (MEM:mode ...) 0)
2194 that may appear inside a ZERO_EXTRACT.
2195 This was legitimate when the MEM was a REG. */
2196 if (GET_CODE (tem
) == SUBREG
2197 && SUBREG_REG (tem
) == var
)
2198 tem
= fixup_memory_subreg (tem
, insn
, 0);
2200 tem
= fixup_stack_1 (tem
, insn
);
2202 if (GET_CODE (XEXP (outerdest
, 1)) == CONST_INT
2203 && GET_CODE (XEXP (outerdest
, 2)) == CONST_INT
2204 && ! mode_dependent_address_p (XEXP (tem
, 0))
2205 && ! MEM_VOLATILE_P (tem
))
2207 enum machine_mode wanted_mode
;
2208 enum machine_mode is_mode
= GET_MODE (tem
);
2209 HOST_WIDE_INT pos
= INTVAL (XEXP (outerdest
, 2));
2211 wanted_mode
= insn_data
[(int) CODE_FOR_insv
].operand
[0].mode
;
2212 if (wanted_mode
== VOIDmode
)
2213 wanted_mode
= word_mode
;
2215 /* If we have a narrower mode, we can do something. */
2216 if (GET_MODE_SIZE (wanted_mode
) < GET_MODE_SIZE (is_mode
))
2218 HOST_WIDE_INT offset
= pos
/ BITS_PER_UNIT
;
2219 rtx old_pos
= XEXP (outerdest
, 2);
2222 if (BYTES_BIG_ENDIAN
!= BITS_BIG_ENDIAN
)
2223 offset
= (GET_MODE_SIZE (is_mode
)
2224 - GET_MODE_SIZE (wanted_mode
) - offset
);
2226 pos
%= GET_MODE_BITSIZE (wanted_mode
);
2228 newmem
= gen_rtx_MEM (wanted_mode
,
2229 plus_constant (XEXP (tem
, 0),
2231 MEM_COPY_ATTRIBUTES (newmem
, tem
);
2233 /* Make the change and see if the insn remains valid. */
2234 INSN_CODE (insn
) = -1;
2235 XEXP (outerdest
, 0) = newmem
;
2236 XEXP (outerdest
, 2) = GEN_INT (pos
);
2238 if (recog_memoized (insn
) >= 0)
2241 /* Otherwise, restore old position. XEXP (x, 0) will be
2243 XEXP (outerdest
, 2) = old_pos
;
2247 /* If we get here, the bit-field store doesn't allow memory
2248 or isn't located at a constant position. Load the value into
2249 a register, do the store, and put it back into memory. */
2251 tem1
= gen_reg_rtx (GET_MODE (tem
));
2252 emit_insn_before (gen_move_insn (tem1
, tem
), insn
);
2253 emit_insn_after (gen_move_insn (tem
, tem1
), insn
);
2254 XEXP (outerdest
, 0) = tem1
;
2259 /* STRICT_LOW_PART is a no-op on memory references
2260 and it can cause combinations to be unrecognizable,
2263 if (dest
== var
&& GET_CODE (SET_DEST (x
)) == STRICT_LOW_PART
)
2264 SET_DEST (x
) = XEXP (SET_DEST (x
), 0);
2266 /* A valid insn to copy VAR into or out of a register
2267 must be left alone, to avoid an infinite loop here.
2268 If the reference to VAR is by a subreg, fix that up,
2269 since SUBREG is not valid for a memref.
2270 Also fix up the address of the stack slot.
2272 Note that we must not try to recognize the insn until
2273 after we know that we have valid addresses and no
2274 (subreg (mem ...) ...) constructs, since these interfere
2275 with determining the validity of the insn. */
2277 if ((SET_SRC (x
) == var
2278 || (GET_CODE (SET_SRC (x
)) == SUBREG
2279 && SUBREG_REG (SET_SRC (x
)) == var
))
2280 && (GET_CODE (SET_DEST (x
)) == REG
2281 || (GET_CODE (SET_DEST (x
)) == SUBREG
2282 && GET_CODE (SUBREG_REG (SET_DEST (x
))) == REG
))
2283 && GET_MODE (var
) == promoted_mode
2284 && x
== single_set (insn
))
2288 replacement
= find_fixup_replacement (replacements
, SET_SRC (x
));
2289 if (replacement
->new)
2290 SET_SRC (x
) = replacement
->new;
2291 else if (GET_CODE (SET_SRC (x
)) == SUBREG
)
2292 SET_SRC (x
) = replacement
->new
2293 = fixup_memory_subreg (SET_SRC (x
), insn
, 0);
2295 SET_SRC (x
) = replacement
->new
2296 = fixup_stack_1 (SET_SRC (x
), insn
);
2298 if (recog_memoized (insn
) >= 0)
2301 /* INSN is not valid, but we know that we want to
2302 copy SET_SRC (x) to SET_DEST (x) in some way. So
2303 we generate the move and see whether it requires more
2304 than one insn. If it does, we emit those insns and
2305 delete INSN. Otherwise, we an just replace the pattern
2306 of INSN; we have already verified above that INSN has
2307 no other function that to do X. */
2309 pat
= gen_move_insn (SET_DEST (x
), SET_SRC (x
));
2310 if (GET_CODE (pat
) == SEQUENCE
)
2312 emit_insn_after (pat
, insn
);
2313 PUT_CODE (insn
, NOTE
);
2314 NOTE_LINE_NUMBER (insn
) = NOTE_INSN_DELETED
;
2315 NOTE_SOURCE_FILE (insn
) = 0;
2318 PATTERN (insn
) = pat
;
2323 if ((SET_DEST (x
) == var
2324 || (GET_CODE (SET_DEST (x
)) == SUBREG
2325 && SUBREG_REG (SET_DEST (x
)) == var
))
2326 && (GET_CODE (SET_SRC (x
)) == REG
2327 || (GET_CODE (SET_SRC (x
)) == SUBREG
2328 && GET_CODE (SUBREG_REG (SET_SRC (x
))) == REG
))
2329 && GET_MODE (var
) == promoted_mode
2330 && x
== single_set (insn
))
2334 if (GET_CODE (SET_DEST (x
)) == SUBREG
)
2335 SET_DEST (x
) = fixup_memory_subreg (SET_DEST (x
), insn
, 0);
2337 SET_DEST (x
) = fixup_stack_1 (SET_DEST (x
), insn
);
2339 if (recog_memoized (insn
) >= 0)
2342 pat
= gen_move_insn (SET_DEST (x
), SET_SRC (x
));
2343 if (GET_CODE (pat
) == SEQUENCE
)
2345 emit_insn_after (pat
, insn
);
2346 PUT_CODE (insn
, NOTE
);
2347 NOTE_LINE_NUMBER (insn
) = NOTE_INSN_DELETED
;
2348 NOTE_SOURCE_FILE (insn
) = 0;
2351 PATTERN (insn
) = pat
;
2356 /* Otherwise, storing into VAR must be handled specially
2357 by storing into a temporary and copying that into VAR
2358 with a new insn after this one. Note that this case
2359 will be used when storing into a promoted scalar since
2360 the insn will now have different modes on the input
2361 and output and hence will be invalid (except for the case
2362 of setting it to a constant, which does not need any
2363 change if it is valid). We generate extra code in that case,
2364 but combine.c will eliminate it. */
2369 rtx fixeddest
= SET_DEST (x
);
2371 /* STRICT_LOW_PART can be discarded, around a MEM. */
2372 if (GET_CODE (fixeddest
) == STRICT_LOW_PART
)
2373 fixeddest
= XEXP (fixeddest
, 0);
2374 /* Convert (SUBREG (MEM)) to a MEM in a changed mode. */
2375 if (GET_CODE (fixeddest
) == SUBREG
)
2377 fixeddest
= fixup_memory_subreg (fixeddest
, insn
, 0);
2378 promoted_mode
= GET_MODE (fixeddest
);
2381 fixeddest
= fixup_stack_1 (fixeddest
, insn
);
2383 temp
= gen_reg_rtx (promoted_mode
);
2385 emit_insn_after (gen_move_insn (fixeddest
,
2386 gen_lowpart (GET_MODE (fixeddest
),
2390 SET_DEST (x
) = temp
;
2398 /* Nothing special about this RTX; fix its operands. */
2400 fmt
= GET_RTX_FORMAT (code
);
2401 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2404 fixup_var_refs_1 (var
, promoted_mode
, &XEXP (x
, i
), insn
, replacements
);
2405 else if (fmt
[i
] == 'E')
2408 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2409 fixup_var_refs_1 (var
, promoted_mode
, &XVECEXP (x
, i
, j
),
2410 insn
, replacements
);
2415 /* Given X, an rtx of the form (SUBREG:m1 (MEM:m2 addr)),
2416 return an rtx (MEM:m1 newaddr) which is equivalent.
2417 If any insns must be emitted to compute NEWADDR, put them before INSN.
2419 UNCRITICAL nonzero means accept paradoxical subregs.
2420 This is used for subregs found inside REG_NOTES. */
2423 fixup_memory_subreg (x
, insn
, uncritical
)
2428 int offset
= SUBREG_WORD (x
) * UNITS_PER_WORD
;
2429 rtx addr
= XEXP (SUBREG_REG (x
), 0);
2430 enum machine_mode mode
= GET_MODE (x
);
2433 /* Paradoxical SUBREGs are usually invalid during RTL generation. */
2434 if (GET_MODE_SIZE (mode
) > GET_MODE_SIZE (GET_MODE (SUBREG_REG (x
)))
2438 if (BYTES_BIG_ENDIAN
)
2439 offset
+= (MIN (UNITS_PER_WORD
, GET_MODE_SIZE (GET_MODE (SUBREG_REG (x
))))
2440 - MIN (UNITS_PER_WORD
, GET_MODE_SIZE (mode
)));
2441 addr
= plus_constant (addr
, offset
);
2442 if (!flag_force_addr
&& memory_address_p (mode
, addr
))
2443 /* Shortcut if no insns need be emitted. */
2444 return change_address (SUBREG_REG (x
), mode
, addr
);
2446 result
= change_address (SUBREG_REG (x
), mode
, addr
);
2447 emit_insn_before (gen_sequence (), insn
);
2452 /* Do fixup_memory_subreg on all (SUBREG (MEM ...) ...) contained in X.
2453 Replace subexpressions of X in place.
2454 If X itself is a (SUBREG (MEM ...) ...), return the replacement expression.
2455 Otherwise return X, with its contents possibly altered.
2457 If any insns must be emitted to compute NEWADDR, put them before INSN.
2459 UNCRITICAL is as in fixup_memory_subreg. */
2462 walk_fixup_memory_subreg (x
, insn
, uncritical
)
2467 register enum rtx_code code
;
2468 register const char *fmt
;
2474 code
= GET_CODE (x
);
2476 if (code
== SUBREG
&& GET_CODE (SUBREG_REG (x
)) == MEM
)
2477 return fixup_memory_subreg (x
, insn
, uncritical
);
2479 /* Nothing special about this RTX; fix its operands. */
2481 fmt
= GET_RTX_FORMAT (code
);
2482 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2485 XEXP (x
, i
) = walk_fixup_memory_subreg (XEXP (x
, i
), insn
, uncritical
);
2486 else if (fmt
[i
] == 'E')
2489 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2491 = walk_fixup_memory_subreg (XVECEXP (x
, i
, j
), insn
, uncritical
);
2497 /* For each memory ref within X, if it refers to a stack slot
2498 with an out of range displacement, put the address in a temp register
2499 (emitting new insns before INSN to load these registers)
2500 and alter the memory ref to use that register.
2501 Replace each such MEM rtx with a copy, to avoid clobberage. */
2504 fixup_stack_1 (x
, insn
)
2509 register RTX_CODE code
= GET_CODE (x
);
2510 register const char *fmt
;
2514 register rtx ad
= XEXP (x
, 0);
2515 /* If we have address of a stack slot but it's not valid
2516 (displacement is too large), compute the sum in a register. */
2517 if (GET_CODE (ad
) == PLUS
2518 && GET_CODE (XEXP (ad
, 0)) == REG
2519 && ((REGNO (XEXP (ad
, 0)) >= FIRST_VIRTUAL_REGISTER
2520 && REGNO (XEXP (ad
, 0)) <= LAST_VIRTUAL_REGISTER
)
2521 || REGNO (XEXP (ad
, 0)) == FRAME_POINTER_REGNUM
2522 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
2523 || REGNO (XEXP (ad
, 0)) == HARD_FRAME_POINTER_REGNUM
2525 || REGNO (XEXP (ad
, 0)) == STACK_POINTER_REGNUM
2526 || REGNO (XEXP (ad
, 0)) == ARG_POINTER_REGNUM
2527 || XEXP (ad
, 0) == current_function_internal_arg_pointer
)
2528 && GET_CODE (XEXP (ad
, 1)) == CONST_INT
)
2531 if (memory_address_p (GET_MODE (x
), ad
))
2535 temp
= copy_to_reg (ad
);
2536 seq
= gen_sequence ();
2538 emit_insn_before (seq
, insn
);
2539 return change_address (x
, VOIDmode
, temp
);
2544 fmt
= GET_RTX_FORMAT (code
);
2545 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2548 XEXP (x
, i
) = fixup_stack_1 (XEXP (x
, i
), insn
);
2549 else if (fmt
[i
] == 'E')
2552 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2553 XVECEXP (x
, i
, j
) = fixup_stack_1 (XVECEXP (x
, i
, j
), insn
);
2559 /* Optimization: a bit-field instruction whose field
2560 happens to be a byte or halfword in memory
2561 can be changed to a move instruction.
2563 We call here when INSN is an insn to examine or store into a bit-field.
2564 BODY is the SET-rtx to be altered.
2566 EQUIV_MEM is the table `reg_equiv_mem' if that is available; else 0.
2567 (Currently this is called only from function.c, and EQUIV_MEM
2571 optimize_bit_field (body
, insn
, equiv_mem
)
2576 register rtx bitfield
;
2579 enum machine_mode mode
;
2581 if (GET_CODE (SET_DEST (body
)) == SIGN_EXTRACT
2582 || GET_CODE (SET_DEST (body
)) == ZERO_EXTRACT
)
2583 bitfield
= SET_DEST (body
), destflag
= 1;
2585 bitfield
= SET_SRC (body
), destflag
= 0;
2587 /* First check that the field being stored has constant size and position
2588 and is in fact a byte or halfword suitably aligned. */
2590 if (GET_CODE (XEXP (bitfield
, 1)) == CONST_INT
2591 && GET_CODE (XEXP (bitfield
, 2)) == CONST_INT
2592 && ((mode
= mode_for_size (INTVAL (XEXP (bitfield
, 1)), MODE_INT
, 1))
2594 && INTVAL (XEXP (bitfield
, 2)) % INTVAL (XEXP (bitfield
, 1)) == 0)
2596 register rtx memref
= 0;
2598 /* Now check that the containing word is memory, not a register,
2599 and that it is safe to change the machine mode. */
2601 if (GET_CODE (XEXP (bitfield
, 0)) == MEM
)
2602 memref
= XEXP (bitfield
, 0);
2603 else if (GET_CODE (XEXP (bitfield
, 0)) == REG
2605 memref
= equiv_mem
[REGNO (XEXP (bitfield
, 0))];
2606 else if (GET_CODE (XEXP (bitfield
, 0)) == SUBREG
2607 && GET_CODE (SUBREG_REG (XEXP (bitfield
, 0))) == MEM
)
2608 memref
= SUBREG_REG (XEXP (bitfield
, 0));
2609 else if (GET_CODE (XEXP (bitfield
, 0)) == SUBREG
2611 && GET_CODE (SUBREG_REG (XEXP (bitfield
, 0))) == REG
)
2612 memref
= equiv_mem
[REGNO (SUBREG_REG (XEXP (bitfield
, 0)))];
2615 && ! mode_dependent_address_p (XEXP (memref
, 0))
2616 && ! MEM_VOLATILE_P (memref
))
2618 /* Now adjust the address, first for any subreg'ing
2619 that we are now getting rid of,
2620 and then for which byte of the word is wanted. */
2622 HOST_WIDE_INT offset
= INTVAL (XEXP (bitfield
, 2));
2625 /* Adjust OFFSET to count bits from low-address byte. */
2626 if (BITS_BIG_ENDIAN
!= BYTES_BIG_ENDIAN
)
2627 offset
= (GET_MODE_BITSIZE (GET_MODE (XEXP (bitfield
, 0)))
2628 - offset
- INTVAL (XEXP (bitfield
, 1)));
2630 /* Adjust OFFSET to count bytes from low-address byte. */
2631 offset
/= BITS_PER_UNIT
;
2632 if (GET_CODE (XEXP (bitfield
, 0)) == SUBREG
)
2634 offset
+= SUBREG_WORD (XEXP (bitfield
, 0)) * UNITS_PER_WORD
;
2635 if (BYTES_BIG_ENDIAN
)
2636 offset
-= (MIN (UNITS_PER_WORD
,
2637 GET_MODE_SIZE (GET_MODE (XEXP (bitfield
, 0))))
2638 - MIN (UNITS_PER_WORD
,
2639 GET_MODE_SIZE (GET_MODE (memref
))));
2643 memref
= change_address (memref
, mode
,
2644 plus_constant (XEXP (memref
, 0), offset
));
2645 insns
= get_insns ();
2647 emit_insns_before (insns
, insn
);
2649 /* Store this memory reference where
2650 we found the bit field reference. */
2654 validate_change (insn
, &SET_DEST (body
), memref
, 1);
2655 if (! CONSTANT_ADDRESS_P (SET_SRC (body
)))
2657 rtx src
= SET_SRC (body
);
2658 while (GET_CODE (src
) == SUBREG
2659 && SUBREG_WORD (src
) == 0)
2660 src
= SUBREG_REG (src
);
2661 if (GET_MODE (src
) != GET_MODE (memref
))
2662 src
= gen_lowpart (GET_MODE (memref
), SET_SRC (body
));
2663 validate_change (insn
, &SET_SRC (body
), src
, 1);
2665 else if (GET_MODE (SET_SRC (body
)) != VOIDmode
2666 && GET_MODE (SET_SRC (body
)) != GET_MODE (memref
))
2667 /* This shouldn't happen because anything that didn't have
2668 one of these modes should have got converted explicitly
2669 and then referenced through a subreg.
2670 This is so because the original bit-field was
2671 handled by agg_mode and so its tree structure had
2672 the same mode that memref now has. */
2677 rtx dest
= SET_DEST (body
);
2679 while (GET_CODE (dest
) == SUBREG
2680 && SUBREG_WORD (dest
) == 0
2681 && (GET_MODE_CLASS (GET_MODE (dest
))
2682 == GET_MODE_CLASS (GET_MODE (SUBREG_REG (dest
))))
2683 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest
)))
2685 dest
= SUBREG_REG (dest
);
2687 validate_change (insn
, &SET_DEST (body
), dest
, 1);
2689 if (GET_MODE (dest
) == GET_MODE (memref
))
2690 validate_change (insn
, &SET_SRC (body
), memref
, 1);
2693 /* Convert the mem ref to the destination mode. */
2694 rtx newreg
= gen_reg_rtx (GET_MODE (dest
));
2697 convert_move (newreg
, memref
,
2698 GET_CODE (SET_SRC (body
)) == ZERO_EXTRACT
);
2702 validate_change (insn
, &SET_SRC (body
), newreg
, 1);
2706 /* See if we can convert this extraction or insertion into
2707 a simple move insn. We might not be able to do so if this
2708 was, for example, part of a PARALLEL.
2710 If we succeed, write out any needed conversions. If we fail,
2711 it is hard to guess why we failed, so don't do anything
2712 special; just let the optimization be suppressed. */
2714 if (apply_change_group () && seq
)
2715 emit_insns_before (seq
, insn
);
2720 /* These routines are responsible for converting virtual register references
2721 to the actual hard register references once RTL generation is complete.
2723 The following four variables are used for communication between the
2724 routines. They contain the offsets of the virtual registers from their
2725 respective hard registers. */
2727 static int in_arg_offset
;
2728 static int var_offset
;
2729 static int dynamic_offset
;
2730 static int out_arg_offset
;
2731 static int cfa_offset
;
2733 /* In most machines, the stack pointer register is equivalent to the bottom
2736 #ifndef STACK_POINTER_OFFSET
2737 #define STACK_POINTER_OFFSET 0
2740 /* If not defined, pick an appropriate default for the offset of dynamically
2741 allocated memory depending on the value of ACCUMULATE_OUTGOING_ARGS,
2742 REG_PARM_STACK_SPACE, and OUTGOING_REG_PARM_STACK_SPACE. */
2744 #ifndef STACK_DYNAMIC_OFFSET
2746 /* The bottom of the stack points to the actual arguments. If
2747 REG_PARM_STACK_SPACE is defined, this includes the space for the register
2748 parameters. However, if OUTGOING_REG_PARM_STACK space is not defined,
2749 stack space for register parameters is not pushed by the caller, but
2750 rather part of the fixed stack areas and hence not included in
2751 `current_function_outgoing_args_size'. Nevertheless, we must allow
2752 for it when allocating stack dynamic objects. */
2754 #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE)
2755 #define STACK_DYNAMIC_OFFSET(FNDECL) \
2756 ((ACCUMULATE_OUTGOING_ARGS \
2757 ? (current_function_outgoing_args_size + REG_PARM_STACK_SPACE (FNDECL)) : 0)\
2758 + (STACK_POINTER_OFFSET)) \
2761 #define STACK_DYNAMIC_OFFSET(FNDECL) \
2762 ((ACCUMULATE_OUTGOING_ARGS ? current_function_outgoing_args_size : 0) \
2763 + (STACK_POINTER_OFFSET))
2767 /* On most machines, the CFA coincides with the first incoming parm. */
2769 #ifndef ARG_POINTER_CFA_OFFSET
2770 #define ARG_POINTER_CFA_OFFSET(FNDECL) FIRST_PARM_OFFSET (FNDECL)
2774 /* Build up a (MEM (ADDRESSOF (REG))) rtx for a register REG that just had
2775 its address taken. DECL is the decl for the object stored in the
2776 register, for later use if we do need to force REG into the stack.
2777 REG is overwritten by the MEM like in put_reg_into_stack. */
2780 gen_mem_addressof (reg
, decl
)
2784 tree type
= TREE_TYPE (decl
);
2785 rtx r
= gen_rtx_ADDRESSOF (Pmode
, gen_reg_rtx (GET_MODE (reg
)),
2788 /* If the original REG was a user-variable, then so is the REG whose
2789 address is being taken. Likewise for unchanging. */
2790 REG_USERVAR_P (XEXP (r
, 0)) = REG_USERVAR_P (reg
);
2791 RTX_UNCHANGING_P (XEXP (r
, 0)) = RTX_UNCHANGING_P (reg
);
2793 PUT_CODE (reg
, MEM
);
2794 PUT_MODE (reg
, DECL_MODE (decl
));
2796 MEM_VOLATILE_P (reg
) = TREE_SIDE_EFFECTS (decl
);
2797 MEM_SET_IN_STRUCT_P (reg
, AGGREGATE_TYPE_P (type
));
2798 MEM_ALIAS_SET (reg
) = get_alias_set (decl
);
2800 if (TREE_USED (decl
) || DECL_INITIAL (decl
) != 0)
2801 fixup_var_refs (reg
, GET_MODE (reg
), TREE_UNSIGNED (type
), 0);
2806 /* If DECL has an RTL that is an ADDRESSOF rtx, put it into the stack. */
2809 flush_addressof (decl
)
2812 if ((TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
2813 && DECL_RTL (decl
) != 0
2814 && GET_CODE (DECL_RTL (decl
)) == MEM
2815 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == ADDRESSOF
2816 && GET_CODE (XEXP (XEXP (DECL_RTL (decl
), 0), 0)) == REG
)
2817 put_addressof_into_stack (XEXP (DECL_RTL (decl
), 0), 0);
2820 /* Force the register pointed to by R, an ADDRESSOF rtx, into the stack. */
2823 put_addressof_into_stack (r
, ht
)
2825 struct hash_table
*ht
;
2827 tree decl
= ADDRESSOF_DECL (r
);
2828 rtx reg
= XEXP (r
, 0);
2830 if (GET_CODE (reg
) != REG
)
2833 put_reg_into_stack (0, reg
, TREE_TYPE (decl
), GET_MODE (reg
),
2835 (TREE_CODE (decl
) != SAVE_EXPR
2836 && TREE_THIS_VOLATILE (decl
)),
2837 ADDRESSOF_REGNO (r
),
2839 || (TREE_CODE (decl
) != SAVE_EXPR
2840 && DECL_INITIAL (decl
) != 0)),
2844 /* List of replacements made below in purge_addressof_1 when creating
2845 bitfield insertions. */
2846 static rtx purge_bitfield_addressof_replacements
;
2848 /* List of replacements made below in purge_addressof_1 for patterns
2849 (MEM (ADDRESSOF (REG ...))). The key of the list entry is the
2850 corresponding (ADDRESSOF (REG ...)) and value is a substitution for
2851 the all pattern. List PURGE_BITFIELD_ADDRESSOF_REPLACEMENTS is not
2852 enough in complex cases, e.g. when some field values can be
2853 extracted by usage MEM with narrower mode. */
2854 static rtx purge_addressof_replacements
;
2856 /* Helper function for purge_addressof. See if the rtx expression at *LOC
2857 in INSN needs to be changed. If FORCE, always put any ADDRESSOFs into
2858 the stack. If the function returns FALSE then the replacement could not
2862 purge_addressof_1 (loc
, insn
, force
, store
, ht
)
2866 struct hash_table
*ht
;
2872 boolean result
= true;
2874 /* Re-start here to avoid recursion in common cases. */
2881 code
= GET_CODE (x
);
2883 /* If we don't return in any of the cases below, we will recurse inside
2884 the RTX, which will normally result in any ADDRESSOF being forced into
2888 result
= purge_addressof_1 (&SET_DEST (x
), insn
, force
, 1, ht
);
2889 result
&= purge_addressof_1 (&SET_SRC (x
), insn
, force
, 0, ht
);
2893 else if (code
== ADDRESSOF
&& GET_CODE (XEXP (x
, 0)) == MEM
)
2895 /* We must create a copy of the rtx because it was created by
2896 overwriting a REG rtx which is always shared. */
2897 rtx sub
= copy_rtx (XEXP (XEXP (x
, 0), 0));
2900 if (validate_change (insn
, loc
, sub
, 0)
2901 || validate_replace_rtx (x
, sub
, insn
))
2905 sub
= force_operand (sub
, NULL_RTX
);
2906 if (! validate_change (insn
, loc
, sub
, 0)
2907 && ! validate_replace_rtx (x
, sub
, insn
))
2910 insns
= gen_sequence ();
2912 emit_insn_before (insns
, insn
);
2916 else if (code
== MEM
&& GET_CODE (XEXP (x
, 0)) == ADDRESSOF
&& ! force
)
2918 rtx sub
= XEXP (XEXP (x
, 0), 0);
2921 if (GET_CODE (sub
) == MEM
)
2923 sub2
= gen_rtx_MEM (GET_MODE (x
), copy_rtx (XEXP (sub
, 0)));
2924 MEM_COPY_ATTRIBUTES (sub2
, sub
);
2927 else if (GET_CODE (sub
) == REG
2928 && (MEM_VOLATILE_P (x
) || GET_MODE (x
) == BLKmode
))
2930 else if (GET_CODE (sub
) == REG
&& GET_MODE (x
) != GET_MODE (sub
))
2932 int size_x
, size_sub
;
2936 /* When processing REG_NOTES look at the list of
2937 replacements done on the insn to find the register that X
2941 for (tem
= purge_bitfield_addressof_replacements
;
2943 tem
= XEXP (XEXP (tem
, 1), 1))
2944 if (rtx_equal_p (x
, XEXP (tem
, 0)))
2946 *loc
= XEXP (XEXP (tem
, 1), 0);
2950 /* See comment for purge_addressof_replacements. */
2951 for (tem
= purge_addressof_replacements
;
2953 tem
= XEXP (XEXP (tem
, 1), 1))
2954 if (rtx_equal_p (XEXP (x
, 0), XEXP (tem
, 0)))
2956 rtx z
= XEXP (XEXP (tem
, 1), 0);
2958 if (GET_MODE (x
) == GET_MODE (z
)
2959 || (GET_CODE (XEXP (XEXP (tem
, 1), 0)) != REG
2960 && GET_CODE (XEXP (XEXP (tem
, 1), 0)) != SUBREG
))
2963 /* It can happen that the note may speak of things
2964 in a wider (or just different) mode than the
2965 code did. This is especially true of
2968 if (GET_CODE (z
) == SUBREG
&& SUBREG_WORD (z
) == 0)
2971 if (GET_MODE_SIZE (GET_MODE (x
)) > UNITS_PER_WORD
2972 && (GET_MODE_SIZE (GET_MODE (x
))
2973 > GET_MODE_SIZE (GET_MODE (z
))))
2975 /* This can occur as a result in invalid
2976 pointer casts, e.g. float f; ...
2977 *(long long int *)&f.
2978 ??? We could emit a warning here, but
2979 without a line number that wouldn't be
2981 z
= gen_rtx_SUBREG (GET_MODE (x
), z
, 0);
2984 z
= gen_lowpart (GET_MODE (x
), z
);
2990 /* Sometimes we may not be able to find the replacement. For
2991 example when the original insn was a MEM in a wider mode,
2992 and the note is part of a sign extension of a narrowed
2993 version of that MEM. Gcc testcase compile/990829-1.c can
2994 generate an example of this siutation. Rather than complain
2995 we return false, which will prompt our caller to remove the
3000 size_x
= GET_MODE_BITSIZE (GET_MODE (x
));
3001 size_sub
= GET_MODE_BITSIZE (GET_MODE (sub
));
3003 /* Don't even consider working with paradoxical subregs,
3004 or the moral equivalent seen here. */
3005 if (size_x
<= size_sub
3006 && int_mode_for_mode (GET_MODE (sub
)) != BLKmode
)
3008 /* Do a bitfield insertion to mirror what would happen
3015 rtx p
= PREV_INSN (insn
);
3018 val
= gen_reg_rtx (GET_MODE (x
));
3019 if (! validate_change (insn
, loc
, val
, 0))
3021 /* Discard the current sequence and put the
3022 ADDRESSOF on stack. */
3026 seq
= gen_sequence ();
3028 emit_insn_before (seq
, insn
);
3029 compute_insns_for_mem (p
? NEXT_INSN (p
) : get_insns (),
3033 store_bit_field (sub
, size_x
, 0, GET_MODE (x
),
3034 val
, GET_MODE_SIZE (GET_MODE (sub
)),
3035 GET_MODE_ALIGNMENT (GET_MODE (sub
)));
3037 /* Make sure to unshare any shared rtl that store_bit_field
3038 might have created. */
3039 unshare_all_rtl_again (get_insns ());
3041 seq
= gen_sequence ();
3043 p
= emit_insn_after (seq
, insn
);
3044 if (NEXT_INSN (insn
))
3045 compute_insns_for_mem (NEXT_INSN (insn
),
3046 p
? NEXT_INSN (p
) : NULL_RTX
,
3051 rtx p
= PREV_INSN (insn
);
3054 val
= extract_bit_field (sub
, size_x
, 0, 1, NULL_RTX
,
3055 GET_MODE (x
), GET_MODE (x
),
3056 GET_MODE_SIZE (GET_MODE (sub
)),
3057 GET_MODE_SIZE (GET_MODE (sub
)));
3059 if (! validate_change (insn
, loc
, val
, 0))
3061 /* Discard the current sequence and put the
3062 ADDRESSOF on stack. */
3067 seq
= gen_sequence ();
3069 emit_insn_before (seq
, insn
);
3070 compute_insns_for_mem (p
? NEXT_INSN (p
) : get_insns (),
3074 /* Remember the replacement so that the same one can be done
3075 on the REG_NOTES. */
3076 purge_bitfield_addressof_replacements
3077 = gen_rtx_EXPR_LIST (VOIDmode
, x
,
3080 purge_bitfield_addressof_replacements
));
3082 /* We replaced with a reg -- all done. */
3087 else if (validate_change (insn
, loc
, sub
, 0))
3089 /* Remember the replacement so that the same one can be done
3090 on the REG_NOTES. */
3091 if (GET_CODE (sub
) == REG
|| GET_CODE (sub
) == SUBREG
)
3095 for (tem
= purge_addressof_replacements
;
3097 tem
= XEXP (XEXP (tem
, 1), 1))
3098 if (rtx_equal_p (XEXP (x
, 0), XEXP (tem
, 0)))
3100 XEXP (XEXP (tem
, 1), 0) = sub
;
3103 purge_addressof_replacements
3104 = gen_rtx (EXPR_LIST
, VOIDmode
, XEXP (x
, 0),
3105 gen_rtx_EXPR_LIST (VOIDmode
, sub
,
3106 purge_addressof_replacements
));
3112 /* else give up and put it into the stack */
3115 else if (code
== ADDRESSOF
)
3117 put_addressof_into_stack (x
, ht
);
3120 else if (code
== SET
)
3122 result
= purge_addressof_1 (&SET_DEST (x
), insn
, force
, 1, ht
);
3123 result
&= purge_addressof_1 (&SET_SRC (x
), insn
, force
, 0, ht
);
3127 /* Scan all subexpressions. */
3128 fmt
= GET_RTX_FORMAT (code
);
3129 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++, fmt
++)
3132 result
&= purge_addressof_1 (&XEXP (x
, i
), insn
, force
, 0, ht
);
3133 else if (*fmt
== 'E')
3134 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
3135 result
&= purge_addressof_1 (&XVECEXP (x
, i
, j
), insn
, force
, 0, ht
);
3141 /* Return a new hash table entry in HT. */
3143 static struct hash_entry
*
3144 insns_for_mem_newfunc (he
, ht
, k
)
3145 struct hash_entry
*he
;
3146 struct hash_table
*ht
;
3147 hash_table_key k ATTRIBUTE_UNUSED
;
3149 struct insns_for_mem_entry
*ifmhe
;
3153 ifmhe
= ((struct insns_for_mem_entry
*)
3154 hash_allocate (ht
, sizeof (struct insns_for_mem_entry
)));
3155 ifmhe
->insns
= NULL_RTX
;
3160 /* Return a hash value for K, a REG. */
3162 static unsigned long
3163 insns_for_mem_hash (k
)
3166 /* K is really a RTX. Just use the address as the hash value. */
3167 return (unsigned long) k
;
3170 /* Return non-zero if K1 and K2 (two REGs) are the same. */
3173 insns_for_mem_comp (k1
, k2
)
3180 struct insns_for_mem_walk_info
{
3181 /* The hash table that we are using to record which INSNs use which
3183 struct hash_table
*ht
;
3185 /* The INSN we are currently proessing. */
3188 /* Zero if we are walking to find ADDRESSOFs, one if we are walking
3189 to find the insns that use the REGs in the ADDRESSOFs. */
3193 /* Called from compute_insns_for_mem via for_each_rtx. If R is a REG
3194 that might be used in an ADDRESSOF expression, record this INSN in
3195 the hash table given by DATA (which is really a pointer to an
3196 insns_for_mem_walk_info structure). */
3199 insns_for_mem_walk (r
, data
)
3203 struct insns_for_mem_walk_info
*ifmwi
3204 = (struct insns_for_mem_walk_info
*) data
;
3206 if (ifmwi
->pass
== 0 && *r
&& GET_CODE (*r
) == ADDRESSOF
3207 && GET_CODE (XEXP (*r
, 0)) == REG
)
3208 hash_lookup (ifmwi
->ht
, XEXP (*r
, 0), /*create=*/1, /*copy=*/0);
3209 else if (ifmwi
->pass
== 1 && *r
&& GET_CODE (*r
) == REG
)
3211 /* Lookup this MEM in the hashtable, creating it if necessary. */
3212 struct insns_for_mem_entry
*ifme
3213 = (struct insns_for_mem_entry
*) hash_lookup (ifmwi
->ht
,
3218 /* If we have not already recorded this INSN, do so now. Since
3219 we process the INSNs in order, we know that if we have
3220 recorded it it must be at the front of the list. */
3221 if (ifme
&& (!ifme
->insns
|| XEXP (ifme
->insns
, 0) != ifmwi
->insn
))
3223 /* We do the allocation on the same obstack as is used for
3224 the hash table since this memory will not be used once
3225 the hash table is deallocated. */
3226 push_obstacks (&ifmwi
->ht
->memory
, &ifmwi
->ht
->memory
);
3227 ifme
->insns
= gen_rtx_EXPR_LIST (VOIDmode
, ifmwi
->insn
,
3236 /* Walk the INSNS, until we reach LAST_INSN, recording which INSNs use
3237 which REGs in HT. */
3240 compute_insns_for_mem (insns
, last_insn
, ht
)
3243 struct hash_table
*ht
;
3246 struct insns_for_mem_walk_info ifmwi
;
3249 for (ifmwi
.pass
= 0; ifmwi
.pass
< 2; ++ifmwi
.pass
)
3250 for (insn
= insns
; insn
!= last_insn
; insn
= NEXT_INSN (insn
))
3251 if (GET_RTX_CLASS (GET_CODE (insn
)) == 'i')
3254 for_each_rtx (&insn
, insns_for_mem_walk
, &ifmwi
);
3258 /* Helper function for purge_addressof called through for_each_rtx.
3259 Returns true iff the rtl is an ADDRESSOF. */
3261 is_addressof (rtl
, data
)
3263 void * data ATTRIBUTE_UNUSED
;
3265 return GET_CODE (* rtl
) == ADDRESSOF
;
3268 /* Eliminate all occurrences of ADDRESSOF from INSNS. Elide any remaining
3269 (MEM (ADDRESSOF)) patterns, and force any needed registers into the
3273 purge_addressof (insns
)
3277 struct hash_table ht
;
3279 /* When we actually purge ADDRESSOFs, we turn REGs into MEMs. That
3280 requires a fixup pass over the instruction stream to correct
3281 INSNs that depended on the REG being a REG, and not a MEM. But,
3282 these fixup passes are slow. Furthermore, most MEMs are not
3283 mentioned in very many instructions. So, we speed up the process
3284 by pre-calculating which REGs occur in which INSNs; that allows
3285 us to perform the fixup passes much more quickly. */
3286 hash_table_init (&ht
,
3287 insns_for_mem_newfunc
,
3289 insns_for_mem_comp
);
3290 compute_insns_for_mem (insns
, NULL_RTX
, &ht
);
3292 for (insn
= insns
; insn
; insn
= NEXT_INSN (insn
))
3293 if (GET_CODE (insn
) == INSN
|| GET_CODE (insn
) == JUMP_INSN
3294 || GET_CODE (insn
) == CALL_INSN
)
3296 if (! purge_addressof_1 (&PATTERN (insn
), insn
,
3297 asm_noperands (PATTERN (insn
)) > 0, 0, &ht
))
3298 /* If we could not replace the ADDRESSOFs in the insn,
3299 something is wrong. */
3302 if (! purge_addressof_1 (®_NOTES (insn
), NULL_RTX
, 0, 0, &ht
))
3304 /* If we could not replace the ADDRESSOFs in the insn's notes,
3305 we can just remove the offending notes instead. */
3308 for (note
= REG_NOTES (insn
); note
; note
= XEXP (note
, 1))
3310 /* If we find a REG_RETVAL note then the insn is a libcall.
3311 Such insns must have REG_EQUAL notes as well, in order
3312 for later passes of the compiler to work. So it is not
3313 safe to delete the notes here, and instead we abort. */
3314 if (REG_NOTE_KIND (note
) == REG_RETVAL
)
3316 if (for_each_rtx (& note
, is_addressof
, NULL
))
3317 remove_note (insn
, note
);
3323 hash_table_free (&ht
);
3324 purge_bitfield_addressof_replacements
= 0;
3325 purge_addressof_replacements
= 0;
3327 /* REGs are shared. purge_addressof will destructively replace a REG
3328 with a MEM, which creates shared MEMs.
3330 Unfortunately, the children of put_reg_into_stack assume that MEMs
3331 referring to the same stack slot are shared (fixup_var_refs and
3332 the associated hash table code).
3334 So, we have to do another unsharing pass after we have flushed any
3335 REGs that had their address taken into the stack.
3337 It may be worth tracking whether or not we converted any REGs into
3338 MEMs to avoid this overhead when it is not needed. */
3339 unshare_all_rtl_again (get_insns ());
3342 /* Pass through the INSNS of function FNDECL and convert virtual register
3343 references to hard register references. */
3346 instantiate_virtual_regs (fndecl
, insns
)
3353 /* Compute the offsets to use for this function. */
3354 in_arg_offset
= FIRST_PARM_OFFSET (fndecl
);
3355 var_offset
= STARTING_FRAME_OFFSET
;
3356 dynamic_offset
= STACK_DYNAMIC_OFFSET (fndecl
);
3357 out_arg_offset
= STACK_POINTER_OFFSET
;
3358 cfa_offset
= ARG_POINTER_CFA_OFFSET (fndecl
);
3360 /* Scan all variables and parameters of this function. For each that is
3361 in memory, instantiate all virtual registers if the result is a valid
3362 address. If not, we do it later. That will handle most uses of virtual
3363 regs on many machines. */
3364 instantiate_decls (fndecl
, 1);
3366 /* Initialize recognition, indicating that volatile is OK. */
3369 /* Scan through all the insns, instantiating every virtual register still
3371 for (insn
= insns
; insn
; insn
= NEXT_INSN (insn
))
3372 if (GET_CODE (insn
) == INSN
|| GET_CODE (insn
) == JUMP_INSN
3373 || GET_CODE (insn
) == CALL_INSN
)
3375 instantiate_virtual_regs_1 (&PATTERN (insn
), insn
, 1);
3376 instantiate_virtual_regs_1 (®_NOTES (insn
), NULL_RTX
, 0);
3379 /* Instantiate the stack slots for the parm registers, for later use in
3380 addressof elimination. */
3381 for (i
= 0; i
< max_parm_reg
; ++i
)
3382 if (parm_reg_stack_loc
[i
])
3383 instantiate_virtual_regs_1 (&parm_reg_stack_loc
[i
], NULL_RTX
, 0);
3385 /* Now instantiate the remaining register equivalences for debugging info.
3386 These will not be valid addresses. */
3387 instantiate_decls (fndecl
, 0);
3389 /* Indicate that, from now on, assign_stack_local should use
3390 frame_pointer_rtx. */
3391 virtuals_instantiated
= 1;
3394 /* Scan all decls in FNDECL (both variables and parameters) and instantiate
3395 all virtual registers in their DECL_RTL's.
3397 If VALID_ONLY, do this only if the resulting address is still valid.
3398 Otherwise, always do it. */
3401 instantiate_decls (fndecl
, valid_only
)
3407 if (DECL_SAVED_INSNS (fndecl
))
3408 /* When compiling an inline function, the obstack used for
3409 rtl allocation is the maybepermanent_obstack. Calling
3410 `resume_temporary_allocation' switches us back to that
3411 obstack while we process this function's parameters. */
3412 resume_temporary_allocation ();
3414 /* Process all parameters of the function. */
3415 for (decl
= DECL_ARGUMENTS (fndecl
); decl
; decl
= TREE_CHAIN (decl
))
3417 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (decl
));
3419 instantiate_decl (DECL_RTL (decl
), size
, valid_only
);
3421 /* If the parameter was promoted, then the incoming RTL mode may be
3422 larger than the declared type size. We must use the larger of
3424 size
= MAX (GET_MODE_SIZE (GET_MODE (DECL_INCOMING_RTL (decl
))), size
);
3425 instantiate_decl (DECL_INCOMING_RTL (decl
), size
, valid_only
);
3428 /* Now process all variables defined in the function or its subblocks. */
3429 instantiate_decls_1 (DECL_INITIAL (fndecl
), valid_only
);
3431 if (DECL_INLINE (fndecl
) || DECL_DEFER_OUTPUT (fndecl
))
3433 /* Save all rtl allocated for this function by raising the
3434 high-water mark on the maybepermanent_obstack. */
3436 /* All further rtl allocation is now done in the current_obstack. */
3437 rtl_in_current_obstack ();
3441 /* Subroutine of instantiate_decls: Process all decls in the given
3442 BLOCK node and all its subblocks. */
3445 instantiate_decls_1 (let
, valid_only
)
3451 for (t
= BLOCK_VARS (let
); t
; t
= TREE_CHAIN (t
))
3452 instantiate_decl (DECL_RTL (t
), int_size_in_bytes (TREE_TYPE (t
)),
3455 /* Process all subblocks. */
3456 for (t
= BLOCK_SUBBLOCKS (let
); t
; t
= TREE_CHAIN (t
))
3457 instantiate_decls_1 (t
, valid_only
);
3460 /* Subroutine of the preceding procedures: Given RTL representing a
3461 decl and the size of the object, do any instantiation required.
3463 If VALID_ONLY is non-zero, it means that the RTL should only be
3464 changed if the new address is valid. */
3467 instantiate_decl (x
, size
, valid_only
)
3472 enum machine_mode mode
;
3475 /* If this is not a MEM, no need to do anything. Similarly if the
3476 address is a constant or a register that is not a virtual register. */
3478 if (x
== 0 || GET_CODE (x
) != MEM
)
3482 if (CONSTANT_P (addr
)
3483 || (GET_CODE (addr
) == ADDRESSOF
&& GET_CODE (XEXP (addr
, 0)) == REG
)
3484 || (GET_CODE (addr
) == REG
3485 && (REGNO (addr
) < FIRST_VIRTUAL_REGISTER
3486 || REGNO (addr
) > LAST_VIRTUAL_REGISTER
)))
3489 /* If we should only do this if the address is valid, copy the address.
3490 We need to do this so we can undo any changes that might make the
3491 address invalid. This copy is unfortunate, but probably can't be
3495 addr
= copy_rtx (addr
);
3497 instantiate_virtual_regs_1 (&addr
, NULL_RTX
, 0);
3499 if (valid_only
&& size
>= 0)
3501 unsigned HOST_WIDE_INT decl_size
= size
;
3503 /* Now verify that the resulting address is valid for every integer or
3504 floating-point mode up to and including SIZE bytes long. We do this
3505 since the object might be accessed in any mode and frame addresses
3508 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
3509 mode
!= VOIDmode
&& GET_MODE_SIZE (mode
) <= decl_size
;
3510 mode
= GET_MODE_WIDER_MODE (mode
))
3511 if (! memory_address_p (mode
, addr
))
3514 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_FLOAT
);
3515 mode
!= VOIDmode
&& GET_MODE_SIZE (mode
) <= decl_size
;
3516 mode
= GET_MODE_WIDER_MODE (mode
))
3517 if (! memory_address_p (mode
, addr
))
3521 /* Put back the address now that we have updated it and we either know
3522 it is valid or we don't care whether it is valid. */
3527 /* Given a pointer to a piece of rtx and an optional pointer to the
3528 containing object, instantiate any virtual registers present in it.
3530 If EXTRA_INSNS, we always do the replacement and generate
3531 any extra insns before OBJECT. If it zero, we do nothing if replacement
3534 Return 1 if we either had nothing to do or if we were able to do the
3535 needed replacement. Return 0 otherwise; we only return zero if
3536 EXTRA_INSNS is zero.
3538 We first try some simple transformations to avoid the creation of extra
3542 instantiate_virtual_regs_1 (loc
, object
, extra_insns
)
3550 HOST_WIDE_INT offset
= 0;
3556 /* Re-start here to avoid recursion in common cases. */
3563 code
= GET_CODE (x
);
3565 /* Check for some special cases. */
3582 /* We are allowed to set the virtual registers. This means that
3583 the actual register should receive the source minus the
3584 appropriate offset. This is used, for example, in the handling
3585 of non-local gotos. */
3586 if (SET_DEST (x
) == virtual_incoming_args_rtx
)
3587 new = arg_pointer_rtx
, offset
= - in_arg_offset
;
3588 else if (SET_DEST (x
) == virtual_stack_vars_rtx
)
3589 new = frame_pointer_rtx
, offset
= - var_offset
;
3590 else if (SET_DEST (x
) == virtual_stack_dynamic_rtx
)
3591 new = stack_pointer_rtx
, offset
= - dynamic_offset
;
3592 else if (SET_DEST (x
) == virtual_outgoing_args_rtx
)
3593 new = stack_pointer_rtx
, offset
= - out_arg_offset
;
3594 else if (SET_DEST (x
) == virtual_cfa_rtx
)
3595 new = arg_pointer_rtx
, offset
= - cfa_offset
;
3599 rtx src
= SET_SRC (x
);
3601 instantiate_virtual_regs_1 (&src
, NULL_RTX
, 0);
3603 /* The only valid sources here are PLUS or REG. Just do
3604 the simplest possible thing to handle them. */
3605 if (GET_CODE (src
) != REG
&& GET_CODE (src
) != PLUS
)
3609 if (GET_CODE (src
) != REG
)
3610 temp
= force_operand (src
, NULL_RTX
);
3613 temp
= force_operand (plus_constant (temp
, offset
), NULL_RTX
);
3617 emit_insns_before (seq
, object
);
3620 if (! validate_change (object
, &SET_SRC (x
), temp
, 0)
3627 instantiate_virtual_regs_1 (&SET_DEST (x
), object
, extra_insns
);
3632 /* Handle special case of virtual register plus constant. */
3633 if (CONSTANT_P (XEXP (x
, 1)))
3635 rtx old
, new_offset
;
3637 /* Check for (plus (plus VIRT foo) (const_int)) first. */
3638 if (GET_CODE (XEXP (x
, 0)) == PLUS
)
3640 rtx inner
= XEXP (XEXP (x
, 0), 0);
3642 if (inner
== virtual_incoming_args_rtx
)
3643 new = arg_pointer_rtx
, offset
= in_arg_offset
;
3644 else if (inner
== virtual_stack_vars_rtx
)
3645 new = frame_pointer_rtx
, offset
= var_offset
;
3646 else if (inner
== virtual_stack_dynamic_rtx
)
3647 new = stack_pointer_rtx
, offset
= dynamic_offset
;
3648 else if (inner
== virtual_outgoing_args_rtx
)
3649 new = stack_pointer_rtx
, offset
= out_arg_offset
;
3650 else if (inner
== virtual_cfa_rtx
)
3651 new = arg_pointer_rtx
, offset
= cfa_offset
;
3658 instantiate_virtual_regs_1 (&XEXP (XEXP (x
, 0), 1), object
,
3660 new = gen_rtx_PLUS (Pmode
, new, XEXP (XEXP (x
, 0), 1));
3663 else if (XEXP (x
, 0) == virtual_incoming_args_rtx
)
3664 new = arg_pointer_rtx
, offset
= in_arg_offset
;
3665 else if (XEXP (x
, 0) == virtual_stack_vars_rtx
)
3666 new = frame_pointer_rtx
, offset
= var_offset
;
3667 else if (XEXP (x
, 0) == virtual_stack_dynamic_rtx
)
3668 new = stack_pointer_rtx
, offset
= dynamic_offset
;
3669 else if (XEXP (x
, 0) == virtual_outgoing_args_rtx
)
3670 new = stack_pointer_rtx
, offset
= out_arg_offset
;
3671 else if (XEXP (x
, 0) == virtual_cfa_rtx
)
3672 new = arg_pointer_rtx
, offset
= cfa_offset
;
3675 /* We know the second operand is a constant. Unless the
3676 first operand is a REG (which has been already checked),
3677 it needs to be checked. */
3678 if (GET_CODE (XEXP (x
, 0)) != REG
)
3686 new_offset
= plus_constant (XEXP (x
, 1), offset
);
3688 /* If the new constant is zero, try to replace the sum with just
3690 if (new_offset
== const0_rtx
3691 && validate_change (object
, loc
, new, 0))
3694 /* Next try to replace the register and new offset.
3695 There are two changes to validate here and we can't assume that
3696 in the case of old offset equals new just changing the register
3697 will yield a valid insn. In the interests of a little efficiency,
3698 however, we only call validate change once (we don't queue up the
3699 changes and then call apply_change_group). */
3703 ? ! validate_change (object
, &XEXP (x
, 0), new, 0)
3704 : (XEXP (x
, 0) = new,
3705 ! validate_change (object
, &XEXP (x
, 1), new_offset
, 0)))
3713 /* Otherwise copy the new constant into a register and replace
3714 constant with that register. */
3715 temp
= gen_reg_rtx (Pmode
);
3717 if (validate_change (object
, &XEXP (x
, 1), temp
, 0))
3718 emit_insn_before (gen_move_insn (temp
, new_offset
), object
);
3721 /* If that didn't work, replace this expression with a
3722 register containing the sum. */
3725 new = gen_rtx_PLUS (Pmode
, new, new_offset
);
3728 temp
= force_operand (new, NULL_RTX
);
3732 emit_insns_before (seq
, object
);
3733 if (! validate_change (object
, loc
, temp
, 0)
3734 && ! validate_replace_rtx (x
, temp
, object
))
3742 /* Fall through to generic two-operand expression case. */
3748 case DIV
: case UDIV
:
3749 case MOD
: case UMOD
:
3750 case AND
: case IOR
: case XOR
:
3751 case ROTATERT
: case ROTATE
:
3752 case ASHIFTRT
: case LSHIFTRT
: case ASHIFT
:
3754 case GE
: case GT
: case GEU
: case GTU
:
3755 case LE
: case LT
: case LEU
: case LTU
:
3756 if (XEXP (x
, 1) && ! CONSTANT_P (XEXP (x
, 1)))
3757 instantiate_virtual_regs_1 (&XEXP (x
, 1), object
, extra_insns
);
3762 /* Most cases of MEM that convert to valid addresses have already been
3763 handled by our scan of decls. The only special handling we
3764 need here is to make a copy of the rtx to ensure it isn't being
3765 shared if we have to change it to a pseudo.
3767 If the rtx is a simple reference to an address via a virtual register,
3768 it can potentially be shared. In such cases, first try to make it
3769 a valid address, which can also be shared. Otherwise, copy it and
3772 First check for common cases that need no processing. These are
3773 usually due to instantiation already being done on a previous instance
3777 if (CONSTANT_ADDRESS_P (temp
)
3778 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
3779 || temp
== arg_pointer_rtx
3781 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
3782 || temp
== hard_frame_pointer_rtx
3784 || temp
== frame_pointer_rtx
)
3787 if (GET_CODE (temp
) == PLUS
3788 && CONSTANT_ADDRESS_P (XEXP (temp
, 1))
3789 && (XEXP (temp
, 0) == frame_pointer_rtx
3790 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
3791 || XEXP (temp
, 0) == hard_frame_pointer_rtx
3793 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
3794 || XEXP (temp
, 0) == arg_pointer_rtx
3799 if (temp
== virtual_stack_vars_rtx
3800 || temp
== virtual_incoming_args_rtx
3801 || (GET_CODE (temp
) == PLUS
3802 && CONSTANT_ADDRESS_P (XEXP (temp
, 1))
3803 && (XEXP (temp
, 0) == virtual_stack_vars_rtx
3804 || XEXP (temp
, 0) == virtual_incoming_args_rtx
)))
3806 /* This MEM may be shared. If the substitution can be done without
3807 the need to generate new pseudos, we want to do it in place
3808 so all copies of the shared rtx benefit. The call below will
3809 only make substitutions if the resulting address is still
3812 Note that we cannot pass X as the object in the recursive call
3813 since the insn being processed may not allow all valid
3814 addresses. However, if we were not passed on object, we can
3815 only modify X without copying it if X will have a valid
3818 ??? Also note that this can still lose if OBJECT is an insn that
3819 has less restrictions on an address that some other insn.
3820 In that case, we will modify the shared address. This case
3821 doesn't seem very likely, though. One case where this could
3822 happen is in the case of a USE or CLOBBER reference, but we
3823 take care of that below. */
3825 if (instantiate_virtual_regs_1 (&XEXP (x
, 0),
3826 object
? object
: x
, 0))
3829 /* Otherwise make a copy and process that copy. We copy the entire
3830 RTL expression since it might be a PLUS which could also be
3832 *loc
= x
= copy_rtx (x
);
3835 /* Fall through to generic unary operation case. */
3837 case STRICT_LOW_PART
:
3839 case PRE_DEC
: case PRE_INC
: case POST_DEC
: case POST_INC
:
3840 case SIGN_EXTEND
: case ZERO_EXTEND
:
3841 case TRUNCATE
: case FLOAT_EXTEND
: case FLOAT_TRUNCATE
:
3842 case FLOAT
: case FIX
:
3843 case UNSIGNED_FIX
: case UNSIGNED_FLOAT
:
3847 /* These case either have just one operand or we know that we need not
3848 check the rest of the operands. */
3854 /* If the operand is a MEM, see if the change is a valid MEM. If not,
3855 go ahead and make the invalid one, but do it to a copy. For a REG,
3856 just make the recursive call, since there's no chance of a problem. */
3858 if ((GET_CODE (XEXP (x
, 0)) == MEM
3859 && instantiate_virtual_regs_1 (&XEXP (XEXP (x
, 0), 0), XEXP (x
, 0),
3861 || (GET_CODE (XEXP (x
, 0)) == REG
3862 && instantiate_virtual_regs_1 (&XEXP (x
, 0), object
, 0)))
3865 XEXP (x
, 0) = copy_rtx (XEXP (x
, 0));
3870 /* Try to replace with a PLUS. If that doesn't work, compute the sum
3871 in front of this insn and substitute the temporary. */
3872 if (x
== virtual_incoming_args_rtx
)
3873 new = arg_pointer_rtx
, offset
= in_arg_offset
;
3874 else if (x
== virtual_stack_vars_rtx
)
3875 new = frame_pointer_rtx
, offset
= var_offset
;
3876 else if (x
== virtual_stack_dynamic_rtx
)
3877 new = stack_pointer_rtx
, offset
= dynamic_offset
;
3878 else if (x
== virtual_outgoing_args_rtx
)
3879 new = stack_pointer_rtx
, offset
= out_arg_offset
;
3880 else if (x
== virtual_cfa_rtx
)
3881 new = arg_pointer_rtx
, offset
= cfa_offset
;
3885 temp
= plus_constant (new, offset
);
3886 if (!validate_change (object
, loc
, temp
, 0))
3892 temp
= force_operand (temp
, NULL_RTX
);
3896 emit_insns_before (seq
, object
);
3897 if (! validate_change (object
, loc
, temp
, 0)
3898 && ! validate_replace_rtx (x
, temp
, object
))
3906 if (GET_CODE (XEXP (x
, 0)) == REG
)
3909 else if (GET_CODE (XEXP (x
, 0)) == MEM
)
3911 /* If we have a (addressof (mem ..)), do any instantiation inside
3912 since we know we'll be making the inside valid when we finally
3913 remove the ADDRESSOF. */
3914 instantiate_virtual_regs_1 (&XEXP (XEXP (x
, 0), 0), NULL_RTX
, 0);
3923 /* Scan all subexpressions. */
3924 fmt
= GET_RTX_FORMAT (code
);
3925 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++, fmt
++)
3928 if (!instantiate_virtual_regs_1 (&XEXP (x
, i
), object
, extra_insns
))
3931 else if (*fmt
== 'E')
3932 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
3933 if (! instantiate_virtual_regs_1 (&XVECEXP (x
, i
, j
), object
,
3940 /* Optimization: assuming this function does not receive nonlocal gotos,
3941 delete the handlers for such, as well as the insns to establish
3942 and disestablish them. */
3948 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
3950 /* Delete the handler by turning off the flag that would
3951 prevent jump_optimize from deleting it.
3952 Also permit deletion of the nonlocal labels themselves
3953 if nothing local refers to them. */
3954 if (GET_CODE (insn
) == CODE_LABEL
)
3958 LABEL_PRESERVE_P (insn
) = 0;
3960 /* Remove it from the nonlocal_label list, to avoid confusing
3962 for (t
= nonlocal_labels
, last_t
= 0; t
;
3963 last_t
= t
, t
= TREE_CHAIN (t
))
3964 if (DECL_RTL (TREE_VALUE (t
)) == insn
)
3969 nonlocal_labels
= TREE_CHAIN (nonlocal_labels
);
3971 TREE_CHAIN (last_t
) = TREE_CHAIN (t
);
3974 if (GET_CODE (insn
) == INSN
)
3978 for (t
= nonlocal_goto_handler_slots
; t
!= 0; t
= XEXP (t
, 1))
3979 if (reg_mentioned_p (t
, PATTERN (insn
)))
3985 || (nonlocal_goto_stack_level
!= 0
3986 && reg_mentioned_p (nonlocal_goto_stack_level
,
3996 return max_parm_reg
;
3999 /* Return the first insn following those generated by `assign_parms'. */
4002 get_first_nonparm_insn ()
4005 return NEXT_INSN (last_parm_insn
);
4006 return get_insns ();
4009 /* Return the first NOTE_INSN_BLOCK_BEG note in the function.
4010 Crash if there is none. */
4013 get_first_block_beg ()
4015 register rtx searcher
;
4016 register rtx insn
= get_first_nonparm_insn ();
4018 for (searcher
= insn
; searcher
; searcher
= NEXT_INSN (searcher
))
4019 if (GET_CODE (searcher
) == NOTE
4020 && NOTE_LINE_NUMBER (searcher
) == NOTE_INSN_BLOCK_BEG
)
4023 abort (); /* Invalid call to this function. (See comments above.) */
4027 /* Return 1 if EXP is an aggregate type (or a value with aggregate type).
4028 This means a type for which function calls must pass an address to the
4029 function or get an address back from the function.
4030 EXP may be a type node or an expression (whose type is tested). */
4033 aggregate_value_p (exp
)
4036 int i
, regno
, nregs
;
4039 tree type
= (TYPE_P (exp
)) ? exp
: TREE_TYPE (exp
);
4041 if (TREE_CODE (type
) == VOID_TYPE
)
4043 if (RETURN_IN_MEMORY (type
))
4045 /* Types that are TREE_ADDRESSABLE must be constructed in memory,
4046 and thus can't be returned in registers. */
4047 if (TREE_ADDRESSABLE (type
))
4049 if (flag_pcc_struct_return
&& AGGREGATE_TYPE_P (type
))
4051 /* Make sure we have suitable call-clobbered regs to return
4052 the value in; if not, we must return it in memory. */
4053 reg
= hard_function_value (type
, 0, 0);
4055 /* If we have something other than a REG (e.g. a PARALLEL), then assume
4057 if (GET_CODE (reg
) != REG
)
4060 regno
= REGNO (reg
);
4061 nregs
= HARD_REGNO_NREGS (regno
, TYPE_MODE (type
));
4062 for (i
= 0; i
< nregs
; i
++)
4063 if (! call_used_regs
[regno
+ i
])
4068 /* Assign RTL expressions to the function's parameters.
4069 This may involve copying them into registers and using
4070 those registers as the RTL for them. */
4073 assign_parms (fndecl
)
4077 register rtx entry_parm
= 0;
4078 register rtx stack_parm
= 0;
4079 CUMULATIVE_ARGS args_so_far
;
4080 enum machine_mode promoted_mode
, passed_mode
;
4081 enum machine_mode nominal_mode
, promoted_nominal_mode
;
4083 /* Total space needed so far for args on the stack,
4084 given as a constant and a tree-expression. */
4085 struct args_size stack_args_size
;
4086 tree fntype
= TREE_TYPE (fndecl
);
4087 tree fnargs
= DECL_ARGUMENTS (fndecl
);
4088 /* This is used for the arg pointer when referring to stack args. */
4089 rtx internal_arg_pointer
;
4090 /* This is a dummy PARM_DECL that we used for the function result if
4091 the function returns a structure. */
4092 tree function_result_decl
= 0;
4093 #ifdef SETUP_INCOMING_VARARGS
4094 int varargs_setup
= 0;
4096 rtx conversion_insns
= 0;
4097 struct args_size alignment_pad
;
4099 /* Nonzero if the last arg is named `__builtin_va_alist',
4100 which is used on some machines for old-fashioned non-ANSI varargs.h;
4101 this should be stuck onto the stack as if it had arrived there. */
4103 = (current_function_varargs
4105 && (parm
= tree_last (fnargs
)) != 0
4107 && (! strcmp (IDENTIFIER_POINTER (DECL_NAME (parm
)),
4108 "__builtin_va_alist")));
4110 /* Nonzero if function takes extra anonymous args.
4111 This means the last named arg must be on the stack
4112 right before the anonymous ones. */
4114 = (TYPE_ARG_TYPES (fntype
) != 0
4115 && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype
)))
4116 != void_type_node
));
4118 current_function_stdarg
= stdarg
;
4120 /* If the reg that the virtual arg pointer will be translated into is
4121 not a fixed reg or is the stack pointer, make a copy of the virtual
4122 arg pointer, and address parms via the copy. The frame pointer is
4123 considered fixed even though it is not marked as such.
4125 The second time through, simply use ap to avoid generating rtx. */
4127 if ((ARG_POINTER_REGNUM
== STACK_POINTER_REGNUM
4128 || ! (fixed_regs
[ARG_POINTER_REGNUM
]
4129 || ARG_POINTER_REGNUM
== FRAME_POINTER_REGNUM
)))
4130 internal_arg_pointer
= copy_to_reg (virtual_incoming_args_rtx
);
4132 internal_arg_pointer
= virtual_incoming_args_rtx
;
4133 current_function_internal_arg_pointer
= internal_arg_pointer
;
4135 stack_args_size
.constant
= 0;
4136 stack_args_size
.var
= 0;
4138 /* If struct value address is treated as the first argument, make it so. */
4139 if (aggregate_value_p (DECL_RESULT (fndecl
))
4140 && ! current_function_returns_pcc_struct
4141 && struct_value_incoming_rtx
== 0)
4143 tree type
= build_pointer_type (TREE_TYPE (fntype
));
4145 function_result_decl
= build_decl (PARM_DECL
, NULL_TREE
, type
);
4147 DECL_ARG_TYPE (function_result_decl
) = type
;
4148 TREE_CHAIN (function_result_decl
) = fnargs
;
4149 fnargs
= function_result_decl
;
4152 max_parm_reg
= LAST_VIRTUAL_REGISTER
+ 1;
4153 parm_reg_stack_loc
= (rtx
*) xcalloc (max_parm_reg
, sizeof (rtx
));
4155 #ifdef INIT_CUMULATIVE_INCOMING_ARGS
4156 INIT_CUMULATIVE_INCOMING_ARGS (args_so_far
, fntype
, NULL_RTX
);
4158 INIT_CUMULATIVE_ARGS (args_so_far
, fntype
, NULL_RTX
, 0);
4161 /* We haven't yet found an argument that we must push and pretend the
4163 current_function_pretend_args_size
= 0;
4165 for (parm
= fnargs
; parm
; parm
= TREE_CHAIN (parm
))
4167 struct args_size stack_offset
;
4168 struct args_size arg_size
;
4169 int passed_pointer
= 0;
4170 int did_conversion
= 0;
4171 tree passed_type
= DECL_ARG_TYPE (parm
);
4172 tree nominal_type
= TREE_TYPE (parm
);
4175 /* Set LAST_NAMED if this is last named arg before some
4177 int last_named
= ((TREE_CHAIN (parm
) == 0
4178 || DECL_NAME (TREE_CHAIN (parm
)) == 0)
4179 && (stdarg
|| current_function_varargs
));
4180 /* Set NAMED_ARG if this arg should be treated as a named arg. For
4181 most machines, if this is a varargs/stdarg function, then we treat
4182 the last named arg as if it were anonymous too. */
4183 int named_arg
= STRICT_ARGUMENT_NAMING
? 1 : ! last_named
;
4185 if (TREE_TYPE (parm
) == error_mark_node
4186 /* This can happen after weird syntax errors
4187 or if an enum type is defined among the parms. */
4188 || TREE_CODE (parm
) != PARM_DECL
4189 || passed_type
== NULL
)
4191 DECL_INCOMING_RTL (parm
) = DECL_RTL (parm
)
4192 = gen_rtx_MEM (BLKmode
, const0_rtx
);
4193 TREE_USED (parm
) = 1;
4197 /* For varargs.h function, save info about regs and stack space
4198 used by the individual args, not including the va_alist arg. */
4199 if (hide_last_arg
&& last_named
)
4200 current_function_args_info
= args_so_far
;
4202 /* Find mode of arg as it is passed, and mode of arg
4203 as it should be during execution of this function. */
4204 passed_mode
= TYPE_MODE (passed_type
);
4205 nominal_mode
= TYPE_MODE (nominal_type
);
4207 /* If the parm's mode is VOID, its value doesn't matter,
4208 and avoid the usual things like emit_move_insn that could crash. */
4209 if (nominal_mode
== VOIDmode
)
4211 DECL_INCOMING_RTL (parm
) = DECL_RTL (parm
) = const0_rtx
;
4215 /* If the parm is to be passed as a transparent union, use the
4216 type of the first field for the tests below. We have already
4217 verified that the modes are the same. */
4218 if (DECL_TRANSPARENT_UNION (parm
)
4219 || (TREE_CODE (passed_type
) == UNION_TYPE
4220 && TYPE_TRANSPARENT_UNION (passed_type
)))
4221 passed_type
= TREE_TYPE (TYPE_FIELDS (passed_type
));
4223 /* See if this arg was passed by invisible reference. It is if
4224 it is an object whose size depends on the contents of the
4225 object itself or if the machine requires these objects be passed
4228 if ((TREE_CODE (TYPE_SIZE (passed_type
)) != INTEGER_CST
4229 && contains_placeholder_p (TYPE_SIZE (passed_type
)))
4230 || TREE_ADDRESSABLE (passed_type
)
4231 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
4232 || FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far
, passed_mode
,
4233 passed_type
, named_arg
)
4237 passed_type
= nominal_type
= build_pointer_type (passed_type
);
4239 passed_mode
= nominal_mode
= Pmode
;
4242 promoted_mode
= passed_mode
;
4244 #ifdef PROMOTE_FUNCTION_ARGS
4245 /* Compute the mode in which the arg is actually extended to. */
4246 unsignedp
= TREE_UNSIGNED (passed_type
);
4247 promoted_mode
= promote_mode (passed_type
, promoted_mode
, &unsignedp
, 1);
4250 /* Let machine desc say which reg (if any) the parm arrives in.
4251 0 means it arrives on the stack. */
4252 #ifdef FUNCTION_INCOMING_ARG
4253 entry_parm
= FUNCTION_INCOMING_ARG (args_so_far
, promoted_mode
,
4254 passed_type
, named_arg
);
4256 entry_parm
= FUNCTION_ARG (args_so_far
, promoted_mode
,
4257 passed_type
, named_arg
);
4260 if (entry_parm
== 0)
4261 promoted_mode
= passed_mode
;
4263 #ifdef SETUP_INCOMING_VARARGS
4264 /* If this is the last named parameter, do any required setup for
4265 varargs or stdargs. We need to know about the case of this being an
4266 addressable type, in which case we skip the registers it
4267 would have arrived in.
4269 For stdargs, LAST_NAMED will be set for two parameters, the one that
4270 is actually the last named, and the dummy parameter. We only
4271 want to do this action once.
4273 Also, indicate when RTL generation is to be suppressed. */
4274 if (last_named
&& !varargs_setup
)
4276 SETUP_INCOMING_VARARGS (args_so_far
, promoted_mode
, passed_type
,
4277 current_function_pretend_args_size
, 0);
4282 /* Determine parm's home in the stack,
4283 in case it arrives in the stack or we should pretend it did.
4285 Compute the stack position and rtx where the argument arrives
4288 There is one complexity here: If this was a parameter that would
4289 have been passed in registers, but wasn't only because it is
4290 __builtin_va_alist, we want locate_and_pad_parm to treat it as if
4291 it came in a register so that REG_PARM_STACK_SPACE isn't skipped.
4292 In this case, we call FUNCTION_ARG with NAMED set to 1 instead of
4293 0 as it was the previous time. */
4295 pretend_named
= named_arg
|| PRETEND_OUTGOING_VARARGS_NAMED
;
4296 locate_and_pad_parm (promoted_mode
, passed_type
,
4297 #ifdef STACK_PARMS_IN_REG_PARM_AREA
4300 #ifdef FUNCTION_INCOMING_ARG
4301 FUNCTION_INCOMING_ARG (args_so_far
, promoted_mode
,
4303 pretend_named
) != 0,
4305 FUNCTION_ARG (args_so_far
, promoted_mode
,
4307 pretend_named
) != 0,
4310 fndecl
, &stack_args_size
, &stack_offset
, &arg_size
,
4314 rtx offset_rtx
= ARGS_SIZE_RTX (stack_offset
);
4316 if (offset_rtx
== const0_rtx
)
4317 stack_parm
= gen_rtx_MEM (promoted_mode
, internal_arg_pointer
);
4319 stack_parm
= gen_rtx_MEM (promoted_mode
,
4320 gen_rtx_PLUS (Pmode
,
4321 internal_arg_pointer
,
4324 set_mem_attributes (stack_parm
, parm
, 1);
4327 /* If this parameter was passed both in registers and in the stack,
4328 use the copy on the stack. */
4329 if (MUST_PASS_IN_STACK (promoted_mode
, passed_type
))
4332 #ifdef FUNCTION_ARG_PARTIAL_NREGS
4333 /* If this parm was passed part in regs and part in memory,
4334 pretend it arrived entirely in memory
4335 by pushing the register-part onto the stack.
4337 In the special case of a DImode or DFmode that is split,
4338 we could put it together in a pseudoreg directly,
4339 but for now that's not worth bothering with. */
4343 int nregs
= FUNCTION_ARG_PARTIAL_NREGS (args_so_far
, promoted_mode
,
4344 passed_type
, named_arg
);
4348 current_function_pretend_args_size
4349 = (((nregs
* UNITS_PER_WORD
) + (PARM_BOUNDARY
/ BITS_PER_UNIT
) - 1)
4350 / (PARM_BOUNDARY
/ BITS_PER_UNIT
)
4351 * (PARM_BOUNDARY
/ BITS_PER_UNIT
));
4353 /* Handle calls that pass values in multiple non-contiguous
4354 locations. The Irix 6 ABI has examples of this. */
4355 if (GET_CODE (entry_parm
) == PARALLEL
)
4356 emit_group_store (validize_mem (stack_parm
), entry_parm
,
4357 int_size_in_bytes (TREE_TYPE (parm
)),
4358 TYPE_ALIGN (TREE_TYPE (parm
)));
4361 move_block_from_reg (REGNO (entry_parm
),
4362 validize_mem (stack_parm
), nregs
,
4363 int_size_in_bytes (TREE_TYPE (parm
)));
4365 entry_parm
= stack_parm
;
4370 /* If we didn't decide this parm came in a register,
4371 by default it came on the stack. */
4372 if (entry_parm
== 0)
4373 entry_parm
= stack_parm
;
4375 /* Record permanently how this parm was passed. */
4376 DECL_INCOMING_RTL (parm
) = entry_parm
;
4378 /* If there is actually space on the stack for this parm,
4379 count it in stack_args_size; otherwise set stack_parm to 0
4380 to indicate there is no preallocated stack slot for the parm. */
4382 if (entry_parm
== stack_parm
4383 || (GET_CODE (entry_parm
) == PARALLEL
4384 && XEXP (XVECEXP (entry_parm
, 0, 0), 0) == NULL_RTX
)
4385 #if defined (REG_PARM_STACK_SPACE) && ! defined (MAYBE_REG_PARM_STACK_SPACE)
4386 /* On some machines, even if a parm value arrives in a register
4387 there is still an (uninitialized) stack slot allocated for it.
4389 ??? When MAYBE_REG_PARM_STACK_SPACE is defined, we can't tell
4390 whether this parameter already has a stack slot allocated,
4391 because an arg block exists only if current_function_args_size
4392 is larger than some threshold, and we haven't calculated that
4393 yet. So, for now, we just assume that stack slots never exist
4395 || REG_PARM_STACK_SPACE (fndecl
) > 0
4399 stack_args_size
.constant
+= arg_size
.constant
;
4401 ADD_PARM_SIZE (stack_args_size
, arg_size
.var
);
4404 /* No stack slot was pushed for this parm. */
4407 /* Update info on where next arg arrives in registers. */
4409 FUNCTION_ARG_ADVANCE (args_so_far
, promoted_mode
,
4410 passed_type
, named_arg
);
4412 /* If we can't trust the parm stack slot to be aligned enough
4413 for its ultimate type, don't use that slot after entry.
4414 We'll make another stack slot, if we need one. */
4416 unsigned int thisparm_boundary
4417 = FUNCTION_ARG_BOUNDARY (promoted_mode
, passed_type
);
4419 if (GET_MODE_ALIGNMENT (nominal_mode
) > thisparm_boundary
)
4423 /* If parm was passed in memory, and we need to convert it on entry,
4424 don't store it back in that same slot. */
4426 && nominal_mode
!= BLKmode
&& nominal_mode
!= passed_mode
)
4429 /* ENTRY_PARM is an RTX for the parameter as it arrives,
4430 in the mode in which it arrives.
4431 STACK_PARM is an RTX for a stack slot where the parameter can live
4432 during the function (in case we want to put it there).
4433 STACK_PARM is 0 if no stack slot was pushed for it.
4435 Now output code if necessary to convert ENTRY_PARM to
4436 the type in which this function declares it,
4437 and store that result in an appropriate place,
4438 which may be a pseudo reg, may be STACK_PARM,
4439 or may be a local stack slot if STACK_PARM is 0.
4441 Set DECL_RTL to that place. */
4443 if (nominal_mode
== BLKmode
|| GET_CODE (entry_parm
) == PARALLEL
)
4445 /* If a BLKmode arrives in registers, copy it to a stack slot.
4446 Handle calls that pass values in multiple non-contiguous
4447 locations. The Irix 6 ABI has examples of this. */
4448 if (GET_CODE (entry_parm
) == REG
4449 || GET_CODE (entry_parm
) == PARALLEL
)
4452 = CEIL_ROUND (int_size_in_bytes (TREE_TYPE (parm
)),
4455 /* Note that we will be storing an integral number of words.
4456 So we have to be careful to ensure that we allocate an
4457 integral number of words. We do this below in the
4458 assign_stack_local if space was not allocated in the argument
4459 list. If it was, this will not work if PARM_BOUNDARY is not
4460 a multiple of BITS_PER_WORD. It isn't clear how to fix this
4461 if it becomes a problem. */
4463 if (stack_parm
== 0)
4466 = assign_stack_local (GET_MODE (entry_parm
),
4468 set_mem_attributes (stack_parm
, parm
, 1);
4471 else if (PARM_BOUNDARY
% BITS_PER_WORD
!= 0)
4474 /* Handle calls that pass values in multiple non-contiguous
4475 locations. The Irix 6 ABI has examples of this. */
4476 if (GET_CODE (entry_parm
) == PARALLEL
)
4477 emit_group_store (validize_mem (stack_parm
), entry_parm
,
4478 int_size_in_bytes (TREE_TYPE (parm
)),
4479 TYPE_ALIGN (TREE_TYPE (parm
)));
4481 move_block_from_reg (REGNO (entry_parm
),
4482 validize_mem (stack_parm
),
4483 size_stored
/ UNITS_PER_WORD
,
4484 int_size_in_bytes (TREE_TYPE (parm
)));
4486 DECL_RTL (parm
) = stack_parm
;
4488 else if (! ((! optimize
4489 && ! DECL_REGISTER (parm
)
4490 && ! DECL_INLINE (fndecl
))
4491 /* layout_decl may set this. */
4492 || TREE_ADDRESSABLE (parm
)
4493 || TREE_SIDE_EFFECTS (parm
)
4494 /* If -ffloat-store specified, don't put explicit
4495 float variables into registers. */
4496 || (flag_float_store
4497 && TREE_CODE (TREE_TYPE (parm
)) == REAL_TYPE
))
4498 /* Always assign pseudo to structure return or item passed
4499 by invisible reference. */
4500 || passed_pointer
|| parm
== function_result_decl
)
4502 /* Store the parm in a pseudoregister during the function, but we
4503 may need to do it in a wider mode. */
4505 register rtx parmreg
;
4506 unsigned int regno
, regnoi
= 0, regnor
= 0;
4508 unsignedp
= TREE_UNSIGNED (TREE_TYPE (parm
));
4510 promoted_nominal_mode
4511 = promote_mode (TREE_TYPE (parm
), nominal_mode
, &unsignedp
, 0);
4513 parmreg
= gen_reg_rtx (promoted_nominal_mode
);
4514 mark_user_reg (parmreg
);
4516 /* If this was an item that we received a pointer to, set DECL_RTL
4521 = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (passed_type
)), parmreg
);
4522 set_mem_attributes (DECL_RTL (parm
), parm
, 1);
4525 DECL_RTL (parm
) = parmreg
;
4527 /* Copy the value into the register. */
4528 if (nominal_mode
!= passed_mode
4529 || promoted_nominal_mode
!= promoted_mode
)
4532 /* ENTRY_PARM has been converted to PROMOTED_MODE, its
4533 mode, by the caller. We now have to convert it to
4534 NOMINAL_MODE, if different. However, PARMREG may be in
4535 a different mode than NOMINAL_MODE if it is being stored
4538 If ENTRY_PARM is a hard register, it might be in a register
4539 not valid for operating in its mode (e.g., an odd-numbered
4540 register for a DFmode). In that case, moves are the only
4541 thing valid, so we can't do a convert from there. This
4542 occurs when the calling sequence allow such misaligned
4545 In addition, the conversion may involve a call, which could
4546 clobber parameters which haven't been copied to pseudo
4547 registers yet. Therefore, we must first copy the parm to
4548 a pseudo reg here, and save the conversion until after all
4549 parameters have been moved. */
4551 rtx tempreg
= gen_reg_rtx (GET_MODE (entry_parm
));
4553 emit_move_insn (tempreg
, validize_mem (entry_parm
));
4555 push_to_sequence (conversion_insns
);
4556 tempreg
= convert_to_mode (nominal_mode
, tempreg
, unsignedp
);
4558 /* TREE_USED gets set erroneously during expand_assignment. */
4559 save_tree_used
= TREE_USED (parm
);
4560 expand_assignment (parm
,
4561 make_tree (nominal_type
, tempreg
), 0, 0);
4562 TREE_USED (parm
) = save_tree_used
;
4563 conversion_insns
= get_insns ();
4568 emit_move_insn (parmreg
, validize_mem (entry_parm
));
4570 /* If we were passed a pointer but the actual value
4571 can safely live in a register, put it in one. */
4572 if (passed_pointer
&& TYPE_MODE (TREE_TYPE (parm
)) != BLKmode
4574 && ! DECL_REGISTER (parm
)
4575 && ! DECL_INLINE (fndecl
))
4576 /* layout_decl may set this. */
4577 || TREE_ADDRESSABLE (parm
)
4578 || TREE_SIDE_EFFECTS (parm
)
4579 /* If -ffloat-store specified, don't put explicit
4580 float variables into registers. */
4581 || (flag_float_store
4582 && TREE_CODE (TREE_TYPE (parm
)) == REAL_TYPE
)))
4584 /* We can't use nominal_mode, because it will have been set to
4585 Pmode above. We must use the actual mode of the parm. */
4586 parmreg
= gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm
)));
4587 mark_user_reg (parmreg
);
4588 emit_move_insn (parmreg
, DECL_RTL (parm
));
4589 DECL_RTL (parm
) = parmreg
;
4590 /* STACK_PARM is the pointer, not the parm, and PARMREG is
4594 #ifdef FUNCTION_ARG_CALLEE_COPIES
4595 /* If we are passed an arg by reference and it is our responsibility
4596 to make a copy, do it now.
4597 PASSED_TYPE and PASSED mode now refer to the pointer, not the
4598 original argument, so we must recreate them in the call to
4599 FUNCTION_ARG_CALLEE_COPIES. */
4600 /* ??? Later add code to handle the case that if the argument isn't
4601 modified, don't do the copy. */
4603 else if (passed_pointer
4604 && FUNCTION_ARG_CALLEE_COPIES (args_so_far
,
4605 TYPE_MODE (DECL_ARG_TYPE (parm
)),
4606 DECL_ARG_TYPE (parm
),
4608 && ! TREE_ADDRESSABLE (DECL_ARG_TYPE (parm
)))
4611 tree type
= DECL_ARG_TYPE (parm
);
4613 /* This sequence may involve a library call perhaps clobbering
4614 registers that haven't been copied to pseudos yet. */
4616 push_to_sequence (conversion_insns
);
4618 if (!COMPLETE_TYPE_P (type
)
4619 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
4620 /* This is a variable sized object. */
4621 copy
= gen_rtx_MEM (BLKmode
,
4622 allocate_dynamic_stack_space
4623 (expr_size (parm
), NULL_RTX
,
4624 TYPE_ALIGN (type
)));
4626 copy
= assign_stack_temp (TYPE_MODE (type
),
4627 int_size_in_bytes (type
), 1);
4628 set_mem_attributes (copy
, parm
, 1);
4630 store_expr (parm
, copy
, 0);
4631 emit_move_insn (parmreg
, XEXP (copy
, 0));
4632 if (current_function_check_memory_usage
)
4633 emit_library_call (chkr_set_right_libfunc
, 1, VOIDmode
, 3,
4634 XEXP (copy
, 0), Pmode
,
4635 GEN_INT (int_size_in_bytes (type
)),
4636 TYPE_MODE (sizetype
),
4637 GEN_INT (MEMORY_USE_RW
),
4638 TYPE_MODE (integer_type_node
));
4639 conversion_insns
= get_insns ();
4643 #endif /* FUNCTION_ARG_CALLEE_COPIES */
4645 /* In any case, record the parm's desired stack location
4646 in case we later discover it must live in the stack.
4648 If it is a COMPLEX value, store the stack location for both
4651 if (GET_CODE (parmreg
) == CONCAT
)
4652 regno
= MAX (REGNO (XEXP (parmreg
, 0)), REGNO (XEXP (parmreg
, 1)));
4654 regno
= REGNO (parmreg
);
4656 if (regno
>= max_parm_reg
)
4659 int old_max_parm_reg
= max_parm_reg
;
4661 /* It's slow to expand this one register at a time,
4662 but it's also rare and we need max_parm_reg to be
4663 precisely correct. */
4664 max_parm_reg
= regno
+ 1;
4665 new = (rtx
*) xrealloc (parm_reg_stack_loc
,
4666 max_parm_reg
* sizeof (rtx
));
4667 bzero ((char *) (new + old_max_parm_reg
),
4668 (max_parm_reg
- old_max_parm_reg
) * sizeof (rtx
));
4669 parm_reg_stack_loc
= new;
4672 if (GET_CODE (parmreg
) == CONCAT
)
4674 enum machine_mode submode
= GET_MODE (XEXP (parmreg
, 0));
4676 regnor
= REGNO (gen_realpart (submode
, parmreg
));
4677 regnoi
= REGNO (gen_imagpart (submode
, parmreg
));
4679 if (stack_parm
!= 0)
4681 parm_reg_stack_loc
[regnor
]
4682 = gen_realpart (submode
, stack_parm
);
4683 parm_reg_stack_loc
[regnoi
]
4684 = gen_imagpart (submode
, stack_parm
);
4688 parm_reg_stack_loc
[regnor
] = 0;
4689 parm_reg_stack_loc
[regnoi
] = 0;
4693 parm_reg_stack_loc
[REGNO (parmreg
)] = stack_parm
;
4695 /* Mark the register as eliminable if we did no conversion
4696 and it was copied from memory at a fixed offset,
4697 and the arg pointer was not copied to a pseudo-reg.
4698 If the arg pointer is a pseudo reg or the offset formed
4699 an invalid address, such memory-equivalences
4700 as we make here would screw up life analysis for it. */
4701 if (nominal_mode
== passed_mode
4704 && GET_CODE (stack_parm
) == MEM
4705 && stack_offset
.var
== 0
4706 && reg_mentioned_p (virtual_incoming_args_rtx
,
4707 XEXP (stack_parm
, 0)))
4709 rtx linsn
= get_last_insn ();
4712 /* Mark complex types separately. */
4713 if (GET_CODE (parmreg
) == CONCAT
)
4714 /* Scan backwards for the set of the real and
4716 for (sinsn
= linsn
; sinsn
!= 0;
4717 sinsn
= prev_nonnote_insn (sinsn
))
4719 set
= single_set (sinsn
);
4721 && SET_DEST (set
) == regno_reg_rtx
[regnoi
])
4723 = gen_rtx_EXPR_LIST (REG_EQUIV
,
4724 parm_reg_stack_loc
[regnoi
],
4727 && SET_DEST (set
) == regno_reg_rtx
[regnor
])
4729 = gen_rtx_EXPR_LIST (REG_EQUIV
,
4730 parm_reg_stack_loc
[regnor
],
4733 else if ((set
= single_set (linsn
)) != 0
4734 && SET_DEST (set
) == parmreg
)
4736 = gen_rtx_EXPR_LIST (REG_EQUIV
,
4737 stack_parm
, REG_NOTES (linsn
));
4740 /* For pointer data type, suggest pointer register. */
4741 if (POINTER_TYPE_P (TREE_TYPE (parm
)))
4742 mark_reg_pointer (parmreg
,
4743 TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm
))));
4748 /* Value must be stored in the stack slot STACK_PARM
4749 during function execution. */
4751 if (promoted_mode
!= nominal_mode
)
4753 /* Conversion is required. */
4754 rtx tempreg
= gen_reg_rtx (GET_MODE (entry_parm
));
4756 emit_move_insn (tempreg
, validize_mem (entry_parm
));
4758 push_to_sequence (conversion_insns
);
4759 entry_parm
= convert_to_mode (nominal_mode
, tempreg
,
4760 TREE_UNSIGNED (TREE_TYPE (parm
)));
4763 /* ??? This may need a big-endian conversion on sparc64. */
4764 stack_parm
= change_address (stack_parm
, nominal_mode
,
4767 conversion_insns
= get_insns ();
4772 if (entry_parm
!= stack_parm
)
4774 if (stack_parm
== 0)
4777 = assign_stack_local (GET_MODE (entry_parm
),
4778 GET_MODE_SIZE (GET_MODE (entry_parm
)), 0);
4779 set_mem_attributes (stack_parm
, parm
, 1);
4782 if (promoted_mode
!= nominal_mode
)
4784 push_to_sequence (conversion_insns
);
4785 emit_move_insn (validize_mem (stack_parm
),
4786 validize_mem (entry_parm
));
4787 conversion_insns
= get_insns ();
4791 emit_move_insn (validize_mem (stack_parm
),
4792 validize_mem (entry_parm
));
4794 if (current_function_check_memory_usage
)
4796 push_to_sequence (conversion_insns
);
4797 emit_library_call (chkr_set_right_libfunc
, 1, VOIDmode
, 3,
4798 XEXP (stack_parm
, 0), Pmode
,
4799 GEN_INT (GET_MODE_SIZE (GET_MODE
4801 TYPE_MODE (sizetype
),
4802 GEN_INT (MEMORY_USE_RW
),
4803 TYPE_MODE (integer_type_node
));
4805 conversion_insns
= get_insns ();
4808 DECL_RTL (parm
) = stack_parm
;
4811 /* If this "parameter" was the place where we are receiving the
4812 function's incoming structure pointer, set up the result. */
4813 if (parm
== function_result_decl
)
4815 tree result
= DECL_RESULT (fndecl
);
4818 = gen_rtx_MEM (DECL_MODE (result
), DECL_RTL (parm
));
4820 set_mem_attributes (DECL_RTL (result
), result
, 1);
4824 /* Output all parameter conversion instructions (possibly including calls)
4825 now that all parameters have been copied out of hard registers. */
4826 emit_insns (conversion_insns
);
4828 last_parm_insn
= get_last_insn ();
4830 current_function_args_size
= stack_args_size
.constant
;
4832 /* Adjust function incoming argument size for alignment and
4835 #ifdef REG_PARM_STACK_SPACE
4836 #ifndef MAYBE_REG_PARM_STACK_SPACE
4837 current_function_args_size
= MAX (current_function_args_size
,
4838 REG_PARM_STACK_SPACE (fndecl
));
4842 #ifdef STACK_BOUNDARY
4843 #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
4845 current_function_args_size
4846 = ((current_function_args_size
+ STACK_BYTES
- 1)
4847 / STACK_BYTES
) * STACK_BYTES
;
4850 #ifdef ARGS_GROW_DOWNWARD
4851 current_function_arg_offset_rtx
4852 = (stack_args_size
.var
== 0 ? GEN_INT (-stack_args_size
.constant
)
4853 : expand_expr (size_diffop (stack_args_size
.var
,
4854 size_int (-stack_args_size
.constant
)),
4855 NULL_RTX
, VOIDmode
, EXPAND_MEMORY_USE_BAD
));
4857 current_function_arg_offset_rtx
= ARGS_SIZE_RTX (stack_args_size
);
4860 /* See how many bytes, if any, of its args a function should try to pop
4863 current_function_pops_args
= RETURN_POPS_ARGS (fndecl
, TREE_TYPE (fndecl
),
4864 current_function_args_size
);
4866 /* For stdarg.h function, save info about
4867 regs and stack space used by the named args. */
4870 current_function_args_info
= args_so_far
;
4872 /* Set the rtx used for the function return value. Put this in its
4873 own variable so any optimizers that need this information don't have
4874 to include tree.h. Do this here so it gets done when an inlined
4875 function gets output. */
4877 current_function_return_rtx
= DECL_RTL (DECL_RESULT (fndecl
));
4880 /* Indicate whether REGNO is an incoming argument to the current function
4881 that was promoted to a wider mode. If so, return the RTX for the
4882 register (to get its mode). PMODE and PUNSIGNEDP are set to the mode
4883 that REGNO is promoted from and whether the promotion was signed or
4886 #ifdef PROMOTE_FUNCTION_ARGS
4889 promoted_input_arg (regno
, pmode
, punsignedp
)
4891 enum machine_mode
*pmode
;
4896 for (arg
= DECL_ARGUMENTS (current_function_decl
); arg
;
4897 arg
= TREE_CHAIN (arg
))
4898 if (GET_CODE (DECL_INCOMING_RTL (arg
)) == REG
4899 && REGNO (DECL_INCOMING_RTL (arg
)) == regno
4900 && TYPE_MODE (DECL_ARG_TYPE (arg
)) == TYPE_MODE (TREE_TYPE (arg
)))
4902 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (arg
));
4903 int unsignedp
= TREE_UNSIGNED (TREE_TYPE (arg
));
4905 mode
= promote_mode (TREE_TYPE (arg
), mode
, &unsignedp
, 1);
4906 if (mode
== GET_MODE (DECL_INCOMING_RTL (arg
))
4907 && mode
!= DECL_MODE (arg
))
4909 *pmode
= DECL_MODE (arg
);
4910 *punsignedp
= unsignedp
;
4911 return DECL_INCOMING_RTL (arg
);
4920 /* Compute the size and offset from the start of the stacked arguments for a
4921 parm passed in mode PASSED_MODE and with type TYPE.
4923 INITIAL_OFFSET_PTR points to the current offset into the stacked
4926 The starting offset and size for this parm are returned in *OFFSET_PTR
4927 and *ARG_SIZE_PTR, respectively.
4929 IN_REGS is non-zero if the argument will be passed in registers. It will
4930 never be set if REG_PARM_STACK_SPACE is not defined.
4932 FNDECL is the function in which the argument was defined.
4934 There are two types of rounding that are done. The first, controlled by
4935 FUNCTION_ARG_BOUNDARY, forces the offset from the start of the argument
4936 list to be aligned to the specific boundary (in bits). This rounding
4937 affects the initial and starting offsets, but not the argument size.
4939 The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY,
4940 optionally rounds the size of the parm to PARM_BOUNDARY. The
4941 initial offset is not affected by this rounding, while the size always
4942 is and the starting offset may be. */
4944 /* offset_ptr will be negative for ARGS_GROW_DOWNWARD case;
4945 initial_offset_ptr is positive because locate_and_pad_parm's
4946 callers pass in the total size of args so far as
4947 initial_offset_ptr. arg_size_ptr is always positive.*/
4950 locate_and_pad_parm (passed_mode
, type
, in_regs
, fndecl
,
4951 initial_offset_ptr
, offset_ptr
, arg_size_ptr
,
4953 enum machine_mode passed_mode
;
4955 int in_regs ATTRIBUTE_UNUSED
;
4956 tree fndecl ATTRIBUTE_UNUSED
;
4957 struct args_size
*initial_offset_ptr
;
4958 struct args_size
*offset_ptr
;
4959 struct args_size
*arg_size_ptr
;
4960 struct args_size
*alignment_pad
;
4964 = type
? size_in_bytes (type
) : size_int (GET_MODE_SIZE (passed_mode
));
4965 enum direction where_pad
= FUNCTION_ARG_PADDING (passed_mode
, type
);
4966 int boundary
= FUNCTION_ARG_BOUNDARY (passed_mode
, type
);
4968 #ifdef REG_PARM_STACK_SPACE
4969 /* If we have found a stack parm before we reach the end of the
4970 area reserved for registers, skip that area. */
4973 int reg_parm_stack_space
= 0;
4975 #ifdef MAYBE_REG_PARM_STACK_SPACE
4976 reg_parm_stack_space
= MAYBE_REG_PARM_STACK_SPACE
;
4978 reg_parm_stack_space
= REG_PARM_STACK_SPACE (fndecl
);
4980 if (reg_parm_stack_space
> 0)
4982 if (initial_offset_ptr
->var
)
4984 initial_offset_ptr
->var
4985 = size_binop (MAX_EXPR
, ARGS_SIZE_TREE (*initial_offset_ptr
),
4986 ssize_int (reg_parm_stack_space
));
4987 initial_offset_ptr
->constant
= 0;
4989 else if (initial_offset_ptr
->constant
< reg_parm_stack_space
)
4990 initial_offset_ptr
->constant
= reg_parm_stack_space
;
4993 #endif /* REG_PARM_STACK_SPACE */
4995 arg_size_ptr
->var
= 0;
4996 arg_size_ptr
->constant
= 0;
4998 #ifdef ARGS_GROW_DOWNWARD
4999 if (initial_offset_ptr
->var
)
5001 offset_ptr
->constant
= 0;
5002 offset_ptr
->var
= size_binop (MINUS_EXPR
, ssize_int (0),
5003 initial_offset_ptr
->var
);
5007 offset_ptr
->constant
= - initial_offset_ptr
->constant
;
5008 offset_ptr
->var
= 0;
5010 if (where_pad
!= none
5011 && (TREE_CODE (sizetree
) != INTEGER_CST
5012 || ((TREE_INT_CST_LOW (sizetree
) * BITS_PER_UNIT
) % PARM_BOUNDARY
)))
5013 sizetree
= round_up (sizetree
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
5014 SUB_PARM_SIZE (*offset_ptr
, sizetree
);
5015 if (where_pad
!= downward
)
5016 pad_to_arg_alignment (offset_ptr
, boundary
, alignment_pad
);
5017 if (initial_offset_ptr
->var
)
5018 arg_size_ptr
->var
= size_binop (MINUS_EXPR
,
5019 size_binop (MINUS_EXPR
,
5021 initial_offset_ptr
->var
),
5025 arg_size_ptr
->constant
= (- initial_offset_ptr
->constant
5026 - offset_ptr
->constant
);
5028 #else /* !ARGS_GROW_DOWNWARD */
5029 pad_to_arg_alignment (initial_offset_ptr
, boundary
, alignment_pad
);
5030 *offset_ptr
= *initial_offset_ptr
;
5032 #ifdef PUSH_ROUNDING
5033 if (passed_mode
!= BLKmode
)
5034 sizetree
= size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree
)));
5037 /* Pad_below needs the pre-rounded size to know how much to pad below
5038 so this must be done before rounding up. */
5039 if (where_pad
== downward
5040 /* However, BLKmode args passed in regs have their padding done elsewhere.
5041 The stack slot must be able to hold the entire register. */
5042 && !(in_regs
&& passed_mode
== BLKmode
))
5043 pad_below (offset_ptr
, passed_mode
, sizetree
);
5045 if (where_pad
!= none
5046 && (TREE_CODE (sizetree
) != INTEGER_CST
5047 || ((TREE_INT_CST_LOW (sizetree
) * BITS_PER_UNIT
) % PARM_BOUNDARY
)))
5048 sizetree
= round_up (sizetree
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
5050 ADD_PARM_SIZE (*arg_size_ptr
, sizetree
);
5051 #endif /* ARGS_GROW_DOWNWARD */
5054 /* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY.
5055 BOUNDARY is measured in bits, but must be a multiple of a storage unit. */
5058 pad_to_arg_alignment (offset_ptr
, boundary
, alignment_pad
)
5059 struct args_size
*offset_ptr
;
5061 struct args_size
*alignment_pad
;
5063 tree save_var
= NULL_TREE
;
5064 HOST_WIDE_INT save_constant
= 0;
5066 int boundary_in_bytes
= boundary
/ BITS_PER_UNIT
;
5068 if (boundary
> PARM_BOUNDARY
&& boundary
> STACK_BOUNDARY
)
5070 save_var
= offset_ptr
->var
;
5071 save_constant
= offset_ptr
->constant
;
5074 alignment_pad
->var
= NULL_TREE
;
5075 alignment_pad
->constant
= 0;
5077 if (boundary
> BITS_PER_UNIT
)
5079 if (offset_ptr
->var
)
5082 #ifdef ARGS_GROW_DOWNWARD
5087 (ARGS_SIZE_TREE (*offset_ptr
),
5088 boundary
/ BITS_PER_UNIT
);
5089 offset_ptr
->constant
= 0; /*?*/
5090 if (boundary
> PARM_BOUNDARY
&& boundary
> STACK_BOUNDARY
)
5091 alignment_pad
->var
= size_binop (MINUS_EXPR
, offset_ptr
->var
,
5096 offset_ptr
->constant
=
5097 #ifdef ARGS_GROW_DOWNWARD
5098 FLOOR_ROUND (offset_ptr
->constant
, boundary_in_bytes
);
5100 CEIL_ROUND (offset_ptr
->constant
, boundary_in_bytes
);
5102 if (boundary
> PARM_BOUNDARY
&& boundary
> STACK_BOUNDARY
)
5103 alignment_pad
->constant
= offset_ptr
->constant
- save_constant
;
5108 #ifndef ARGS_GROW_DOWNWARD
5110 pad_below (offset_ptr
, passed_mode
, sizetree
)
5111 struct args_size
*offset_ptr
;
5112 enum machine_mode passed_mode
;
5115 if (passed_mode
!= BLKmode
)
5117 if (GET_MODE_BITSIZE (passed_mode
) % PARM_BOUNDARY
)
5118 offset_ptr
->constant
5119 += (((GET_MODE_BITSIZE (passed_mode
) + PARM_BOUNDARY
- 1)
5120 / PARM_BOUNDARY
* PARM_BOUNDARY
/ BITS_PER_UNIT
)
5121 - GET_MODE_SIZE (passed_mode
));
5125 if (TREE_CODE (sizetree
) != INTEGER_CST
5126 || (TREE_INT_CST_LOW (sizetree
) * BITS_PER_UNIT
) % PARM_BOUNDARY
)
5128 /* Round the size up to multiple of PARM_BOUNDARY bits. */
5129 tree s2
= round_up (sizetree
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
5131 ADD_PARM_SIZE (*offset_ptr
, s2
);
5132 SUB_PARM_SIZE (*offset_ptr
, sizetree
);
5138 /* Walk the tree of blocks describing the binding levels within a function
5139 and warn about uninitialized variables.
5140 This is done after calling flow_analysis and before global_alloc
5141 clobbers the pseudo-regs to hard regs. */
5144 uninitialized_vars_warning (block
)
5147 register tree decl
, sub
;
5148 for (decl
= BLOCK_VARS (block
); decl
; decl
= TREE_CHAIN (decl
))
5150 if (warn_uninitialized
5151 && TREE_CODE (decl
) == VAR_DECL
5152 /* These warnings are unreliable for and aggregates
5153 because assigning the fields one by one can fail to convince
5154 flow.c that the entire aggregate was initialized.
5155 Unions are troublesome because members may be shorter. */
5156 && ! AGGREGATE_TYPE_P (TREE_TYPE (decl
))
5157 && DECL_RTL (decl
) != 0
5158 && GET_CODE (DECL_RTL (decl
)) == REG
5159 /* Global optimizations can make it difficult to determine if a
5160 particular variable has been initialized. However, a VAR_DECL
5161 with a nonzero DECL_INITIAL had an initializer, so do not
5162 claim it is potentially uninitialized.
5164 We do not care about the actual value in DECL_INITIAL, so we do
5165 not worry that it may be a dangling pointer. */
5166 && DECL_INITIAL (decl
) == NULL_TREE
5167 && regno_uninitialized (REGNO (DECL_RTL (decl
))))
5168 warning_with_decl (decl
,
5169 "`%s' might be used uninitialized in this function");
5171 && TREE_CODE (decl
) == VAR_DECL
5172 && DECL_RTL (decl
) != 0
5173 && GET_CODE (DECL_RTL (decl
)) == REG
5174 && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl
))))
5175 warning_with_decl (decl
,
5176 "variable `%s' might be clobbered by `longjmp' or `vfork'");
5178 for (sub
= BLOCK_SUBBLOCKS (block
); sub
; sub
= TREE_CHAIN (sub
))
5179 uninitialized_vars_warning (sub
);
5182 /* Do the appropriate part of uninitialized_vars_warning
5183 but for arguments instead of local variables. */
5186 setjmp_args_warning ()
5189 for (decl
= DECL_ARGUMENTS (current_function_decl
);
5190 decl
; decl
= TREE_CHAIN (decl
))
5191 if (DECL_RTL (decl
) != 0
5192 && GET_CODE (DECL_RTL (decl
)) == REG
5193 && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl
))))
5194 warning_with_decl (decl
, "argument `%s' might be clobbered by `longjmp' or `vfork'");
5197 /* If this function call setjmp, put all vars into the stack
5198 unless they were declared `register'. */
5201 setjmp_protect (block
)
5204 register tree decl
, sub
;
5205 for (decl
= BLOCK_VARS (block
); decl
; decl
= TREE_CHAIN (decl
))
5206 if ((TREE_CODE (decl
) == VAR_DECL
5207 || TREE_CODE (decl
) == PARM_DECL
)
5208 && DECL_RTL (decl
) != 0
5209 && (GET_CODE (DECL_RTL (decl
)) == REG
5210 || (GET_CODE (DECL_RTL (decl
)) == MEM
5211 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == ADDRESSOF
))
5212 /* If this variable came from an inline function, it must be
5213 that its life doesn't overlap the setjmp. If there was a
5214 setjmp in the function, it would already be in memory. We
5215 must exclude such variable because their DECL_RTL might be
5216 set to strange things such as virtual_stack_vars_rtx. */
5217 && ! DECL_FROM_INLINE (decl
)
5219 #ifdef NON_SAVING_SETJMP
5220 /* If longjmp doesn't restore the registers,
5221 don't put anything in them. */
5225 ! DECL_REGISTER (decl
)))
5226 put_var_into_stack (decl
);
5227 for (sub
= BLOCK_SUBBLOCKS (block
); sub
; sub
= TREE_CHAIN (sub
))
5228 setjmp_protect (sub
);
5231 /* Like the previous function, but for args instead of local variables. */
5234 setjmp_protect_args ()
5237 for (decl
= DECL_ARGUMENTS (current_function_decl
);
5238 decl
; decl
= TREE_CHAIN (decl
))
5239 if ((TREE_CODE (decl
) == VAR_DECL
5240 || TREE_CODE (decl
) == PARM_DECL
)
5241 && DECL_RTL (decl
) != 0
5242 && (GET_CODE (DECL_RTL (decl
)) == REG
5243 || (GET_CODE (DECL_RTL (decl
)) == MEM
5244 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == ADDRESSOF
))
5246 /* If longjmp doesn't restore the registers,
5247 don't put anything in them. */
5248 #ifdef NON_SAVING_SETJMP
5252 ! DECL_REGISTER (decl
)))
5253 put_var_into_stack (decl
);
5256 /* Return the context-pointer register corresponding to DECL,
5257 or 0 if it does not need one. */
5260 lookup_static_chain (decl
)
5263 tree context
= decl_function_context (decl
);
5267 || (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_NO_STATIC_CHAIN (decl
)))
5270 /* We treat inline_function_decl as an alias for the current function
5271 because that is the inline function whose vars, types, etc.
5272 are being merged into the current function.
5273 See expand_inline_function. */
5274 if (context
== current_function_decl
|| context
== inline_function_decl
)
5275 return virtual_stack_vars_rtx
;
5277 for (link
= context_display
; link
; link
= TREE_CHAIN (link
))
5278 if (TREE_PURPOSE (link
) == context
)
5279 return RTL_EXPR_RTL (TREE_VALUE (link
));
5284 /* Convert a stack slot address ADDR for variable VAR
5285 (from a containing function)
5286 into an address valid in this function (using a static chain). */
5289 fix_lexical_addr (addr
, var
)
5294 HOST_WIDE_INT displacement
;
5295 tree context
= decl_function_context (var
);
5296 struct function
*fp
;
5299 /* If this is the present function, we need not do anything. */
5300 if (context
== current_function_decl
|| context
== inline_function_decl
)
5303 for (fp
= outer_function_chain
; fp
; fp
= fp
->next
)
5304 if (fp
->decl
== context
)
5310 if (GET_CODE (addr
) == ADDRESSOF
&& GET_CODE (XEXP (addr
, 0)) == MEM
)
5311 addr
= XEXP (XEXP (addr
, 0), 0);
5313 /* Decode given address as base reg plus displacement. */
5314 if (GET_CODE (addr
) == REG
)
5315 basereg
= addr
, displacement
= 0;
5316 else if (GET_CODE (addr
) == PLUS
&& GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
5317 basereg
= XEXP (addr
, 0), displacement
= INTVAL (XEXP (addr
, 1));
5321 /* We accept vars reached via the containing function's
5322 incoming arg pointer and via its stack variables pointer. */
5323 if (basereg
== fp
->internal_arg_pointer
)
5325 /* If reached via arg pointer, get the arg pointer value
5326 out of that function's stack frame.
5328 There are two cases: If a separate ap is needed, allocate a
5329 slot in the outer function for it and dereference it that way.
5330 This is correct even if the real ap is actually a pseudo.
5331 Otherwise, just adjust the offset from the frame pointer to
5334 #ifdef NEED_SEPARATE_AP
5337 if (fp
->x_arg_pointer_save_area
== 0)
5338 fp
->x_arg_pointer_save_area
5339 = assign_stack_local_1 (Pmode
, GET_MODE_SIZE (Pmode
), 0, fp
);
5341 addr
= fix_lexical_addr (XEXP (fp
->x_arg_pointer_save_area
, 0), var
);
5342 addr
= memory_address (Pmode
, addr
);
5344 base
= gen_rtx_MEM (Pmode
, addr
);
5345 MEM_ALIAS_SET (base
) = get_frame_alias_set ();
5346 base
= copy_to_reg (base
);
5348 displacement
+= (FIRST_PARM_OFFSET (context
) - STARTING_FRAME_OFFSET
);
5349 base
= lookup_static_chain (var
);
5353 else if (basereg
== virtual_stack_vars_rtx
)
5355 /* This is the same code as lookup_static_chain, duplicated here to
5356 avoid an extra call to decl_function_context. */
5359 for (link
= context_display
; link
; link
= TREE_CHAIN (link
))
5360 if (TREE_PURPOSE (link
) == context
)
5362 base
= RTL_EXPR_RTL (TREE_VALUE (link
));
5370 /* Use same offset, relative to appropriate static chain or argument
5372 return plus_constant (base
, displacement
);
5375 /* Return the address of the trampoline for entering nested fn FUNCTION.
5376 If necessary, allocate a trampoline (in the stack frame)
5377 and emit rtl to initialize its contents (at entry to this function). */
5380 trampoline_address (function
)
5386 struct function
*fp
;
5389 /* Find an existing trampoline and return it. */
5390 for (link
= trampoline_list
; link
; link
= TREE_CHAIN (link
))
5391 if (TREE_PURPOSE (link
) == function
)
5393 round_trampoline_addr (XEXP (RTL_EXPR_RTL (TREE_VALUE (link
)), 0));
5395 for (fp
= outer_function_chain
; fp
; fp
= fp
->next
)
5396 for (link
= fp
->x_trampoline_list
; link
; link
= TREE_CHAIN (link
))
5397 if (TREE_PURPOSE (link
) == function
)
5399 tramp
= fix_lexical_addr (XEXP (RTL_EXPR_RTL (TREE_VALUE (link
)), 0),
5401 return round_trampoline_addr (tramp
);
5404 /* None exists; we must make one. */
5406 /* Find the `struct function' for the function containing FUNCTION. */
5408 fn_context
= decl_function_context (function
);
5409 if (fn_context
!= current_function_decl
5410 && fn_context
!= inline_function_decl
)
5411 for (fp
= outer_function_chain
; fp
; fp
= fp
->next
)
5412 if (fp
->decl
== fn_context
)
5415 /* Allocate run-time space for this trampoline
5416 (usually in the defining function's stack frame). */
5417 #ifdef ALLOCATE_TRAMPOLINE
5418 tramp
= ALLOCATE_TRAMPOLINE (fp
);
5420 /* If rounding needed, allocate extra space
5421 to ensure we have TRAMPOLINE_SIZE bytes left after rounding up. */
5422 #ifdef TRAMPOLINE_ALIGNMENT
5423 #define TRAMPOLINE_REAL_SIZE \
5424 (TRAMPOLINE_SIZE + (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT) - 1)
5426 #define TRAMPOLINE_REAL_SIZE (TRAMPOLINE_SIZE)
5428 tramp
= assign_stack_local_1 (BLKmode
, TRAMPOLINE_REAL_SIZE
, 0,
5432 /* Record the trampoline for reuse and note it for later initialization
5433 by expand_function_end. */
5436 push_obstacks (fp
->function_maybepermanent_obstack
,
5437 fp
->function_maybepermanent_obstack
);
5438 rtlexp
= make_node (RTL_EXPR
);
5439 RTL_EXPR_RTL (rtlexp
) = tramp
;
5440 fp
->x_trampoline_list
= tree_cons (function
, rtlexp
,
5441 fp
->x_trampoline_list
);
5446 /* Make the RTL_EXPR node temporary, not momentary, so that the
5447 trampoline_list doesn't become garbage. */
5448 int momentary
= suspend_momentary ();
5449 rtlexp
= make_node (RTL_EXPR
);
5450 resume_momentary (momentary
);
5452 RTL_EXPR_RTL (rtlexp
) = tramp
;
5453 trampoline_list
= tree_cons (function
, rtlexp
, trampoline_list
);
5456 tramp
= fix_lexical_addr (XEXP (tramp
, 0), function
);
5457 return round_trampoline_addr (tramp
);
5460 /* Given a trampoline address,
5461 round it to multiple of TRAMPOLINE_ALIGNMENT. */
5464 round_trampoline_addr (tramp
)
5467 #ifdef TRAMPOLINE_ALIGNMENT
5468 /* Round address up to desired boundary. */
5469 rtx temp
= gen_reg_rtx (Pmode
);
5470 temp
= expand_binop (Pmode
, add_optab
, tramp
,
5471 GEN_INT (TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
- 1),
5472 temp
, 0, OPTAB_LIB_WIDEN
);
5473 tramp
= expand_binop (Pmode
, and_optab
, temp
,
5474 GEN_INT (- TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
),
5475 temp
, 0, OPTAB_LIB_WIDEN
);
5480 /* Put all this function's BLOCK nodes including those that are chained
5481 onto the first block into a vector, and return it.
5482 Also store in each NOTE for the beginning or end of a block
5483 the index of that block in the vector.
5484 The arguments are BLOCK, the chain of top-level blocks of the function,
5485 and INSNS, the insn chain of the function. */
5491 tree
*block_vector
, *last_block_vector
;
5493 tree block
= DECL_INITIAL (current_function_decl
);
5498 /* Fill the BLOCK_VECTOR with all of the BLOCKs in this function, in
5499 depth-first order. */
5500 block_vector
= get_block_vector (block
, &n_blocks
);
5501 block_stack
= (tree
*) xmalloc (n_blocks
* sizeof (tree
));
5503 last_block_vector
= identify_blocks_1 (get_insns (),
5505 block_vector
+ n_blocks
,
5508 /* If we didn't use all of the subblocks, we've misplaced block notes. */
5509 /* ??? This appears to happen all the time. Latent bugs elsewhere? */
5510 if (0 && last_block_vector
!= block_vector
+ n_blocks
)
5513 free (block_vector
);
5517 /* Subroutine of identify_blocks. Do the block substitution on the
5518 insn chain beginning with INSNS. Recurse for CALL_PLACEHOLDER chains.
5520 BLOCK_STACK is pushed and popped for each BLOCK_BEGIN/BLOCK_END pair.
5521 BLOCK_VECTOR is incremented for each block seen. */
5524 identify_blocks_1 (insns
, block_vector
, end_block_vector
, orig_block_stack
)
5527 tree
*end_block_vector
;
5528 tree
*orig_block_stack
;
5531 tree
*block_stack
= orig_block_stack
;
5533 for (insn
= insns
; insn
; insn
= NEXT_INSN (insn
))
5535 if (GET_CODE (insn
) == NOTE
)
5537 if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_BEG
)
5541 /* If there are more block notes than BLOCKs, something
5543 if (block_vector
== end_block_vector
)
5546 b
= *block_vector
++;
5547 NOTE_BLOCK (insn
) = b
;
5550 else if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_END
)
5552 /* If there are more NOTE_INSN_BLOCK_ENDs than
5553 NOTE_INSN_BLOCK_BEGs, something is badly wrong. */
5554 if (block_stack
== orig_block_stack
)
5557 NOTE_BLOCK (insn
) = *--block_stack
;
5560 else if (GET_CODE (insn
) == CALL_INSN
5561 && GET_CODE (PATTERN (insn
)) == CALL_PLACEHOLDER
)
5563 rtx cp
= PATTERN (insn
);
5565 block_vector
= identify_blocks_1 (XEXP (cp
, 0), block_vector
,
5566 end_block_vector
, block_stack
);
5568 block_vector
= identify_blocks_1 (XEXP (cp
, 1), block_vector
,
5569 end_block_vector
, block_stack
);
5571 block_vector
= identify_blocks_1 (XEXP (cp
, 2), block_vector
,
5572 end_block_vector
, block_stack
);
5576 /* If there are more NOTE_INSN_BLOCK_BEGINs than NOTE_INSN_BLOCK_ENDs,
5577 something is badly wrong. */
5578 if (block_stack
!= orig_block_stack
)
5581 return block_vector
;
5584 /* Identify BLOCKs referenced by more than one
5585 NOTE_INSN_BLOCK_{BEG,END}, and create duplicate blocks. */
5590 tree block
= DECL_INITIAL (current_function_decl
);
5591 varray_type block_stack
;
5593 if (block
== NULL_TREE
)
5596 VARRAY_TREE_INIT (block_stack
, 10, "block_stack");
5598 /* Prune the old trees away, so that they don't get in the way. */
5599 BLOCK_SUBBLOCKS (block
) = NULL_TREE
;
5600 BLOCK_CHAIN (block
) = NULL_TREE
;
5602 reorder_blocks_1 (get_insns (), block
, &block_stack
);
5604 BLOCK_SUBBLOCKS (block
)
5605 = blocks_nreverse (BLOCK_SUBBLOCKS (block
));
5607 VARRAY_FREE (block_stack
);
5610 /* Helper function for reorder_blocks. Process the insn chain beginning
5611 at INSNS. Recurse for CALL_PLACEHOLDER insns. */
5614 reorder_blocks_1 (insns
, current_block
, p_block_stack
)
5617 varray_type
*p_block_stack
;
5621 for (insn
= insns
; insn
; insn
= NEXT_INSN (insn
))
5623 if (GET_CODE (insn
) == NOTE
)
5625 if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_BEG
)
5627 tree block
= NOTE_BLOCK (insn
);
5628 /* If we have seen this block before, copy it. */
5629 if (TREE_ASM_WRITTEN (block
))
5631 block
= copy_node (block
);
5632 NOTE_BLOCK (insn
) = block
;
5634 BLOCK_SUBBLOCKS (block
) = 0;
5635 TREE_ASM_WRITTEN (block
) = 1;
5636 BLOCK_SUPERCONTEXT (block
) = current_block
;
5637 BLOCK_CHAIN (block
) = BLOCK_SUBBLOCKS (current_block
);
5638 BLOCK_SUBBLOCKS (current_block
) = block
;
5639 current_block
= block
;
5640 VARRAY_PUSH_TREE (*p_block_stack
, block
);
5642 else if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_END
)
5644 NOTE_BLOCK (insn
) = VARRAY_TOP_TREE (*p_block_stack
);
5645 VARRAY_POP (*p_block_stack
);
5646 BLOCK_SUBBLOCKS (current_block
)
5647 = blocks_nreverse (BLOCK_SUBBLOCKS (current_block
));
5648 current_block
= BLOCK_SUPERCONTEXT (current_block
);
5651 else if (GET_CODE (insn
) == CALL_INSN
5652 && GET_CODE (PATTERN (insn
)) == CALL_PLACEHOLDER
)
5654 rtx cp
= PATTERN (insn
);
5655 reorder_blocks_1 (XEXP (cp
, 0), current_block
, p_block_stack
);
5657 reorder_blocks_1 (XEXP (cp
, 1), current_block
, p_block_stack
);
5659 reorder_blocks_1 (XEXP (cp
, 2), current_block
, p_block_stack
);
5664 /* Reverse the order of elements in the chain T of blocks,
5665 and return the new head of the chain (old last element). */
5671 register tree prev
= 0, decl
, next
;
5672 for (decl
= t
; decl
; decl
= next
)
5674 next
= BLOCK_CHAIN (decl
);
5675 BLOCK_CHAIN (decl
) = prev
;
5681 /* Count the subblocks of the list starting with BLOCK. If VECTOR is
5682 non-NULL, list them all into VECTOR, in a depth-first preorder
5683 traversal of the block tree. Also clear TREE_ASM_WRITTEN in all
5687 all_blocks (block
, vector
)
5695 TREE_ASM_WRITTEN (block
) = 0;
5697 /* Record this block. */
5699 vector
[n_blocks
] = block
;
5703 /* Record the subblocks, and their subblocks... */
5704 n_blocks
+= all_blocks (BLOCK_SUBBLOCKS (block
),
5705 vector
? vector
+ n_blocks
: 0);
5706 block
= BLOCK_CHAIN (block
);
5712 /* Return a vector containing all the blocks rooted at BLOCK. The
5713 number of elements in the vector is stored in N_BLOCKS_P. The
5714 vector is dynamically allocated; it is the caller's responsibility
5715 to call `free' on the pointer returned. */
5718 get_block_vector (block
, n_blocks_p
)
5724 *n_blocks_p
= all_blocks (block
, NULL
);
5725 block_vector
= (tree
*) xmalloc (*n_blocks_p
* sizeof (tree
));
5726 all_blocks (block
, block_vector
);
5728 return block_vector
;
5731 static int next_block_index
= 2;
5733 /* Set BLOCK_NUMBER for all the blocks in FN. */
5743 /* For SDB and XCOFF debugging output, we start numbering the blocks
5744 from 1 within each function, rather than keeping a running
5746 #if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
5747 if (write_symbols
== SDB_DEBUG
|| write_symbols
== XCOFF_DEBUG
)
5748 next_block_index
= 1;
5751 block_vector
= get_block_vector (DECL_INITIAL (fn
), &n_blocks
);
5753 /* The top-level BLOCK isn't numbered at all. */
5754 for (i
= 1; i
< n_blocks
; ++i
)
5755 /* We number the blocks from two. */
5756 BLOCK_NUMBER (block_vector
[i
]) = next_block_index
++;
5758 free (block_vector
);
5764 /* Allocate a function structure and reset its contents to the defaults. */
5766 prepare_function_start ()
5768 cfun
= (struct function
*) xcalloc (1, sizeof (struct function
));
5770 init_stmt_for_function ();
5771 init_eh_for_function ();
5773 cse_not_expected
= ! optimize
;
5775 /* Caller save not needed yet. */
5776 caller_save_needed
= 0;
5778 /* No stack slots have been made yet. */
5779 stack_slot_list
= 0;
5781 current_function_has_nonlocal_label
= 0;
5782 current_function_has_nonlocal_goto
= 0;
5784 /* There is no stack slot for handling nonlocal gotos. */
5785 nonlocal_goto_handler_slots
= 0;
5786 nonlocal_goto_stack_level
= 0;
5788 /* No labels have been declared for nonlocal use. */
5789 nonlocal_labels
= 0;
5790 nonlocal_goto_handler_labels
= 0;
5792 /* No function calls so far in this function. */
5793 function_call_count
= 0;
5795 /* No parm regs have been allocated.
5796 (This is important for output_inline_function.) */
5797 max_parm_reg
= LAST_VIRTUAL_REGISTER
+ 1;
5799 /* Initialize the RTL mechanism. */
5802 /* Initialize the queue of pending postincrement and postdecrements,
5803 and some other info in expr.c. */
5806 /* We haven't done register allocation yet. */
5809 init_varasm_status (cfun
);
5811 /* Clear out data used for inlining. */
5812 cfun
->inlinable
= 0;
5813 cfun
->original_decl_initial
= 0;
5814 cfun
->original_arg_vector
= 0;
5816 #ifdef STACK_BOUNDARY
5817 cfun
->stack_alignment_needed
= STACK_BOUNDARY
;
5818 cfun
->preferred_stack_boundary
= STACK_BOUNDARY
;
5820 cfun
->stack_alignment_needed
= 0;
5821 cfun
->preferred_stack_boundary
= 0;
5824 /* Set if a call to setjmp is seen. */
5825 current_function_calls_setjmp
= 0;
5827 /* Set if a call to longjmp is seen. */
5828 current_function_calls_longjmp
= 0;
5830 current_function_calls_alloca
= 0;
5831 current_function_contains_functions
= 0;
5832 current_function_is_leaf
= 0;
5833 current_function_nothrow
= 0;
5834 current_function_sp_is_unchanging
= 0;
5835 current_function_uses_only_leaf_regs
= 0;
5836 current_function_has_computed_jump
= 0;
5837 current_function_is_thunk
= 0;
5839 current_function_returns_pcc_struct
= 0;
5840 current_function_returns_struct
= 0;
5841 current_function_epilogue_delay_list
= 0;
5842 current_function_uses_const_pool
= 0;
5843 current_function_uses_pic_offset_table
= 0;
5844 current_function_cannot_inline
= 0;
5846 /* We have not yet needed to make a label to jump to for tail-recursion. */
5847 tail_recursion_label
= 0;
5849 /* We haven't had a need to make a save area for ap yet. */
5850 arg_pointer_save_area
= 0;
5852 /* No stack slots allocated yet. */
5855 /* No SAVE_EXPRs in this function yet. */
5858 /* No RTL_EXPRs in this function yet. */
5861 /* Set up to allocate temporaries. */
5864 /* Indicate that we need to distinguish between the return value of the
5865 present function and the return value of a function being called. */
5866 rtx_equal_function_value_matters
= 1;
5868 /* Indicate that we have not instantiated virtual registers yet. */
5869 virtuals_instantiated
= 0;
5871 /* Indicate we have no need of a frame pointer yet. */
5872 frame_pointer_needed
= 0;
5874 /* By default assume not varargs or stdarg. */
5875 current_function_varargs
= 0;
5876 current_function_stdarg
= 0;
5878 /* We haven't made any trampolines for this function yet. */
5879 trampoline_list
= 0;
5881 init_pending_stack_adjust ();
5882 inhibit_defer_pop
= 0;
5884 current_function_outgoing_args_size
= 0;
5886 if (init_lang_status
)
5887 (*init_lang_status
) (cfun
);
5888 if (init_machine_status
)
5889 (*init_machine_status
) (cfun
);
5892 /* Initialize the rtl expansion mechanism so that we can do simple things
5893 like generate sequences. This is used to provide a context during global
5894 initialization of some passes. */
5896 init_dummy_function_start ()
5898 prepare_function_start ();
5901 /* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node)
5902 and initialize static variables for generating RTL for the statements
5906 init_function_start (subr
, filename
, line
)
5908 const char *filename
;
5911 prepare_function_start ();
5913 /* Remember this function for later. */
5914 cfun
->next_global
= all_functions
;
5915 all_functions
= cfun
;
5917 current_function_name
= (*decl_printable_name
) (subr
, 2);
5920 /* Nonzero if this is a nested function that uses a static chain. */
5922 current_function_needs_context
5923 = (decl_function_context (current_function_decl
) != 0
5924 && ! DECL_NO_STATIC_CHAIN (current_function_decl
));
5926 /* Within function body, compute a type's size as soon it is laid out. */
5927 immediate_size_expand
++;
5929 /* Prevent ever trying to delete the first instruction of a function.
5930 Also tell final how to output a linenum before the function prologue.
5931 Note linenums could be missing, e.g. when compiling a Java .class file. */
5933 emit_line_note (filename
, line
);
5935 /* Make sure first insn is a note even if we don't want linenums.
5936 This makes sure the first insn will never be deleted.
5937 Also, final expects a note to appear there. */
5938 emit_note (NULL_PTR
, NOTE_INSN_DELETED
);
5940 /* Set flags used by final.c. */
5941 if (aggregate_value_p (DECL_RESULT (subr
)))
5943 #ifdef PCC_STATIC_STRUCT_RETURN
5944 current_function_returns_pcc_struct
= 1;
5946 current_function_returns_struct
= 1;
5949 /* Warn if this value is an aggregate type,
5950 regardless of which calling convention we are using for it. */
5951 if (warn_aggregate_return
5952 && AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr
))))
5953 warning ("function returns an aggregate");
5955 current_function_returns_pointer
5956 = POINTER_TYPE_P (TREE_TYPE (DECL_RESULT (subr
)));
5959 /* Make sure all values used by the optimization passes have sane
5962 init_function_for_compilation ()
5966 /* No prologue/epilogue insns yet. */
5967 VARRAY_GROW (prologue
, 0);
5968 VARRAY_GROW (epilogue
, 0);
5969 VARRAY_GROW (sibcall_epilogue
, 0);
5972 /* Indicate that the current function uses extra args
5973 not explicitly mentioned in the argument list in any fashion. */
5978 current_function_varargs
= 1;
5981 /* Expand a call to __main at the beginning of a possible main function. */
5983 #if defined(INIT_SECTION_ASM_OP) && !defined(INVOKE__main)
5984 #undef HAS_INIT_SECTION
5985 #define HAS_INIT_SECTION
5989 expand_main_function ()
5991 #if !defined (HAS_INIT_SECTION)
5992 emit_library_call (gen_rtx_SYMBOL_REF (Pmode
, NAME__MAIN
), 0,
5994 #endif /* not HAS_INIT_SECTION */
5997 extern struct obstack permanent_obstack
;
5999 /* Start the RTL for a new function, and set variables used for
6001 SUBR is the FUNCTION_DECL node.
6002 PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with
6003 the function's parameters, which must be run at any return statement. */
6006 expand_function_start (subr
, parms_have_cleanups
)
6008 int parms_have_cleanups
;
6011 rtx last_ptr
= NULL_RTX
;
6013 /* Make sure volatile mem refs aren't considered
6014 valid operands of arithmetic insns. */
6015 init_recog_no_volatile ();
6017 /* Set this before generating any memory accesses. */
6018 current_function_check_memory_usage
6019 = (flag_check_memory_usage
6020 && ! DECL_NO_CHECK_MEMORY_USAGE (current_function_decl
));
6022 current_function_instrument_entry_exit
6023 = (flag_instrument_function_entry_exit
6024 && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr
));
6026 current_function_limit_stack
6027 = (stack_limit_rtx
!= NULL_RTX
&& ! DECL_NO_LIMIT_STACK (subr
));
6029 /* If function gets a static chain arg, store it in the stack frame.
6030 Do this first, so it gets the first stack slot offset. */
6031 if (current_function_needs_context
)
6033 last_ptr
= assign_stack_local (Pmode
, GET_MODE_SIZE (Pmode
), 0);
6035 /* Delay copying static chain if it is not a register to avoid
6036 conflicts with regs used for parameters. */
6037 if (! SMALL_REGISTER_CLASSES
6038 || GET_CODE (static_chain_incoming_rtx
) == REG
)
6039 emit_move_insn (last_ptr
, static_chain_incoming_rtx
);
6042 /* If the parameters of this function need cleaning up, get a label
6043 for the beginning of the code which executes those cleanups. This must
6044 be done before doing anything with return_label. */
6045 if (parms_have_cleanups
)
6046 cleanup_label
= gen_label_rtx ();
6050 /* Make the label for return statements to jump to, if this machine
6051 does not have a one-instruction return and uses an epilogue,
6052 or if it returns a structure, or if it has parm cleanups. */
6054 if (cleanup_label
== 0 && HAVE_return
6055 && ! current_function_instrument_entry_exit
6056 && ! current_function_returns_pcc_struct
6057 && ! (current_function_returns_struct
&& ! optimize
))
6060 return_label
= gen_label_rtx ();
6062 return_label
= gen_label_rtx ();
6065 /* Initialize rtx used to return the value. */
6066 /* Do this before assign_parms so that we copy the struct value address
6067 before any library calls that assign parms might generate. */
6069 /* Decide whether to return the value in memory or in a register. */
6070 if (aggregate_value_p (DECL_RESULT (subr
)))
6072 /* Returning something that won't go in a register. */
6073 register rtx value_address
= 0;
6075 #ifdef PCC_STATIC_STRUCT_RETURN
6076 if (current_function_returns_pcc_struct
)
6078 int size
= int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr
)));
6079 value_address
= assemble_static_space (size
);
6084 /* Expect to be passed the address of a place to store the value.
6085 If it is passed as an argument, assign_parms will take care of
6087 if (struct_value_incoming_rtx
)
6089 value_address
= gen_reg_rtx (Pmode
);
6090 emit_move_insn (value_address
, struct_value_incoming_rtx
);
6095 DECL_RTL (DECL_RESULT (subr
))
6096 = gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr
)), value_address
);
6097 set_mem_attributes (DECL_RTL (DECL_RESULT (subr
)),
6098 DECL_RESULT (subr
), 1);
6101 else if (DECL_MODE (DECL_RESULT (subr
)) == VOIDmode
)
6102 /* If return mode is void, this decl rtl should not be used. */
6103 DECL_RTL (DECL_RESULT (subr
)) = 0;
6104 else if (parms_have_cleanups
|| current_function_instrument_entry_exit
)
6106 /* If function will end with cleanup code for parms,
6107 compute the return values into a pseudo reg,
6108 which we will copy into the true return register
6109 after the cleanups are done. */
6111 enum machine_mode mode
= DECL_MODE (DECL_RESULT (subr
));
6113 #ifdef PROMOTE_FUNCTION_RETURN
6114 tree type
= TREE_TYPE (DECL_RESULT (subr
));
6115 int unsignedp
= TREE_UNSIGNED (type
);
6117 mode
= promote_mode (type
, mode
, &unsignedp
, 1);
6120 DECL_RTL (DECL_RESULT (subr
)) = gen_reg_rtx (mode
);
6123 /* Scalar, returned in a register. */
6125 DECL_RTL (DECL_RESULT (subr
))
6126 = hard_function_value (TREE_TYPE (DECL_RESULT (subr
)), subr
, 1);
6128 /* Mark this reg as the function's return value. */
6129 if (GET_CODE (DECL_RTL (DECL_RESULT (subr
))) == REG
)
6131 REG_FUNCTION_VALUE_P (DECL_RTL (DECL_RESULT (subr
))) = 1;
6132 /* Needed because we may need to move this to memory
6133 in case it's a named return value whose address is taken. */
6134 DECL_REGISTER (DECL_RESULT (subr
)) = 1;
6138 /* Initialize rtx for parameters and local variables.
6139 In some cases this requires emitting insns. */
6141 assign_parms (subr
);
6143 /* Copy the static chain now if it wasn't a register. The delay is to
6144 avoid conflicts with the parameter passing registers. */
6146 if (SMALL_REGISTER_CLASSES
&& current_function_needs_context
)
6147 if (GET_CODE (static_chain_incoming_rtx
) != REG
)
6148 emit_move_insn (last_ptr
, static_chain_incoming_rtx
);
6150 /* The following was moved from init_function_start.
6151 The move is supposed to make sdb output more accurate. */
6152 /* Indicate the beginning of the function body,
6153 as opposed to parm setup. */
6154 emit_note (NULL_PTR
, NOTE_INSN_FUNCTION_BEG
);
6156 if (GET_CODE (get_last_insn ()) != NOTE
)
6157 emit_note (NULL_PTR
, NOTE_INSN_DELETED
);
6158 parm_birth_insn
= get_last_insn ();
6160 context_display
= 0;
6161 if (current_function_needs_context
)
6163 /* Fetch static chain values for containing functions. */
6164 tem
= decl_function_context (current_function_decl
);
6165 /* Copy the static chain pointer into a pseudo. If we have
6166 small register classes, copy the value from memory if
6167 static_chain_incoming_rtx is a REG. */
6170 /* If the static chain originally came in a register, put it back
6171 there, then move it out in the next insn. The reason for
6172 this peculiar code is to satisfy function integration. */
6173 if (SMALL_REGISTER_CLASSES
6174 && GET_CODE (static_chain_incoming_rtx
) == REG
)
6175 emit_move_insn (static_chain_incoming_rtx
, last_ptr
);
6176 last_ptr
= copy_to_reg (static_chain_incoming_rtx
);
6181 tree rtlexp
= make_node (RTL_EXPR
);
6183 RTL_EXPR_RTL (rtlexp
) = last_ptr
;
6184 context_display
= tree_cons (tem
, rtlexp
, context_display
);
6185 tem
= decl_function_context (tem
);
6188 /* Chain thru stack frames, assuming pointer to next lexical frame
6189 is found at the place we always store it. */
6190 #ifdef FRAME_GROWS_DOWNWARD
6191 last_ptr
= plus_constant (last_ptr
, - GET_MODE_SIZE (Pmode
));
6193 last_ptr
= gen_rtx_MEM (Pmode
, memory_address (Pmode
, last_ptr
));
6194 MEM_ALIAS_SET (last_ptr
) = get_frame_alias_set ();
6195 last_ptr
= copy_to_reg (last_ptr
);
6197 /* If we are not optimizing, ensure that we know that this
6198 piece of context is live over the entire function. */
6200 save_expr_regs
= gen_rtx_EXPR_LIST (VOIDmode
, last_ptr
,
6205 if (current_function_instrument_entry_exit
)
6207 rtx fun
= DECL_RTL (current_function_decl
);
6208 if (GET_CODE (fun
) == MEM
)
6209 fun
= XEXP (fun
, 0);
6212 emit_library_call (profile_function_entry_libfunc
, 0, VOIDmode
, 2,
6214 expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS
,
6216 hard_frame_pointer_rtx
),
6220 /* After the display initializations is where the tail-recursion label
6221 should go, if we end up needing one. Ensure we have a NOTE here
6222 since some things (like trampolines) get placed before this. */
6223 tail_recursion_reentry
= emit_note (NULL_PTR
, NOTE_INSN_DELETED
);
6225 /* Evaluate now the sizes of any types declared among the arguments. */
6226 for (tem
= nreverse (get_pending_sizes ()); tem
; tem
= TREE_CHAIN (tem
))
6228 expand_expr (TREE_VALUE (tem
), const0_rtx
, VOIDmode
,
6229 EXPAND_MEMORY_USE_BAD
);
6230 /* Flush the queue in case this parameter declaration has
6235 /* Make sure there is a line number after the function entry setup code. */
6236 force_next_line_note ();
6239 /* Undo the effects of init_dummy_function_start. */
6241 expand_dummy_function_end ()
6243 /* End any sequences that failed to be closed due to syntax errors. */
6244 while (in_sequence_p ())
6247 /* Outside function body, can't compute type's actual size
6248 until next function's body starts. */
6250 free_after_parsing (cfun
);
6251 free_after_compilation (cfun
);
6256 /* Call DOIT for each hard register used as a return value from
6257 the current function. */
6260 diddle_return_value (doit
, arg
)
6261 void (*doit
) PARAMS ((rtx
, void *));
6264 rtx outgoing
= current_function_return_rtx
;
6270 pcc
= (current_function_returns_struct
6271 || current_function_returns_pcc_struct
);
6273 if ((GET_CODE (outgoing
) == REG
6274 && REGNO (outgoing
) >= FIRST_PSEUDO_REGISTER
)
6277 tree type
= TREE_TYPE (DECL_RESULT (current_function_decl
));
6279 /* A PCC-style return returns a pointer to the memory in which
6280 the structure is stored. */
6282 type
= build_pointer_type (type
);
6284 #ifdef FUNCTION_OUTGOING_VALUE
6285 outgoing
= FUNCTION_OUTGOING_VALUE (type
, current_function_decl
);
6287 outgoing
= FUNCTION_VALUE (type
, current_function_decl
);
6289 /* If this is a BLKmode structure being returned in registers, then use
6290 the mode computed in expand_return. */
6291 if (GET_MODE (outgoing
) == BLKmode
)
6293 GET_MODE (DECL_RTL (DECL_RESULT (current_function_decl
))));
6294 REG_FUNCTION_VALUE_P (outgoing
) = 1;
6297 if (GET_CODE (outgoing
) == REG
)
6298 (*doit
) (outgoing
, arg
);
6299 else if (GET_CODE (outgoing
) == PARALLEL
)
6303 for (i
= 0; i
< XVECLEN (outgoing
, 0); i
++)
6305 rtx x
= XEXP (XVECEXP (outgoing
, 0, i
), 0);
6307 if (GET_CODE (x
) == REG
&& REGNO (x
) < FIRST_PSEUDO_REGISTER
)
6314 do_clobber_return_reg (reg
, arg
)
6316 void *arg ATTRIBUTE_UNUSED
;
6318 emit_insn (gen_rtx_CLOBBER (VOIDmode
, reg
));
6322 clobber_return_register ()
6324 diddle_return_value (do_clobber_return_reg
, NULL
);
6328 do_use_return_reg (reg
, arg
)
6330 void *arg ATTRIBUTE_UNUSED
;
6332 emit_insn (gen_rtx_USE (VOIDmode
, reg
));
6336 use_return_register ()
6338 diddle_return_value (do_use_return_reg
, NULL
);
6341 /* Generate RTL for the end of the current function.
6342 FILENAME and LINE are the current position in the source file.
6344 It is up to language-specific callers to do cleanups for parameters--
6345 or else, supply 1 for END_BINDINGS and we will call expand_end_bindings. */
6348 expand_function_end (filename
, line
, end_bindings
)
6349 const char *filename
;
6355 #ifdef TRAMPOLINE_TEMPLATE
6356 static rtx initial_trampoline
;
6359 finish_expr_for_function ();
6361 #ifdef NON_SAVING_SETJMP
6362 /* Don't put any variables in registers if we call setjmp
6363 on a machine that fails to restore the registers. */
6364 if (NON_SAVING_SETJMP
&& current_function_calls_setjmp
)
6366 if (DECL_INITIAL (current_function_decl
) != error_mark_node
)
6367 setjmp_protect (DECL_INITIAL (current_function_decl
));
6369 setjmp_protect_args ();
6373 /* Save the argument pointer if a save area was made for it. */
6374 if (arg_pointer_save_area
)
6376 /* arg_pointer_save_area may not be a valid memory address, so we
6377 have to check it and fix it if necessary. */
6380 emit_move_insn (validize_mem (arg_pointer_save_area
),
6381 virtual_incoming_args_rtx
);
6382 seq
= gen_sequence ();
6384 emit_insn_before (seq
, tail_recursion_reentry
);
6387 /* Initialize any trampolines required by this function. */
6388 for (link
= trampoline_list
; link
; link
= TREE_CHAIN (link
))
6390 tree function
= TREE_PURPOSE (link
);
6391 rtx context ATTRIBUTE_UNUSED
= lookup_static_chain (function
);
6392 rtx tramp
= RTL_EXPR_RTL (TREE_VALUE (link
));
6393 #ifdef TRAMPOLINE_TEMPLATE
6398 #ifdef TRAMPOLINE_TEMPLATE
6399 /* First make sure this compilation has a template for
6400 initializing trampolines. */
6401 if (initial_trampoline
== 0)
6403 end_temporary_allocation ();
6405 = gen_rtx_MEM (BLKmode
, assemble_trampoline_template ());
6406 resume_temporary_allocation ();
6408 ggc_add_rtx_root (&initial_trampoline
, 1);
6412 /* Generate insns to initialize the trampoline. */
6414 tramp
= round_trampoline_addr (XEXP (tramp
, 0));
6415 #ifdef TRAMPOLINE_TEMPLATE
6416 blktramp
= change_address (initial_trampoline
, BLKmode
, tramp
);
6417 emit_block_move (blktramp
, initial_trampoline
,
6418 GEN_INT (TRAMPOLINE_SIZE
),
6419 TRAMPOLINE_ALIGNMENT
);
6421 INITIALIZE_TRAMPOLINE (tramp
, XEXP (DECL_RTL (function
), 0), context
);
6425 /* Put those insns at entry to the containing function (this one). */
6426 emit_insns_before (seq
, tail_recursion_reentry
);
6429 /* If we are doing stack checking and this function makes calls,
6430 do a stack probe at the start of the function to ensure we have enough
6431 space for another stack frame. */
6432 if (flag_stack_check
&& ! STACK_CHECK_BUILTIN
)
6436 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
6437 if (GET_CODE (insn
) == CALL_INSN
)
6440 probe_stack_range (STACK_CHECK_PROTECT
,
6441 GEN_INT (STACK_CHECK_MAX_FRAME_SIZE
));
6444 emit_insns_before (seq
, tail_recursion_reentry
);
6449 /* Warn about unused parms if extra warnings were specified. */
6450 /* Either ``-W -Wunused'' or ``-Wunused-parameter'' enables this
6451 warning. WARN_UNUSED_PARAMETER is negative when set by
6453 if (warn_unused_parameter
> 0
6454 || (warn_unused_parameter
< 0 && extra_warnings
))
6458 for (decl
= DECL_ARGUMENTS (current_function_decl
);
6459 decl
; decl
= TREE_CHAIN (decl
))
6460 if (! TREE_USED (decl
) && TREE_CODE (decl
) == PARM_DECL
6461 && DECL_NAME (decl
) && ! DECL_ARTIFICIAL (decl
))
6462 warning_with_decl (decl
, "unused parameter `%s'");
6465 /* Delete handlers for nonlocal gotos if nothing uses them. */
6466 if (nonlocal_goto_handler_slots
!= 0
6467 && ! current_function_has_nonlocal_label
)
6470 /* End any sequences that failed to be closed due to syntax errors. */
6471 while (in_sequence_p ())
6474 /* Outside function body, can't compute type's actual size
6475 until next function's body starts. */
6476 immediate_size_expand
--;
6478 clear_pending_stack_adjust ();
6479 do_pending_stack_adjust ();
6481 /* Mark the end of the function body.
6482 If control reaches this insn, the function can drop through
6483 without returning a value. */
6484 emit_note (NULL_PTR
, NOTE_INSN_FUNCTION_END
);
6486 /* Must mark the last line number note in the function, so that the test
6487 coverage code can avoid counting the last line twice. This just tells
6488 the code to ignore the immediately following line note, since there
6489 already exists a copy of this note somewhere above. This line number
6490 note is still needed for debugging though, so we can't delete it. */
6491 if (flag_test_coverage
)
6492 emit_note (NULL_PTR
, NOTE_INSN_REPEATED_LINE_NUMBER
);
6494 /* Output a linenumber for the end of the function.
6495 SDB depends on this. */
6496 emit_line_note_force (filename
, line
);
6498 /* Output the label for the actual return from the function,
6499 if one is expected. This happens either because a function epilogue
6500 is used instead of a return instruction, or because a return was done
6501 with a goto in order to run local cleanups, or because of pcc-style
6502 structure returning. */
6506 /* Before the return label, clobber the return registers so that
6507 they are not propogated live to the rest of the function. This
6508 can only happen with functions that drop through; if there had
6509 been a return statement, there would have either been a return
6510 rtx, or a jump to the return label. */
6511 clobber_return_register ();
6513 emit_label (return_label
);
6516 /* C++ uses this. */
6518 expand_end_bindings (0, 0, 0);
6520 /* Now handle any leftover exception regions that may have been
6521 created for the parameters. */
6523 rtx last
= get_last_insn ();
6526 expand_leftover_cleanups ();
6528 /* If there are any catch_clauses remaining, output them now. */
6529 emit_insns (catch_clauses
);
6530 catch_clauses
= catch_clauses_last
= NULL_RTX
;
6531 /* If the above emitted any code, may sure we jump around it. */
6532 if (last
!= get_last_insn ())
6534 label
= gen_label_rtx ();
6535 last
= emit_jump_insn_after (gen_jump (label
), last
);
6536 last
= emit_barrier_after (last
);
6541 if (current_function_instrument_entry_exit
)
6543 rtx fun
= DECL_RTL (current_function_decl
);
6544 if (GET_CODE (fun
) == MEM
)
6545 fun
= XEXP (fun
, 0);
6548 emit_library_call (profile_function_exit_libfunc
, 0, VOIDmode
, 2,
6550 expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS
,
6552 hard_frame_pointer_rtx
),
6556 /* If we had calls to alloca, and this machine needs
6557 an accurate stack pointer to exit the function,
6558 insert some code to save and restore the stack pointer. */
6559 #ifdef EXIT_IGNORE_STACK
6560 if (! EXIT_IGNORE_STACK
)
6562 if (current_function_calls_alloca
)
6566 emit_stack_save (SAVE_FUNCTION
, &tem
, parm_birth_insn
);
6567 emit_stack_restore (SAVE_FUNCTION
, tem
, NULL_RTX
);
6570 /* If scalar return value was computed in a pseudo-reg,
6571 copy that to the hard return register. */
6572 if (DECL_RTL (DECL_RESULT (current_function_decl
)) != 0
6573 && GET_CODE (DECL_RTL (DECL_RESULT (current_function_decl
))) == REG
6574 && (REGNO (DECL_RTL (DECL_RESULT (current_function_decl
)))
6575 >= FIRST_PSEUDO_REGISTER
))
6577 rtx real_decl_result
;
6579 #ifdef FUNCTION_OUTGOING_VALUE
6581 = FUNCTION_OUTGOING_VALUE (TREE_TYPE (DECL_RESULT (current_function_decl
)),
6582 current_function_decl
);
6585 = FUNCTION_VALUE (TREE_TYPE (DECL_RESULT (current_function_decl
)),
6586 current_function_decl
);
6588 REG_FUNCTION_VALUE_P (real_decl_result
) = 1;
6589 /* If this is a BLKmode structure being returned in registers, then use
6590 the mode computed in expand_return. */
6591 if (GET_MODE (real_decl_result
) == BLKmode
)
6592 PUT_MODE (real_decl_result
,
6593 GET_MODE (DECL_RTL (DECL_RESULT (current_function_decl
))));
6594 emit_move_insn (real_decl_result
,
6595 DECL_RTL (DECL_RESULT (current_function_decl
)));
6597 /* The delay slot scheduler assumes that current_function_return_rtx
6598 holds the hard register containing the return value, not a temporary
6600 current_function_return_rtx
= real_decl_result
;
6603 /* If returning a structure, arrange to return the address of the value
6604 in a place where debuggers expect to find it.
6606 If returning a structure PCC style,
6607 the caller also depends on this value.
6608 And current_function_returns_pcc_struct is not necessarily set. */
6609 if (current_function_returns_struct
6610 || current_function_returns_pcc_struct
)
6612 rtx value_address
= XEXP (DECL_RTL (DECL_RESULT (current_function_decl
)), 0);
6613 tree type
= TREE_TYPE (DECL_RESULT (current_function_decl
));
6614 #ifdef FUNCTION_OUTGOING_VALUE
6616 = FUNCTION_OUTGOING_VALUE (build_pointer_type (type
),
6617 current_function_decl
);
6620 = FUNCTION_VALUE (build_pointer_type (type
),
6621 current_function_decl
);
6624 /* Mark this as a function return value so integrate will delete the
6625 assignment and USE below when inlining this function. */
6626 REG_FUNCTION_VALUE_P (outgoing
) = 1;
6628 emit_move_insn (outgoing
, value_address
);
6631 /* ??? This should no longer be necessary since stupid is no longer with
6632 us, but there are some parts of the compiler (eg reload_combine, and
6633 sh mach_dep_reorg) that still try and compute their own lifetime info
6634 instead of using the general framework. */
6635 use_return_register ();
6637 /* If this is an implementation of __throw, do what's necessary to
6638 communicate between __builtin_eh_return and the epilogue. */
6639 expand_eh_return ();
6641 /* Output a return insn if we are using one.
6642 Otherwise, let the rtl chain end here, to drop through
6643 into the epilogue. */
6648 emit_jump_insn (gen_return ());
6653 /* Fix up any gotos that jumped out to the outermost
6654 binding level of the function.
6655 Must follow emitting RETURN_LABEL. */
6657 /* If you have any cleanups to do at this point,
6658 and they need to create temporary variables,
6659 then you will lose. */
6660 expand_fixups (get_insns ());
6663 /* Extend a vector that records the INSN_UIDs of INSNS (either a
6664 sequence or a single insn). */
6667 record_insns (insns
, vecp
)
6671 if (GET_CODE (insns
) == SEQUENCE
)
6673 int len
= XVECLEN (insns
, 0);
6674 int i
= VARRAY_SIZE (*vecp
);
6676 VARRAY_GROW (*vecp
, i
+ len
);
6679 VARRAY_INT (*vecp
, i
) = INSN_UID (XVECEXP (insns
, 0, len
));
6685 int i
= VARRAY_SIZE (*vecp
);
6686 VARRAY_GROW (*vecp
, i
+ 1);
6687 VARRAY_INT (*vecp
, i
) = INSN_UID (insns
);
6691 /* Determine how many INSN_UIDs in VEC are part of INSN. */
6694 contains (insn
, vec
)
6700 if (GET_CODE (insn
) == INSN
6701 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
6704 for (i
= XVECLEN (PATTERN (insn
), 0) - 1; i
>= 0; i
--)
6705 for (j
= VARRAY_SIZE (vec
) - 1; j
>= 0; --j
)
6706 if (INSN_UID (XVECEXP (PATTERN (insn
), 0, i
)) == VARRAY_INT (vec
, j
))
6712 for (j
= VARRAY_SIZE (vec
) - 1; j
>= 0; --j
)
6713 if (INSN_UID (insn
) == VARRAY_INT (vec
, j
))
6720 prologue_epilogue_contains (insn
)
6723 if (contains (insn
, prologue
))
6725 if (contains (insn
, epilogue
))
6731 sibcall_epilogue_contains (insn
)
6734 if (sibcall_epilogue
)
6735 return contains (insn
, sibcall_epilogue
);
6740 /* Insert gen_return at the end of block BB. This also means updating
6741 block_for_insn appropriately. */
6744 emit_return_into_block (bb
, line_note
)
6750 p
= NEXT_INSN (bb
->end
);
6751 end
= emit_jump_insn_after (gen_return (), bb
->end
);
6753 emit_line_note_after (NOTE_SOURCE_FILE (line_note
),
6754 NOTE_LINE_NUMBER (line_note
), bb
->end
);
6758 set_block_for_insn (p
, bb
);
6765 #endif /* HAVE_return */
6767 /* Generate the prologue and epilogue RTL if the machine supports it. Thread
6768 this into place with notes indicating where the prologue ends and where
6769 the epilogue begins. Update the basic block information when possible. */
6772 thread_prologue_and_epilogue_insns (f
)
6773 rtx f ATTRIBUTE_UNUSED
;
6778 #ifdef HAVE_prologue
6779 rtx prologue_end
= NULL_RTX
;
6781 #if defined (HAVE_epilogue) || defined(HAVE_return)
6782 rtx epilogue_end
= NULL_RTX
;
6785 #ifdef HAVE_prologue
6789 seq
= gen_prologue();
6792 /* Retain a map of the prologue insns. */
6793 if (GET_CODE (seq
) != SEQUENCE
)
6795 record_insns (seq
, &prologue
);
6796 prologue_end
= emit_note (NULL
, NOTE_INSN_PROLOGUE_END
);
6798 seq
= gen_sequence ();
6801 /* If optimization is off, and perhaps in an empty function,
6802 the entry block will have no successors. */
6803 if (ENTRY_BLOCK_PTR
->succ
)
6805 /* Can't deal with multiple successsors of the entry block. */
6806 if (ENTRY_BLOCK_PTR
->succ
->succ_next
)
6809 insert_insn_on_edge (seq
, ENTRY_BLOCK_PTR
->succ
);
6813 emit_insn_after (seq
, f
);
6817 /* If the exit block has no non-fake predecessors, we don't need
6819 for (e
= EXIT_BLOCK_PTR
->pred
; e
; e
= e
->pred_next
)
6820 if ((e
->flags
& EDGE_FAKE
) == 0)
6826 if (optimize
&& HAVE_return
)
6828 /* If we're allowed to generate a simple return instruction,
6829 then by definition we don't need a full epilogue. Examine
6830 the block that falls through to EXIT. If it does not
6831 contain any code, examine its predecessors and try to
6832 emit (conditional) return instructions. */
6838 for (e
= EXIT_BLOCK_PTR
->pred
; e
; e
= e
->pred_next
)
6839 if (e
->flags
& EDGE_FALLTHRU
)
6845 /* Verify that there are no active instructions in the last block. */
6847 while (label
&& GET_CODE (label
) != CODE_LABEL
)
6849 if (active_insn_p (label
))
6851 label
= PREV_INSN (label
);
6854 if (last
->head
== label
&& GET_CODE (label
) == CODE_LABEL
)
6856 rtx epilogue_line_note
= NULL_RTX
;
6858 /* Locate the line number associated with the closing brace,
6859 if we can find one. */
6860 for (seq
= get_last_insn ();
6861 seq
&& ! active_insn_p (seq
);
6862 seq
= PREV_INSN (seq
))
6863 if (GET_CODE (seq
) == NOTE
&& NOTE_LINE_NUMBER (seq
) > 0)
6865 epilogue_line_note
= seq
;
6869 for (e
= last
->pred
; e
; e
= e_next
)
6871 basic_block bb
= e
->src
;
6874 e_next
= e
->pred_next
;
6875 if (bb
== ENTRY_BLOCK_PTR
)
6879 if ((GET_CODE (jump
) != JUMP_INSN
) || JUMP_LABEL (jump
) != label
)
6882 /* If we have an unconditional jump, we can replace that
6883 with a simple return instruction. */
6884 if (simplejump_p (jump
))
6886 emit_return_into_block (bb
, epilogue_line_note
);
6887 flow_delete_insn (jump
);
6890 /* If we have a conditional jump, we can try to replace
6891 that with a conditional return instruction. */
6892 else if (condjump_p (jump
))
6896 ret
= SET_SRC (PATTERN (jump
));
6897 if (GET_CODE (XEXP (ret
, 1)) == LABEL_REF
)
6898 loc
= &XEXP (ret
, 1);
6900 loc
= &XEXP (ret
, 2);
6901 ret
= gen_rtx_RETURN (VOIDmode
);
6903 if (! validate_change (jump
, loc
, ret
, 0))
6905 if (JUMP_LABEL (jump
))
6906 LABEL_NUSES (JUMP_LABEL (jump
))--;
6908 /* If this block has only one successor, it both jumps
6909 and falls through to the fallthru block, so we can't
6911 if (bb
->succ
->succ_next
== NULL
)
6917 /* Fix up the CFG for the successful change we just made. */
6918 redirect_edge_succ (e
, EXIT_BLOCK_PTR
);
6921 /* Emit a return insn for the exit fallthru block. Whether
6922 this is still reachable will be determined later. */
6924 emit_barrier_after (last
->end
);
6925 emit_return_into_block (last
, epilogue_line_note
);
6926 epilogue_end
= last
->end
;
6931 #ifdef HAVE_epilogue
6934 /* Find the edge that falls through to EXIT. Other edges may exist
6935 due to RETURN instructions, but those don't need epilogues.
6936 There really shouldn't be a mixture -- either all should have
6937 been converted or none, however... */
6939 for (e
= EXIT_BLOCK_PTR
->pred
; e
; e
= e
->pred_next
)
6940 if (e
->flags
& EDGE_FALLTHRU
)
6946 epilogue_end
= emit_note (NULL
, NOTE_INSN_EPILOGUE_BEG
);
6948 seq
= gen_epilogue ();
6949 emit_jump_insn (seq
);
6951 /* Retain a map of the epilogue insns. */
6952 if (GET_CODE (seq
) != SEQUENCE
)
6954 record_insns (seq
, &epilogue
);
6956 seq
= gen_sequence ();
6959 insert_insn_on_edge (seq
, e
);
6966 commit_edge_insertions ();
6968 #ifdef HAVE_sibcall_epilogue
6969 /* Emit sibling epilogues before any sibling call sites. */
6970 for (e
= EXIT_BLOCK_PTR
->pred
; e
; e
= e
->pred_next
)
6972 basic_block bb
= e
->src
;
6977 if (GET_CODE (insn
) != CALL_INSN
6978 || ! SIBLING_CALL_P (insn
))
6982 seq
= gen_sibcall_epilogue ();
6985 i
= PREV_INSN (insn
);
6986 newinsn
= emit_insn_before (seq
, insn
);
6988 /* Update the UID to basic block map. */
6989 for (i
= NEXT_INSN (i
); i
!= insn
; i
= NEXT_INSN (i
))
6990 set_block_for_insn (i
, bb
);
6992 /* Retain a map of the epilogue insns. Used in life analysis to
6993 avoid getting rid of sibcall epilogue insns. */
6994 record_insns (GET_CODE (seq
) == SEQUENCE
6995 ? seq
: newinsn
, &sibcall_epilogue
);
6999 #ifdef HAVE_prologue
7004 /* GDB handles `break f' by setting a breakpoint on the first
7005 line note after the prologue. Which means (1) that if
7006 there are line number notes before where we inserted the
7007 prologue we should move them, and (2) we should generate a
7008 note before the end of the first basic block, if there isn't
7009 one already there. */
7011 for (insn
= prologue_end
; insn
; insn
= prev
)
7013 prev
= PREV_INSN (insn
);
7014 if (GET_CODE (insn
) == NOTE
&& NOTE_LINE_NUMBER (insn
) > 0)
7016 /* Note that we cannot reorder the first insn in the
7017 chain, since rest_of_compilation relies on that
7018 remaining constant. */
7021 reorder_insns (insn
, insn
, prologue_end
);
7025 /* Find the last line number note in the first block. */
7026 for (insn
= BASIC_BLOCK (0)->end
;
7027 insn
!= prologue_end
;
7028 insn
= PREV_INSN (insn
))
7029 if (GET_CODE (insn
) == NOTE
&& NOTE_LINE_NUMBER (insn
) > 0)
7032 /* If we didn't find one, make a copy of the first line number
7036 for (insn
= next_active_insn (prologue_end
);
7038 insn
= PREV_INSN (insn
))
7039 if (GET_CODE (insn
) == NOTE
&& NOTE_LINE_NUMBER (insn
) > 0)
7041 emit_line_note_after (NOTE_SOURCE_FILE (insn
),
7042 NOTE_LINE_NUMBER (insn
),
7049 #ifdef HAVE_epilogue
7054 /* Similarly, move any line notes that appear after the epilogue.
7055 There is no need, however, to be quite so anal about the existance
7057 for (insn
= epilogue_end
; insn
; insn
= next
)
7059 next
= NEXT_INSN (insn
);
7060 if (GET_CODE (insn
) == NOTE
&& NOTE_LINE_NUMBER (insn
) > 0)
7061 reorder_insns (insn
, insn
, PREV_INSN (epilogue_end
));
7067 /* Reposition the prologue-end and epilogue-begin notes after instruction
7068 scheduling and delayed branch scheduling. */
7071 reposition_prologue_and_epilogue_notes (f
)
7072 rtx f ATTRIBUTE_UNUSED
;
7074 #if defined (HAVE_prologue) || defined (HAVE_epilogue)
7077 if ((len
= VARRAY_SIZE (prologue
)) > 0)
7079 register rtx insn
, note
= 0;
7081 /* Scan from the beginning until we reach the last prologue insn.
7082 We apparently can't depend on basic_block_{head,end} after
7084 for (insn
= f
; len
&& insn
; insn
= NEXT_INSN (insn
))
7086 if (GET_CODE (insn
) == NOTE
)
7088 if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_PROLOGUE_END
)
7091 else if ((len
-= contains (insn
, prologue
)) == 0)
7094 /* Find the prologue-end note if we haven't already, and
7095 move it to just after the last prologue insn. */
7098 for (note
= insn
; (note
= NEXT_INSN (note
));)
7099 if (GET_CODE (note
) == NOTE
7100 && NOTE_LINE_NUMBER (note
) == NOTE_INSN_PROLOGUE_END
)
7104 next
= NEXT_INSN (note
);
7106 /* Whether or not we can depend on BLOCK_HEAD,
7107 attempt to keep it up-to-date. */
7108 if (BLOCK_HEAD (0) == note
)
7109 BLOCK_HEAD (0) = next
;
7112 add_insn_after (note
, insn
);
7117 if ((len
= VARRAY_SIZE (epilogue
)) > 0)
7119 register rtx insn
, note
= 0;
7121 /* Scan from the end until we reach the first epilogue insn.
7122 We apparently can't depend on basic_block_{head,end} after
7124 for (insn
= get_last_insn (); len
&& insn
; insn
= PREV_INSN (insn
))
7126 if (GET_CODE (insn
) == NOTE
)
7128 if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_EPILOGUE_BEG
)
7131 else if ((len
-= contains (insn
, epilogue
)) == 0)
7133 /* Find the epilogue-begin note if we haven't already, and
7134 move it to just before the first epilogue insn. */
7137 for (note
= insn
; (note
= PREV_INSN (note
));)
7138 if (GET_CODE (note
) == NOTE
7139 && NOTE_LINE_NUMBER (note
) == NOTE_INSN_EPILOGUE_BEG
)
7143 /* Whether or not we can depend on BLOCK_HEAD,
7144 attempt to keep it up-to-date. */
7146 && BLOCK_HEAD (n_basic_blocks
-1) == insn
)
7147 BLOCK_HEAD (n_basic_blocks
-1) = note
;
7150 add_insn_before (note
, insn
);
7154 #endif /* HAVE_prologue or HAVE_epilogue */
7157 /* Mark T for GC. */
7161 struct temp_slot
*t
;
7165 ggc_mark_rtx (t
->slot
);
7166 ggc_mark_rtx (t
->address
);
7167 ggc_mark_tree (t
->rtl_expr
);
7173 /* Mark P for GC. */
7176 mark_function_status (p
)
7185 ggc_mark_rtx (p
->arg_offset_rtx
);
7187 if (p
->x_parm_reg_stack_loc
)
7188 for (i
= p
->x_max_parm_reg
, r
= p
->x_parm_reg_stack_loc
;
7192 ggc_mark_rtx (p
->return_rtx
);
7193 ggc_mark_rtx (p
->x_cleanup_label
);
7194 ggc_mark_rtx (p
->x_return_label
);
7195 ggc_mark_rtx (p
->x_save_expr_regs
);
7196 ggc_mark_rtx (p
->x_stack_slot_list
);
7197 ggc_mark_rtx (p
->x_parm_birth_insn
);
7198 ggc_mark_rtx (p
->x_tail_recursion_label
);
7199 ggc_mark_rtx (p
->x_tail_recursion_reentry
);
7200 ggc_mark_rtx (p
->internal_arg_pointer
);
7201 ggc_mark_rtx (p
->x_arg_pointer_save_area
);
7202 ggc_mark_tree (p
->x_rtl_expr_chain
);
7203 ggc_mark_rtx (p
->x_last_parm_insn
);
7204 ggc_mark_tree (p
->x_context_display
);
7205 ggc_mark_tree (p
->x_trampoline_list
);
7206 ggc_mark_rtx (p
->epilogue_delay_list
);
7208 mark_temp_slot (p
->x_temp_slots
);
7211 struct var_refs_queue
*q
= p
->fixup_var_refs_queue
;
7214 ggc_mark_rtx (q
->modified
);
7219 ggc_mark_rtx (p
->x_nonlocal_goto_handler_slots
);
7220 ggc_mark_rtx (p
->x_nonlocal_goto_handler_labels
);
7221 ggc_mark_rtx (p
->x_nonlocal_goto_stack_level
);
7222 ggc_mark_tree (p
->x_nonlocal_labels
);
7225 /* Mark the function chain ARG (which is really a struct function **)
7229 mark_function_chain (arg
)
7232 struct function
*f
= *(struct function
**) arg
;
7234 for (; f
; f
= f
->next_global
)
7236 ggc_mark_tree (f
->decl
);
7238 mark_function_status (f
);
7239 mark_eh_status (f
->eh
);
7240 mark_stmt_status (f
->stmt
);
7241 mark_expr_status (f
->expr
);
7242 mark_emit_status (f
->emit
);
7243 mark_varasm_status (f
->varasm
);
7245 if (mark_machine_status
)
7246 (*mark_machine_status
) (f
);
7247 if (mark_lang_status
)
7248 (*mark_lang_status
) (f
);
7250 if (f
->original_arg_vector
)
7251 ggc_mark_rtvec ((rtvec
) f
->original_arg_vector
);
7252 if (f
->original_decl_initial
)
7253 ggc_mark_tree (f
->original_decl_initial
);
7257 /* Called once, at initialization, to initialize function.c. */
7260 init_function_once ()
7262 ggc_add_root (&all_functions
, 1, sizeof all_functions
,
7263 mark_function_chain
);
7265 VARRAY_INT_INIT (prologue
, 0, "prologue");
7266 VARRAY_INT_INIT (epilogue
, 0, "epilogue");
7267 VARRAY_INT_INIT (sibcall_epilogue
, 0, "sibcall_epilogue");