1 /* Expands front end tree to back end RTL for GCC.
2 Copyright (C) 1987, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 /* This file handles the generation of rtl code from tree structure
23 at the level of the function as a whole.
24 It creates the rtl expressions for parameters and auto variables
25 and has full responsibility for allocating stack slots.
27 `expand_function_start' is called at the beginning of a function,
28 before the function body is parsed, and `expand_function_end' is
29 called after parsing the body.
31 Call `assign_stack_local' to allocate a stack slot for a local variable.
32 This is usually done during the RTL generation for the function body,
33 but it can also be done in the reload pass when a pseudo-register does
34 not get a hard register. */
38 #include "coretypes.h"
49 #include "hard-reg-set.h"
50 #include "insn-config.h"
53 #include "basic-block.h"
58 #include "integrate.h"
59 #include "langhooks.h"
61 #include "cfglayout.h"
63 #ifndef LOCAL_ALIGNMENT
64 #define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT
67 #ifndef STACK_ALIGNMENT_NEEDED
68 #define STACK_ALIGNMENT_NEEDED 1
71 #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
73 /* Some systems use __main in a way incompatible with its use in gcc, in these
74 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
75 give the same symbol without quotes for an alternative entry point. You
76 must define both, or neither. */
78 #define NAME__MAIN "__main"
81 /* Round a value to the lowest integer less than it that is a multiple of
82 the required alignment. Avoid using division in case the value is
83 negative. Assume the alignment is a power of two. */
84 #define FLOOR_ROUND(VALUE,ALIGN) ((VALUE) & ~((ALIGN) - 1))
86 /* Similar, but round to the next highest integer that meets the
88 #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
90 /* Nonzero if function being compiled doesn't contain any calls
91 (ignoring the prologue and epilogue). This is set prior to
92 local register allocation and is valid for the remaining
94 int current_function_is_leaf;
96 /* Nonzero if function being compiled doesn't modify the stack pointer
97 (ignoring the prologue and epilogue). This is only valid after
98 life_analysis has run. */
99 int current_function_sp_is_unchanging;
101 /* Nonzero if the function being compiled is a leaf function which only
102 uses leaf registers. This is valid after reload (specifically after
103 sched2) and is useful only if the port defines LEAF_REGISTERS. */
104 int current_function_uses_only_leaf_regs;
106 /* Nonzero once virtual register instantiation has been done.
107 assign_stack_local uses frame_pointer_rtx when this is nonzero.
108 calls.c:emit_library_call_value_1 uses it to set up
109 post-instantiation libcalls. */
110 int virtuals_instantiated;
112 /* Assign unique numbers to labels generated for profiling, debugging, etc. */
113 static GTY(()) int funcdef_no;
115 /* These variables hold pointers to functions to create and destroy
116 target specific, per-function data structures. */
117 struct machine_function * (*init_machine_status) (void);
119 /* The currently compiled function. */
120 struct function *cfun = 0;
122 /* These arrays record the INSN_UIDs of the prologue and epilogue insns. */
123 static GTY(()) varray_type prologue;
124 static GTY(()) varray_type epilogue;
126 /* Array of INSN_UIDs to hold the INSN_UIDs for each sibcall epilogue
128 static GTY(()) varray_type sibcall_epilogue;
130 /* In order to evaluate some expressions, such as function calls returning
131 structures in memory, we need to temporarily allocate stack locations.
132 We record each allocated temporary in the following structure.
134 Associated with each temporary slot is a nesting level. When we pop up
135 one level, all temporaries associated with the previous level are freed.
136 Normally, all temporaries are freed after the execution of the statement
137 in which they were created. However, if we are inside a ({...}) grouping,
138 the result may be in a temporary and hence must be preserved. If the
139 result could be in a temporary, we preserve it if we can determine which
140 one it is in. If we cannot determine which temporary may contain the
141 result, all temporaries are preserved. A temporary is preserved by
142 pretending it was allocated at the previous nesting level.
144 Automatic variables are also assigned temporary slots, at the nesting
145 level where they are defined. They are marked a "kept" so that
146 free_temp_slots will not free them. */
148 struct temp_slot GTY(())
150 /* Points to next temporary slot. */
151 struct temp_slot *next;
152 /* Points to previous temporary slot. */
153 struct temp_slot *prev;
155 /* The rtx to used to reference the slot. */
157 /* The rtx used to represent the address if not the address of the
158 slot above. May be an EXPR_LIST if multiple addresses exist. */
160 /* The alignment (in bits) of the slot. */
162 /* The size, in units, of the slot. */
164 /* The type of the object in the slot, or zero if it doesn't correspond
165 to a type. We use this to determine whether a slot can be reused.
166 It can be reused if objects of the type of the new slot will always
167 conflict with objects of the type of the old slot. */
169 /* Nonzero if this temporary is currently in use. */
171 /* Nonzero if this temporary has its address taken. */
173 /* Nesting level at which this slot is being used. */
175 /* Nonzero if this should survive a call to free_temp_slots. */
177 /* The offset of the slot from the frame_pointer, including extra space
178 for alignment. This info is for combine_temp_slots. */
179 HOST_WIDE_INT base_offset;
180 /* The size of the slot, including extra space for alignment. This
181 info is for combine_temp_slots. */
182 HOST_WIDE_INT full_size;
185 /* Forward declarations. */
187 static rtx assign_stack_local_1 (enum machine_mode, HOST_WIDE_INT, int,
189 static struct temp_slot *find_temp_slot_from_address (rtx);
190 static void instantiate_decls (tree, int);
191 static void instantiate_decls_1 (tree, int);
192 static void instantiate_decl (rtx, HOST_WIDE_INT, int);
193 static rtx instantiate_new_reg (rtx, HOST_WIDE_INT *);
194 static int instantiate_virtual_regs_1 (rtx *, rtx, int);
195 static void pad_to_arg_alignment (struct args_size *, int, struct args_size *);
196 static void pad_below (struct args_size *, enum machine_mode, tree);
197 static void reorder_blocks_1 (rtx, tree, varray_type *);
198 static void reorder_fix_fragments (tree);
199 static int all_blocks (tree, tree *);
200 static tree *get_block_vector (tree, int *);
201 extern tree debug_find_var_in_block_tree (tree, tree);
202 /* We always define `record_insns' even if it's not used so that we
203 can always export `prologue_epilogue_contains'. */
204 static void record_insns (rtx, varray_type *) ATTRIBUTE_UNUSED;
205 static int contains (rtx, varray_type);
207 static void emit_return_into_block (basic_block, rtx);
209 #if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX)
210 static rtx keep_stack_depressed (rtx);
212 static void prepare_function_start (tree);
213 static void do_clobber_return_reg (rtx, void *);
214 static void do_use_return_reg (rtx, void *);
215 static void instantiate_virtual_regs_lossage (rtx);
216 static void set_insn_locators (rtx, int) ATTRIBUTE_UNUSED;
218 /* Pointer to chain of `struct function' for containing functions. */
219 struct function *outer_function_chain;
221 /* Given a function decl for a containing function,
222 return the `struct function' for it. */
225 find_function_data (tree decl)
229 for (p = outer_function_chain; p; p = p->outer)
236 /* Save the current context for compilation of a nested function.
237 This is called from language-specific code. The caller should use
238 the enter_nested langhook to save any language-specific state,
239 since this function knows only about language-independent
243 push_function_context_to (tree context)
249 if (context == current_function_decl)
250 cfun->contains_functions = 1;
253 struct function *containing = find_function_data (context);
254 containing->contains_functions = 1;
259 init_dummy_function_start ();
262 p->outer = outer_function_chain;
263 outer_function_chain = p;
265 lang_hooks.function.enter_nested (p);
271 push_function_context (void)
273 push_function_context_to (current_function_decl);
276 /* Restore the last saved context, at the end of a nested function.
277 This function is called from language-specific code. */
280 pop_function_context_from (tree context ATTRIBUTE_UNUSED)
282 struct function *p = outer_function_chain;
285 outer_function_chain = p->outer;
287 current_function_decl = p->decl;
290 lang_hooks.function.leave_nested (p);
292 /* Reset variables that have known state during rtx generation. */
293 virtuals_instantiated = 0;
294 generating_concat_p = 1;
298 pop_function_context (void)
300 pop_function_context_from (current_function_decl);
303 /* Clear out all parts of the state in F that can safely be discarded
304 after the function has been parsed, but not compiled, to let
305 garbage collection reclaim the memory. */
308 free_after_parsing (struct function *f)
310 /* f->expr->forced_labels is used by code generation. */
311 /* f->emit->regno_reg_rtx is used by code generation. */
312 /* f->varasm is used by code generation. */
313 /* f->eh->eh_return_stub_label is used by code generation. */
315 lang_hooks.function.final (f);
318 /* Clear out all parts of the state in F that can safely be discarded
319 after the function has been compiled, to let garbage collection
320 reclaim the memory. */
323 free_after_compilation (struct function *f)
331 f->x_avail_temp_slots = NULL;
332 f->x_used_temp_slots = NULL;
333 f->arg_offset_rtx = NULL;
334 f->return_rtx = NULL;
335 f->internal_arg_pointer = NULL;
336 f->x_nonlocal_goto_handler_labels = NULL;
337 f->x_return_label = NULL;
338 f->x_naked_return_label = NULL;
339 f->x_stack_slot_list = NULL;
340 f->x_tail_recursion_reentry = NULL;
341 f->x_arg_pointer_save_area = NULL;
342 f->x_parm_birth_insn = NULL;
343 f->original_arg_vector = NULL;
344 f->original_decl_initial = NULL;
345 f->epilogue_delay_list = NULL;
348 /* Allocate fixed slots in the stack frame of the current function. */
350 /* Return size needed for stack frame based on slots so far allocated in
352 This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY;
353 the caller may have to do that. */
356 get_func_frame_size (struct function *f)
358 #ifdef FRAME_GROWS_DOWNWARD
359 return -f->x_frame_offset;
361 return f->x_frame_offset;
365 /* Return size needed for stack frame based on slots so far allocated.
366 This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY;
367 the caller may have to do that. */
369 get_frame_size (void)
371 return get_func_frame_size (cfun);
374 /* Allocate a stack slot of SIZE bytes and return a MEM rtx for it
375 with machine mode MODE.
377 ALIGN controls the amount of alignment for the address of the slot:
378 0 means according to MODE,
379 -1 means use BIGGEST_ALIGNMENT and round size to multiple of that,
380 -2 means use BITS_PER_UNIT,
381 positive specifies alignment boundary in bits.
383 We do not round to stack_boundary here.
385 FUNCTION specifies the function to allocate in. */
388 assign_stack_local_1 (enum machine_mode mode, HOST_WIDE_INT size, int align,
389 struct function *function)
392 int bigend_correction = 0;
393 unsigned int alignment;
394 int frame_off, frame_alignment, frame_phase;
401 alignment = BIGGEST_ALIGNMENT;
403 alignment = GET_MODE_ALIGNMENT (mode);
405 /* Allow the target to (possibly) increase the alignment of this
407 type = lang_hooks.types.type_for_mode (mode, 0);
409 alignment = LOCAL_ALIGNMENT (type, alignment);
411 alignment /= BITS_PER_UNIT;
413 else if (align == -1)
415 alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
416 size = CEIL_ROUND (size, alignment);
418 else if (align == -2)
419 alignment = 1; /* BITS_PER_UNIT / BITS_PER_UNIT */
421 alignment = align / BITS_PER_UNIT;
423 #ifdef FRAME_GROWS_DOWNWARD
424 function->x_frame_offset -= size;
427 /* Ignore alignment we can't do with expected alignment of the boundary. */
428 if (alignment * BITS_PER_UNIT > PREFERRED_STACK_BOUNDARY)
429 alignment = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
431 if (function->stack_alignment_needed < alignment * BITS_PER_UNIT)
432 function->stack_alignment_needed = alignment * BITS_PER_UNIT;
434 /* Calculate how many bytes the start of local variables is off from
436 frame_alignment = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
437 frame_off = STARTING_FRAME_OFFSET % frame_alignment;
438 frame_phase = frame_off ? frame_alignment - frame_off : 0;
440 /* Round the frame offset to the specified alignment. The default is
441 to always honor requests to align the stack but a port may choose to
442 do its own stack alignment by defining STACK_ALIGNMENT_NEEDED. */
443 if (STACK_ALIGNMENT_NEEDED
447 /* We must be careful here, since FRAME_OFFSET might be negative and
448 division with a negative dividend isn't as well defined as we might
449 like. So we instead assume that ALIGNMENT is a power of two and
450 use logical operations which are unambiguous. */
451 #ifdef FRAME_GROWS_DOWNWARD
452 function->x_frame_offset
453 = (FLOOR_ROUND (function->x_frame_offset - frame_phase,
454 (unsigned HOST_WIDE_INT) alignment)
457 function->x_frame_offset
458 = (CEIL_ROUND (function->x_frame_offset - frame_phase,
459 (unsigned HOST_WIDE_INT) alignment)
464 /* On a big-endian machine, if we are allocating more space than we will use,
465 use the least significant bytes of those that are allocated. */
466 if (BYTES_BIG_ENDIAN && mode != BLKmode)
467 bigend_correction = size - GET_MODE_SIZE (mode);
469 /* If we have already instantiated virtual registers, return the actual
470 address relative to the frame pointer. */
471 if (function == cfun && virtuals_instantiated)
472 addr = plus_constant (frame_pointer_rtx,
474 (frame_offset + bigend_correction
475 + STARTING_FRAME_OFFSET, Pmode));
477 addr = plus_constant (virtual_stack_vars_rtx,
479 (function->x_frame_offset + bigend_correction,
482 #ifndef FRAME_GROWS_DOWNWARD
483 function->x_frame_offset += size;
486 x = gen_rtx_MEM (mode, addr);
488 function->x_stack_slot_list
489 = gen_rtx_EXPR_LIST (VOIDmode, x, function->x_stack_slot_list);
494 /* Wrapper around assign_stack_local_1; assign a local stack slot for the
498 assign_stack_local (enum machine_mode mode, HOST_WIDE_INT size, int align)
500 return assign_stack_local_1 (mode, size, align, cfun);
504 /* Removes temporary slot TEMP from LIST. */
507 cut_slot_from_list (struct temp_slot *temp, struct temp_slot **list)
510 temp->next->prev = temp->prev;
512 temp->prev->next = temp->next;
516 temp->prev = temp->next = NULL;
519 /* Inserts temporary slot TEMP to LIST. */
522 insert_slot_to_list (struct temp_slot *temp, struct temp_slot **list)
526 (*list)->prev = temp;
531 /* Returns the list of used temp slots at LEVEL. */
533 static struct temp_slot **
534 temp_slots_at_level (int level)
538 if (!used_temp_slots)
539 VARRAY_GENERIC_PTR_INIT (used_temp_slots, 3, "used_temp_slots");
541 while (level >= (int) VARRAY_ACTIVE_SIZE (used_temp_slots))
542 VARRAY_PUSH_GENERIC_PTR (used_temp_slots, NULL);
544 return (struct temp_slot **) &VARRAY_GENERIC_PTR (used_temp_slots, level);
547 /* Returns the maximal temporary slot level. */
550 max_slot_level (void)
552 if (!used_temp_slots)
555 return VARRAY_ACTIVE_SIZE (used_temp_slots) - 1;
558 /* Moves temporary slot TEMP to LEVEL. */
561 move_slot_to_level (struct temp_slot *temp, int level)
563 cut_slot_from_list (temp, temp_slots_at_level (temp->level));
564 insert_slot_to_list (temp, temp_slots_at_level (level));
568 /* Make temporary slot TEMP available. */
571 make_slot_available (struct temp_slot *temp)
573 cut_slot_from_list (temp, temp_slots_at_level (temp->level));
574 insert_slot_to_list (temp, &avail_temp_slots);
579 /* Allocate a temporary stack slot and record it for possible later
582 MODE is the machine mode to be given to the returned rtx.
584 SIZE is the size in units of the space required. We do no rounding here
585 since assign_stack_local will do any required rounding.
587 KEEP is 1 if this slot is to be retained after a call to
588 free_temp_slots. Automatic variables for a block are allocated
589 with this flag. KEEP values of 2 or 3 were needed respectively
590 for variables whose lifetime is controlled by CLEANUP_POINT_EXPRs
591 or for SAVE_EXPRs, but they are now unused and will abort.
593 TYPE is the type that will be used for the stack slot. */
596 assign_stack_temp_for_type (enum machine_mode mode, HOST_WIDE_INT size, int keep,
600 struct temp_slot *p, *best_p = 0, *selected = NULL, **pp;
603 /* If SIZE is -1 it means that somebody tried to allocate a temporary
604 of a variable size. */
605 gcc_assert (size != -1);
607 /* These are now unused. */
608 gcc_assert (keep <= 1);
611 align = BIGGEST_ALIGNMENT;
613 align = GET_MODE_ALIGNMENT (mode);
616 type = lang_hooks.types.type_for_mode (mode, 0);
619 align = LOCAL_ALIGNMENT (type, align);
621 /* Try to find an available, already-allocated temporary of the proper
622 mode which meets the size and alignment requirements. Choose the
623 smallest one with the closest alignment. */
624 for (p = avail_temp_slots; p; p = p->next)
626 if (p->align >= align && p->size >= size && GET_MODE (p->slot) == mode
627 && objects_must_conflict_p (p->type, type)
628 && (best_p == 0 || best_p->size > p->size
629 || (best_p->size == p->size && best_p->align > p->align)))
631 if (p->align == align && p->size == size)
634 cut_slot_from_list (selected, &avail_temp_slots);
642 /* Make our best, if any, the one to use. */
646 cut_slot_from_list (selected, &avail_temp_slots);
648 /* If there are enough aligned bytes left over, make them into a new
649 temp_slot so that the extra bytes don't get wasted. Do this only
650 for BLKmode slots, so that we can be sure of the alignment. */
651 if (GET_MODE (best_p->slot) == BLKmode)
653 int alignment = best_p->align / BITS_PER_UNIT;
654 HOST_WIDE_INT rounded_size = CEIL_ROUND (size, alignment);
656 if (best_p->size - rounded_size >= alignment)
658 p = ggc_alloc (sizeof (struct temp_slot));
659 p->in_use = p->addr_taken = 0;
660 p->size = best_p->size - rounded_size;
661 p->base_offset = best_p->base_offset + rounded_size;
662 p->full_size = best_p->full_size - rounded_size;
663 p->slot = gen_rtx_MEM (BLKmode,
664 plus_constant (XEXP (best_p->slot, 0),
666 p->align = best_p->align;
668 p->type = best_p->type;
669 insert_slot_to_list (p, &avail_temp_slots);
671 stack_slot_list = gen_rtx_EXPR_LIST (VOIDmode, p->slot,
674 best_p->size = rounded_size;
675 best_p->full_size = rounded_size;
680 /* If we still didn't find one, make a new temporary. */
683 HOST_WIDE_INT frame_offset_old = frame_offset;
685 p = ggc_alloc (sizeof (struct temp_slot));
687 /* We are passing an explicit alignment request to assign_stack_local.
688 One side effect of that is assign_stack_local will not round SIZE
689 to ensure the frame offset remains suitably aligned.
691 So for requests which depended on the rounding of SIZE, we go ahead
692 and round it now. We also make sure ALIGNMENT is at least
693 BIGGEST_ALIGNMENT. */
694 gcc_assert (mode != BLKmode || align == BIGGEST_ALIGNMENT);
695 p->slot = assign_stack_local (mode,
697 ? CEIL_ROUND (size, (int) align / BITS_PER_UNIT)
703 /* The following slot size computation is necessary because we don't
704 know the actual size of the temporary slot until assign_stack_local
705 has performed all the frame alignment and size rounding for the
706 requested temporary. Note that extra space added for alignment
707 can be either above or below this stack slot depending on which
708 way the frame grows. We include the extra space if and only if it
709 is above this slot. */
710 #ifdef FRAME_GROWS_DOWNWARD
711 p->size = frame_offset_old - frame_offset;
716 /* Now define the fields used by combine_temp_slots. */
717 #ifdef FRAME_GROWS_DOWNWARD
718 p->base_offset = frame_offset;
719 p->full_size = frame_offset_old - frame_offset;
721 p->base_offset = frame_offset_old;
722 p->full_size = frame_offset - frame_offset_old;
733 p->level = temp_slot_level;
736 pp = temp_slots_at_level (p->level);
737 insert_slot_to_list (p, pp);
739 /* Create a new MEM rtx to avoid clobbering MEM flags of old slots. */
740 slot = gen_rtx_MEM (mode, XEXP (p->slot, 0));
741 stack_slot_list = gen_rtx_EXPR_LIST (VOIDmode, slot, stack_slot_list);
743 /* If we know the alias set for the memory that will be used, use
744 it. If there's no TYPE, then we don't know anything about the
745 alias set for the memory. */
746 set_mem_alias_set (slot, type ? get_alias_set (type) : 0);
747 set_mem_align (slot, align);
749 /* If a type is specified, set the relevant flags. */
752 MEM_VOLATILE_P (slot) = TYPE_VOLATILE (type);
753 MEM_SET_IN_STRUCT_P (slot, AGGREGATE_TYPE_P (type));
759 /* Allocate a temporary stack slot and record it for possible later
760 reuse. First three arguments are same as in preceding function. */
763 assign_stack_temp (enum machine_mode mode, HOST_WIDE_INT size, int keep)
765 return assign_stack_temp_for_type (mode, size, keep, NULL_TREE);
768 /* Assign a temporary.
769 If TYPE_OR_DECL is a decl, then we are doing it on behalf of the decl
770 and so that should be used in error messages. In either case, we
771 allocate of the given type.
772 KEEP is as for assign_stack_temp.
773 MEMORY_REQUIRED is 1 if the result must be addressable stack memory;
774 it is 0 if a register is OK.
775 DONT_PROMOTE is 1 if we should not promote values in register
779 assign_temp (tree type_or_decl, int keep, int memory_required,
780 int dont_promote ATTRIBUTE_UNUSED)
783 enum machine_mode mode;
788 if (DECL_P (type_or_decl))
789 decl = type_or_decl, type = TREE_TYPE (decl);
791 decl = NULL, type = type_or_decl;
793 mode = TYPE_MODE (type);
795 unsignedp = TYPE_UNSIGNED (type);
798 if (mode == BLKmode || memory_required)
800 HOST_WIDE_INT size = int_size_in_bytes (type);
804 /* Zero sized arrays are GNU C extension. Set size to 1 to avoid
805 problems with allocating the stack space. */
809 /* Unfortunately, we don't yet know how to allocate variable-sized
810 temporaries. However, sometimes we have a fixed upper limit on
811 the size (which is stored in TYPE_ARRAY_MAX_SIZE) and can use that
812 instead. This is the case for Chill variable-sized strings. */
813 if (size == -1 && TREE_CODE (type) == ARRAY_TYPE
814 && TYPE_ARRAY_MAX_SIZE (type) != NULL_TREE
815 && host_integerp (TYPE_ARRAY_MAX_SIZE (type), 1))
816 size = tree_low_cst (TYPE_ARRAY_MAX_SIZE (type), 1);
818 /* If we still haven't been able to get a size, see if the language
819 can compute a maximum size. */
821 && (size_tree = lang_hooks.types.max_size (type)) != 0
822 && host_integerp (size_tree, 1))
823 size = tree_low_cst (size_tree, 1);
825 /* The size of the temporary may be too large to fit into an integer. */
826 /* ??? Not sure this should happen except for user silliness, so limit
827 this to things that aren't compiler-generated temporaries. The
828 rest of the time we'll abort in assign_stack_temp_for_type. */
829 if (decl && size == -1
830 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST)
832 error ("%Jsize of variable %qD is too large", decl, decl);
836 tmp = assign_stack_temp_for_type (mode, size, keep, type);
842 mode = promote_mode (type, mode, &unsignedp, 0);
845 return gen_reg_rtx (mode);
848 /* Combine temporary stack slots which are adjacent on the stack.
850 This allows for better use of already allocated stack space. This is only
851 done for BLKmode slots because we can be sure that we won't have alignment
852 problems in this case. */
855 combine_temp_slots (void)
857 struct temp_slot *p, *q, *next, *next_q;
860 /* We can't combine slots, because the information about which slot
861 is in which alias set will be lost. */
862 if (flag_strict_aliasing)
865 /* If there are a lot of temp slots, don't do anything unless
866 high levels of optimization. */
867 if (! flag_expensive_optimizations)
868 for (p = avail_temp_slots, num_slots = 0; p; p = p->next, num_slots++)
869 if (num_slots > 100 || (num_slots > 10 && optimize == 0))
872 for (p = avail_temp_slots; p; p = next)
878 if (GET_MODE (p->slot) != BLKmode)
881 for (q = p->next; q; q = next_q)
887 if (GET_MODE (q->slot) != BLKmode)
890 if (p->base_offset + p->full_size == q->base_offset)
892 /* Q comes after P; combine Q into P. */
894 p->full_size += q->full_size;
897 else if (q->base_offset + q->full_size == p->base_offset)
899 /* P comes after Q; combine P into Q. */
901 q->full_size += p->full_size;
906 cut_slot_from_list (q, &avail_temp_slots);
909 /* Either delete P or advance past it. */
911 cut_slot_from_list (p, &avail_temp_slots);
915 /* Find the temp slot corresponding to the object at address X. */
917 static struct temp_slot *
918 find_temp_slot_from_address (rtx x)
924 for (i = max_slot_level (); i >= 0; i--)
925 for (p = *temp_slots_at_level (i); p; p = p->next)
927 if (XEXP (p->slot, 0) == x
929 || (GET_CODE (x) == PLUS
930 && XEXP (x, 0) == virtual_stack_vars_rtx
931 && GET_CODE (XEXP (x, 1)) == CONST_INT
932 && INTVAL (XEXP (x, 1)) >= p->base_offset
933 && INTVAL (XEXP (x, 1)) < p->base_offset + p->full_size))
936 else if (p->address != 0 && GET_CODE (p->address) == EXPR_LIST)
937 for (next = p->address; next; next = XEXP (next, 1))
938 if (XEXP (next, 0) == x)
942 /* If we have a sum involving a register, see if it points to a temp
944 if (GET_CODE (x) == PLUS && REG_P (XEXP (x, 0))
945 && (p = find_temp_slot_from_address (XEXP (x, 0))) != 0)
947 else if (GET_CODE (x) == PLUS && REG_P (XEXP (x, 1))
948 && (p = find_temp_slot_from_address (XEXP (x, 1))) != 0)
954 /* Indicate that NEW is an alternate way of referring to the temp slot
955 that previously was known by OLD. */
958 update_temp_slot_address (rtx old, rtx new)
962 if (rtx_equal_p (old, new))
965 p = find_temp_slot_from_address (old);
967 /* If we didn't find one, see if both OLD is a PLUS. If so, and NEW
968 is a register, see if one operand of the PLUS is a temporary
969 location. If so, NEW points into it. Otherwise, if both OLD and
970 NEW are a PLUS and if there is a register in common between them.
971 If so, try a recursive call on those values. */
974 if (GET_CODE (old) != PLUS)
979 update_temp_slot_address (XEXP (old, 0), new);
980 update_temp_slot_address (XEXP (old, 1), new);
983 else if (GET_CODE (new) != PLUS)
986 if (rtx_equal_p (XEXP (old, 0), XEXP (new, 0)))
987 update_temp_slot_address (XEXP (old, 1), XEXP (new, 1));
988 else if (rtx_equal_p (XEXP (old, 1), XEXP (new, 0)))
989 update_temp_slot_address (XEXP (old, 0), XEXP (new, 1));
990 else if (rtx_equal_p (XEXP (old, 0), XEXP (new, 1)))
991 update_temp_slot_address (XEXP (old, 1), XEXP (new, 0));
992 else if (rtx_equal_p (XEXP (old, 1), XEXP (new, 1)))
993 update_temp_slot_address (XEXP (old, 0), XEXP (new, 0));
998 /* Otherwise add an alias for the temp's address. */
999 else if (p->address == 0)
1003 if (GET_CODE (p->address) != EXPR_LIST)
1004 p->address = gen_rtx_EXPR_LIST (VOIDmode, p->address, NULL_RTX);
1006 p->address = gen_rtx_EXPR_LIST (VOIDmode, new, p->address);
1010 /* If X could be a reference to a temporary slot, mark the fact that its
1011 address was taken. */
1014 mark_temp_addr_taken (rtx x)
1016 struct temp_slot *p;
1021 /* If X is not in memory or is at a constant address, it cannot be in
1022 a temporary slot. */
1023 if (!MEM_P (x) || CONSTANT_P (XEXP (x, 0)))
1026 p = find_temp_slot_from_address (XEXP (x, 0));
1031 /* If X could be a reference to a temporary slot, mark that slot as
1032 belonging to the to one level higher than the current level. If X
1033 matched one of our slots, just mark that one. Otherwise, we can't
1034 easily predict which it is, so upgrade all of them. Kept slots
1035 need not be touched.
1037 This is called when an ({...}) construct occurs and a statement
1038 returns a value in memory. */
1041 preserve_temp_slots (rtx x)
1043 struct temp_slot *p = 0, *next;
1045 /* If there is no result, we still might have some objects whose address
1046 were taken, so we need to make sure they stay around. */
1049 for (p = *temp_slots_at_level (temp_slot_level); p; p = next)
1054 move_slot_to_level (p, temp_slot_level - 1);
1060 /* If X is a register that is being used as a pointer, see if we have
1061 a temporary slot we know it points to. To be consistent with
1062 the code below, we really should preserve all non-kept slots
1063 if we can't find a match, but that seems to be much too costly. */
1064 if (REG_P (x) && REG_POINTER (x))
1065 p = find_temp_slot_from_address (x);
1067 /* If X is not in memory or is at a constant address, it cannot be in
1068 a temporary slot, but it can contain something whose address was
1070 if (p == 0 && (!MEM_P (x) || CONSTANT_P (XEXP (x, 0))))
1072 for (p = *temp_slots_at_level (temp_slot_level); p; p = next)
1077 move_slot_to_level (p, temp_slot_level - 1);
1083 /* First see if we can find a match. */
1085 p = find_temp_slot_from_address (XEXP (x, 0));
1089 /* Move everything at our level whose address was taken to our new
1090 level in case we used its address. */
1091 struct temp_slot *q;
1093 if (p->level == temp_slot_level)
1095 for (q = *temp_slots_at_level (temp_slot_level); q; q = next)
1099 if (p != q && q->addr_taken)
1100 move_slot_to_level (q, temp_slot_level - 1);
1103 move_slot_to_level (p, temp_slot_level - 1);
1109 /* Otherwise, preserve all non-kept slots at this level. */
1110 for (p = *temp_slots_at_level (temp_slot_level); p; p = next)
1115 move_slot_to_level (p, temp_slot_level - 1);
1119 /* Free all temporaries used so far. This is normally called at the
1120 end of generating code for a statement. */
1123 free_temp_slots (void)
1125 struct temp_slot *p, *next;
1127 for (p = *temp_slots_at_level (temp_slot_level); p; p = next)
1132 make_slot_available (p);
1135 combine_temp_slots ();
1138 /* Push deeper into the nesting level for stack temporaries. */
1141 push_temp_slots (void)
1146 /* Pop a temporary nesting level. All slots in use in the current level
1150 pop_temp_slots (void)
1152 struct temp_slot *p, *next;
1154 for (p = *temp_slots_at_level (temp_slot_level); p; p = next)
1157 make_slot_available (p);
1160 combine_temp_slots ();
1165 /* Initialize temporary slots. */
1168 init_temp_slots (void)
1170 /* We have not allocated any temporaries yet. */
1171 avail_temp_slots = 0;
1172 used_temp_slots = 0;
1173 temp_slot_level = 0;
1176 /* These routines are responsible for converting virtual register references
1177 to the actual hard register references once RTL generation is complete.
1179 The following four variables are used for communication between the
1180 routines. They contain the offsets of the virtual registers from their
1181 respective hard registers. */
1183 static int in_arg_offset;
1184 static int var_offset;
1185 static int dynamic_offset;
1186 static int out_arg_offset;
1187 static int cfa_offset;
1189 /* In most machines, the stack pointer register is equivalent to the bottom
1192 #ifndef STACK_POINTER_OFFSET
1193 #define STACK_POINTER_OFFSET 0
1196 /* If not defined, pick an appropriate default for the offset of dynamically
1197 allocated memory depending on the value of ACCUMULATE_OUTGOING_ARGS,
1198 REG_PARM_STACK_SPACE, and OUTGOING_REG_PARM_STACK_SPACE. */
1200 #ifndef STACK_DYNAMIC_OFFSET
1202 /* The bottom of the stack points to the actual arguments. If
1203 REG_PARM_STACK_SPACE is defined, this includes the space for the register
1204 parameters. However, if OUTGOING_REG_PARM_STACK space is not defined,
1205 stack space for register parameters is not pushed by the caller, but
1206 rather part of the fixed stack areas and hence not included in
1207 `current_function_outgoing_args_size'. Nevertheless, we must allow
1208 for it when allocating stack dynamic objects. */
1210 #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE)
1211 #define STACK_DYNAMIC_OFFSET(FNDECL) \
1212 ((ACCUMULATE_OUTGOING_ARGS \
1213 ? (current_function_outgoing_args_size + REG_PARM_STACK_SPACE (FNDECL)) : 0)\
1214 + (STACK_POINTER_OFFSET)) \
1217 #define STACK_DYNAMIC_OFFSET(FNDECL) \
1218 ((ACCUMULATE_OUTGOING_ARGS ? current_function_outgoing_args_size : 0) \
1219 + (STACK_POINTER_OFFSET))
1223 /* On most machines, the CFA coincides with the first incoming parm. */
1225 #ifndef ARG_POINTER_CFA_OFFSET
1226 #define ARG_POINTER_CFA_OFFSET(FNDECL) FIRST_PARM_OFFSET (FNDECL)
1230 /* Pass through the INSNS of function FNDECL and convert virtual register
1231 references to hard register references. */
1234 instantiate_virtual_regs (void)
1238 /* Compute the offsets to use for this function. */
1239 in_arg_offset = FIRST_PARM_OFFSET (current_function_decl);
1240 var_offset = STARTING_FRAME_OFFSET;
1241 dynamic_offset = STACK_DYNAMIC_OFFSET (current_function_decl);
1242 out_arg_offset = STACK_POINTER_OFFSET;
1243 cfa_offset = ARG_POINTER_CFA_OFFSET (current_function_decl);
1245 /* Scan all variables and parameters of this function. For each that is
1246 in memory, instantiate all virtual registers if the result is a valid
1247 address. If not, we do it later. That will handle most uses of virtual
1248 regs on many machines. */
1249 instantiate_decls (current_function_decl, 1);
1251 /* Initialize recognition, indicating that volatile is OK. */
1254 /* Scan through all the insns, instantiating every virtual register still
1256 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
1257 if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN
1258 || GET_CODE (insn) == CALL_INSN)
1260 instantiate_virtual_regs_1 (&PATTERN (insn), insn, 1);
1261 if (INSN_DELETED_P (insn))
1263 instantiate_virtual_regs_1 (®_NOTES (insn), NULL_RTX, 0);
1264 /* Instantiate any virtual registers in CALL_INSN_FUNCTION_USAGE. */
1265 if (GET_CODE (insn) == CALL_INSN)
1266 instantiate_virtual_regs_1 (&CALL_INSN_FUNCTION_USAGE (insn),
1269 /* Past this point all ASM statements should match. Verify that
1270 to avoid failures later in the compilation process. */
1271 if (asm_noperands (PATTERN (insn)) >= 0
1272 && ! check_asm_operands (PATTERN (insn)))
1273 instantiate_virtual_regs_lossage (insn);
1276 /* Now instantiate the remaining register equivalences for debugging info.
1277 These will not be valid addresses. */
1278 instantiate_decls (current_function_decl, 0);
1280 /* Indicate that, from now on, assign_stack_local should use
1281 frame_pointer_rtx. */
1282 virtuals_instantiated = 1;
1285 /* Scan all decls in FNDECL (both variables and parameters) and instantiate
1286 all virtual registers in their DECL_RTL's.
1288 If VALID_ONLY, do this only if the resulting address is still valid.
1289 Otherwise, always do it. */
1292 instantiate_decls (tree fndecl, int valid_only)
1296 /* Process all parameters of the function. */
1297 for (decl = DECL_ARGUMENTS (fndecl); decl; decl = TREE_CHAIN (decl))
1299 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (decl));
1300 HOST_WIDE_INT size_rtl;
1302 instantiate_decl (DECL_RTL (decl), size, valid_only);
1304 /* If the parameter was promoted, then the incoming RTL mode may be
1305 larger than the declared type size. We must use the larger of
1307 size_rtl = GET_MODE_SIZE (GET_MODE (DECL_INCOMING_RTL (decl)));
1308 size = MAX (size_rtl, size);
1309 instantiate_decl (DECL_INCOMING_RTL (decl), size, valid_only);
1312 /* Now process all variables defined in the function or its subblocks. */
1313 instantiate_decls_1 (DECL_INITIAL (fndecl), valid_only);
1316 /* Subroutine of instantiate_decls: Process all decls in the given
1317 BLOCK node and all its subblocks. */
1320 instantiate_decls_1 (tree let, int valid_only)
1324 for (t = BLOCK_VARS (let); t; t = TREE_CHAIN (t))
1325 if (DECL_RTL_SET_P (t))
1326 instantiate_decl (DECL_RTL (t),
1327 int_size_in_bytes (TREE_TYPE (t)),
1330 /* Process all subblocks. */
1331 for (t = BLOCK_SUBBLOCKS (let); t; t = TREE_CHAIN (t))
1332 instantiate_decls_1 (t, valid_only);
1335 /* Subroutine of the preceding procedures: Given RTL representing a
1336 decl and the size of the object, do any instantiation required.
1338 If VALID_ONLY is nonzero, it means that the RTL should only be
1339 changed if the new address is valid. */
1342 instantiate_decl (rtx x, HOST_WIDE_INT size, int valid_only)
1344 enum machine_mode mode;
1347 /* If this is not a MEM, no need to do anything. Similarly if the
1348 address is a constant or a register that is not a virtual register. */
1350 if (x == 0 || !MEM_P (x))
1354 if (CONSTANT_P (addr)
1356 && (REGNO (addr) < FIRST_VIRTUAL_REGISTER
1357 || REGNO (addr) > LAST_VIRTUAL_REGISTER)))
1360 /* If we should only do this if the address is valid, copy the address.
1361 We need to do this so we can undo any changes that might make the
1362 address invalid. This copy is unfortunate, but probably can't be
1366 addr = copy_rtx (addr);
1368 instantiate_virtual_regs_1 (&addr, NULL_RTX, 0);
1370 if (valid_only && size >= 0)
1372 unsigned HOST_WIDE_INT decl_size = size;
1374 /* Now verify that the resulting address is valid for every integer or
1375 floating-point mode up to and including SIZE bytes long. We do this
1376 since the object might be accessed in any mode and frame addresses
1379 for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1380 mode != VOIDmode && GET_MODE_SIZE (mode) <= decl_size;
1381 mode = GET_MODE_WIDER_MODE (mode))
1382 if (! memory_address_p (mode, addr))
1385 for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
1386 mode != VOIDmode && GET_MODE_SIZE (mode) <= decl_size;
1387 mode = GET_MODE_WIDER_MODE (mode))
1388 if (! memory_address_p (mode, addr))
1392 /* Put back the address now that we have updated it and we either know
1393 it is valid or we don't care whether it is valid. */
1398 /* Given a piece of RTX and a pointer to a HOST_WIDE_INT, if the RTX
1399 is a virtual register, return the equivalent hard register and set the
1400 offset indirectly through the pointer. Otherwise, return 0. */
1403 instantiate_new_reg (rtx x, HOST_WIDE_INT *poffset)
1406 HOST_WIDE_INT offset;
1408 if (x == virtual_incoming_args_rtx)
1409 new = arg_pointer_rtx, offset = in_arg_offset;
1410 else if (x == virtual_stack_vars_rtx)
1411 new = frame_pointer_rtx, offset = var_offset;
1412 else if (x == virtual_stack_dynamic_rtx)
1413 new = stack_pointer_rtx, offset = dynamic_offset;
1414 else if (x == virtual_outgoing_args_rtx)
1415 new = stack_pointer_rtx, offset = out_arg_offset;
1416 else if (x == virtual_cfa_rtx)
1417 new = arg_pointer_rtx, offset = cfa_offset;
1426 /* Called when instantiate_virtual_regs has failed to update the instruction.
1427 Usually this means that non-matching instruction has been emit, however for
1428 asm statements it may be the problem in the constraints. */
1430 instantiate_virtual_regs_lossage (rtx insn)
1432 gcc_assert (asm_noperands (PATTERN (insn)) >= 0);
1433 error_for_asm (insn, "impossible constraint in %<asm%>");
1436 /* Given a pointer to a piece of rtx and an optional pointer to the
1437 containing object, instantiate any virtual registers present in it.
1439 If EXTRA_INSNS, we always do the replacement and generate
1440 any extra insns before OBJECT. If it zero, we do nothing if replacement
1443 Return 1 if we either had nothing to do or if we were able to do the
1444 needed replacement. Return 0 otherwise; we only return zero if
1445 EXTRA_INSNS is zero.
1447 We first try some simple transformations to avoid the creation of extra
1451 instantiate_virtual_regs_1 (rtx *loc, rtx object, int extra_insns)
1456 HOST_WIDE_INT offset = 0;
1462 /* Re-start here to avoid recursion in common cases. */
1469 /* We may have detected and deleted invalid asm statements. */
1470 if (object && INSN_P (object) && INSN_DELETED_P (object))
1473 code = GET_CODE (x);
1475 /* Check for some special cases. */
1493 /* We are allowed to set the virtual registers. This means that
1494 the actual register should receive the source minus the
1495 appropriate offset. This is used, for example, in the handling
1496 of non-local gotos. */
1497 if ((new = instantiate_new_reg (SET_DEST (x), &offset)) != 0)
1499 rtx src = SET_SRC (x);
1501 /* We are setting the register, not using it, so the relevant
1502 offset is the negative of the offset to use were we using
1505 instantiate_virtual_regs_1 (&src, NULL_RTX, 0);
1507 /* The only valid sources here are PLUS or REG. Just do
1508 the simplest possible thing to handle them. */
1509 if (!REG_P (src) && GET_CODE (src) != PLUS)
1511 instantiate_virtual_regs_lossage (object);
1517 temp = force_operand (src, NULL_RTX);
1520 temp = force_operand (plus_constant (temp, offset), NULL_RTX);
1524 emit_insn_before (seq, object);
1527 if (! validate_change (object, &SET_SRC (x), temp, 0)
1529 instantiate_virtual_regs_lossage (object);
1534 instantiate_virtual_regs_1 (&SET_DEST (x), object, extra_insns);
1539 /* Handle special case of virtual register plus constant. */
1540 if (CONSTANT_P (XEXP (x, 1)))
1542 rtx old, new_offset;
1544 /* Check for (plus (plus VIRT foo) (const_int)) first. */
1545 if (GET_CODE (XEXP (x, 0)) == PLUS)
1547 if ((new = instantiate_new_reg (XEXP (XEXP (x, 0), 0), &offset)))
1549 instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 1), object,
1551 new = gen_rtx_PLUS (Pmode, new, XEXP (XEXP (x, 0), 1));
1560 #ifdef POINTERS_EXTEND_UNSIGNED
1561 /* If we have (plus (subreg (virtual-reg)) (const_int)), we know
1562 we can commute the PLUS and SUBREG because pointers into the
1563 frame are well-behaved. */
1564 else if (GET_CODE (XEXP (x, 0)) == SUBREG && GET_MODE (x) == ptr_mode
1565 && GET_CODE (XEXP (x, 1)) == CONST_INT
1567 = instantiate_new_reg (SUBREG_REG (XEXP (x, 0)),
1569 && validate_change (object, loc,
1570 plus_constant (gen_lowpart (ptr_mode,
1573 + INTVAL (XEXP (x, 1))),
1577 else if ((new = instantiate_new_reg (XEXP (x, 0), &offset)) == 0)
1579 /* We know the second operand is a constant. Unless the
1580 first operand is a REG (which has been already checked),
1581 it needs to be checked. */
1582 if (!REG_P (XEXP (x, 0)))
1590 new_offset = plus_constant (XEXP (x, 1), offset);
1592 /* If the new constant is zero, try to replace the sum with just
1594 if (new_offset == const0_rtx
1595 && validate_change (object, loc, new, 0))
1598 /* Next try to replace the register and new offset.
1599 There are two changes to validate here and we can't assume that
1600 in the case of old offset equals new just changing the register
1601 will yield a valid insn. In the interests of a little efficiency,
1602 however, we only call validate change once (we don't queue up the
1603 changes and then call apply_change_group). */
1607 ? ! validate_change (object, &XEXP (x, 0), new, 0)
1608 : (XEXP (x, 0) = new,
1609 ! validate_change (object, &XEXP (x, 1), new_offset, 0)))
1617 /* Otherwise copy the new constant into a register and replace
1618 constant with that register. */
1619 temp = gen_reg_rtx (Pmode);
1621 if (validate_change (object, &XEXP (x, 1), temp, 0))
1622 emit_insn_before (gen_move_insn (temp, new_offset), object);
1625 /* If that didn't work, replace this expression with a
1626 register containing the sum. */
1629 new = gen_rtx_PLUS (Pmode, new, new_offset);
1632 temp = force_operand (new, NULL_RTX);
1636 emit_insn_before (seq, object);
1637 if (! validate_change (object, loc, temp, 0)
1638 && ! validate_replace_rtx (x, temp, object))
1640 instantiate_virtual_regs_lossage (object);
1649 /* Fall through to generic two-operand expression case. */
1655 case DIV: case UDIV:
1656 case MOD: case UMOD:
1657 case AND: case IOR: case XOR:
1658 case ROTATERT: case ROTATE:
1659 case ASHIFTRT: case LSHIFTRT: case ASHIFT:
1661 case GE: case GT: case GEU: case GTU:
1662 case LE: case LT: case LEU: case LTU:
1663 if (XEXP (x, 1) && ! CONSTANT_P (XEXP (x, 1)))
1664 instantiate_virtual_regs_1 (&XEXP (x, 1), object, extra_insns);
1669 /* Most cases of MEM that convert to valid addresses have already been
1670 handled by our scan of decls. The only special handling we
1671 need here is to make a copy of the rtx to ensure it isn't being
1672 shared if we have to change it to a pseudo.
1674 If the rtx is a simple reference to an address via a virtual register,
1675 it can potentially be shared. In such cases, first try to make it
1676 a valid address, which can also be shared. Otherwise, copy it and
1679 First check for common cases that need no processing. These are
1680 usually due to instantiation already being done on a previous instance
1684 if (CONSTANT_ADDRESS_P (temp)
1685 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1686 || temp == arg_pointer_rtx
1688 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
1689 || temp == hard_frame_pointer_rtx
1691 || temp == frame_pointer_rtx)
1694 if (GET_CODE (temp) == PLUS
1695 && CONSTANT_ADDRESS_P (XEXP (temp, 1))
1696 && (XEXP (temp, 0) == frame_pointer_rtx
1697 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
1698 || XEXP (temp, 0) == hard_frame_pointer_rtx
1700 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1701 || XEXP (temp, 0) == arg_pointer_rtx
1706 if (temp == virtual_stack_vars_rtx
1707 || temp == virtual_incoming_args_rtx
1708 || (GET_CODE (temp) == PLUS
1709 && CONSTANT_ADDRESS_P (XEXP (temp, 1))
1710 && (XEXP (temp, 0) == virtual_stack_vars_rtx
1711 || XEXP (temp, 0) == virtual_incoming_args_rtx)))
1713 /* This MEM may be shared. If the substitution can be done without
1714 the need to generate new pseudos, we want to do it in place
1715 so all copies of the shared rtx benefit. The call below will
1716 only make substitutions if the resulting address is still
1719 Note that we cannot pass X as the object in the recursive call
1720 since the insn being processed may not allow all valid
1721 addresses. However, if we were not passed on object, we can
1722 only modify X without copying it if X will have a valid
1725 ??? Also note that this can still lose if OBJECT is an insn that
1726 has less restrictions on an address that some other insn.
1727 In that case, we will modify the shared address. This case
1728 doesn't seem very likely, though. One case where this could
1729 happen is in the case of a USE or CLOBBER reference, but we
1730 take care of that below. */
1732 if (instantiate_virtual_regs_1 (&XEXP (x, 0),
1733 object ? object : x, 0))
1736 /* Otherwise make a copy and process that copy. We copy the entire
1737 RTL expression since it might be a PLUS which could also be
1739 *loc = x = copy_rtx (x);
1742 /* Fall through to generic unary operation case. */
1745 case STRICT_LOW_PART:
1747 case PRE_DEC: case PRE_INC: case POST_DEC: case POST_INC:
1748 case SIGN_EXTEND: case ZERO_EXTEND:
1749 case TRUNCATE: case FLOAT_EXTEND: case FLOAT_TRUNCATE:
1750 case FLOAT: case FIX:
1751 case UNSIGNED_FIX: case UNSIGNED_FLOAT:
1756 case POPCOUNT: case PARITY:
1757 /* These case either have just one operand or we know that we need not
1758 check the rest of the operands. */
1764 /* If the operand is a MEM, see if the change is a valid MEM. If not,
1765 go ahead and make the invalid one, but do it to a copy. For a REG,
1766 just make the recursive call, since there's no chance of a problem. */
1768 if ((MEM_P (XEXP (x, 0))
1769 && instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 0), XEXP (x, 0),
1771 || (REG_P (XEXP (x, 0))
1772 && instantiate_virtual_regs_1 (&XEXP (x, 0), object, 0)))
1775 XEXP (x, 0) = copy_rtx (XEXP (x, 0));
1780 /* Try to replace with a PLUS. If that doesn't work, compute the sum
1781 in front of this insn and substitute the temporary. */
1782 if ((new = instantiate_new_reg (x, &offset)) != 0)
1784 temp = plus_constant (new, offset);
1785 if (!validate_change (object, loc, temp, 0))
1791 temp = force_operand (temp, NULL_RTX);
1795 emit_insn_before (seq, object);
1796 if (! validate_change (object, loc, temp, 0)
1797 && ! validate_replace_rtx (x, temp, object))
1798 instantiate_virtual_regs_lossage (object);
1808 /* Scan all subexpressions. */
1809 fmt = GET_RTX_FORMAT (code);
1810 for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
1813 if (!instantiate_virtual_regs_1 (&XEXP (x, i), object, extra_insns))
1816 else if (*fmt == 'E')
1817 for (j = 0; j < XVECLEN (x, i); j++)
1818 if (! instantiate_virtual_regs_1 (&XVECEXP (x, i, j), object,
1825 /* Return 1 if EXP is an aggregate type (or a value with aggregate type).
1826 This means a type for which function calls must pass an address to the
1827 function or get an address back from the function.
1828 EXP may be a type node or an expression (whose type is tested). */
1831 aggregate_value_p (tree exp, tree fntype)
1833 int i, regno, nregs;
1836 tree type = (TYPE_P (exp)) ? exp : TREE_TYPE (exp);
1839 switch (TREE_CODE (fntype))
1842 fntype = get_callee_fndecl (fntype);
1843 fntype = fntype ? TREE_TYPE (fntype) : 0;
1846 fntype = TREE_TYPE (fntype);
1851 case IDENTIFIER_NODE:
1855 /* We don't expect other rtl types here. */
1859 if (TREE_CODE (type) == VOID_TYPE)
1861 /* If the front end has decided that this needs to be passed by
1862 reference, do so. */
1863 if ((TREE_CODE (exp) == PARM_DECL || TREE_CODE (exp) == RESULT_DECL)
1864 && DECL_BY_REFERENCE (exp))
1866 if (targetm.calls.return_in_memory (type, fntype))
1868 /* Types that are TREE_ADDRESSABLE must be constructed in memory,
1869 and thus can't be returned in registers. */
1870 if (TREE_ADDRESSABLE (type))
1872 if (flag_pcc_struct_return && AGGREGATE_TYPE_P (type))
1874 /* Make sure we have suitable call-clobbered regs to return
1875 the value in; if not, we must return it in memory. */
1876 reg = hard_function_value (type, 0, 0);
1878 /* If we have something other than a REG (e.g. a PARALLEL), then assume
1883 regno = REGNO (reg);
1884 nregs = hard_regno_nregs[regno][TYPE_MODE (type)];
1885 for (i = 0; i < nregs; i++)
1886 if (! call_used_regs[regno + i])
1891 /* Return true if we should assign DECL a pseudo register; false if it
1892 should live on the local stack. */
1895 use_register_for_decl (tree decl)
1897 /* Honor volatile. */
1898 if (TREE_SIDE_EFFECTS (decl))
1901 /* Honor addressability. */
1902 if (TREE_ADDRESSABLE (decl))
1905 /* Only register-like things go in registers. */
1906 if (DECL_MODE (decl) == BLKmode)
1909 /* If -ffloat-store specified, don't put explicit float variables
1911 /* ??? This should be checked after DECL_ARTIFICIAL, but tree-ssa
1912 propagates values across these stores, and it probably shouldn't. */
1913 if (flag_float_store && FLOAT_TYPE_P (TREE_TYPE (decl)))
1916 /* Compiler-generated temporaries can always go in registers. */
1917 if (DECL_ARTIFICIAL (decl))
1920 #ifdef NON_SAVING_SETJMP
1921 /* Protect variables not declared "register" from setjmp. */
1922 if (NON_SAVING_SETJMP
1923 && current_function_calls_setjmp
1924 && !DECL_REGISTER (decl))
1928 return (optimize || DECL_REGISTER (decl));
1931 /* Return true if TYPE should be passed by invisible reference. */
1934 pass_by_reference (CUMULATIVE_ARGS *ca, enum machine_mode mode,
1935 tree type, bool named_arg)
1939 /* If this type contains non-trivial constructors, then it is
1940 forbidden for the middle-end to create any new copies. */
1941 if (TREE_ADDRESSABLE (type))
1944 /* GCC post 3.4 passes *all* variable sized types by reference. */
1945 if (!TYPE_SIZE (type) || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1949 return targetm.calls.pass_by_reference (ca, mode, type, named_arg);
1952 /* Return true if TYPE, which is passed by reference, should be callee
1953 copied instead of caller copied. */
1956 reference_callee_copied (CUMULATIVE_ARGS *ca, enum machine_mode mode,
1957 tree type, bool named_arg)
1959 if (type && TREE_ADDRESSABLE (type))
1961 return targetm.calls.callee_copies (ca, mode, type, named_arg);
1964 /* Structures to communicate between the subroutines of assign_parms.
1965 The first holds data persistent across all parameters, the second
1966 is cleared out for each parameter. */
1968 struct assign_parm_data_all
1970 CUMULATIVE_ARGS args_so_far;
1971 struct args_size stack_args_size;
1972 tree function_result_decl;
1974 rtx conversion_insns;
1975 HOST_WIDE_INT pretend_args_size;
1976 HOST_WIDE_INT extra_pretend_bytes;
1977 int reg_parm_stack_space;
1980 struct assign_parm_data_one
1986 enum machine_mode nominal_mode;
1987 enum machine_mode passed_mode;
1988 enum machine_mode promoted_mode;
1989 struct locate_and_pad_arg_data locate;
1991 BOOL_BITFIELD named_arg : 1;
1992 BOOL_BITFIELD last_named : 1;
1993 BOOL_BITFIELD passed_pointer : 1;
1994 BOOL_BITFIELD on_stack : 1;
1995 BOOL_BITFIELD loaded_in_reg : 1;
1998 /* A subroutine of assign_parms. Initialize ALL. */
2001 assign_parms_initialize_all (struct assign_parm_data_all *all)
2005 memset (all, 0, sizeof (*all));
2007 fntype = TREE_TYPE (current_function_decl);
2009 #ifdef INIT_CUMULATIVE_INCOMING_ARGS
2010 INIT_CUMULATIVE_INCOMING_ARGS (all->args_so_far, fntype, NULL_RTX);
2012 INIT_CUMULATIVE_ARGS (all->args_so_far, fntype, NULL_RTX,
2013 current_function_decl, -1);
2016 #ifdef REG_PARM_STACK_SPACE
2017 all->reg_parm_stack_space = REG_PARM_STACK_SPACE (current_function_decl);
2021 /* If ARGS contains entries with complex types, split the entry into two
2022 entries of the component type. Return a new list of substitutions are
2023 needed, else the old list. */
2026 split_complex_args (tree args)
2030 /* Before allocating memory, check for the common case of no complex. */
2031 for (p = args; p; p = TREE_CHAIN (p))
2033 tree type = TREE_TYPE (p);
2034 if (TREE_CODE (type) == COMPLEX_TYPE
2035 && targetm.calls.split_complex_arg (type))
2041 args = copy_list (args);
2043 for (p = args; p; p = TREE_CHAIN (p))
2045 tree type = TREE_TYPE (p);
2046 if (TREE_CODE (type) == COMPLEX_TYPE
2047 && targetm.calls.split_complex_arg (type))
2050 tree subtype = TREE_TYPE (type);
2052 /* Rewrite the PARM_DECL's type with its component. */
2053 TREE_TYPE (p) = subtype;
2054 DECL_ARG_TYPE (p) = TREE_TYPE (DECL_ARG_TYPE (p));
2055 DECL_MODE (p) = VOIDmode;
2056 DECL_SIZE (p) = NULL;
2057 DECL_SIZE_UNIT (p) = NULL;
2060 /* Build a second synthetic decl. */
2061 decl = build_decl (PARM_DECL, NULL_TREE, subtype);
2062 DECL_ARG_TYPE (decl) = DECL_ARG_TYPE (p);
2063 layout_decl (decl, 0);
2065 /* Splice it in; skip the new decl. */
2066 TREE_CHAIN (decl) = TREE_CHAIN (p);
2067 TREE_CHAIN (p) = decl;
2075 /* A subroutine of assign_parms. Adjust the parameter list to incorporate
2076 the hidden struct return argument, and (abi willing) complex args.
2077 Return the new parameter list. */
2080 assign_parms_augmented_arg_list (struct assign_parm_data_all *all)
2082 tree fndecl = current_function_decl;
2083 tree fntype = TREE_TYPE (fndecl);
2084 tree fnargs = DECL_ARGUMENTS (fndecl);
2086 /* If struct value address is treated as the first argument, make it so. */
2087 if (aggregate_value_p (DECL_RESULT (fndecl), fndecl)
2088 && ! current_function_returns_pcc_struct
2089 && targetm.calls.struct_value_rtx (TREE_TYPE (fndecl), 1) == 0)
2091 tree type = build_pointer_type (TREE_TYPE (fntype));
2094 decl = build_decl (PARM_DECL, NULL_TREE, type);
2095 DECL_ARG_TYPE (decl) = type;
2096 DECL_ARTIFICIAL (decl) = 1;
2098 TREE_CHAIN (decl) = fnargs;
2100 all->function_result_decl = decl;
2103 all->orig_fnargs = fnargs;
2105 /* If the target wants to split complex arguments into scalars, do so. */
2106 if (targetm.calls.split_complex_arg)
2107 fnargs = split_complex_args (fnargs);
2112 /* A subroutine of assign_parms. Examine PARM and pull out type and mode
2113 data for the parameter. Incorporate ABI specifics such as pass-by-
2114 reference and type promotion. */
2117 assign_parm_find_data_types (struct assign_parm_data_all *all, tree parm,
2118 struct assign_parm_data_one *data)
2120 tree nominal_type, passed_type;
2121 enum machine_mode nominal_mode, passed_mode, promoted_mode;
2123 memset (data, 0, sizeof (*data));
2125 /* Set LAST_NAMED if this is last named arg before last anonymous args. */
2126 if (current_function_stdarg)
2129 for (tem = TREE_CHAIN (parm); tem; tem = TREE_CHAIN (tem))
2130 if (DECL_NAME (tem))
2133 data->last_named = true;
2136 /* Set NAMED_ARG if this arg should be treated as a named arg. For
2137 most machines, if this is a varargs/stdarg function, then we treat
2138 the last named arg as if it were anonymous too. */
2139 if (targetm.calls.strict_argument_naming (&all->args_so_far))
2140 data->named_arg = 1;
2142 data->named_arg = !data->last_named;
2144 nominal_type = TREE_TYPE (parm);
2145 passed_type = DECL_ARG_TYPE (parm);
2147 /* Look out for errors propagating this far. Also, if the parameter's
2148 type is void then its value doesn't matter. */
2149 if (TREE_TYPE (parm) == error_mark_node
2150 /* This can happen after weird syntax errors
2151 or if an enum type is defined among the parms. */
2152 || TREE_CODE (parm) != PARM_DECL
2153 || passed_type == NULL
2154 || VOID_TYPE_P (nominal_type))
2156 nominal_type = passed_type = void_type_node;
2157 nominal_mode = passed_mode = promoted_mode = VOIDmode;
2161 /* Find mode of arg as it is passed, and mode of arg as it should be
2162 during execution of this function. */
2163 passed_mode = TYPE_MODE (passed_type);
2164 nominal_mode = TYPE_MODE (nominal_type);
2166 /* If the parm is to be passed as a transparent union, use the type of
2167 the first field for the tests below. We have already verified that
2168 the modes are the same. */
2169 if (DECL_TRANSPARENT_UNION (parm)
2170 || (TREE_CODE (passed_type) == UNION_TYPE
2171 && TYPE_TRANSPARENT_UNION (passed_type)))
2172 passed_type = TREE_TYPE (TYPE_FIELDS (passed_type));
2174 /* See if this arg was passed by invisible reference. */
2175 if (pass_by_reference (&all->args_so_far, passed_mode,
2176 passed_type, data->named_arg))
2178 passed_type = nominal_type = build_pointer_type (passed_type);
2179 data->passed_pointer = true;
2180 passed_mode = nominal_mode = Pmode;
2183 /* Find mode as it is passed by the ABI. */
2184 promoted_mode = passed_mode;
2185 if (targetm.calls.promote_function_args (TREE_TYPE (current_function_decl)))
2187 int unsignedp = TYPE_UNSIGNED (passed_type);
2188 promoted_mode = promote_mode (passed_type, promoted_mode,
2193 data->nominal_type = nominal_type;
2194 data->passed_type = passed_type;
2195 data->nominal_mode = nominal_mode;
2196 data->passed_mode = passed_mode;
2197 data->promoted_mode = promoted_mode;
2200 /* A subroutine of assign_parms. Invoke setup_incoming_varargs. */
2203 assign_parms_setup_varargs (struct assign_parm_data_all *all,
2204 struct assign_parm_data_one *data, bool no_rtl)
2206 int varargs_pretend_bytes = 0;
2208 targetm.calls.setup_incoming_varargs (&all->args_so_far,
2209 data->promoted_mode,
2211 &varargs_pretend_bytes, no_rtl);
2213 /* If the back-end has requested extra stack space, record how much is
2214 needed. Do not change pretend_args_size otherwise since it may be
2215 nonzero from an earlier partial argument. */
2216 if (varargs_pretend_bytes > 0)
2217 all->pretend_args_size = varargs_pretend_bytes;
2220 /* A subroutine of assign_parms. Set DATA->ENTRY_PARM corresponding to
2221 the incoming location of the current parameter. */
2224 assign_parm_find_entry_rtl (struct assign_parm_data_all *all,
2225 struct assign_parm_data_one *data)
2227 HOST_WIDE_INT pretend_bytes = 0;
2231 if (data->promoted_mode == VOIDmode)
2233 data->entry_parm = data->stack_parm = const0_rtx;
2237 #ifdef FUNCTION_INCOMING_ARG
2238 entry_parm = FUNCTION_INCOMING_ARG (all->args_so_far, data->promoted_mode,
2239 data->passed_type, data->named_arg);
2241 entry_parm = FUNCTION_ARG (all->args_so_far, data->promoted_mode,
2242 data->passed_type, data->named_arg);
2245 if (entry_parm == 0)
2246 data->promoted_mode = data->passed_mode;
2248 /* Determine parm's home in the stack, in case it arrives in the stack
2249 or we should pretend it did. Compute the stack position and rtx where
2250 the argument arrives and its size.
2252 There is one complexity here: If this was a parameter that would
2253 have been passed in registers, but wasn't only because it is
2254 __builtin_va_alist, we want locate_and_pad_parm to treat it as if
2255 it came in a register so that REG_PARM_STACK_SPACE isn't skipped.
2256 In this case, we call FUNCTION_ARG with NAMED set to 1 instead of 0
2257 as it was the previous time. */
2258 in_regs = entry_parm != 0;
2259 #ifdef STACK_PARMS_IN_REG_PARM_AREA
2262 if (!in_regs && !data->named_arg)
2264 if (targetm.calls.pretend_outgoing_varargs_named (&all->args_so_far))
2267 #ifdef FUNCTION_INCOMING_ARG
2268 tem = FUNCTION_INCOMING_ARG (all->args_so_far, data->promoted_mode,
2269 data->passed_type, true);
2271 tem = FUNCTION_ARG (all->args_so_far, data->promoted_mode,
2272 data->passed_type, true);
2274 in_regs = tem != NULL;
2278 /* If this parameter was passed both in registers and in the stack, use
2279 the copy on the stack. */
2280 if (targetm.calls.must_pass_in_stack (data->promoted_mode,
2288 partial = FUNCTION_ARG_PARTIAL_NREGS (all->args_so_far,
2289 data->promoted_mode,
2292 data->partial = partial;
2294 /* The caller might already have allocated stack space for the
2295 register parameters. */
2296 if (partial != 0 && all->reg_parm_stack_space == 0)
2298 /* Part of this argument is passed in registers and part
2299 is passed on the stack. Ask the prologue code to extend
2300 the stack part so that we can recreate the full value.
2302 PRETEND_BYTES is the size of the registers we need to store.
2303 CURRENT_FUNCTION_PRETEND_ARGS_SIZE is the amount of extra
2304 stack space that the prologue should allocate.
2306 Internally, gcc assumes that the argument pointer is aligned
2307 to STACK_BOUNDARY bits. This is used both for alignment
2308 optimizations (see init_emit) and to locate arguments that are
2309 aligned to more than PARM_BOUNDARY bits. We must preserve this
2310 invariant by rounding CURRENT_FUNCTION_PRETEND_ARGS_SIZE up to
2311 a stack boundary. */
2313 /* We assume at most one partial arg, and it must be the first
2314 argument on the stack. */
2315 gcc_assert (!all->extra_pretend_bytes && !all->pretend_args_size);
2317 pretend_bytes = partial * UNITS_PER_WORD;
2318 all->pretend_args_size = CEIL_ROUND (pretend_bytes, STACK_BYTES);
2320 /* We want to align relative to the actual stack pointer, so
2321 don't include this in the stack size until later. */
2322 all->extra_pretend_bytes = all->pretend_args_size;
2326 locate_and_pad_parm (data->promoted_mode, data->passed_type, in_regs,
2327 entry_parm ? data->partial : 0, current_function_decl,
2328 &all->stack_args_size, &data->locate);
2330 /* Adjust offsets to include the pretend args. */
2331 pretend_bytes = all->extra_pretend_bytes - pretend_bytes;
2332 data->locate.slot_offset.constant += pretend_bytes;
2333 data->locate.offset.constant += pretend_bytes;
2335 data->entry_parm = entry_parm;
2338 /* A subroutine of assign_parms. If there is actually space on the stack
2339 for this parm, count it in stack_args_size and return true. */
2342 assign_parm_is_stack_parm (struct assign_parm_data_all *all,
2343 struct assign_parm_data_one *data)
2345 /* Trivially true if we've no incoming register. */
2346 if (data->entry_parm == NULL)
2348 /* Also true if we're partially in registers and partially not,
2349 since we've arranged to drop the entire argument on the stack. */
2350 else if (data->partial != 0)
2352 /* Also true if the target says that it's passed in both registers
2353 and on the stack. */
2354 else if (GET_CODE (data->entry_parm) == PARALLEL
2355 && XEXP (XVECEXP (data->entry_parm, 0, 0), 0) == NULL_RTX)
2357 /* Also true if the target says that there's stack allocated for
2358 all register parameters. */
2359 else if (all->reg_parm_stack_space > 0)
2361 /* Otherwise, no, this parameter has no ABI defined stack slot. */
2365 all->stack_args_size.constant += data->locate.size.constant;
2366 if (data->locate.size.var)
2367 ADD_PARM_SIZE (all->stack_args_size, data->locate.size.var);
2372 /* A subroutine of assign_parms. Given that this parameter is allocated
2373 stack space by the ABI, find it. */
2376 assign_parm_find_stack_rtl (tree parm, struct assign_parm_data_one *data)
2378 rtx offset_rtx, stack_parm;
2379 unsigned int align, boundary;
2381 /* If we're passing this arg using a reg, make its stack home the
2382 aligned stack slot. */
2383 if (data->entry_parm)
2384 offset_rtx = ARGS_SIZE_RTX (data->locate.slot_offset);
2386 offset_rtx = ARGS_SIZE_RTX (data->locate.offset);
2388 stack_parm = current_function_internal_arg_pointer;
2389 if (offset_rtx != const0_rtx)
2390 stack_parm = gen_rtx_PLUS (Pmode, stack_parm, offset_rtx);
2391 stack_parm = gen_rtx_MEM (data->promoted_mode, stack_parm);
2393 set_mem_attributes (stack_parm, parm, 1);
2395 boundary = FUNCTION_ARG_BOUNDARY (data->promoted_mode, data->passed_type);
2398 /* If we're padding upward, we know that the alignment of the slot
2399 is FUNCTION_ARG_BOUNDARY. If we're using slot_offset, we're
2400 intentionally forcing upward padding. Otherwise we have to come
2401 up with a guess at the alignment based on OFFSET_RTX. */
2402 if (data->locate.where_pad == upward || data->entry_parm)
2404 else if (GET_CODE (offset_rtx) == CONST_INT)
2406 align = INTVAL (offset_rtx) * BITS_PER_UNIT | boundary;
2407 align = align & -align;
2410 set_mem_align (stack_parm, align);
2412 if (data->entry_parm)
2413 set_reg_attrs_for_parm (data->entry_parm, stack_parm);
2415 data->stack_parm = stack_parm;
2418 /* A subroutine of assign_parms. Adjust DATA->ENTRY_RTL such that it's
2419 always valid and contiguous. */
2422 assign_parm_adjust_entry_rtl (struct assign_parm_data_one *data)
2424 rtx entry_parm = data->entry_parm;
2425 rtx stack_parm = data->stack_parm;
2427 /* If this parm was passed part in regs and part in memory, pretend it
2428 arrived entirely in memory by pushing the register-part onto the stack.
2429 In the special case of a DImode or DFmode that is split, we could put
2430 it together in a pseudoreg directly, but for now that's not worth
2432 if (data->partial != 0)
2434 /* Handle calls that pass values in multiple non-contiguous
2435 locations. The Irix 6 ABI has examples of this. */
2436 if (GET_CODE (entry_parm) == PARALLEL)
2437 emit_group_store (validize_mem (stack_parm), entry_parm,
2439 int_size_in_bytes (data->passed_type));
2441 move_block_from_reg (REGNO (entry_parm), validize_mem (stack_parm),
2444 entry_parm = stack_parm;
2447 /* If we didn't decide this parm came in a register, by default it came
2449 else if (entry_parm == NULL)
2450 entry_parm = stack_parm;
2452 /* When an argument is passed in multiple locations, we can't make use
2453 of this information, but we can save some copying if the whole argument
2454 is passed in a single register. */
2455 else if (GET_CODE (entry_parm) == PARALLEL
2456 && data->nominal_mode != BLKmode
2457 && data->passed_mode != BLKmode)
2459 size_t i, len = XVECLEN (entry_parm, 0);
2461 for (i = 0; i < len; i++)
2462 if (XEXP (XVECEXP (entry_parm, 0, i), 0) != NULL_RTX
2463 && REG_P (XEXP (XVECEXP (entry_parm, 0, i), 0))
2464 && (GET_MODE (XEXP (XVECEXP (entry_parm, 0, i), 0))
2465 == data->passed_mode)
2466 && INTVAL (XEXP (XVECEXP (entry_parm, 0, i), 1)) == 0)
2468 entry_parm = XEXP (XVECEXP (entry_parm, 0, i), 0);
2473 data->entry_parm = entry_parm;
2476 /* A subroutine of assign_parms. Adjust DATA->STACK_RTL such that it's
2477 always valid and properly aligned. */
2481 assign_parm_adjust_stack_rtl (struct assign_parm_data_one *data)
2483 rtx stack_parm = data->stack_parm;
2485 /* If we can't trust the parm stack slot to be aligned enough for its
2486 ultimate type, don't use that slot after entry. We'll make another
2487 stack slot, if we need one. */
2488 if (STRICT_ALIGNMENT && stack_parm
2489 && GET_MODE_ALIGNMENT (data->nominal_mode) > MEM_ALIGN (stack_parm))
2492 /* If parm was passed in memory, and we need to convert it on entry,
2493 don't store it back in that same slot. */
2494 else if (data->entry_parm == stack_parm
2495 && data->nominal_mode != BLKmode
2496 && data->nominal_mode != data->passed_mode)
2499 data->stack_parm = stack_parm;
2502 /* A subroutine of assign_parms. Return true if the current parameter
2503 should be stored as a BLKmode in the current frame. */
2506 assign_parm_setup_block_p (struct assign_parm_data_one *data)
2508 if (data->nominal_mode == BLKmode)
2510 if (GET_CODE (data->entry_parm) == PARALLEL)
2513 #ifdef BLOCK_REG_PADDING
2514 /* Only assign_parm_setup_block knows how to deal with register arguments
2515 that are padded at the least significant end. */
2516 if (REG_P (data->entry_parm)
2517 && GET_MODE_SIZE (data->promoted_mode) < UNITS_PER_WORD
2518 && (BLOCK_REG_PADDING (data->passed_mode, data->passed_type, 1)
2519 == (BYTES_BIG_ENDIAN ? upward : downward)))
2526 /* A subroutine of assign_parms. Arrange for the parameter to be
2527 present and valid in DATA->STACK_RTL. */
2530 assign_parm_setup_block (tree parm, struct assign_parm_data_one *data)
2532 rtx entry_parm = data->entry_parm;
2533 rtx stack_parm = data->stack_parm;
2535 /* If we've a non-block object that's nevertheless passed in parts,
2536 reconstitute it in register operations rather than on the stack. */
2537 if (GET_CODE (entry_parm) == PARALLEL
2538 && data->nominal_mode != BLKmode
2539 && XVECLEN (entry_parm, 0) > 1
2540 && use_register_for_decl (parm))
2542 rtx parmreg = gen_reg_rtx (data->nominal_mode);
2544 emit_group_store (parmreg, entry_parm, data->nominal_type,
2545 int_size_in_bytes (data->nominal_type));
2546 SET_DECL_RTL (parm, parmreg);
2550 /* If a BLKmode arrives in registers, copy it to a stack slot. Handle
2551 calls that pass values in multiple non-contiguous locations. */
2552 if (REG_P (entry_parm) || GET_CODE (entry_parm) == PARALLEL)
2554 HOST_WIDE_INT size = int_size_in_bytes (data->passed_type);
2555 HOST_WIDE_INT size_stored = CEIL_ROUND (size, UNITS_PER_WORD);
2558 /* Note that we will be storing an integral number of words.
2559 So we have to be careful to ensure that we allocate an
2560 integral number of words. We do this below in the
2561 assign_stack_local if space was not allocated in the argument
2562 list. If it was, this will not work if PARM_BOUNDARY is not
2563 a multiple of BITS_PER_WORD. It isn't clear how to fix this
2564 if it becomes a problem. Exception is when BLKmode arrives
2565 with arguments not conforming to word_mode. */
2567 if (stack_parm == 0)
2569 stack_parm = assign_stack_local (BLKmode, size_stored, 0);
2570 data->stack_parm = stack_parm;
2571 PUT_MODE (stack_parm, GET_MODE (entry_parm));
2572 set_mem_attributes (stack_parm, parm, 1);
2574 else if (GET_CODE (entry_parm) == PARALLEL)
2577 gcc_assert (!size || !(PARM_BOUNDARY % BITS_PER_WORD));
2579 mem = validize_mem (stack_parm);
2581 /* Handle values in multiple non-contiguous locations. */
2582 if (GET_CODE (entry_parm) == PARALLEL)
2583 emit_group_store (mem, entry_parm, data->passed_type, size);
2588 /* If SIZE is that of a mode no bigger than a word, just use
2589 that mode's store operation. */
2590 else if (size <= UNITS_PER_WORD)
2592 enum machine_mode mode
2593 = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
2596 #ifdef BLOCK_REG_PADDING
2597 && (size == UNITS_PER_WORD
2598 || (BLOCK_REG_PADDING (mode, data->passed_type, 1)
2599 != (BYTES_BIG_ENDIAN ? upward : downward)))
2603 rtx reg = gen_rtx_REG (mode, REGNO (entry_parm));
2604 emit_move_insn (change_address (mem, mode, 0), reg);
2607 /* Blocks smaller than a word on a BYTES_BIG_ENDIAN
2608 machine must be aligned to the left before storing
2609 to memory. Note that the previous test doesn't
2610 handle all cases (e.g. SIZE == 3). */
2611 else if (size != UNITS_PER_WORD
2612 #ifdef BLOCK_REG_PADDING
2613 && (BLOCK_REG_PADDING (mode, data->passed_type, 1)
2621 int by = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
2622 rtx reg = gen_rtx_REG (word_mode, REGNO (data->entry_parm));
2624 x = expand_shift (LSHIFT_EXPR, word_mode, reg,
2625 build_int_cst (NULL_TREE, by),
2627 tem = change_address (mem, word_mode, 0);
2628 emit_move_insn (tem, x);
2631 move_block_from_reg (REGNO (data->entry_parm), mem,
2632 size_stored / UNITS_PER_WORD);
2635 move_block_from_reg (REGNO (data->entry_parm), mem,
2636 size_stored / UNITS_PER_WORD);
2639 SET_DECL_RTL (parm, stack_parm);
2642 /* A subroutine of assign_parms. Allocate a pseudo to hold the current
2643 parameter. Get it there. Perform all ABI specified conversions. */
2646 assign_parm_setup_reg (struct assign_parm_data_all *all, tree parm,
2647 struct assign_parm_data_one *data)
2650 enum machine_mode promoted_nominal_mode;
2651 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (parm));
2652 bool did_conversion = false;
2654 /* Store the parm in a pseudoregister during the function, but we may
2655 need to do it in a wider mode. */
2657 promoted_nominal_mode
2658 = promote_mode (data->nominal_type, data->nominal_mode, &unsignedp, 0);
2660 parmreg = gen_reg_rtx (promoted_nominal_mode);
2662 if (!DECL_ARTIFICIAL (parm))
2663 mark_user_reg (parmreg);
2665 /* If this was an item that we received a pointer to,
2666 set DECL_RTL appropriately. */
2667 if (data->passed_pointer)
2669 rtx x = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data->passed_type)), parmreg);
2670 set_mem_attributes (x, parm, 1);
2671 SET_DECL_RTL (parm, x);
2674 SET_DECL_RTL (parm, parmreg);
2676 /* Copy the value into the register. */
2677 if (data->nominal_mode != data->passed_mode
2678 || promoted_nominal_mode != data->promoted_mode)
2682 /* ENTRY_PARM has been converted to PROMOTED_MODE, its
2683 mode, by the caller. We now have to convert it to
2684 NOMINAL_MODE, if different. However, PARMREG may be in
2685 a different mode than NOMINAL_MODE if it is being stored
2688 If ENTRY_PARM is a hard register, it might be in a register
2689 not valid for operating in its mode (e.g., an odd-numbered
2690 register for a DFmode). In that case, moves are the only
2691 thing valid, so we can't do a convert from there. This
2692 occurs when the calling sequence allow such misaligned
2695 In addition, the conversion may involve a call, which could
2696 clobber parameters which haven't been copied to pseudo
2697 registers yet. Therefore, we must first copy the parm to
2698 a pseudo reg here, and save the conversion until after all
2699 parameters have been moved. */
2701 rtx tempreg = gen_reg_rtx (GET_MODE (data->entry_parm));
2703 emit_move_insn (tempreg, validize_mem (data->entry_parm));
2705 push_to_sequence (all->conversion_insns);
2706 tempreg = convert_to_mode (data->nominal_mode, tempreg, unsignedp);
2708 if (GET_CODE (tempreg) == SUBREG
2709 && GET_MODE (tempreg) == data->nominal_mode
2710 && REG_P (SUBREG_REG (tempreg))
2711 && data->nominal_mode == data->passed_mode
2712 && GET_MODE (SUBREG_REG (tempreg)) == GET_MODE (data->entry_parm)
2713 && GET_MODE_SIZE (GET_MODE (tempreg))
2714 < GET_MODE_SIZE (GET_MODE (data->entry_parm)))
2716 /* The argument is already sign/zero extended, so note it
2718 SUBREG_PROMOTED_VAR_P (tempreg) = 1;
2719 SUBREG_PROMOTED_UNSIGNED_SET (tempreg, unsignedp);
2722 /* TREE_USED gets set erroneously during expand_assignment. */
2723 save_tree_used = TREE_USED (parm);
2724 expand_assignment (parm, make_tree (data->nominal_type, tempreg), 0);
2725 TREE_USED (parm) = save_tree_used;
2726 all->conversion_insns = get_insns ();
2729 did_conversion = true;
2732 emit_move_insn (parmreg, validize_mem (data->entry_parm));
2734 /* If we were passed a pointer but the actual value can safely live
2735 in a register, put it in one. */
2736 if (data->passed_pointer
2737 && TYPE_MODE (TREE_TYPE (parm)) != BLKmode
2738 /* If by-reference argument was promoted, demote it. */
2739 && (TYPE_MODE (TREE_TYPE (parm)) != GET_MODE (DECL_RTL (parm))
2740 || use_register_for_decl (parm)))
2742 /* We can't use nominal_mode, because it will have been set to
2743 Pmode above. We must use the actual mode of the parm. */
2744 parmreg = gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm)));
2745 mark_user_reg (parmreg);
2747 if (GET_MODE (parmreg) != GET_MODE (DECL_RTL (parm)))
2749 rtx tempreg = gen_reg_rtx (GET_MODE (DECL_RTL (parm)));
2750 int unsigned_p = TYPE_UNSIGNED (TREE_TYPE (parm));
2752 push_to_sequence (all->conversion_insns);
2753 emit_move_insn (tempreg, DECL_RTL (parm));
2754 tempreg = convert_to_mode (GET_MODE (parmreg), tempreg, unsigned_p);
2755 emit_move_insn (parmreg, tempreg);
2756 all->conversion_insns = get_insns();
2759 did_conversion = true;
2762 emit_move_insn (parmreg, DECL_RTL (parm));
2764 SET_DECL_RTL (parm, parmreg);
2766 /* STACK_PARM is the pointer, not the parm, and PARMREG is
2768 data->stack_parm = NULL;
2771 /* If we are passed an arg by reference and it is our responsibility
2772 to make a copy, do it now.
2773 PASSED_TYPE and PASSED mode now refer to the pointer, not the
2774 original argument, so we must recreate them in the call to
2775 FUNCTION_ARG_CALLEE_COPIES. */
2776 /* ??? Later add code to handle the case that if the argument isn't
2777 modified, don't do the copy. */
2779 else if (data->passed_pointer)
2781 tree type = TREE_TYPE (data->passed_type);
2783 if (reference_callee_copied (&all->args_so_far, TYPE_MODE (type),
2784 type, data->named_arg))
2788 /* This sequence may involve a library call perhaps clobbering
2789 registers that haven't been copied to pseudos yet. */
2791 push_to_sequence (all->conversion_insns);
2793 if (!COMPLETE_TYPE_P (type)
2794 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
2796 /* This is a variable sized object. */
2797 copy = allocate_dynamic_stack_space (expr_size (parm), NULL_RTX,
2799 copy = gen_rtx_MEM (BLKmode, copy);
2802 copy = assign_stack_temp (TYPE_MODE (type),
2803 int_size_in_bytes (type), 1);
2804 set_mem_attributes (copy, parm, 1);
2806 store_expr (parm, copy, 0);
2807 emit_move_insn (parmreg, XEXP (copy, 0));
2808 all->conversion_insns = get_insns ();
2811 did_conversion = true;
2815 /* Mark the register as eliminable if we did no conversion and it was
2816 copied from memory at a fixed offset, and the arg pointer was not
2817 copied to a pseudo-reg. If the arg pointer is a pseudo reg or the
2818 offset formed an invalid address, such memory-equivalences as we
2819 make here would screw up life analysis for it. */
2820 if (data->nominal_mode == data->passed_mode
2822 && data->stack_parm != 0
2823 && MEM_P (data->stack_parm)
2824 && data->locate.offset.var == 0
2825 && reg_mentioned_p (virtual_incoming_args_rtx,
2826 XEXP (data->stack_parm, 0)))
2828 rtx linsn = get_last_insn ();
2831 /* Mark complex types separately. */
2832 if (GET_CODE (parmreg) == CONCAT)
2834 enum machine_mode submode
2835 = GET_MODE_INNER (GET_MODE (parmreg));
2836 int regnor = REGNO (gen_realpart (submode, parmreg));
2837 int regnoi = REGNO (gen_imagpart (submode, parmreg));
2838 rtx stackr = gen_realpart (submode, data->stack_parm);
2839 rtx stacki = gen_imagpart (submode, data->stack_parm);
2841 /* Scan backwards for the set of the real and
2843 for (sinsn = linsn; sinsn != 0;
2844 sinsn = prev_nonnote_insn (sinsn))
2846 set = single_set (sinsn);
2850 if (SET_DEST (set) == regno_reg_rtx [regnoi])
2852 = gen_rtx_EXPR_LIST (REG_EQUIV, stacki,
2854 else if (SET_DEST (set) == regno_reg_rtx [regnor])
2856 = gen_rtx_EXPR_LIST (REG_EQUIV, stackr,
2860 else if ((set = single_set (linsn)) != 0
2861 && SET_DEST (set) == parmreg)
2863 = gen_rtx_EXPR_LIST (REG_EQUIV,
2864 data->stack_parm, REG_NOTES (linsn));
2867 /* For pointer data type, suggest pointer register. */
2868 if (POINTER_TYPE_P (TREE_TYPE (parm)))
2869 mark_reg_pointer (parmreg,
2870 TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm))));
2873 /* A subroutine of assign_parms. Allocate stack space to hold the current
2874 parameter. Get it there. Perform all ABI specified conversions. */
2877 assign_parm_setup_stack (struct assign_parm_data_all *all, tree parm,
2878 struct assign_parm_data_one *data)
2880 /* Value must be stored in the stack slot STACK_PARM during function
2883 if (data->promoted_mode != data->nominal_mode)
2885 /* Conversion is required. */
2886 rtx tempreg = gen_reg_rtx (GET_MODE (data->entry_parm));
2888 emit_move_insn (tempreg, validize_mem (data->entry_parm));
2890 push_to_sequence (all->conversion_insns);
2891 data->entry_parm = convert_to_mode (data->nominal_mode, tempreg,
2892 TYPE_UNSIGNED (TREE_TYPE (parm)));
2894 if (data->stack_parm)
2895 /* ??? This may need a big-endian conversion on sparc64. */
2897 = adjust_address (data->stack_parm, data->nominal_mode, 0);
2899 all->conversion_insns = get_insns ();
2903 if (data->entry_parm != data->stack_parm)
2905 if (data->stack_parm == 0)
2908 = assign_stack_local (GET_MODE (data->entry_parm),
2909 GET_MODE_SIZE (GET_MODE (data->entry_parm)),
2911 set_mem_attributes (data->stack_parm, parm, 1);
2914 if (data->promoted_mode != data->nominal_mode)
2916 push_to_sequence (all->conversion_insns);
2917 emit_move_insn (validize_mem (data->stack_parm),
2918 validize_mem (data->entry_parm));
2919 all->conversion_insns = get_insns ();
2923 emit_move_insn (validize_mem (data->stack_parm),
2924 validize_mem (data->entry_parm));
2927 SET_DECL_RTL (parm, data->stack_parm);
2930 /* A subroutine of assign_parms. If the ABI splits complex arguments, then
2931 undo the frobbing that we did in assign_parms_augmented_arg_list. */
2934 assign_parms_unsplit_complex (tree orig_fnargs, tree fnargs)
2938 for (parm = orig_fnargs; parm; parm = TREE_CHAIN (parm))
2940 if (TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE
2941 && targetm.calls.split_complex_arg (TREE_TYPE (parm)))
2943 rtx tmp, real, imag;
2944 enum machine_mode inner = GET_MODE_INNER (DECL_MODE (parm));
2946 real = DECL_RTL (fnargs);
2947 imag = DECL_RTL (TREE_CHAIN (fnargs));
2948 if (inner != GET_MODE (real))
2950 real = gen_lowpart_SUBREG (inner, real);
2951 imag = gen_lowpart_SUBREG (inner, imag);
2953 tmp = gen_rtx_CONCAT (DECL_MODE (parm), real, imag);
2954 SET_DECL_RTL (parm, tmp);
2956 real = DECL_INCOMING_RTL (fnargs);
2957 imag = DECL_INCOMING_RTL (TREE_CHAIN (fnargs));
2958 if (inner != GET_MODE (real))
2960 real = gen_lowpart_SUBREG (inner, real);
2961 imag = gen_lowpart_SUBREG (inner, imag);
2963 tmp = gen_rtx_CONCAT (DECL_MODE (parm), real, imag);
2964 set_decl_incoming_rtl (parm, tmp);
2965 fnargs = TREE_CHAIN (fnargs);
2969 SET_DECL_RTL (parm, DECL_RTL (fnargs));
2970 set_decl_incoming_rtl (parm, DECL_INCOMING_RTL (fnargs));
2972 /* Set MEM_EXPR to the original decl, i.e. to PARM,
2973 instead of the copy of decl, i.e. FNARGS. */
2974 if (DECL_INCOMING_RTL (parm) && MEM_P (DECL_INCOMING_RTL (parm)))
2975 set_mem_expr (DECL_INCOMING_RTL (parm), parm);
2978 fnargs = TREE_CHAIN (fnargs);
2982 /* Assign RTL expressions to the function's parameters. This may involve
2983 copying them into registers and using those registers as the DECL_RTL. */
2986 assign_parms (tree fndecl)
2988 struct assign_parm_data_all all;
2990 rtx internal_arg_pointer;
2991 int varargs_setup = 0;
2993 /* If the reg that the virtual arg pointer will be translated into is
2994 not a fixed reg or is the stack pointer, make a copy of the virtual
2995 arg pointer, and address parms via the copy. The frame pointer is
2996 considered fixed even though it is not marked as such.
2998 The second time through, simply use ap to avoid generating rtx. */
3000 if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
3001 || ! (fixed_regs[ARG_POINTER_REGNUM]
3002 || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)))
3003 internal_arg_pointer = copy_to_reg (virtual_incoming_args_rtx);
3005 internal_arg_pointer = virtual_incoming_args_rtx;
3006 current_function_internal_arg_pointer = internal_arg_pointer;
3008 assign_parms_initialize_all (&all);
3009 fnargs = assign_parms_augmented_arg_list (&all);
3011 for (parm = fnargs; parm; parm = TREE_CHAIN (parm))
3013 struct assign_parm_data_one data;
3015 /* Extract the type of PARM; adjust it according to ABI. */
3016 assign_parm_find_data_types (&all, parm, &data);
3018 /* Early out for errors and void parameters. */
3019 if (data.passed_mode == VOIDmode)
3021 SET_DECL_RTL (parm, const0_rtx);
3022 DECL_INCOMING_RTL (parm) = DECL_RTL (parm);
3026 /* Handle stdargs. LAST_NAMED is a slight mis-nomer; it's also true
3027 for the unnamed dummy argument following the last named argument.
3028 See ABI silliness wrt strict_argument_naming and NAMED_ARG. So
3029 we only want to do this when we get to the actual last named
3030 argument, which will be the first time LAST_NAMED gets set. */
3031 if (data.last_named && !varargs_setup)
3033 varargs_setup = true;
3034 assign_parms_setup_varargs (&all, &data, false);
3037 /* Find out where the parameter arrives in this function. */
3038 assign_parm_find_entry_rtl (&all, &data);
3040 /* Find out where stack space for this parameter might be. */
3041 if (assign_parm_is_stack_parm (&all, &data))
3043 assign_parm_find_stack_rtl (parm, &data);
3044 assign_parm_adjust_entry_rtl (&data);
3047 /* Record permanently how this parm was passed. */
3048 set_decl_incoming_rtl (parm, data.entry_parm);
3050 /* Update info on where next arg arrives in registers. */
3051 FUNCTION_ARG_ADVANCE (all.args_so_far, data.promoted_mode,
3052 data.passed_type, data.named_arg);
3054 assign_parm_adjust_stack_rtl (&data);
3056 if (assign_parm_setup_block_p (&data))
3057 assign_parm_setup_block (parm, &data);
3058 else if (data.passed_pointer || use_register_for_decl (parm))
3059 assign_parm_setup_reg (&all, parm, &data);
3061 assign_parm_setup_stack (&all, parm, &data);
3064 if (targetm.calls.split_complex_arg && fnargs != all.orig_fnargs)
3065 assign_parms_unsplit_complex (all.orig_fnargs, fnargs);
3067 /* Output all parameter conversion instructions (possibly including calls)
3068 now that all parameters have been copied out of hard registers. */
3069 emit_insn (all.conversion_insns);
3071 /* If we are receiving a struct value address as the first argument, set up
3072 the RTL for the function result. As this might require code to convert
3073 the transmitted address to Pmode, we do this here to ensure that possible
3074 preliminary conversions of the address have been emitted already. */
3075 if (all.function_result_decl)
3077 tree result = DECL_RESULT (current_function_decl);
3078 rtx addr = DECL_RTL (all.function_result_decl);
3081 if (DECL_BY_REFERENCE (result))
3085 addr = convert_memory_address (Pmode, addr);
3086 x = gen_rtx_MEM (DECL_MODE (result), addr);
3087 set_mem_attributes (x, result, 1);
3089 SET_DECL_RTL (result, x);
3092 /* We have aligned all the args, so add space for the pretend args. */
3093 current_function_pretend_args_size = all.pretend_args_size;
3094 all.stack_args_size.constant += all.extra_pretend_bytes;
3095 current_function_args_size = all.stack_args_size.constant;
3097 /* Adjust function incoming argument size for alignment and
3100 #ifdef REG_PARM_STACK_SPACE
3101 current_function_args_size = MAX (current_function_args_size,
3102 REG_PARM_STACK_SPACE (fndecl));
3105 current_function_args_size
3106 = ((current_function_args_size + STACK_BYTES - 1)
3107 / STACK_BYTES) * STACK_BYTES;
3109 #ifdef ARGS_GROW_DOWNWARD
3110 current_function_arg_offset_rtx
3111 = (all.stack_args_size.var == 0 ? GEN_INT (-all.stack_args_size.constant)
3112 : expand_expr (size_diffop (all.stack_args_size.var,
3113 size_int (-all.stack_args_size.constant)),
3114 NULL_RTX, VOIDmode, 0));
3116 current_function_arg_offset_rtx = ARGS_SIZE_RTX (all.stack_args_size);
3119 /* See how many bytes, if any, of its args a function should try to pop
3122 current_function_pops_args = RETURN_POPS_ARGS (fndecl, TREE_TYPE (fndecl),
3123 current_function_args_size);
3125 /* For stdarg.h function, save info about
3126 regs and stack space used by the named args. */
3128 current_function_args_info = all.args_so_far;
3130 /* Set the rtx used for the function return value. Put this in its
3131 own variable so any optimizers that need this information don't have
3132 to include tree.h. Do this here so it gets done when an inlined
3133 function gets output. */
3135 current_function_return_rtx
3136 = (DECL_RTL_SET_P (DECL_RESULT (fndecl))
3137 ? DECL_RTL (DECL_RESULT (fndecl)) : NULL_RTX);
3139 /* If scalar return value was computed in a pseudo-reg, or was a named
3140 return value that got dumped to the stack, copy that to the hard
3142 if (DECL_RTL_SET_P (DECL_RESULT (fndecl)))
3144 tree decl_result = DECL_RESULT (fndecl);
3145 rtx decl_rtl = DECL_RTL (decl_result);
3147 if (REG_P (decl_rtl)
3148 ? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER
3149 : DECL_REGISTER (decl_result))
3153 #ifdef FUNCTION_OUTGOING_VALUE
3154 real_decl_rtl = FUNCTION_OUTGOING_VALUE (TREE_TYPE (decl_result),
3157 real_decl_rtl = FUNCTION_VALUE (TREE_TYPE (decl_result),
3160 REG_FUNCTION_VALUE_P (real_decl_rtl) = 1;
3161 /* The delay slot scheduler assumes that current_function_return_rtx
3162 holds the hard register containing the return value, not a
3163 temporary pseudo. */
3164 current_function_return_rtx = real_decl_rtl;
3169 /* Indicate whether REGNO is an incoming argument to the current function
3170 that was promoted to a wider mode. If so, return the RTX for the
3171 register (to get its mode). PMODE and PUNSIGNEDP are set to the mode
3172 that REGNO is promoted from and whether the promotion was signed or
3176 promoted_input_arg (unsigned int regno, enum machine_mode *pmode, int *punsignedp)
3180 for (arg = DECL_ARGUMENTS (current_function_decl); arg;
3181 arg = TREE_CHAIN (arg))
3182 if (REG_P (DECL_INCOMING_RTL (arg))
3183 && REGNO (DECL_INCOMING_RTL (arg)) == regno
3184 && TYPE_MODE (DECL_ARG_TYPE (arg)) == TYPE_MODE (TREE_TYPE (arg)))
3186 enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg));
3187 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (arg));
3189 mode = promote_mode (TREE_TYPE (arg), mode, &unsignedp, 1);
3190 if (mode == GET_MODE (DECL_INCOMING_RTL (arg))
3191 && mode != DECL_MODE (arg))
3193 *pmode = DECL_MODE (arg);
3194 *punsignedp = unsignedp;
3195 return DECL_INCOMING_RTL (arg);
3203 /* Compute the size and offset from the start of the stacked arguments for a
3204 parm passed in mode PASSED_MODE and with type TYPE.
3206 INITIAL_OFFSET_PTR points to the current offset into the stacked
3209 The starting offset and size for this parm are returned in
3210 LOCATE->OFFSET and LOCATE->SIZE, respectively. When IN_REGS is
3211 nonzero, the offset is that of stack slot, which is returned in
3212 LOCATE->SLOT_OFFSET. LOCATE->ALIGNMENT_PAD is the amount of
3213 padding required from the initial offset ptr to the stack slot.
3215 IN_REGS is nonzero if the argument will be passed in registers. It will
3216 never be set if REG_PARM_STACK_SPACE is not defined.
3218 FNDECL is the function in which the argument was defined.
3220 There are two types of rounding that are done. The first, controlled by
3221 FUNCTION_ARG_BOUNDARY, forces the offset from the start of the argument
3222 list to be aligned to the specific boundary (in bits). This rounding
3223 affects the initial and starting offsets, but not the argument size.
3225 The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY,
3226 optionally rounds the size of the parm to PARM_BOUNDARY. The
3227 initial offset is not affected by this rounding, while the size always
3228 is and the starting offset may be. */
3230 /* LOCATE->OFFSET will be negative for ARGS_GROW_DOWNWARD case;
3231 INITIAL_OFFSET_PTR is positive because locate_and_pad_parm's
3232 callers pass in the total size of args so far as
3233 INITIAL_OFFSET_PTR. LOCATE->SIZE is always positive. */
3236 locate_and_pad_parm (enum machine_mode passed_mode, tree type, int in_regs,
3237 int partial, tree fndecl ATTRIBUTE_UNUSED,
3238 struct args_size *initial_offset_ptr,
3239 struct locate_and_pad_arg_data *locate)
3242 enum direction where_pad;
3244 int reg_parm_stack_space = 0;
3245 int part_size_in_regs;
3247 #ifdef REG_PARM_STACK_SPACE
3248 reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
3250 /* If we have found a stack parm before we reach the end of the
3251 area reserved for registers, skip that area. */
3254 if (reg_parm_stack_space > 0)
3256 if (initial_offset_ptr->var)
3258 initial_offset_ptr->var
3259 = size_binop (MAX_EXPR, ARGS_SIZE_TREE (*initial_offset_ptr),
3260 ssize_int (reg_parm_stack_space));
3261 initial_offset_ptr->constant = 0;
3263 else if (initial_offset_ptr->constant < reg_parm_stack_space)
3264 initial_offset_ptr->constant = reg_parm_stack_space;
3267 #endif /* REG_PARM_STACK_SPACE */
3269 part_size_in_regs = 0;
3270 if (reg_parm_stack_space == 0)
3271 part_size_in_regs = ((partial * UNITS_PER_WORD)
3272 / (PARM_BOUNDARY / BITS_PER_UNIT)
3273 * (PARM_BOUNDARY / BITS_PER_UNIT));
3276 = type ? size_in_bytes (type) : size_int (GET_MODE_SIZE (passed_mode));
3277 where_pad = FUNCTION_ARG_PADDING (passed_mode, type);
3278 boundary = FUNCTION_ARG_BOUNDARY (passed_mode, type);
3279 locate->where_pad = where_pad;
3281 #ifdef ARGS_GROW_DOWNWARD
3282 locate->slot_offset.constant = -initial_offset_ptr->constant;
3283 if (initial_offset_ptr->var)
3284 locate->slot_offset.var = size_binop (MINUS_EXPR, ssize_int (0),
3285 initial_offset_ptr->var);
3289 if (where_pad != none
3290 && (!host_integerp (sizetree, 1)
3291 || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % PARM_BOUNDARY))
3292 s2 = round_up (s2, PARM_BOUNDARY / BITS_PER_UNIT);
3293 SUB_PARM_SIZE (locate->slot_offset, s2);
3296 locate->slot_offset.constant += part_size_in_regs;
3299 #ifdef REG_PARM_STACK_SPACE
3300 || REG_PARM_STACK_SPACE (fndecl) > 0
3303 pad_to_arg_alignment (&locate->slot_offset, boundary,
3304 &locate->alignment_pad);
3306 locate->size.constant = (-initial_offset_ptr->constant
3307 - locate->slot_offset.constant);
3308 if (initial_offset_ptr->var)
3309 locate->size.var = size_binop (MINUS_EXPR,
3310 size_binop (MINUS_EXPR,
3312 initial_offset_ptr->var),
3313 locate->slot_offset.var);
3315 /* Pad_below needs the pre-rounded size to know how much to pad
3317 locate->offset = locate->slot_offset;
3318 if (where_pad == downward)
3319 pad_below (&locate->offset, passed_mode, sizetree);
3321 #else /* !ARGS_GROW_DOWNWARD */
3323 #ifdef REG_PARM_STACK_SPACE
3324 || REG_PARM_STACK_SPACE (fndecl) > 0
3327 pad_to_arg_alignment (initial_offset_ptr, boundary,
3328 &locate->alignment_pad);
3329 locate->slot_offset = *initial_offset_ptr;
3331 #ifdef PUSH_ROUNDING
3332 if (passed_mode != BLKmode)
3333 sizetree = size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree)));
3336 /* Pad_below needs the pre-rounded size to know how much to pad below
3337 so this must be done before rounding up. */
3338 locate->offset = locate->slot_offset;
3339 if (where_pad == downward)
3340 pad_below (&locate->offset, passed_mode, sizetree);
3342 if (where_pad != none
3343 && (!host_integerp (sizetree, 1)
3344 || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % PARM_BOUNDARY))
3345 sizetree = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT);
3347 ADD_PARM_SIZE (locate->size, sizetree);
3349 locate->size.constant -= part_size_in_regs;
3350 #endif /* ARGS_GROW_DOWNWARD */
3353 /* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY.
3354 BOUNDARY is measured in bits, but must be a multiple of a storage unit. */
3357 pad_to_arg_alignment (struct args_size *offset_ptr, int boundary,
3358 struct args_size *alignment_pad)
3360 tree save_var = NULL_TREE;
3361 HOST_WIDE_INT save_constant = 0;
3362 int boundary_in_bytes = boundary / BITS_PER_UNIT;
3363 HOST_WIDE_INT sp_offset = STACK_POINTER_OFFSET;
3365 #ifdef SPARC_STACK_BOUNDARY_HACK
3366 /* The sparc port has a bug. It sometimes claims a STACK_BOUNDARY
3367 higher than the real alignment of %sp. However, when it does this,
3368 the alignment of %sp+STACK_POINTER_OFFSET will be STACK_BOUNDARY.
3369 This is a temporary hack while the sparc port is fixed. */
3370 if (SPARC_STACK_BOUNDARY_HACK)
3374 if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY)
3376 save_var = offset_ptr->var;
3377 save_constant = offset_ptr->constant;
3380 alignment_pad->var = NULL_TREE;
3381 alignment_pad->constant = 0;
3383 if (boundary > BITS_PER_UNIT)
3385 if (offset_ptr->var)
3387 tree sp_offset_tree = ssize_int (sp_offset);
3388 tree offset = size_binop (PLUS_EXPR,
3389 ARGS_SIZE_TREE (*offset_ptr),
3391 #ifdef ARGS_GROW_DOWNWARD
3392 tree rounded = round_down (offset, boundary / BITS_PER_UNIT);
3394 tree rounded = round_up (offset, boundary / BITS_PER_UNIT);
3397 offset_ptr->var = size_binop (MINUS_EXPR, rounded, sp_offset_tree);
3398 /* ARGS_SIZE_TREE includes constant term. */
3399 offset_ptr->constant = 0;
3400 if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY)
3401 alignment_pad->var = size_binop (MINUS_EXPR, offset_ptr->var,
3406 offset_ptr->constant = -sp_offset +
3407 #ifdef ARGS_GROW_DOWNWARD
3408 FLOOR_ROUND (offset_ptr->constant + sp_offset, boundary_in_bytes);
3410 CEIL_ROUND (offset_ptr->constant + sp_offset, boundary_in_bytes);
3412 if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY)
3413 alignment_pad->constant = offset_ptr->constant - save_constant;
3419 pad_below (struct args_size *offset_ptr, enum machine_mode passed_mode, tree sizetree)
3421 if (passed_mode != BLKmode)
3423 if (GET_MODE_BITSIZE (passed_mode) % PARM_BOUNDARY)
3424 offset_ptr->constant
3425 += (((GET_MODE_BITSIZE (passed_mode) + PARM_BOUNDARY - 1)
3426 / PARM_BOUNDARY * PARM_BOUNDARY / BITS_PER_UNIT)
3427 - GET_MODE_SIZE (passed_mode));
3431 if (TREE_CODE (sizetree) != INTEGER_CST
3432 || (TREE_INT_CST_LOW (sizetree) * BITS_PER_UNIT) % PARM_BOUNDARY)
3434 /* Round the size up to multiple of PARM_BOUNDARY bits. */
3435 tree s2 = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT);
3437 ADD_PARM_SIZE (*offset_ptr, s2);
3438 SUB_PARM_SIZE (*offset_ptr, sizetree);
3443 /* Walk the tree of blocks describing the binding levels within a function
3444 and warn about variables the might be killed by setjmp or vfork.
3445 This is done after calling flow_analysis and before global_alloc
3446 clobbers the pseudo-regs to hard regs. */
3449 setjmp_vars_warning (tree block)
3453 for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
3455 if (TREE_CODE (decl) == VAR_DECL
3456 && DECL_RTL_SET_P (decl)
3457 && REG_P (DECL_RTL (decl))
3458 && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl))))
3459 warning ("%Jvariable %qD might be clobbered by %<longjmp%>"
3464 for (sub = BLOCK_SUBBLOCKS (block); sub; sub = TREE_CHAIN (sub))
3465 setjmp_vars_warning (sub);
3468 /* Do the appropriate part of setjmp_vars_warning
3469 but for arguments instead of local variables. */
3472 setjmp_args_warning (void)
3475 for (decl = DECL_ARGUMENTS (current_function_decl);
3476 decl; decl = TREE_CHAIN (decl))
3477 if (DECL_RTL (decl) != 0
3478 && REG_P (DECL_RTL (decl))
3479 && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl))))
3480 warning ("%Jargument %qD might be clobbered by %<longjmp%> or %<vfork%>",
3485 /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
3486 and create duplicate blocks. */
3487 /* ??? Need an option to either create block fragments or to create
3488 abstract origin duplicates of a source block. It really depends
3489 on what optimization has been performed. */
3492 reorder_blocks (void)
3494 tree block = DECL_INITIAL (current_function_decl);
3495 varray_type block_stack;
3497 if (block == NULL_TREE)
3500 VARRAY_TREE_INIT (block_stack, 10, "block_stack");
3502 /* Reset the TREE_ASM_WRITTEN bit for all blocks. */
3503 clear_block_marks (block);
3505 /* Prune the old trees away, so that they don't get in the way. */
3506 BLOCK_SUBBLOCKS (block) = NULL_TREE;
3507 BLOCK_CHAIN (block) = NULL_TREE;
3509 /* Recreate the block tree from the note nesting. */
3510 reorder_blocks_1 (get_insns (), block, &block_stack);
3511 BLOCK_SUBBLOCKS (block) = blocks_nreverse (BLOCK_SUBBLOCKS (block));
3513 /* Remove deleted blocks from the block fragment chains. */
3514 reorder_fix_fragments (block);
3517 /* Helper function for reorder_blocks. Reset TREE_ASM_WRITTEN. */
3520 clear_block_marks (tree block)
3524 TREE_ASM_WRITTEN (block) = 0;
3525 clear_block_marks (BLOCK_SUBBLOCKS (block));
3526 block = BLOCK_CHAIN (block);
3531 reorder_blocks_1 (rtx insns, tree current_block, varray_type *p_block_stack)
3535 for (insn = insns; insn; insn = NEXT_INSN (insn))
3539 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG)
3541 tree block = NOTE_BLOCK (insn);
3543 /* If we have seen this block before, that means it now
3544 spans multiple address regions. Create a new fragment. */
3545 if (TREE_ASM_WRITTEN (block))
3547 tree new_block = copy_node (block);
3550 origin = (BLOCK_FRAGMENT_ORIGIN (block)
3551 ? BLOCK_FRAGMENT_ORIGIN (block)
3553 BLOCK_FRAGMENT_ORIGIN (new_block) = origin;
3554 BLOCK_FRAGMENT_CHAIN (new_block)
3555 = BLOCK_FRAGMENT_CHAIN (origin);
3556 BLOCK_FRAGMENT_CHAIN (origin) = new_block;
3558 NOTE_BLOCK (insn) = new_block;
3562 BLOCK_SUBBLOCKS (block) = 0;
3563 TREE_ASM_WRITTEN (block) = 1;
3564 /* When there's only one block for the entire function,
3565 current_block == block and we mustn't do this, it
3566 will cause infinite recursion. */
3567 if (block != current_block)
3569 BLOCK_SUPERCONTEXT (block) = current_block;
3570 BLOCK_CHAIN (block) = BLOCK_SUBBLOCKS (current_block);
3571 BLOCK_SUBBLOCKS (current_block) = block;
3572 current_block = block;
3574 VARRAY_PUSH_TREE (*p_block_stack, block);
3576 else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
3578 NOTE_BLOCK (insn) = VARRAY_TOP_TREE (*p_block_stack);
3579 VARRAY_POP (*p_block_stack);
3580 BLOCK_SUBBLOCKS (current_block)
3581 = blocks_nreverse (BLOCK_SUBBLOCKS (current_block));
3582 current_block = BLOCK_SUPERCONTEXT (current_block);
3588 /* Rationalize BLOCK_FRAGMENT_ORIGIN. If an origin block no longer
3589 appears in the block tree, select one of the fragments to become
3590 the new origin block. */
3593 reorder_fix_fragments (tree block)
3597 tree dup_origin = BLOCK_FRAGMENT_ORIGIN (block);
3598 tree new_origin = NULL_TREE;
3602 if (! TREE_ASM_WRITTEN (dup_origin))
3604 new_origin = BLOCK_FRAGMENT_CHAIN (dup_origin);
3606 /* Find the first of the remaining fragments. There must
3607 be at least one -- the current block. */
3608 while (! TREE_ASM_WRITTEN (new_origin))
3609 new_origin = BLOCK_FRAGMENT_CHAIN (new_origin);
3610 BLOCK_FRAGMENT_ORIGIN (new_origin) = NULL_TREE;
3613 else if (! dup_origin)
3616 /* Re-root the rest of the fragments to the new origin. In the
3617 case that DUP_ORIGIN was null, that means BLOCK was the origin
3618 of a chain of fragments and we want to remove those fragments
3619 that didn't make it to the output. */
3622 tree *pp = &BLOCK_FRAGMENT_CHAIN (new_origin);
3627 if (TREE_ASM_WRITTEN (chain))
3629 BLOCK_FRAGMENT_ORIGIN (chain) = new_origin;
3631 pp = &BLOCK_FRAGMENT_CHAIN (chain);
3633 chain = BLOCK_FRAGMENT_CHAIN (chain);
3638 reorder_fix_fragments (BLOCK_SUBBLOCKS (block));
3639 block = BLOCK_CHAIN (block);
3643 /* Reverse the order of elements in the chain T of blocks,
3644 and return the new head of the chain (old last element). */
3647 blocks_nreverse (tree t)
3649 tree prev = 0, decl, next;
3650 for (decl = t; decl; decl = next)
3652 next = BLOCK_CHAIN (decl);
3653 BLOCK_CHAIN (decl) = prev;
3659 /* Count the subblocks of the list starting with BLOCK. If VECTOR is
3660 non-NULL, list them all into VECTOR, in a depth-first preorder
3661 traversal of the block tree. Also clear TREE_ASM_WRITTEN in all
3665 all_blocks (tree block, tree *vector)
3671 TREE_ASM_WRITTEN (block) = 0;
3673 /* Record this block. */
3675 vector[n_blocks] = block;
3679 /* Record the subblocks, and their subblocks... */
3680 n_blocks += all_blocks (BLOCK_SUBBLOCKS (block),
3681 vector ? vector + n_blocks : 0);
3682 block = BLOCK_CHAIN (block);
3688 /* Return a vector containing all the blocks rooted at BLOCK. The
3689 number of elements in the vector is stored in N_BLOCKS_P. The
3690 vector is dynamically allocated; it is the caller's responsibility
3691 to call `free' on the pointer returned. */
3694 get_block_vector (tree block, int *n_blocks_p)
3698 *n_blocks_p = all_blocks (block, NULL);
3699 block_vector = xmalloc (*n_blocks_p * sizeof (tree));
3700 all_blocks (block, block_vector);
3702 return block_vector;
3705 static GTY(()) int next_block_index = 2;
3707 /* Set BLOCK_NUMBER for all the blocks in FN. */
3710 number_blocks (tree fn)
3716 /* For SDB and XCOFF debugging output, we start numbering the blocks
3717 from 1 within each function, rather than keeping a running
3719 #if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
3720 if (write_symbols == SDB_DEBUG || write_symbols == XCOFF_DEBUG)
3721 next_block_index = 1;
3724 block_vector = get_block_vector (DECL_INITIAL (fn), &n_blocks);
3726 /* The top-level BLOCK isn't numbered at all. */
3727 for (i = 1; i < n_blocks; ++i)
3728 /* We number the blocks from two. */
3729 BLOCK_NUMBER (block_vector[i]) = next_block_index++;
3731 free (block_vector);
3736 /* If VAR is present in a subblock of BLOCK, return the subblock. */
3739 debug_find_var_in_block_tree (tree var, tree block)
3743 for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t))
3747 for (t = BLOCK_SUBBLOCKS (block); t; t = TREE_CHAIN (t))
3749 tree ret = debug_find_var_in_block_tree (var, t);
3757 /* Allocate a function structure for FNDECL and set its contents
3761 allocate_struct_function (tree fndecl)
3764 tree fntype = fndecl ? TREE_TYPE (fndecl) : NULL_TREE;
3766 cfun = ggc_alloc_cleared (sizeof (struct function));
3768 cfun->stack_alignment_needed = STACK_BOUNDARY;
3769 cfun->preferred_stack_boundary = STACK_BOUNDARY;
3771 current_function_funcdef_no = funcdef_no++;
3773 cfun->function_frequency = FUNCTION_FREQUENCY_NORMAL;
3775 init_eh_for_function ();
3777 lang_hooks.function.init (cfun);
3778 if (init_machine_status)
3779 cfun->machine = (*init_machine_status) ();
3784 DECL_STRUCT_FUNCTION (fndecl) = cfun;
3785 cfun->decl = fndecl;
3787 result = DECL_RESULT (fndecl);
3788 if (aggregate_value_p (result, fndecl))
3790 #ifdef PCC_STATIC_STRUCT_RETURN
3791 current_function_returns_pcc_struct = 1;
3793 current_function_returns_struct = 1;
3796 current_function_returns_pointer = POINTER_TYPE_P (TREE_TYPE (result));
3798 current_function_stdarg
3800 && TYPE_ARG_TYPES (fntype) != 0
3801 && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
3802 != void_type_node));
3805 /* Reset cfun, and other non-struct-function variables to defaults as
3806 appropriate for emitting rtl at the start of a function. */
3809 prepare_function_start (tree fndecl)
3811 if (fndecl && DECL_STRUCT_FUNCTION (fndecl))
3812 cfun = DECL_STRUCT_FUNCTION (fndecl);
3814 allocate_struct_function (fndecl);
3816 init_varasm_status (cfun);
3819 cse_not_expected = ! optimize;
3821 /* Caller save not needed yet. */
3822 caller_save_needed = 0;
3824 /* We haven't done register allocation yet. */
3827 /* Indicate that we have not instantiated virtual registers yet. */
3828 virtuals_instantiated = 0;
3830 /* Indicate that we want CONCATs now. */
3831 generating_concat_p = 1;
3833 /* Indicate we have no need of a frame pointer yet. */
3834 frame_pointer_needed = 0;
3837 /* Initialize the rtl expansion mechanism so that we can do simple things
3838 like generate sequences. This is used to provide a context during global
3839 initialization of some passes. */
3841 init_dummy_function_start (void)
3843 prepare_function_start (NULL);
3846 /* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node)
3847 and initialize static variables for generating RTL for the statements
3851 init_function_start (tree subr)
3853 prepare_function_start (subr);
3855 /* Prevent ever trying to delete the first instruction of a
3856 function. Also tell final how to output a linenum before the
3857 function prologue. Note linenums could be missing, e.g. when
3858 compiling a Java .class file. */
3859 if (! DECL_IS_BUILTIN (subr))
3860 emit_line_note (DECL_SOURCE_LOCATION (subr));
3862 /* Make sure first insn is a note even if we don't want linenums.
3863 This makes sure the first insn will never be deleted.
3864 Also, final expects a note to appear there. */
3865 emit_note (NOTE_INSN_DELETED);
3867 /* Warn if this value is an aggregate type,
3868 regardless of which calling convention we are using for it. */
3869 if (warn_aggregate_return
3870 && AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr))))
3871 warning ("function returns an aggregate");
3874 /* Make sure all values used by the optimization passes have sane
3877 init_function_for_compilation (void)
3881 /* No prologue/epilogue insns yet. */
3882 VARRAY_GROW (prologue, 0);
3883 VARRAY_GROW (epilogue, 0);
3884 VARRAY_GROW (sibcall_epilogue, 0);
3887 /* Expand a call to __main at the beginning of a possible main function. */
3889 #if defined(INIT_SECTION_ASM_OP) && !defined(INVOKE__main)
3890 #undef HAS_INIT_SECTION
3891 #define HAS_INIT_SECTION
3895 expand_main_function (void)
3897 #ifdef FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN
3898 if (FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN)
3900 int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
3904 /* Forcibly align the stack. */
3905 #ifdef STACK_GROWS_DOWNWARD
3906 tmp = expand_simple_binop (Pmode, AND, stack_pointer_rtx, GEN_INT(-align),
3907 stack_pointer_rtx, 1, OPTAB_WIDEN);
3909 tmp = expand_simple_binop (Pmode, PLUS, stack_pointer_rtx,
3910 GEN_INT (align - 1), NULL_RTX, 1, OPTAB_WIDEN);
3911 tmp = expand_simple_binop (Pmode, AND, tmp, GEN_INT (-align),
3912 stack_pointer_rtx, 1, OPTAB_WIDEN);
3914 if (tmp != stack_pointer_rtx)
3915 emit_move_insn (stack_pointer_rtx, tmp);
3917 /* Enlist allocate_dynamic_stack_space to pick up the pieces. */
3918 tmp = force_reg (Pmode, const0_rtx);
3919 allocate_dynamic_stack_space (tmp, NULL_RTX, BIGGEST_ALIGNMENT);
3923 for (tmp = get_last_insn (); tmp; tmp = PREV_INSN (tmp))
3924 if (NOTE_P (tmp) && NOTE_LINE_NUMBER (tmp) == NOTE_INSN_FUNCTION_BEG)
3927 emit_insn_before (seq, tmp);
3933 #ifndef HAS_INIT_SECTION
3934 emit_library_call (init_one_libfunc (NAME__MAIN), LCT_NORMAL, VOIDmode, 0);
3938 /* The PENDING_SIZES represent the sizes of variable-sized types.
3939 Create RTL for the various sizes now (using temporary variables),
3940 so that we can refer to the sizes from the RTL we are generating
3941 for the current function. The PENDING_SIZES are a TREE_LIST. The
3942 TREE_VALUE of each node is a SAVE_EXPR. */
3945 expand_pending_sizes (tree pending_sizes)
3949 /* Evaluate now the sizes of any types declared among the arguments. */
3950 for (tem = pending_sizes; tem; tem = TREE_CHAIN (tem))
3951 expand_expr (TREE_VALUE (tem), const0_rtx, VOIDmode, 0);
3954 /* Start the RTL for a new function, and set variables used for
3956 SUBR is the FUNCTION_DECL node.
3957 PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with
3958 the function's parameters, which must be run at any return statement. */
3961 expand_function_start (tree subr)
3963 /* Make sure volatile mem refs aren't considered
3964 valid operands of arithmetic insns. */
3965 init_recog_no_volatile ();
3967 current_function_profile
3969 && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr));
3971 current_function_limit_stack
3972 = (stack_limit_rtx != NULL_RTX && ! DECL_NO_LIMIT_STACK (subr));
3974 /* Make the label for return statements to jump to. Do not special
3975 case machines with special return instructions -- they will be
3976 handled later during jump, ifcvt, or epilogue creation. */
3977 return_label = gen_label_rtx ();
3979 /* Initialize rtx used to return the value. */
3980 /* Do this before assign_parms so that we copy the struct value address
3981 before any library calls that assign parms might generate. */
3983 /* Decide whether to return the value in memory or in a register. */
3984 if (aggregate_value_p (DECL_RESULT (subr), subr))
3986 /* Returning something that won't go in a register. */
3987 rtx value_address = 0;
3989 #ifdef PCC_STATIC_STRUCT_RETURN
3990 if (current_function_returns_pcc_struct)
3992 int size = int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr)));
3993 value_address = assemble_static_space (size);
3998 rtx sv = targetm.calls.struct_value_rtx (TREE_TYPE (subr), 1);
3999 /* Expect to be passed the address of a place to store the value.
4000 If it is passed as an argument, assign_parms will take care of
4004 value_address = gen_reg_rtx (Pmode);
4005 emit_move_insn (value_address, sv);
4010 rtx x = value_address;
4011 if (!DECL_BY_REFERENCE (DECL_RESULT (subr)))
4013 x = gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr)), x);
4014 set_mem_attributes (x, DECL_RESULT (subr), 1);
4016 SET_DECL_RTL (DECL_RESULT (subr), x);
4019 else if (DECL_MODE (DECL_RESULT (subr)) == VOIDmode)
4020 /* If return mode is void, this decl rtl should not be used. */
4021 SET_DECL_RTL (DECL_RESULT (subr), NULL_RTX);
4024 /* Compute the return values into a pseudo reg, which we will copy
4025 into the true return register after the cleanups are done. */
4027 /* In order to figure out what mode to use for the pseudo, we
4028 figure out what the mode of the eventual return register will
4029 actually be, and use that. */
4031 = hard_function_value (TREE_TYPE (DECL_RESULT (subr)),
4034 /* Structures that are returned in registers are not aggregate_value_p,
4035 so we may see a PARALLEL or a REG. */
4036 if (REG_P (hard_reg))
4037 SET_DECL_RTL (DECL_RESULT (subr), gen_reg_rtx (GET_MODE (hard_reg)));
4040 gcc_assert (GET_CODE (hard_reg) == PARALLEL);
4041 SET_DECL_RTL (DECL_RESULT (subr), gen_group_rtx (hard_reg));
4044 /* Set DECL_REGISTER flag so that expand_function_end will copy the
4045 result to the real return register(s). */
4046 DECL_REGISTER (DECL_RESULT (subr)) = 1;
4049 /* Initialize rtx for parameters and local variables.
4050 In some cases this requires emitting insns. */
4051 assign_parms (subr);
4053 /* If function gets a static chain arg, store it. */
4054 if (cfun->static_chain_decl)
4056 tree parm = cfun->static_chain_decl;
4057 rtx local = gen_reg_rtx (Pmode);
4059 set_decl_incoming_rtl (parm, static_chain_incoming_rtx);
4060 SET_DECL_RTL (parm, local);
4061 mark_reg_pointer (local, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm))));
4063 emit_move_insn (local, static_chain_incoming_rtx);
4066 /* If the function receives a non-local goto, then store the
4067 bits we need to restore the frame pointer. */
4068 if (cfun->nonlocal_goto_save_area)
4073 /* ??? We need to do this save early. Unfortunately here is
4074 before the frame variable gets declared. Help out... */
4075 expand_var (TREE_OPERAND (cfun->nonlocal_goto_save_area, 0));
4077 t_save = build4 (ARRAY_REF, ptr_type_node,
4078 cfun->nonlocal_goto_save_area,
4079 integer_zero_node, NULL_TREE, NULL_TREE);
4080 r_save = expand_expr (t_save, NULL_RTX, VOIDmode, EXPAND_WRITE);
4081 r_save = convert_memory_address (Pmode, r_save);
4083 emit_move_insn (r_save, virtual_stack_vars_rtx);
4084 update_nonlocal_goto_save_area ();
4087 /* The following was moved from init_function_start.
4088 The move is supposed to make sdb output more accurate. */
4089 /* Indicate the beginning of the function body,
4090 as opposed to parm setup. */
4091 emit_note (NOTE_INSN_FUNCTION_BEG);
4093 if (!NOTE_P (get_last_insn ()))
4094 emit_note (NOTE_INSN_DELETED);
4095 parm_birth_insn = get_last_insn ();
4097 if (current_function_profile)
4100 PROFILE_HOOK (current_function_funcdef_no);
4104 /* After the display initializations is where the tail-recursion label
4105 should go, if we end up needing one. Ensure we have a NOTE here
4106 since some things (like trampolines) get placed before this. */
4107 tail_recursion_reentry = emit_note (NOTE_INSN_DELETED);
4109 /* Evaluate now the sizes of any types declared among the arguments. */
4110 expand_pending_sizes (nreverse (get_pending_sizes ()));
4112 /* Make sure there is a line number after the function entry setup code. */
4113 force_next_line_note ();
4116 /* Undo the effects of init_dummy_function_start. */
4118 expand_dummy_function_end (void)
4120 /* End any sequences that failed to be closed due to syntax errors. */
4121 while (in_sequence_p ())
4124 /* Outside function body, can't compute type's actual size
4125 until next function's body starts. */
4127 free_after_parsing (cfun);
4128 free_after_compilation (cfun);
4132 /* Call DOIT for each hard register used as a return value from
4133 the current function. */
4136 diddle_return_value (void (*doit) (rtx, void *), void *arg)
4138 rtx outgoing = current_function_return_rtx;
4143 if (REG_P (outgoing))
4144 (*doit) (outgoing, arg);
4145 else if (GET_CODE (outgoing) == PARALLEL)
4149 for (i = 0; i < XVECLEN (outgoing, 0); i++)
4151 rtx x = XEXP (XVECEXP (outgoing, 0, i), 0);
4153 if (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER)
4160 do_clobber_return_reg (rtx reg, void *arg ATTRIBUTE_UNUSED)
4162 emit_insn (gen_rtx_CLOBBER (VOIDmode, reg));
4166 clobber_return_register (void)
4168 diddle_return_value (do_clobber_return_reg, NULL);
4170 /* In case we do use pseudo to return value, clobber it too. */
4171 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl)))
4173 tree decl_result = DECL_RESULT (current_function_decl);
4174 rtx decl_rtl = DECL_RTL (decl_result);
4175 if (REG_P (decl_rtl) && REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER)
4177 do_clobber_return_reg (decl_rtl, NULL);
4183 do_use_return_reg (rtx reg, void *arg ATTRIBUTE_UNUSED)
4185 emit_insn (gen_rtx_USE (VOIDmode, reg));
4189 use_return_register (void)
4191 diddle_return_value (do_use_return_reg, NULL);
4194 /* Possibly warn about unused parameters. */
4196 do_warn_unused_parameter (tree fn)
4200 for (decl = DECL_ARGUMENTS (fn);
4201 decl; decl = TREE_CHAIN (decl))
4202 if (!TREE_USED (decl) && TREE_CODE (decl) == PARM_DECL
4203 && DECL_NAME (decl) && !DECL_ARTIFICIAL (decl))
4204 warning ("%Junused parameter %qD", decl, decl);
4207 static GTY(()) rtx initial_trampoline;
4209 /* Generate RTL for the end of the current function. */
4212 expand_function_end (void)
4216 /* If arg_pointer_save_area was referenced only from a nested
4217 function, we will not have initialized it yet. Do that now. */
4218 if (arg_pointer_save_area && ! cfun->arg_pointer_save_area_init)
4219 get_arg_pointer_save_area (cfun);
4221 /* If we are doing stack checking and this function makes calls,
4222 do a stack probe at the start of the function to ensure we have enough
4223 space for another stack frame. */
4224 if (flag_stack_check && ! STACK_CHECK_BUILTIN)
4228 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4232 probe_stack_range (STACK_CHECK_PROTECT,
4233 GEN_INT (STACK_CHECK_MAX_FRAME_SIZE));
4236 emit_insn_before (seq, tail_recursion_reentry);
4241 /* Possibly warn about unused parameters.
4242 When frontend does unit-at-a-time, the warning is already
4243 issued at finalization time. */
4244 if (warn_unused_parameter
4245 && !lang_hooks.callgraph.expand_function)
4246 do_warn_unused_parameter (current_function_decl);
4248 /* End any sequences that failed to be closed due to syntax errors. */
4249 while (in_sequence_p ())
4252 clear_pending_stack_adjust ();
4253 do_pending_stack_adjust ();
4255 /* @@@ This is a kludge. We want to ensure that instructions that
4256 may trap are not moved into the epilogue by scheduling, because
4257 we don't always emit unwind information for the epilogue.
4258 However, not all machine descriptions define a blockage insn, so
4259 emit an ASM_INPUT to act as one. */
4260 if (flag_non_call_exceptions)
4261 emit_insn (gen_rtx_ASM_INPUT (VOIDmode, ""));
4263 /* Mark the end of the function body.
4264 If control reaches this insn, the function can drop through
4265 without returning a value. */
4266 emit_note (NOTE_INSN_FUNCTION_END);
4268 /* Must mark the last line number note in the function, so that the test
4269 coverage code can avoid counting the last line twice. This just tells
4270 the code to ignore the immediately following line note, since there
4271 already exists a copy of this note somewhere above. This line number
4272 note is still needed for debugging though, so we can't delete it. */
4273 if (flag_test_coverage)
4274 emit_note (NOTE_INSN_REPEATED_LINE_NUMBER);
4276 /* Output a linenumber for the end of the function.
4277 SDB depends on this. */
4278 force_next_line_note ();
4279 emit_line_note (input_location);
4281 /* Before the return label (if any), clobber the return
4282 registers so that they are not propagated live to the rest of
4283 the function. This can only happen with functions that drop
4284 through; if there had been a return statement, there would
4285 have either been a return rtx, or a jump to the return label.
4287 We delay actual code generation after the current_function_value_rtx
4289 clobber_after = get_last_insn ();
4291 /* Output the label for the actual return from the function,
4292 if one is expected. This happens either because a function epilogue
4293 is used instead of a return instruction, or because a return was done
4294 with a goto in order to run local cleanups, or because of pcc-style
4295 structure returning. */
4297 emit_label (return_label);
4299 /* Let except.c know where it should emit the call to unregister
4300 the function context for sjlj exceptions. */
4301 if (flag_exceptions && USING_SJLJ_EXCEPTIONS)
4302 sjlj_emit_function_exit_after (get_last_insn ());
4304 /* If we had calls to alloca, and this machine needs
4305 an accurate stack pointer to exit the function,
4306 insert some code to save and restore the stack pointer. */
4307 if (! EXIT_IGNORE_STACK
4308 && current_function_calls_alloca)
4312 emit_stack_save (SAVE_FUNCTION, &tem, parm_birth_insn);
4313 emit_stack_restore (SAVE_FUNCTION, tem, NULL_RTX);
4316 /* If scalar return value was computed in a pseudo-reg, or was a named
4317 return value that got dumped to the stack, copy that to the hard
4319 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl)))
4321 tree decl_result = DECL_RESULT (current_function_decl);
4322 rtx decl_rtl = DECL_RTL (decl_result);
4324 if (REG_P (decl_rtl)
4325 ? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER
4326 : DECL_REGISTER (decl_result))
4328 rtx real_decl_rtl = current_function_return_rtx;
4330 /* This should be set in assign_parms. */
4331 gcc_assert (REG_FUNCTION_VALUE_P (real_decl_rtl));
4333 /* If this is a BLKmode structure being returned in registers,
4334 then use the mode computed in expand_return. Note that if
4335 decl_rtl is memory, then its mode may have been changed,
4336 but that current_function_return_rtx has not. */
4337 if (GET_MODE (real_decl_rtl) == BLKmode)
4338 PUT_MODE (real_decl_rtl, GET_MODE (decl_rtl));
4340 /* If a named return value dumped decl_return to memory, then
4341 we may need to re-do the PROMOTE_MODE signed/unsigned
4343 if (GET_MODE (real_decl_rtl) != GET_MODE (decl_rtl))
4345 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (decl_result));
4347 if (targetm.calls.promote_function_return (TREE_TYPE (current_function_decl)))
4348 promote_mode (TREE_TYPE (decl_result), GET_MODE (decl_rtl),
4351 convert_move (real_decl_rtl, decl_rtl, unsignedp);
4353 else if (GET_CODE (real_decl_rtl) == PARALLEL)
4355 /* If expand_function_start has created a PARALLEL for decl_rtl,
4356 move the result to the real return registers. Otherwise, do
4357 a group load from decl_rtl for a named return. */
4358 if (GET_CODE (decl_rtl) == PARALLEL)
4359 emit_group_move (real_decl_rtl, decl_rtl);
4361 emit_group_load (real_decl_rtl, decl_rtl,
4362 TREE_TYPE (decl_result),
4363 int_size_in_bytes (TREE_TYPE (decl_result)));
4366 emit_move_insn (real_decl_rtl, decl_rtl);
4370 /* If returning a structure, arrange to return the address of the value
4371 in a place where debuggers expect to find it.
4373 If returning a structure PCC style,
4374 the caller also depends on this value.
4375 And current_function_returns_pcc_struct is not necessarily set. */
4376 if (current_function_returns_struct
4377 || current_function_returns_pcc_struct)
4379 rtx value_address = DECL_RTL (DECL_RESULT (current_function_decl));
4380 tree type = TREE_TYPE (DECL_RESULT (current_function_decl));
4383 if (DECL_BY_REFERENCE (DECL_RESULT (current_function_decl)))
4384 type = TREE_TYPE (type);
4386 value_address = XEXP (value_address, 0);
4388 #ifdef FUNCTION_OUTGOING_VALUE
4389 outgoing = FUNCTION_OUTGOING_VALUE (build_pointer_type (type),
4390 current_function_decl);
4392 outgoing = FUNCTION_VALUE (build_pointer_type (type),
4393 current_function_decl);
4396 /* Mark this as a function return value so integrate will delete the
4397 assignment and USE below when inlining this function. */
4398 REG_FUNCTION_VALUE_P (outgoing) = 1;
4400 /* The address may be ptr_mode and OUTGOING may be Pmode. */
4401 value_address = convert_memory_address (GET_MODE (outgoing),
4404 emit_move_insn (outgoing, value_address);
4406 /* Show return register used to hold result (in this case the address
4408 current_function_return_rtx = outgoing;
4411 /* If this is an implementation of throw, do what's necessary to
4412 communicate between __builtin_eh_return and the epilogue. */
4413 expand_eh_return ();
4415 /* Emit the actual code to clobber return register. */
4420 clobber_return_register ();
4421 expand_naked_return ();
4425 emit_insn_after (seq, clobber_after);
4428 /* Output the label for the naked return from the function. */
4429 emit_label (naked_return_label);
4431 /* ??? This should no longer be necessary since stupid is no longer with
4432 us, but there are some parts of the compiler (eg reload_combine, and
4433 sh mach_dep_reorg) that still try and compute their own lifetime info
4434 instead of using the general framework. */
4435 use_return_register ();
4439 get_arg_pointer_save_area (struct function *f)
4441 rtx ret = f->x_arg_pointer_save_area;
4445 ret = assign_stack_local_1 (Pmode, GET_MODE_SIZE (Pmode), 0, f);
4446 f->x_arg_pointer_save_area = ret;
4449 if (f == cfun && ! f->arg_pointer_save_area_init)
4453 /* Save the arg pointer at the beginning of the function. The
4454 generated stack slot may not be a valid memory address, so we
4455 have to check it and fix it if necessary. */
4457 emit_move_insn (validize_mem (ret), virtual_incoming_args_rtx);
4461 push_topmost_sequence ();
4462 emit_insn_after (seq, get_insns ());
4463 pop_topmost_sequence ();
4469 /* Extend a vector that records the INSN_UIDs of INSNS
4470 (a list of one or more insns). */
4473 record_insns (rtx insns, varray_type *vecp)
4480 while (tmp != NULL_RTX)
4483 tmp = NEXT_INSN (tmp);
4486 i = VARRAY_SIZE (*vecp);
4487 VARRAY_GROW (*vecp, i + len);
4489 while (tmp != NULL_RTX)
4491 VARRAY_INT (*vecp, i) = INSN_UID (tmp);
4493 tmp = NEXT_INSN (tmp);
4497 /* Set the locator of the insn chain starting at INSN to LOC. */
4499 set_insn_locators (rtx insn, int loc)
4501 while (insn != NULL_RTX)
4504 INSN_LOCATOR (insn) = loc;
4505 insn = NEXT_INSN (insn);
4509 /* Determine how many INSN_UIDs in VEC are part of INSN. Because we can
4510 be running after reorg, SEQUENCE rtl is possible. */
4513 contains (rtx insn, varray_type vec)
4517 if (NONJUMP_INSN_P (insn)
4518 && GET_CODE (PATTERN (insn)) == SEQUENCE)
4521 for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
4522 for (j = VARRAY_SIZE (vec) - 1; j >= 0; --j)
4523 if (INSN_UID (XVECEXP (PATTERN (insn), 0, i)) == VARRAY_INT (vec, j))
4529 for (j = VARRAY_SIZE (vec) - 1; j >= 0; --j)
4530 if (INSN_UID (insn) == VARRAY_INT (vec, j))
4537 prologue_epilogue_contains (rtx insn)
4539 if (contains (insn, prologue))
4541 if (contains (insn, epilogue))
4547 sibcall_epilogue_contains (rtx insn)
4549 if (sibcall_epilogue)
4550 return contains (insn, sibcall_epilogue);
4555 /* Insert gen_return at the end of block BB. This also means updating
4556 block_for_insn appropriately. */
4559 emit_return_into_block (basic_block bb, rtx line_note)
4561 emit_jump_insn_after (gen_return (), BB_END (bb));
4563 emit_note_copy_after (line_note, PREV_INSN (BB_END (bb)));
4565 #endif /* HAVE_return */
4567 #if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX)
4569 /* These functions convert the epilogue into a variant that does not modify the
4570 stack pointer. This is used in cases where a function returns an object
4571 whose size is not known until it is computed. The called function leaves the
4572 object on the stack, leaves the stack depressed, and returns a pointer to
4575 What we need to do is track all modifications and references to the stack
4576 pointer, deleting the modifications and changing the references to point to
4577 the location the stack pointer would have pointed to had the modifications
4580 These functions need to be portable so we need to make as few assumptions
4581 about the epilogue as we can. However, the epilogue basically contains
4582 three things: instructions to reset the stack pointer, instructions to
4583 reload registers, possibly including the frame pointer, and an
4584 instruction to return to the caller.
4586 If we can't be sure of what a relevant epilogue insn is doing, we abort.
4587 We also make no attempt to validate the insns we make since if they are
4588 invalid, we probably can't do anything valid. The intent is that these
4589 routines get "smarter" as more and more machines start to use them and
4590 they try operating on different epilogues.
4592 We use the following structure to track what the part of the epilogue that
4593 we've already processed has done. We keep two copies of the SP equivalence,
4594 one for use during the insn we are processing and one for use in the next
4595 insn. The difference is because one part of a PARALLEL may adjust SP
4596 and the other may use it. */
4600 rtx sp_equiv_reg; /* REG that SP is set from, perhaps SP. */
4601 HOST_WIDE_INT sp_offset; /* Offset from SP_EQUIV_REG of present SP. */
4602 rtx new_sp_equiv_reg; /* REG to be used at end of insn. */
4603 HOST_WIDE_INT new_sp_offset; /* Offset to be used at end of insn. */
4604 rtx equiv_reg_src; /* If nonzero, the value that SP_EQUIV_REG
4605 should be set to once we no longer need
4607 rtx const_equiv[FIRST_PSEUDO_REGISTER]; /* Any known constant equivalences
4611 static void handle_epilogue_set (rtx, struct epi_info *);
4612 static void update_epilogue_consts (rtx, rtx, void *);
4613 static void emit_equiv_load (struct epi_info *);
4615 /* Modify INSN, a list of one or more insns that is part of the epilogue, to
4616 no modifications to the stack pointer. Return the new list of insns. */
4619 keep_stack_depressed (rtx insns)
4622 struct epi_info info;
4625 /* If the epilogue is just a single instruction, it must be OK as is. */
4626 if (NEXT_INSN (insns) == NULL_RTX)
4629 /* Otherwise, start a sequence, initialize the information we have, and
4630 process all the insns we were given. */
4633 info.sp_equiv_reg = stack_pointer_rtx;
4635 info.equiv_reg_src = 0;
4637 for (j = 0; j < FIRST_PSEUDO_REGISTER; j++)
4638 info.const_equiv[j] = 0;
4642 while (insn != NULL_RTX)
4644 next = NEXT_INSN (insn);
4653 /* If this insn references the register that SP is equivalent to and
4654 we have a pending load to that register, we must force out the load
4655 first and then indicate we no longer know what SP's equivalent is. */
4656 if (info.equiv_reg_src != 0
4657 && reg_referenced_p (info.sp_equiv_reg, PATTERN (insn)))
4659 emit_equiv_load (&info);
4660 info.sp_equiv_reg = 0;
4663 info.new_sp_equiv_reg = info.sp_equiv_reg;
4664 info.new_sp_offset = info.sp_offset;
4666 /* If this is a (RETURN) and the return address is on the stack,
4667 update the address and change to an indirect jump. */
4668 if (GET_CODE (PATTERN (insn)) == RETURN
4669 || (GET_CODE (PATTERN (insn)) == PARALLEL
4670 && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == RETURN))
4672 rtx retaddr = INCOMING_RETURN_ADDR_RTX;
4674 HOST_WIDE_INT offset = 0;
4675 rtx jump_insn, jump_set;
4677 /* If the return address is in a register, we can emit the insn
4678 unchanged. Otherwise, it must be a MEM and we see what the
4679 base register and offset are. In any case, we have to emit any
4680 pending load to the equivalent reg of SP, if any. */
4681 if (REG_P (retaddr))
4683 emit_equiv_load (&info);
4691 gcc_assert (MEM_P (retaddr));
4693 ret_ptr = XEXP (retaddr, 0);
4695 if (REG_P (ret_ptr))
4697 base = gen_rtx_REG (Pmode, REGNO (ret_ptr));
4702 gcc_assert (GET_CODE (ret_ptr) == PLUS
4703 && REG_P (XEXP (ret_ptr, 0))
4704 && GET_CODE (XEXP (ret_ptr, 1)) == CONST_INT);
4705 base = gen_rtx_REG (Pmode, REGNO (XEXP (ret_ptr, 0)));
4706 offset = INTVAL (XEXP (ret_ptr, 1));
4710 /* If the base of the location containing the return pointer
4711 is SP, we must update it with the replacement address. Otherwise,
4712 just build the necessary MEM. */
4713 retaddr = plus_constant (base, offset);
4714 if (base == stack_pointer_rtx)
4715 retaddr = simplify_replace_rtx (retaddr, stack_pointer_rtx,
4716 plus_constant (info.sp_equiv_reg,
4719 retaddr = gen_rtx_MEM (Pmode, retaddr);
4721 /* If there is a pending load to the equivalent register for SP
4722 and we reference that register, we must load our address into
4723 a scratch register and then do that load. */
4724 if (info.equiv_reg_src
4725 && reg_overlap_mentioned_p (info.equiv_reg_src, retaddr))
4730 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
4731 if (HARD_REGNO_MODE_OK (regno, Pmode)
4732 && !fixed_regs[regno]
4733 && TEST_HARD_REG_BIT (regs_invalidated_by_call, regno)
4734 && !REGNO_REG_SET_P (EXIT_BLOCK_PTR->global_live_at_start,
4736 && !refers_to_regno_p (regno,
4737 regno + hard_regno_nregs[regno]
4739 info.equiv_reg_src, NULL)
4740 && info.const_equiv[regno] == 0)
4743 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
4745 reg = gen_rtx_REG (Pmode, regno);
4746 emit_move_insn (reg, retaddr);
4750 emit_equiv_load (&info);
4751 jump_insn = emit_jump_insn (gen_indirect_jump (retaddr));
4753 /* Show the SET in the above insn is a RETURN. */
4754 jump_set = single_set (jump_insn);
4755 gcc_assert (jump_set);
4756 SET_IS_RETURN_P (jump_set) = 1;
4759 /* If SP is not mentioned in the pattern and its equivalent register, if
4760 any, is not modified, just emit it. Otherwise, if neither is set,
4761 replace the reference to SP and emit the insn. If none of those are
4762 true, handle each SET individually. */
4763 else if (!reg_mentioned_p (stack_pointer_rtx, PATTERN (insn))
4764 && (info.sp_equiv_reg == stack_pointer_rtx
4765 || !reg_set_p (info.sp_equiv_reg, insn)))
4767 else if (! reg_set_p (stack_pointer_rtx, insn)
4768 && (info.sp_equiv_reg == stack_pointer_rtx
4769 || !reg_set_p (info.sp_equiv_reg, insn)))
4773 changed = validate_replace_rtx (stack_pointer_rtx,
4774 plus_constant (info.sp_equiv_reg,
4777 gcc_assert (changed);
4781 else if (GET_CODE (PATTERN (insn)) == SET)
4782 handle_epilogue_set (PATTERN (insn), &info);
4783 else if (GET_CODE (PATTERN (insn)) == PARALLEL)
4785 for (j = 0; j < XVECLEN (PATTERN (insn), 0); j++)
4786 if (GET_CODE (XVECEXP (PATTERN (insn), 0, j)) == SET)
4787 handle_epilogue_set (XVECEXP (PATTERN (insn), 0, j), &info);
4792 info.sp_equiv_reg = info.new_sp_equiv_reg;
4793 info.sp_offset = info.new_sp_offset;
4795 /* Now update any constants this insn sets. */
4796 note_stores (PATTERN (insn), update_epilogue_consts, &info);
4800 insns = get_insns ();
4805 /* SET is a SET from an insn in the epilogue. P is a pointer to the epi_info
4806 structure that contains information about what we've seen so far. We
4807 process this SET by either updating that data or by emitting one or
4811 handle_epilogue_set (rtx set, struct epi_info *p)
4813 /* First handle the case where we are setting SP. Record what it is being
4814 set from. If unknown, abort. */
4815 if (reg_set_p (stack_pointer_rtx, set))
4817 gcc_assert (SET_DEST (set) == stack_pointer_rtx);
4819 if (GET_CODE (SET_SRC (set)) == PLUS)
4821 p->new_sp_equiv_reg = XEXP (SET_SRC (set), 0);
4822 if (GET_CODE (XEXP (SET_SRC (set), 1)) == CONST_INT)
4823 p->new_sp_offset = INTVAL (XEXP (SET_SRC (set), 1));
4826 gcc_assert (REG_P (XEXP (SET_SRC (set), 1))
4827 && (REGNO (XEXP (SET_SRC (set), 1))
4828 < FIRST_PSEUDO_REGISTER)
4829 && p->const_equiv[REGNO (XEXP (SET_SRC (set), 1))]);
4831 = INTVAL (p->const_equiv[REGNO (XEXP (SET_SRC (set), 1))]);
4835 p->new_sp_equiv_reg = SET_SRC (set), p->new_sp_offset = 0;
4837 /* If we are adjusting SP, we adjust from the old data. */
4838 if (p->new_sp_equiv_reg == stack_pointer_rtx)
4840 p->new_sp_equiv_reg = p->sp_equiv_reg;
4841 p->new_sp_offset += p->sp_offset;
4844 gcc_assert (p->new_sp_equiv_reg && REG_P (p->new_sp_equiv_reg));
4849 /* Next handle the case where we are setting SP's equivalent register.
4850 If we already have a value to set it to, abort. We could update, but
4851 there seems little point in handling that case. Note that we have
4852 to allow for the case where we are setting the register set in
4853 the previous part of a PARALLEL inside a single insn. But use the
4854 old offset for any updates within this insn. We must allow for the case
4855 where the register is being set in a different (usually wider) mode than
4857 else if (p->new_sp_equiv_reg != 0 && reg_set_p (p->new_sp_equiv_reg, set))
4859 gcc_assert (!p->equiv_reg_src
4860 && REG_P (p->new_sp_equiv_reg)
4861 && REG_P (SET_DEST (set))
4862 && (GET_MODE_BITSIZE (GET_MODE (SET_DEST (set)))
4864 && REGNO (p->new_sp_equiv_reg) == REGNO (SET_DEST (set)));
4866 = simplify_replace_rtx (SET_SRC (set), stack_pointer_rtx,
4867 plus_constant (p->sp_equiv_reg,
4871 /* Otherwise, replace any references to SP in the insn to its new value
4872 and emit the insn. */
4875 SET_SRC (set) = simplify_replace_rtx (SET_SRC (set), stack_pointer_rtx,
4876 plus_constant (p->sp_equiv_reg,
4878 SET_DEST (set) = simplify_replace_rtx (SET_DEST (set), stack_pointer_rtx,
4879 plus_constant (p->sp_equiv_reg,
4885 /* Update the tracking information for registers set to constants. */
4888 update_epilogue_consts (rtx dest, rtx x, void *data)
4890 struct epi_info *p = (struct epi_info *) data;
4893 if (!REG_P (dest) || REGNO (dest) >= FIRST_PSEUDO_REGISTER)
4896 /* If we are either clobbering a register or doing a partial set,
4897 show we don't know the value. */
4898 else if (GET_CODE (x) == CLOBBER || ! rtx_equal_p (dest, SET_DEST (x)))
4899 p->const_equiv[REGNO (dest)] = 0;
4901 /* If we are setting it to a constant, record that constant. */
4902 else if (GET_CODE (SET_SRC (x)) == CONST_INT)
4903 p->const_equiv[REGNO (dest)] = SET_SRC (x);
4905 /* If this is a binary operation between a register we have been tracking
4906 and a constant, see if we can compute a new constant value. */
4907 else if (ARITHMETIC_P (SET_SRC (x))
4908 && REG_P (XEXP (SET_SRC (x), 0))
4909 && REGNO (XEXP (SET_SRC (x), 0)) < FIRST_PSEUDO_REGISTER
4910 && p->const_equiv[REGNO (XEXP (SET_SRC (x), 0))] != 0
4911 && GET_CODE (XEXP (SET_SRC (x), 1)) == CONST_INT
4912 && 0 != (new = simplify_binary_operation
4913 (GET_CODE (SET_SRC (x)), GET_MODE (dest),
4914 p->const_equiv[REGNO (XEXP (SET_SRC (x), 0))],
4915 XEXP (SET_SRC (x), 1)))
4916 && GET_CODE (new) == CONST_INT)
4917 p->const_equiv[REGNO (dest)] = new;
4919 /* Otherwise, we can't do anything with this value. */
4921 p->const_equiv[REGNO (dest)] = 0;
4924 /* Emit an insn to do the load shown in p->equiv_reg_src, if needed. */
4927 emit_equiv_load (struct epi_info *p)
4929 if (p->equiv_reg_src != 0)
4931 rtx dest = p->sp_equiv_reg;
4933 if (GET_MODE (p->equiv_reg_src) != GET_MODE (dest))
4934 dest = gen_rtx_REG (GET_MODE (p->equiv_reg_src),
4935 REGNO (p->sp_equiv_reg));
4937 emit_move_insn (dest, p->equiv_reg_src);
4938 p->equiv_reg_src = 0;
4943 /* Generate the prologue and epilogue RTL if the machine supports it. Thread
4944 this into place with notes indicating where the prologue ends and where
4945 the epilogue begins. Update the basic block information when possible. */
4948 thread_prologue_and_epilogue_insns (rtx f ATTRIBUTE_UNUSED)
4952 #if defined (HAVE_sibcall_epilogue) || defined (HAVE_epilogue) || defined (HAVE_return) || defined (HAVE_prologue)
4955 #ifdef HAVE_prologue
4956 rtx prologue_end = NULL_RTX;
4958 #if defined (HAVE_epilogue) || defined(HAVE_return)
4959 rtx epilogue_end = NULL_RTX;
4963 #ifdef HAVE_prologue
4967 seq = gen_prologue ();
4970 /* Retain a map of the prologue insns. */
4971 record_insns (seq, &prologue);
4972 prologue_end = emit_note (NOTE_INSN_PROLOGUE_END);
4976 set_insn_locators (seq, prologue_locator);
4978 /* Can't deal with multiple successors of the entry block
4979 at the moment. Function should always have at least one
4981 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR->succs) == 1);
4983 insert_insn_on_edge (seq, EDGE_SUCC (ENTRY_BLOCK_PTR, 0));
4988 /* If the exit block has no non-fake predecessors, we don't need
4990 FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
4991 if ((e->flags & EDGE_FAKE) == 0)
4997 if (optimize && HAVE_return)
4999 /* If we're allowed to generate a simple return instruction,
5000 then by definition we don't need a full epilogue. Examine
5001 the block that falls through to EXIT. If it does not
5002 contain any code, examine its predecessors and try to
5003 emit (conditional) return instructions. */
5008 FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
5009 if (e->flags & EDGE_FALLTHRU)
5015 /* Verify that there are no active instructions in the last block. */
5016 label = BB_END (last);
5017 while (label && !LABEL_P (label))
5019 if (active_insn_p (label))
5021 label = PREV_INSN (label);
5024 if (BB_HEAD (last) == label && LABEL_P (label))
5027 rtx epilogue_line_note = NULL_RTX;
5029 /* Locate the line number associated with the closing brace,
5030 if we can find one. */
5031 for (seq = get_last_insn ();
5032 seq && ! active_insn_p (seq);
5033 seq = PREV_INSN (seq))
5034 if (NOTE_P (seq) && NOTE_LINE_NUMBER (seq) > 0)
5036 epilogue_line_note = seq;
5040 for (ei2 = ei_start (last->preds); (e = ei_safe_edge (ei2)); )
5042 basic_block bb = e->src;
5045 if (bb == ENTRY_BLOCK_PTR)
5052 if (!JUMP_P (jump) || JUMP_LABEL (jump) != label)
5058 /* If we have an unconditional jump, we can replace that
5059 with a simple return instruction. */
5060 if (simplejump_p (jump))
5062 emit_return_into_block (bb, epilogue_line_note);
5066 /* If we have a conditional jump, we can try to replace
5067 that with a conditional return instruction. */
5068 else if (condjump_p (jump))
5070 if (! redirect_jump (jump, 0, 0))
5076 /* If this block has only one successor, it both jumps
5077 and falls through to the fallthru block, so we can't
5079 if (EDGE_COUNT (bb->succs) == 1)
5091 /* Fix up the CFG for the successful change we just made. */
5092 redirect_edge_succ (e, EXIT_BLOCK_PTR);
5095 /* Emit a return insn for the exit fallthru block. Whether
5096 this is still reachable will be determined later. */
5098 emit_barrier_after (BB_END (last));
5099 emit_return_into_block (last, epilogue_line_note);
5100 epilogue_end = BB_END (last);
5101 EDGE_SUCC (last, 0)->flags &= ~EDGE_FALLTHRU;
5106 /* Find the edge that falls through to EXIT. Other edges may exist
5107 due to RETURN instructions, but those don't need epilogues.
5108 There really shouldn't be a mixture -- either all should have
5109 been converted or none, however... */
5111 FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
5112 if (e->flags & EDGE_FALLTHRU)
5117 #ifdef HAVE_epilogue
5121 epilogue_end = emit_note (NOTE_INSN_EPILOGUE_BEG);
5123 seq = gen_epilogue ();
5125 #ifdef INCOMING_RETURN_ADDR_RTX
5126 /* If this function returns with the stack depressed and we can support
5127 it, massage the epilogue to actually do that. */
5128 if (TREE_CODE (TREE_TYPE (current_function_decl)) == FUNCTION_TYPE
5129 && TYPE_RETURNS_STACK_DEPRESSED (TREE_TYPE (current_function_decl)))
5130 seq = keep_stack_depressed (seq);
5133 emit_jump_insn (seq);
5135 /* Retain a map of the epilogue insns. */
5136 record_insns (seq, &epilogue);
5137 set_insn_locators (seq, epilogue_locator);
5142 insert_insn_on_edge (seq, e);
5150 if (! next_active_insn (BB_END (e->src)))
5152 /* We have a fall-through edge to the exit block, the source is not
5153 at the end of the function, and there will be an assembler epilogue
5154 at the end of the function.
5155 We can't use force_nonfallthru here, because that would try to
5156 use return. Inserting a jump 'by hand' is extremely messy, so
5157 we take advantage of cfg_layout_finalize using
5158 fixup_fallthru_exit_predecessor. */
5159 cfg_layout_initialize (0);
5160 FOR_EACH_BB (cur_bb)
5161 if (cur_bb->index >= 0 && cur_bb->next_bb->index >= 0)
5162 cur_bb->rbi->next = cur_bb->next_bb;
5163 cfg_layout_finalize ();
5168 commit_edge_insertions ();
5170 #ifdef HAVE_sibcall_epilogue
5171 /* Emit sibling epilogues before any sibling call sites. */
5172 for (ei = ei_start (EXIT_BLOCK_PTR->preds); (e = ei_safe_edge (ei)); )
5174 basic_block bb = e->src;
5175 rtx insn = BB_END (bb);
5180 || ! SIBLING_CALL_P (insn))
5187 emit_insn (gen_sibcall_epilogue ());
5191 /* Retain a map of the epilogue insns. Used in life analysis to
5192 avoid getting rid of sibcall epilogue insns. Do this before we
5193 actually emit the sequence. */
5194 record_insns (seq, &sibcall_epilogue);
5195 set_insn_locators (seq, epilogue_locator);
5197 i = PREV_INSN (insn);
5198 newinsn = emit_insn_before (seq, insn);
5203 #ifdef HAVE_prologue
5204 /* This is probably all useless now that we use locators. */
5209 /* GDB handles `break f' by setting a breakpoint on the first
5210 line note after the prologue. Which means (1) that if
5211 there are line number notes before where we inserted the
5212 prologue we should move them, and (2) we should generate a
5213 note before the end of the first basic block, if there isn't
5216 ??? This behavior is completely broken when dealing with
5217 multiple entry functions. We simply place the note always
5218 into first basic block and let alternate entry points
5222 for (insn = prologue_end; insn; insn = prev)
5224 prev = PREV_INSN (insn);
5225 if (NOTE_P (insn) && NOTE_LINE_NUMBER (insn) > 0)
5227 /* Note that we cannot reorder the first insn in the
5228 chain, since rest_of_compilation relies on that
5229 remaining constant. */
5232 reorder_insns (insn, insn, prologue_end);
5236 /* Find the last line number note in the first block. */
5237 for (insn = BB_END (ENTRY_BLOCK_PTR->next_bb);
5238 insn != prologue_end && insn;
5239 insn = PREV_INSN (insn))
5240 if (NOTE_P (insn) && NOTE_LINE_NUMBER (insn) > 0)
5243 /* If we didn't find one, make a copy of the first line number
5247 for (insn = next_active_insn (prologue_end);
5249 insn = PREV_INSN (insn))
5250 if (NOTE_P (insn) && NOTE_LINE_NUMBER (insn) > 0)
5252 emit_note_copy_after (insn, prologue_end);
5258 #ifdef HAVE_epilogue
5263 /* Similarly, move any line notes that appear after the epilogue.
5264 There is no need, however, to be quite so anal about the existence
5265 of such a note. Also move the NOTE_INSN_FUNCTION_END and (possibly)
5266 NOTE_INSN_FUNCTION_BEG notes, as those can be relevant for debug
5268 for (insn = epilogue_end; insn; insn = next)
5270 next = NEXT_INSN (insn);
5272 && (NOTE_LINE_NUMBER (insn) > 0
5273 || NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG
5274 || NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_END))
5275 reorder_insns (insn, insn, PREV_INSN (epilogue_end));
5281 /* Reposition the prologue-end and epilogue-begin notes after instruction
5282 scheduling and delayed branch scheduling. */
5285 reposition_prologue_and_epilogue_notes (rtx f ATTRIBUTE_UNUSED)
5287 #if defined (HAVE_prologue) || defined (HAVE_epilogue)
5288 rtx insn, last, note;
5291 if ((len = VARRAY_SIZE (prologue)) > 0)
5295 /* Scan from the beginning until we reach the last prologue insn.
5296 We apparently can't depend on basic_block_{head,end} after
5298 for (insn = f; insn; insn = NEXT_INSN (insn))
5302 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_PROLOGUE_END)
5305 else if (contains (insn, prologue))
5315 /* Find the prologue-end note if we haven't already, and
5316 move it to just after the last prologue insn. */
5319 for (note = last; (note = NEXT_INSN (note));)
5321 && NOTE_LINE_NUMBER (note) == NOTE_INSN_PROLOGUE_END)
5325 /* Avoid placing note between CODE_LABEL and BASIC_BLOCK note. */
5327 last = NEXT_INSN (last);
5328 reorder_insns (note, note, last);
5332 if ((len = VARRAY_SIZE (epilogue)) > 0)
5336 /* Scan from the end until we reach the first epilogue insn.
5337 We apparently can't depend on basic_block_{head,end} after
5339 for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
5343 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EPILOGUE_BEG)
5346 else if (contains (insn, epilogue))
5356 /* Find the epilogue-begin note if we haven't already, and
5357 move it to just before the first epilogue insn. */
5360 for (note = insn; (note = PREV_INSN (note));)
5362 && NOTE_LINE_NUMBER (note) == NOTE_INSN_EPILOGUE_BEG)
5366 if (PREV_INSN (last) != note)
5367 reorder_insns (note, note, PREV_INSN (last));
5370 #endif /* HAVE_prologue or HAVE_epilogue */
5373 /* Called once, at initialization, to initialize function.c. */
5376 init_function_once (void)
5378 VARRAY_INT_INIT (prologue, 0, "prologue");
5379 VARRAY_INT_INIT (epilogue, 0, "epilogue");
5380 VARRAY_INT_INIT (sibcall_epilogue, 0, "sibcall_epilogue");
5383 /* Resets insn_block_boundaries array. */
5386 reset_block_changes (void)
5388 VARRAY_TREE_INIT (cfun->ib_boundaries_block, 100, "ib_boundaries_block");
5389 VARRAY_PUSH_TREE (cfun->ib_boundaries_block, NULL_TREE);
5392 /* Record the boundary for BLOCK. */
5394 record_block_change (tree block)
5402 last_block = VARRAY_TOP_TREE (cfun->ib_boundaries_block);
5403 VARRAY_POP (cfun->ib_boundaries_block);
5405 for (i = VARRAY_ACTIVE_SIZE (cfun->ib_boundaries_block); i < n; i++)
5406 VARRAY_PUSH_TREE (cfun->ib_boundaries_block, last_block);
5408 VARRAY_PUSH_TREE (cfun->ib_boundaries_block, block);
5411 /* Finishes record of boundaries. */
5412 void finalize_block_changes (void)
5414 record_block_change (DECL_INITIAL (current_function_decl));
5417 /* For INSN return the BLOCK it belongs to. */
5419 check_block_change (rtx insn, tree *block)
5421 unsigned uid = INSN_UID (insn);
5423 if (uid >= VARRAY_ACTIVE_SIZE (cfun->ib_boundaries_block))
5426 *block = VARRAY_TREE (cfun->ib_boundaries_block, uid);
5429 /* Releases the ib_boundaries_block records. */
5431 free_block_changes (void)
5433 cfun->ib_boundaries_block = NULL;
5436 /* Returns the name of the current function. */
5438 current_function_name (void)
5440 return lang_hooks.decl_printable_name (cfun->decl, 2);
5443 #include "gt-function.h"