1 /* A pass for lowering trees to RTL.
2 Copyright (C) 2004, 2005 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING. If not, write to
18 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
19 Boston, MA 02110-1301, USA. */
23 #include "coretypes.h"
28 #include "basic-block.h"
31 #include "langhooks.h"
32 #include "tree-flow.h"
34 #include "tree-dump.h"
35 #include "tree-pass.h"
38 #include "diagnostic.h"
43 /* Verify that there is exactly single jump instruction since last and attach
44 REG_BR_PROB note specifying probability.
45 ??? We really ought to pass the probability down to RTL expanders and let it
46 re-distribute it when the conditional expands into multiple conditionals.
47 This is however difficult to do. */
49 add_reg_br_prob_note (rtx last, int probability)
51 if (profile_status == PROFILE_ABSENT)
53 for (last = NEXT_INSN (last); last && NEXT_INSN (last); last = NEXT_INSN (last))
56 /* It is common to emit condjump-around-jump sequence when we don't know
57 how to reverse the conditional. Special case this. */
58 if (!any_condjump_p (last)
59 || !JUMP_P (NEXT_INSN (last))
60 || !simplejump_p (NEXT_INSN (last))
61 || !NEXT_INSN (NEXT_INSN (last))
62 || !BARRIER_P (NEXT_INSN (NEXT_INSN (last)))
63 || !NEXT_INSN (NEXT_INSN (NEXT_INSN (last)))
64 || !LABEL_P (NEXT_INSN (NEXT_INSN (NEXT_INSN (last))))
65 || NEXT_INSN (NEXT_INSN (NEXT_INSN (NEXT_INSN (last)))))
67 gcc_assert (!find_reg_note (last, REG_BR_PROB, 0));
69 = gen_rtx_EXPR_LIST (REG_BR_PROB,
70 GEN_INT (REG_BR_PROB_BASE - probability),
74 if (!last || !JUMP_P (last) || !any_condjump_p (last))
76 gcc_assert (!find_reg_note (last, REG_BR_PROB, 0));
78 = gen_rtx_EXPR_LIST (REG_BR_PROB,
79 GEN_INT (probability), REG_NOTES (last));
83 fprintf (dump_file, "Failed to add probability note\n");
87 #ifndef LOCAL_ALIGNMENT
88 #define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT
91 #ifndef STACK_ALIGNMENT_NEEDED
92 #define STACK_ALIGNMENT_NEEDED 1
96 /* This structure holds data relevant to one variable that will be
97 placed in a stack slot. */
103 /* The offset of the variable. During partitioning, this is the
104 offset relative to the partition. After partitioning, this
105 is relative to the stack frame. */
106 HOST_WIDE_INT offset;
108 /* Initially, the size of the variable. Later, the size of the partition,
109 if this variable becomes it's partition's representative. */
112 /* The *byte* alignment required for this variable. Or as, with the
113 size, the alignment for this partition. */
116 /* The partition representative. */
117 size_t representative;
119 /* The next stack variable in the partition, or EOC. */
123 #define EOC ((size_t)-1)
125 /* We have an array of such objects while deciding allocation. */
126 static struct stack_var *stack_vars;
127 static size_t stack_vars_alloc;
128 static size_t stack_vars_num;
130 /* An array of indicies such that stack_vars[stack_vars_sorted[i]].size
131 is non-decreasing. */
132 static size_t *stack_vars_sorted;
134 /* We have an interference graph between such objects. This graph
135 is lower triangular. */
136 static bool *stack_vars_conflict;
137 static size_t stack_vars_conflict_alloc;
139 /* The phase of the stack frame. This is the known misalignment of
140 virtual_stack_vars_rtx from PREFERRED_STACK_BOUNDARY. That is,
141 (frame_offset+frame_phase) % PREFERRED_STACK_BOUNDARY == 0. */
142 static int frame_phase;
144 /* Used during expand_used_vars to remember if we saw any decls for
145 which we'd like to enable stack smashing protection. */
146 static bool has_protected_decls;
148 /* Used during expand_used_vars. Remember if we say a character buffer
149 smaller than our cutoff threshold. Used for -Wstack-protector. */
150 static bool has_short_buffer;
152 /* Discover the byte alignment to use for DECL. Ignore alignment
153 we can't do with expected alignment of the stack boundary. */
156 get_decl_align_unit (tree decl)
160 align = DECL_ALIGN (decl);
161 align = LOCAL_ALIGNMENT (TREE_TYPE (decl), align);
162 if (align > PREFERRED_STACK_BOUNDARY)
163 align = PREFERRED_STACK_BOUNDARY;
164 if (cfun->stack_alignment_needed < align)
165 cfun->stack_alignment_needed = align;
167 return align / BITS_PER_UNIT;
170 /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
171 Return the frame offset. */
174 alloc_stack_frame_space (HOST_WIDE_INT size, HOST_WIDE_INT align)
176 HOST_WIDE_INT offset, new_frame_offset;
178 new_frame_offset = frame_offset;
179 if (FRAME_GROWS_DOWNWARD)
181 new_frame_offset -= size + frame_phase;
182 new_frame_offset &= -align;
183 new_frame_offset += frame_phase;
184 offset = new_frame_offset;
188 new_frame_offset -= frame_phase;
189 new_frame_offset += align - 1;
190 new_frame_offset &= -align;
191 new_frame_offset += frame_phase;
192 offset = new_frame_offset;
193 new_frame_offset += size;
195 frame_offset = new_frame_offset;
197 if (frame_offset_overflow (frame_offset, cfun->decl))
198 frame_offset = offset = 0;
203 /* Accumulate DECL into STACK_VARS. */
206 add_stack_var (tree decl)
208 if (stack_vars_num >= stack_vars_alloc)
210 if (stack_vars_alloc)
211 stack_vars_alloc = stack_vars_alloc * 3 / 2;
213 stack_vars_alloc = 32;
215 = XRESIZEVEC (struct stack_var, stack_vars, stack_vars_alloc);
217 stack_vars[stack_vars_num].decl = decl;
218 stack_vars[stack_vars_num].offset = 0;
219 stack_vars[stack_vars_num].size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
220 stack_vars[stack_vars_num].alignb = get_decl_align_unit (decl);
222 /* All variables are initially in their own partition. */
223 stack_vars[stack_vars_num].representative = stack_vars_num;
224 stack_vars[stack_vars_num].next = EOC;
226 /* Ensure that this decl doesn't get put onto the list twice. */
227 SET_DECL_RTL (decl, pc_rtx);
232 /* Compute the linear index of a lower-triangular coordinate (I, J). */
235 triangular_index (size_t i, size_t j)
242 return (i * (i + 1)) / 2 + j;
245 /* Ensure that STACK_VARS_CONFLICT is large enough for N objects. */
248 resize_stack_vars_conflict (size_t n)
250 size_t size = triangular_index (n-1, n-1) + 1;
252 if (size <= stack_vars_conflict_alloc)
255 stack_vars_conflict = XRESIZEVEC (bool, stack_vars_conflict, size);
256 memset (stack_vars_conflict + stack_vars_conflict_alloc, 0,
257 (size - stack_vars_conflict_alloc) * sizeof (bool));
258 stack_vars_conflict_alloc = size;
261 /* Make the decls associated with luid's X and Y conflict. */
264 add_stack_var_conflict (size_t x, size_t y)
266 size_t index = triangular_index (x, y);
267 gcc_assert (index < stack_vars_conflict_alloc);
268 stack_vars_conflict[index] = true;
271 /* Check whether the decls associated with luid's X and Y conflict. */
274 stack_var_conflict_p (size_t x, size_t y)
276 size_t index = triangular_index (x, y);
277 gcc_assert (index < stack_vars_conflict_alloc);
278 return stack_vars_conflict[index];
281 /* Returns true if TYPE is or contains a union type. */
284 aggregate_contains_union_type (tree type)
288 if (TREE_CODE (type) == UNION_TYPE
289 || TREE_CODE (type) == QUAL_UNION_TYPE)
291 if (TREE_CODE (type) == ARRAY_TYPE)
292 return aggregate_contains_union_type (TREE_TYPE (type));
293 if (TREE_CODE (type) != RECORD_TYPE)
296 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
297 if (TREE_CODE (field) == FIELD_DECL)
298 if (aggregate_contains_union_type (TREE_TYPE (field)))
304 /* A subroutine of expand_used_vars. If two variables X and Y have alias
305 sets that do not conflict, then do add a conflict for these variables
306 in the interference graph. We also need to make sure to add conflicts
307 for union containing structures. Else RTL alias analysis comes along
308 and due to type based aliasing rules decides that for two overlapping
309 union temporaries { short s; int i; } accesses to the same mem through
310 different types may not alias and happily reorders stores across
311 life-time boundaries of the temporaries (See PR25654).
312 We also have to mind MEM_IN_STRUCT_P and MEM_SCALAR_P. */
315 add_alias_set_conflicts (void)
317 size_t i, j, n = stack_vars_num;
319 for (i = 0; i < n; ++i)
321 tree type_i = TREE_TYPE (stack_vars[i].decl);
322 bool aggr_i = AGGREGATE_TYPE_P (type_i);
325 contains_union = aggregate_contains_union_type (type_i);
326 for (j = 0; j < i; ++j)
328 tree type_j = TREE_TYPE (stack_vars[j].decl);
329 bool aggr_j = AGGREGATE_TYPE_P (type_j);
331 /* Either the objects conflict by means of type based
332 aliasing rules, or we need to add a conflict. */
333 || !objects_must_conflict_p (type_i, type_j)
334 /* In case the types do not conflict ensure that access
335 to elements will conflict. In case of unions we have
336 to be careful as type based aliasing rules may say
337 access to the same memory does not conflict. So play
338 safe and add a conflict in this case. */
340 add_stack_var_conflict (i, j);
345 /* A subroutine of partition_stack_vars. A comparison function for qsort,
346 sorting an array of indicies by the size of the object. */
349 stack_var_size_cmp (const void *a, const void *b)
351 HOST_WIDE_INT sa = stack_vars[*(const size_t *)a].size;
352 HOST_WIDE_INT sb = stack_vars[*(const size_t *)b].size;
353 unsigned int uida = DECL_UID (stack_vars[*(const size_t *)a].decl);
354 unsigned int uidb = DECL_UID (stack_vars[*(const size_t *)b].decl);
360 /* For stack variables of the same size use the uid of the decl
361 to make the sort stable. */
369 /* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
370 partitioning algorithm. Partitions A and B are known to be non-conflicting.
371 Merge them into a single partition A.
373 At the same time, add OFFSET to all variables in partition B. At the end
374 of the partitioning process we've have a nice block easy to lay out within
378 union_stack_vars (size_t a, size_t b, HOST_WIDE_INT offset)
382 /* Update each element of partition B with the given offset,
383 and merge them into partition A. */
384 for (last = i = b; i != EOC; last = i, i = stack_vars[i].next)
386 stack_vars[i].offset += offset;
387 stack_vars[i].representative = a;
389 stack_vars[last].next = stack_vars[a].next;
390 stack_vars[a].next = b;
392 /* Update the required alignment of partition A to account for B. */
393 if (stack_vars[a].alignb < stack_vars[b].alignb)
394 stack_vars[a].alignb = stack_vars[b].alignb;
396 /* Update the interference graph and merge the conflicts. */
397 for (last = stack_vars_num, i = 0; i < last; ++i)
398 if (stack_var_conflict_p (b, i))
399 add_stack_var_conflict (a, i);
402 /* A subroutine of expand_used_vars. Binpack the variables into
403 partitions constrained by the interference graph. The overall
404 algorithm used is as follows:
406 Sort the objects by size.
411 Look for the largest non-conflicting object B with size <= S.
421 partition_stack_vars (void)
423 size_t si, sj, n = stack_vars_num;
425 stack_vars_sorted = XNEWVEC (size_t, stack_vars_num);
426 for (si = 0; si < n; ++si)
427 stack_vars_sorted[si] = si;
432 qsort (stack_vars_sorted, n, sizeof (size_t), stack_var_size_cmp);
434 /* Special case: detect when all variables conflict, and thus we can't
435 do anything during the partitioning loop. It isn't uncommon (with
436 C code at least) to declare all variables at the top of the function,
437 and if we're not inlining, then all variables will be in the same scope.
438 Take advantage of very fast libc routines for this scan. */
439 gcc_assert (sizeof(bool) == sizeof(char));
440 if (memchr (stack_vars_conflict, false, stack_vars_conflict_alloc) == NULL)
443 for (si = 0; si < n; ++si)
445 size_t i = stack_vars_sorted[si];
446 HOST_WIDE_INT isize = stack_vars[i].size;
447 HOST_WIDE_INT offset = 0;
449 for (sj = si; sj-- > 0; )
451 size_t j = stack_vars_sorted[sj];
452 HOST_WIDE_INT jsize = stack_vars[j].size;
453 unsigned int jalign = stack_vars[j].alignb;
455 /* Ignore objects that aren't partition representatives. */
456 if (stack_vars[j].representative != j)
459 /* Ignore objects too large for the remaining space. */
463 /* Ignore conflicting objects. */
464 if (stack_var_conflict_p (i, j))
467 /* Refine the remaining space check to include alignment. */
468 if (offset & (jalign - 1))
470 HOST_WIDE_INT toff = offset;
472 toff &= -(HOST_WIDE_INT)jalign;
473 if (isize - (toff - offset) < jsize)
476 isize -= toff - offset;
480 /* UNION the objects, placing J at OFFSET. */
481 union_stack_vars (i, j, offset);
490 /* A debugging aid for expand_used_vars. Dump the generated partitions. */
493 dump_stack_var_partition (void)
495 size_t si, i, j, n = stack_vars_num;
497 for (si = 0; si < n; ++si)
499 i = stack_vars_sorted[si];
501 /* Skip variables that aren't partition representatives, for now. */
502 if (stack_vars[i].representative != i)
505 fprintf (dump_file, "Partition %lu: size " HOST_WIDE_INT_PRINT_DEC
506 " align %u\n", (unsigned long) i, stack_vars[i].size,
507 stack_vars[i].alignb);
509 for (j = i; j != EOC; j = stack_vars[j].next)
511 fputc ('\t', dump_file);
512 print_generic_expr (dump_file, stack_vars[j].decl, dump_flags);
513 fprintf (dump_file, ", offset " HOST_WIDE_INT_PRINT_DEC "\n",
514 stack_vars[i].offset);
519 /* Assign rtl to DECL at frame offset OFFSET. */
522 expand_one_stack_var_at (tree decl, HOST_WIDE_INT offset)
527 /* If this fails, we've overflowed the stack frame. Error nicely? */
528 gcc_assert (offset == trunc_int_for_mode (offset, Pmode));
530 x = plus_constant (virtual_stack_vars_rtx, offset);
531 x = gen_rtx_MEM (DECL_MODE (decl), x);
533 /* Set alignment we actually gave this decl. */
534 offset -= frame_phase;
535 align = offset & -offset;
536 align *= BITS_PER_UNIT;
537 if (align > STACK_BOUNDARY || align == 0)
538 align = STACK_BOUNDARY;
539 DECL_ALIGN (decl) = align;
540 DECL_USER_ALIGN (decl) = 0;
542 set_mem_attributes (x, decl, true);
543 SET_DECL_RTL (decl, x);
546 /* A subroutine of expand_used_vars. Give each partition representative
547 a unique location within the stack frame. Update each partition member
548 with that location. */
551 expand_stack_vars (bool (*pred) (tree))
553 size_t si, i, j, n = stack_vars_num;
555 for (si = 0; si < n; ++si)
557 HOST_WIDE_INT offset;
559 i = stack_vars_sorted[si];
561 /* Skip variables that aren't partition representatives, for now. */
562 if (stack_vars[i].representative != i)
565 /* Skip variables that have already had rtl assigned. See also
566 add_stack_var where we perpetrate this pc_rtx hack. */
567 if (DECL_RTL (stack_vars[i].decl) != pc_rtx)
570 /* Check the predicate to see whether this variable should be
571 allocated in this pass. */
572 if (pred && !pred (stack_vars[i].decl))
575 offset = alloc_stack_frame_space (stack_vars[i].size,
576 stack_vars[i].alignb);
578 /* Create rtl for each variable based on their location within the
580 for (j = i; j != EOC; j = stack_vars[j].next)
581 expand_one_stack_var_at (stack_vars[j].decl,
582 stack_vars[j].offset + offset);
586 /* A subroutine of expand_one_var. Called to immediately assign rtl
587 to a variable to be allocated in the stack frame. */
590 expand_one_stack_var (tree var)
592 HOST_WIDE_INT size, offset, align;
594 size = tree_low_cst (DECL_SIZE_UNIT (var), 1);
595 align = get_decl_align_unit (var);
596 offset = alloc_stack_frame_space (size, align);
598 expand_one_stack_var_at (var, offset);
601 /* A subroutine of expand_one_var. Called to assign rtl
602 to a TREE_STATIC VAR_DECL. */
605 expand_one_static_var (tree var)
607 /* In unit-at-a-time all the static variables are expanded at the end
608 of compilation process. */
609 if (flag_unit_at_a_time)
611 /* If this is an inlined copy of a static local variable,
612 look up the original. */
613 var = DECL_ORIGIN (var);
615 /* If we've already processed this variable because of that, do nothing. */
616 if (TREE_ASM_WRITTEN (var))
619 /* Give the front end a chance to do whatever. In practice, this is
620 resolving duplicate names for IMA in C. */
621 if (lang_hooks.expand_decl (var))
624 /* Otherwise, just emit the variable. */
625 rest_of_decl_compilation (var, 0, 0);
628 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
629 that will reside in a hard register. */
632 expand_one_hard_reg_var (tree var)
634 rest_of_decl_compilation (var, 0, 0);
637 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
638 that will reside in a pseudo register. */
641 expand_one_register_var (tree var)
643 tree type = TREE_TYPE (var);
644 int unsignedp = TYPE_UNSIGNED (type);
645 enum machine_mode reg_mode
646 = promote_mode (type, DECL_MODE (var), &unsignedp, 0);
647 rtx x = gen_reg_rtx (reg_mode);
649 SET_DECL_RTL (var, x);
651 /* Note if the object is a user variable. */
652 if (!DECL_ARTIFICIAL (var))
656 /* Trust user variables which have a pointer type to really
657 be pointers. Do not trust compiler generated temporaries
658 as our type system is totally busted as it relates to
659 pointer arithmetic which translates into lots of compiler
660 generated objects with pointer types, but which are not really
662 if (POINTER_TYPE_P (type))
663 mark_reg_pointer (x, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (var))));
667 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
668 has some associated error, e.g. its type is error-mark. We just need
669 to pick something that won't crash the rest of the compiler. */
672 expand_one_error_var (tree var)
674 enum machine_mode mode = DECL_MODE (var);
678 x = gen_rtx_MEM (BLKmode, const0_rtx);
679 else if (mode == VOIDmode)
682 x = gen_reg_rtx (mode);
684 SET_DECL_RTL (var, x);
687 /* A subroutine of expand_one_var. VAR is a variable that will be
688 allocated to the local stack frame. Return true if we wish to
689 add VAR to STACK_VARS so that it will be coalesced with other
690 variables. Return false to allocate VAR immediately.
692 This function is used to reduce the number of variables considered
693 for coalescing, which reduces the size of the quadratic problem. */
696 defer_stack_allocation (tree var, bool toplevel)
698 /* If stack protection is enabled, *all* stack variables must be deferred,
699 so that we can re-order the strings to the top of the frame. */
700 if (flag_stack_protect)
703 /* Variables in the outermost scope automatically conflict with
704 every other variable. The only reason to want to defer them
705 at all is that, after sorting, we can more efficiently pack
706 small variables in the stack frame. Continue to defer at -O2. */
707 if (toplevel && optimize < 2)
710 /* Without optimization, *most* variables are allocated from the
711 stack, which makes the quadratic problem large exactly when we
712 want compilation to proceed as quickly as possible. On the
713 other hand, we don't want the function's stack frame size to
714 get completely out of hand. So we avoid adding scalars and
715 "small" aggregates to the list at all. */
716 if (optimize == 0 && tree_low_cst (DECL_SIZE_UNIT (var), 1) < 32)
722 /* A subroutine of expand_used_vars. Expand one variable according to
723 its flavor. Variables to be placed on the stack are not actually
724 expanded yet, merely recorded. */
727 expand_one_var (tree var, bool toplevel)
729 if (TREE_CODE (var) != VAR_DECL)
730 lang_hooks.expand_decl (var);
731 else if (DECL_EXTERNAL (var))
733 else if (DECL_HAS_VALUE_EXPR_P (var))
735 else if (TREE_STATIC (var))
736 expand_one_static_var (var);
737 else if (DECL_RTL_SET_P (var))
739 else if (TREE_TYPE (var) == error_mark_node)
740 expand_one_error_var (var);
741 else if (DECL_HARD_REGISTER (var))
742 expand_one_hard_reg_var (var);
743 else if (use_register_for_decl (var))
744 expand_one_register_var (var);
745 else if (defer_stack_allocation (var, toplevel))
748 expand_one_stack_var (var);
751 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
752 expanding variables. Those variables that can be put into registers
753 are allocated pseudos; those that can't are put on the stack.
755 TOPLEVEL is true if this is the outermost BLOCK. */
758 expand_used_vars_for_block (tree block, bool toplevel)
760 size_t i, j, old_sv_num, this_sv_num, new_sv_num;
763 old_sv_num = toplevel ? 0 : stack_vars_num;
765 /* Expand all variables at this level. */
766 for (t = BLOCK_VARS (block); t ; t = TREE_CHAIN (t))
768 expand_one_var (t, toplevel);
770 this_sv_num = stack_vars_num;
772 /* Expand all variables at containing levels. */
773 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
774 expand_used_vars_for_block (t, false);
776 /* Since we do not track exact variable lifetimes (which is not even
777 possible for variables whose address escapes), we mirror the block
778 tree in the interference graph. Here we cause all variables at this
779 level, and all sublevels, to conflict. Do make certain that a
780 variable conflicts with itself. */
781 if (old_sv_num < this_sv_num)
783 new_sv_num = stack_vars_num;
784 resize_stack_vars_conflict (new_sv_num);
786 for (i = old_sv_num; i < new_sv_num; ++i)
787 for (j = i < this_sv_num ? i+1 : this_sv_num; j-- > old_sv_num ;)
788 add_stack_var_conflict (i, j);
792 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
793 and clear TREE_USED on all local variables. */
796 clear_tree_used (tree block)
800 for (t = BLOCK_VARS (block); t ; t = TREE_CHAIN (t))
801 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
804 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
808 /* Examine TYPE and determine a bit mask of the following features. */
810 #define SPCT_HAS_LARGE_CHAR_ARRAY 1
811 #define SPCT_HAS_SMALL_CHAR_ARRAY 2
812 #define SPCT_HAS_ARRAY 4
813 #define SPCT_HAS_AGGREGATE 8
816 stack_protect_classify_type (tree type)
818 unsigned int ret = 0;
821 switch (TREE_CODE (type))
824 t = TYPE_MAIN_VARIANT (TREE_TYPE (type));
825 if (t == char_type_node
826 || t == signed_char_type_node
827 || t == unsigned_char_type_node)
829 unsigned HOST_WIDE_INT max = PARAM_VALUE (PARAM_SSP_BUFFER_SIZE);
830 unsigned HOST_WIDE_INT len;
832 if (!TYPE_SIZE_UNIT (type)
833 || !host_integerp (TYPE_SIZE_UNIT (type), 1))
836 len = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
839 ret = SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_ARRAY;
841 ret = SPCT_HAS_LARGE_CHAR_ARRAY | SPCT_HAS_ARRAY;
844 ret = SPCT_HAS_ARRAY;
848 case QUAL_UNION_TYPE:
850 ret = SPCT_HAS_AGGREGATE;
851 for (t = TYPE_FIELDS (type); t ; t = TREE_CHAIN (t))
852 if (TREE_CODE (t) == FIELD_DECL)
853 ret |= stack_protect_classify_type (TREE_TYPE (t));
863 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
864 part of the local stack frame. Remember if we ever return nonzero for
865 any variable in this function. The return value is the phase number in
866 which the variable should be allocated. */
869 stack_protect_decl_phase (tree decl)
871 unsigned int bits = stack_protect_classify_type (TREE_TYPE (decl));
874 if (bits & SPCT_HAS_SMALL_CHAR_ARRAY)
875 has_short_buffer = true;
877 if (flag_stack_protect == 2)
879 if ((bits & (SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_LARGE_CHAR_ARRAY))
880 && !(bits & SPCT_HAS_AGGREGATE))
882 else if (bits & SPCT_HAS_ARRAY)
886 ret = (bits & SPCT_HAS_LARGE_CHAR_ARRAY) != 0;
889 has_protected_decls = true;
894 /* Two helper routines that check for phase 1 and phase 2. These are used
895 as callbacks for expand_stack_vars. */
898 stack_protect_decl_phase_1 (tree decl)
900 return stack_protect_decl_phase (decl) == 1;
904 stack_protect_decl_phase_2 (tree decl)
906 return stack_protect_decl_phase (decl) == 2;
909 /* Ensure that variables in different stack protection phases conflict
910 so that they are not merged and share the same stack slot. */
913 add_stack_protection_conflicts (void)
915 size_t i, j, n = stack_vars_num;
916 unsigned char *phase;
918 phase = XNEWVEC (unsigned char, n);
919 for (i = 0; i < n; ++i)
920 phase[i] = stack_protect_decl_phase (stack_vars[i].decl);
922 for (i = 0; i < n; ++i)
924 unsigned char ph_i = phase[i];
925 for (j = 0; j < i; ++j)
926 if (ph_i != phase[j])
927 add_stack_var_conflict (i, j);
933 /* Create a decl for the guard at the top of the stack frame. */
936 create_stack_guard (void)
938 tree guard = build_decl (VAR_DECL, NULL, ptr_type_node);
939 TREE_THIS_VOLATILE (guard) = 1;
940 TREE_USED (guard) = 1;
941 expand_one_stack_var (guard);
942 cfun->stack_protect_guard = guard;
945 /* Expand all variables used in the function. */
948 expand_used_vars (void)
950 tree t, outer_block = DECL_INITIAL (current_function_decl);
952 /* Compute the phase of the stack frame for this function. */
954 int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
955 int off = STARTING_FRAME_OFFSET % align;
956 frame_phase = off ? align - off : 0;
959 /* Set TREE_USED on all variables in the unexpanded_var_list. */
960 for (t = cfun->unexpanded_var_list; t; t = TREE_CHAIN (t))
961 TREE_USED (TREE_VALUE (t)) = 1;
963 /* Clear TREE_USED on all variables associated with a block scope. */
964 clear_tree_used (outer_block);
966 /* Initialize local stack smashing state. */
967 has_protected_decls = false;
968 has_short_buffer = false;
970 /* At this point all variables on the unexpanded_var_list with TREE_USED
971 set are not associated with any block scope. Lay them out. */
972 for (t = cfun->unexpanded_var_list; t; t = TREE_CHAIN (t))
974 tree var = TREE_VALUE (t);
975 bool expand_now = false;
977 /* We didn't set a block for static or extern because it's hard
978 to tell the difference between a global variable (re)declared
979 in a local scope, and one that's really declared there to
980 begin with. And it doesn't really matter much, since we're
981 not giving them stack space. Expand them now. */
982 if (TREE_STATIC (var) || DECL_EXTERNAL (var))
985 /* Any variable that could have been hoisted into an SSA_NAME
986 will have been propagated anywhere the optimizers chose,
987 i.e. not confined to their original block. Allocate them
988 as if they were defined in the outermost scope. */
989 else if (is_gimple_reg (var))
992 /* If the variable is not associated with any block, then it
993 was created by the optimizers, and could be live anywhere
995 else if (TREE_USED (var))
998 /* Finally, mark all variables on the list as used. We'll use
999 this in a moment when we expand those associated with scopes. */
1000 TREE_USED (var) = 1;
1003 expand_one_var (var, true);
1005 cfun->unexpanded_var_list = NULL_TREE;
1007 /* At this point, all variables within the block tree with TREE_USED
1008 set are actually used by the optimized function. Lay them out. */
1009 expand_used_vars_for_block (outer_block, true);
1011 if (stack_vars_num > 0)
1013 /* Due to the way alias sets work, no variables with non-conflicting
1014 alias sets may be assigned the same address. Add conflicts to
1016 add_alias_set_conflicts ();
1018 /* If stack protection is enabled, we don't share space between
1019 vulnerable data and non-vulnerable data. */
1020 if (flag_stack_protect)
1021 add_stack_protection_conflicts ();
1023 /* Now that we have collected all stack variables, and have computed a
1024 minimal interference graph, attempt to save some stack space. */
1025 partition_stack_vars ();
1027 dump_stack_var_partition ();
1030 /* There are several conditions under which we should create a
1031 stack guard: protect-all, alloca used, protected decls present. */
1032 if (flag_stack_protect == 2
1033 || (flag_stack_protect
1034 && (current_function_calls_alloca || has_protected_decls)))
1035 create_stack_guard ();
1037 /* Assign rtl to each variable based on these partitions. */
1038 if (stack_vars_num > 0)
1040 /* Reorder decls to be protected by iterating over the variables
1041 array multiple times, and allocating out of each phase in turn. */
1042 /* ??? We could probably integrate this into the qsort we did
1043 earlier, such that we naturally see these variables first,
1044 and thus naturally allocate things in the right order. */
1045 if (has_protected_decls)
1047 /* Phase 1 contains only character arrays. */
1048 expand_stack_vars (stack_protect_decl_phase_1);
1050 /* Phase 2 contains other kinds of arrays. */
1051 if (flag_stack_protect == 2)
1052 expand_stack_vars (stack_protect_decl_phase_2);
1055 expand_stack_vars (NULL);
1057 /* Free up stack variable graph data. */
1058 XDELETEVEC (stack_vars);
1059 XDELETEVEC (stack_vars_sorted);
1060 XDELETEVEC (stack_vars_conflict);
1062 stack_vars_alloc = stack_vars_num = 0;
1063 stack_vars_conflict = NULL;
1064 stack_vars_conflict_alloc = 0;
1067 /* If the target requires that FRAME_OFFSET be aligned, do it. */
1068 if (STACK_ALIGNMENT_NEEDED)
1070 HOST_WIDE_INT align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
1071 if (!FRAME_GROWS_DOWNWARD)
1072 frame_offset += align - 1;
1073 frame_offset &= -align;
1078 /* If we need to produce a detailed dump, print the tree representation
1079 for STMT to the dump file. SINCE is the last RTX after which the RTL
1080 generated for STMT should have been appended. */
1083 maybe_dump_rtl_for_tree_stmt (tree stmt, rtx since)
1085 if (dump_file && (dump_flags & TDF_DETAILS))
1087 fprintf (dump_file, "\n;; ");
1088 print_generic_expr (dump_file, stmt, TDF_SLIM);
1089 fprintf (dump_file, "\n");
1091 print_rtl (dump_file, since ? NEXT_INSN (since) : since);
1095 /* A subroutine of expand_gimple_basic_block. Expand one COND_EXPR.
1096 Returns a new basic block if we've terminated the current basic
1097 block and created a new one. */
1100 expand_gimple_cond_expr (basic_block bb, tree stmt)
1102 basic_block new_bb, dest;
1106 tree pred = COND_EXPR_COND (stmt);
1107 tree then_exp = COND_EXPR_THEN (stmt);
1108 tree else_exp = COND_EXPR_ELSE (stmt);
1111 last2 = last = get_last_insn ();
1113 extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
1114 if (EXPR_LOCUS (stmt))
1116 emit_line_note (*(EXPR_LOCUS (stmt)));
1117 record_block_change (TREE_BLOCK (stmt));
1120 /* These flags have no purpose in RTL land. */
1121 true_edge->flags &= ~EDGE_TRUE_VALUE;
1122 false_edge->flags &= ~EDGE_FALSE_VALUE;
1124 /* We can either have a pure conditional jump with one fallthru edge or
1125 two-way jump that needs to be decomposed into two basic blocks. */
1126 if (TREE_CODE (then_exp) == GOTO_EXPR && IS_EMPTY_STMT (else_exp))
1128 jumpif (pred, label_rtx (GOTO_DESTINATION (then_exp)));
1129 add_reg_br_prob_note (last, true_edge->probability);
1130 maybe_dump_rtl_for_tree_stmt (stmt, last);
1131 if (EXPR_LOCUS (then_exp))
1132 emit_line_note (*(EXPR_LOCUS (then_exp)));
1135 if (TREE_CODE (else_exp) == GOTO_EXPR && IS_EMPTY_STMT (then_exp))
1137 jumpifnot (pred, label_rtx (GOTO_DESTINATION (else_exp)));
1138 add_reg_br_prob_note (last, false_edge->probability);
1139 maybe_dump_rtl_for_tree_stmt (stmt, last);
1140 if (EXPR_LOCUS (else_exp))
1141 emit_line_note (*(EXPR_LOCUS (else_exp)));
1144 gcc_assert (TREE_CODE (then_exp) == GOTO_EXPR
1145 && TREE_CODE (else_exp) == GOTO_EXPR);
1147 jumpif (pred, label_rtx (GOTO_DESTINATION (then_exp)));
1148 add_reg_br_prob_note (last, true_edge->probability);
1149 last = get_last_insn ();
1150 expand_expr (else_exp, const0_rtx, VOIDmode, 0);
1153 if (BARRIER_P (BB_END (bb)))
1154 BB_END (bb) = PREV_INSN (BB_END (bb));
1155 update_bb_for_insn (bb);
1157 new_bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
1158 dest = false_edge->dest;
1159 redirect_edge_succ (false_edge, new_bb);
1160 false_edge->flags |= EDGE_FALLTHRU;
1161 new_bb->count = false_edge->count;
1162 new_bb->frequency = EDGE_FREQUENCY (false_edge);
1163 new_edge = make_edge (new_bb, dest, 0);
1164 new_edge->probability = REG_BR_PROB_BASE;
1165 new_edge->count = new_bb->count;
1166 if (BARRIER_P (BB_END (new_bb)))
1167 BB_END (new_bb) = PREV_INSN (BB_END (new_bb));
1168 update_bb_for_insn (new_bb);
1170 maybe_dump_rtl_for_tree_stmt (stmt, last2);
1172 if (EXPR_LOCUS (else_exp))
1173 emit_line_note (*(EXPR_LOCUS (else_exp)));
1178 /* A subroutine of expand_gimple_basic_block. Expand one CALL_EXPR
1179 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
1180 generated a tail call (something that might be denied by the ABI
1181 rules governing the call; see calls.c).
1183 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
1184 can still reach the rest of BB. The case here is __builtin_sqrt,
1185 where the NaN result goes through the external function (with a
1186 tailcall) and the normal result happens via a sqrt instruction. */
1189 expand_gimple_tailcall (basic_block bb, tree stmt, bool *can_fallthru)
1197 last2 = last = get_last_insn ();
1199 expand_expr_stmt (stmt);
1201 for (last = NEXT_INSN (last); last; last = NEXT_INSN (last))
1202 if (CALL_P (last) && SIBLING_CALL_P (last))
1205 maybe_dump_rtl_for_tree_stmt (stmt, last2);
1207 *can_fallthru = true;
1211 /* ??? Wouldn't it be better to just reset any pending stack adjust?
1212 Any instructions emitted here are about to be deleted. */
1213 do_pending_stack_adjust ();
1215 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
1216 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
1217 EH or abnormal edges, we shouldn't have created a tail call in
1218 the first place. So it seems to me we should just be removing
1219 all edges here, or redirecting the existing fallthru edge to
1225 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
1227 if (!(e->flags & (EDGE_ABNORMAL | EDGE_EH)))
1229 if (e->dest != EXIT_BLOCK_PTR)
1231 e->dest->count -= e->count;
1232 e->dest->frequency -= EDGE_FREQUENCY (e);
1233 if (e->dest->count < 0)
1235 if (e->dest->frequency < 0)
1236 e->dest->frequency = 0;
1239 probability += e->probability;
1246 /* This is somewhat ugly: the call_expr expander often emits instructions
1247 after the sibcall (to perform the function return). These confuse the
1248 find_many_sub_basic_blocks code, so we need to get rid of these. */
1249 last = NEXT_INSN (last);
1250 gcc_assert (BARRIER_P (last));
1252 *can_fallthru = false;
1253 while (NEXT_INSN (last))
1255 /* For instance an sqrt builtin expander expands if with
1256 sibcall in the then and label for `else`. */
1257 if (LABEL_P (NEXT_INSN (last)))
1259 *can_fallthru = true;
1262 delete_insn (NEXT_INSN (last));
1265 e = make_edge (bb, EXIT_BLOCK_PTR, EDGE_ABNORMAL | EDGE_SIBCALL);
1266 e->probability += probability;
1269 update_bb_for_insn (bb);
1271 if (NEXT_INSN (last))
1273 bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
1276 if (BARRIER_P (last))
1277 BB_END (bb) = PREV_INSN (last);
1280 maybe_dump_rtl_for_tree_stmt (stmt, last2);
1285 /* Expand basic block BB from GIMPLE trees to RTL. */
1288 expand_gimple_basic_block (basic_block bb)
1290 block_stmt_iterator bsi = bsi_start (bb);
1299 "\n;; Generating RTL for tree basic block %d\n",
1303 init_rtl_bb_info (bb);
1304 bb->flags |= BB_RTL;
1306 if (!bsi_end_p (bsi))
1307 stmt = bsi_stmt (bsi);
1309 if (stmt && TREE_CODE (stmt) == LABEL_EXPR)
1311 last = get_last_insn ();
1313 expand_expr_stmt (stmt);
1315 /* Java emits line number notes in the top of labels.
1316 ??? Make this go away once line number notes are obsoleted. */
1317 BB_HEAD (bb) = NEXT_INSN (last);
1318 if (NOTE_P (BB_HEAD (bb)))
1319 BB_HEAD (bb) = NEXT_INSN (BB_HEAD (bb));
1321 note = emit_note_after (NOTE_INSN_BASIC_BLOCK, BB_HEAD (bb));
1323 maybe_dump_rtl_for_tree_stmt (stmt, last);
1326 note = BB_HEAD (bb) = emit_note (NOTE_INSN_BASIC_BLOCK);
1328 NOTE_BASIC_BLOCK (note) = bb;
1330 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
1332 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
1333 e->flags &= ~EDGE_EXECUTABLE;
1335 /* At the moment not all abnormal edges match the RTL representation.
1336 It is safe to remove them here as find_many_sub_basic_blocks will
1337 rediscover them. In the future we should get this fixed properly. */
1338 if (e->flags & EDGE_ABNORMAL)
1344 for (; !bsi_end_p (bsi); bsi_next (&bsi))
1346 tree stmt = bsi_stmt (bsi);
1352 /* Expand this statement, then evaluate the resulting RTL and
1353 fixup the CFG accordingly. */
1354 if (TREE_CODE (stmt) == COND_EXPR)
1356 new_bb = expand_gimple_cond_expr (bb, stmt);
1362 tree call = get_call_expr_in (stmt);
1363 if (call && CALL_EXPR_TAILCALL (call))
1366 new_bb = expand_gimple_tailcall (bb, stmt, &can_fallthru);
1377 last = get_last_insn ();
1378 expand_expr_stmt (stmt);
1379 maybe_dump_rtl_for_tree_stmt (stmt, last);
1384 do_pending_stack_adjust ();
1386 /* Find the block tail. The last insn in the block is the insn
1387 before a barrier and/or table jump insn. */
1388 last = get_last_insn ();
1389 if (BARRIER_P (last))
1390 last = PREV_INSN (last);
1391 if (JUMP_TABLE_DATA_P (last))
1392 last = PREV_INSN (PREV_INSN (last));
1395 update_bb_for_insn (bb);
1401 /* Create a basic block for initialization code. */
1404 construct_init_block (void)
1406 basic_block init_block, first_block;
1410 /* Multiple entry points not supported yet. */
1411 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR->succs) == 1);
1412 init_rtl_bb_info (ENTRY_BLOCK_PTR);
1413 init_rtl_bb_info (EXIT_BLOCK_PTR);
1414 ENTRY_BLOCK_PTR->flags |= BB_RTL;
1415 EXIT_BLOCK_PTR->flags |= BB_RTL;
1417 e = EDGE_SUCC (ENTRY_BLOCK_PTR, 0);
1419 /* When entry edge points to first basic block, we don't need jump,
1420 otherwise we have to jump into proper target. */
1421 if (e && e->dest != ENTRY_BLOCK_PTR->next_bb)
1423 tree label = tree_block_label (e->dest);
1425 emit_jump (label_rtx (label));
1429 flags = EDGE_FALLTHRU;
1431 init_block = create_basic_block (NEXT_INSN (get_insns ()),
1434 init_block->frequency = ENTRY_BLOCK_PTR->frequency;
1435 init_block->count = ENTRY_BLOCK_PTR->count;
1438 first_block = e->dest;
1439 redirect_edge_succ (e, init_block);
1440 e = make_edge (init_block, first_block, flags);
1443 e = make_edge (init_block, EXIT_BLOCK_PTR, EDGE_FALLTHRU);
1444 e->probability = REG_BR_PROB_BASE;
1445 e->count = ENTRY_BLOCK_PTR->count;
1447 update_bb_for_insn (init_block);
1452 /* Create a block containing landing pads and similar stuff. */
1455 construct_exit_block (void)
1457 rtx head = get_last_insn ();
1459 basic_block exit_block;
1464 /* Make sure the locus is set to the end of the function, so that
1465 epilogue line numbers and warnings are set properly. */
1466 #ifdef USE_MAPPED_LOCATION
1467 if (cfun->function_end_locus != UNKNOWN_LOCATION)
1469 if (cfun->function_end_locus.file)
1471 input_location = cfun->function_end_locus;
1473 /* The following insns belong to the top scope. */
1474 record_block_change (DECL_INITIAL (current_function_decl));
1476 /* Generate rtl for function exit. */
1477 expand_function_end ();
1479 end = get_last_insn ();
1482 while (NEXT_INSN (head) && NOTE_P (NEXT_INSN (head)))
1483 head = NEXT_INSN (head);
1484 exit_block = create_basic_block (NEXT_INSN (head), end,
1485 EXIT_BLOCK_PTR->prev_bb);
1486 exit_block->frequency = EXIT_BLOCK_PTR->frequency;
1487 exit_block->count = EXIT_BLOCK_PTR->count;
1490 while (ix < EDGE_COUNT (EXIT_BLOCK_PTR->preds))
1492 e = EDGE_PRED (EXIT_BLOCK_PTR, ix);
1493 if (!(e->flags & EDGE_ABNORMAL))
1494 redirect_edge_succ (e, exit_block);
1499 e = make_edge (exit_block, EXIT_BLOCK_PTR, EDGE_FALLTHRU);
1500 e->probability = REG_BR_PROB_BASE;
1501 e->count = EXIT_BLOCK_PTR->count;
1502 FOR_EACH_EDGE (e2, ei, EXIT_BLOCK_PTR->preds)
1505 e->count -= e2->count;
1506 exit_block->count -= e2->count;
1507 exit_block->frequency -= EDGE_FREQUENCY (e2);
1511 if (exit_block->count < 0)
1512 exit_block->count = 0;
1513 if (exit_block->frequency < 0)
1514 exit_block->frequency = 0;
1515 update_bb_for_insn (exit_block);
1518 /* Helper function for discover_nonconstant_array_refs.
1519 Look for ARRAY_REF nodes with non-constant indexes and mark them
1523 discover_nonconstant_array_refs_r (tree * tp, int *walk_subtrees,
1524 void *data ATTRIBUTE_UNUSED)
1528 if (IS_TYPE_OR_DECL_P (t))
1530 else if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1532 while (((TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1533 && is_gimple_min_invariant (TREE_OPERAND (t, 1))
1534 && (!TREE_OPERAND (t, 2)
1535 || is_gimple_min_invariant (TREE_OPERAND (t, 2))))
1536 || (TREE_CODE (t) == COMPONENT_REF
1537 && (!TREE_OPERAND (t,2)
1538 || is_gimple_min_invariant (TREE_OPERAND (t, 2))))
1539 || TREE_CODE (t) == BIT_FIELD_REF
1540 || TREE_CODE (t) == REALPART_EXPR
1541 || TREE_CODE (t) == IMAGPART_EXPR
1542 || TREE_CODE (t) == VIEW_CONVERT_EXPR
1543 || TREE_CODE (t) == NOP_EXPR
1544 || TREE_CODE (t) == CONVERT_EXPR)
1545 t = TREE_OPERAND (t, 0);
1547 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1549 t = get_base_address (t);
1550 if (t && DECL_P (t))
1551 TREE_ADDRESSABLE (t) = 1;
1560 /* RTL expansion is not able to compile array references with variable
1561 offsets for arrays stored in single register. Discover such
1562 expressions and mark variables as addressable to avoid this
1566 discover_nonconstant_array_refs (void)
1569 block_stmt_iterator bsi;
1573 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
1574 walk_tree (bsi_stmt_ptr (bsi), discover_nonconstant_array_refs_r,
1579 /* Translate the intermediate representation contained in the CFG
1580 from GIMPLE trees to RTL.
1582 We do conversion per basic block and preserve/update the tree CFG.
1583 This implies we have to do some magic as the CFG can simultaneously
1584 consist of basic blocks containing RTL and GIMPLE trees. This can
1585 confuse the CFG hooks, so be careful to not manipulate CFG during
1589 tree_expand_cfg (void)
1591 basic_block bb, init_block;
1596 /* Some backends want to know that we are expanding to RTL. */
1597 currently_expanding_to_rtl = 1;
1599 /* Prepare the rtl middle end to start recording block changes. */
1600 reset_block_changes ();
1602 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
1603 discover_nonconstant_array_refs ();
1605 /* Expand the variables recorded during gimple lowering. */
1606 expand_used_vars ();
1608 /* Honor stack protection warnings. */
1609 if (warn_stack_protect)
1611 if (current_function_calls_alloca)
1612 warning (0, "not protecting local variables: variable length buffer");
1613 if (has_short_buffer && !cfun->stack_protect_guard)
1614 warning (0, "not protecting function: no buffer at least %d bytes long",
1615 (int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE));
1618 /* Set up parameters and prepare for return, for the function. */
1619 expand_function_start (current_function_decl);
1621 /* If this function is `main', emit a call to `__main'
1622 to run global initializers, etc. */
1623 if (DECL_NAME (current_function_decl)
1624 && MAIN_NAME_P (DECL_NAME (current_function_decl))
1625 && DECL_FILE_SCOPE_P (current_function_decl))
1626 expand_main_function ();
1628 /* Initialize the stack_protect_guard field. This must happen after the
1629 call to __main (if any) so that the external decl is initialized. */
1630 if (cfun->stack_protect_guard)
1631 stack_protect_prologue ();
1633 /* Register rtl specific functions for cfg. */
1634 rtl_register_cfg_hooks ();
1636 init_block = construct_init_block ();
1638 /* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
1639 remaining edges in expand_gimple_basic_block. */
1640 FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
1641 e->flags &= ~EDGE_EXECUTABLE;
1643 FOR_BB_BETWEEN (bb, init_block->next_bb, EXIT_BLOCK_PTR, next_bb)
1644 bb = expand_gimple_basic_block (bb);
1646 construct_exit_block ();
1648 /* We're done expanding trees to RTL. */
1649 currently_expanding_to_rtl = 0;
1651 /* Convert tree EH labels to RTL EH labels, and clean out any unreachable
1653 convert_from_eh_region_ranges ();
1655 rebuild_jump_labels (get_insns ());
1656 find_exception_handler_labels ();
1658 blocks = sbitmap_alloc (last_basic_block);
1659 sbitmap_ones (blocks);
1660 find_many_sub_basic_blocks (blocks);
1661 purge_all_dead_edges ();
1662 sbitmap_free (blocks);
1665 #ifdef ENABLE_CHECKING
1669 /* There's no need to defer outputting this function any more; we
1670 know we want to output it. */
1671 DECL_DEFER_OUTPUT (current_function_decl) = 0;
1673 /* Now that we're done expanding trees to RTL, we shouldn't have any
1674 more CONCATs anywhere. */
1675 generating_concat_p = 0;
1677 finalize_block_changes ();
1682 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
1683 /* And the pass manager will dump RTL for us. */
1686 /* If we're emitting a nested function, make sure its parent gets
1687 emitted as well. Doing otherwise confuses debug info. */
1690 for (parent = DECL_CONTEXT (current_function_decl);
1691 parent != NULL_TREE;
1692 parent = get_containing_scope (parent))
1693 if (TREE_CODE (parent) == FUNCTION_DECL)
1694 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent)) = 1;
1697 /* We are now committed to emitting code for this function. Do any
1698 preparation, such as emitting abstract debug info for the inline
1699 before it gets mangled by optimization. */
1700 if (cgraph_function_possibly_inlined_p (current_function_decl))
1701 (*debug_hooks->outlining_inline_function) (current_function_decl);
1703 TREE_ASM_WRITTEN (current_function_decl) = 1;
1705 /* After expanding, the return labels are no longer needed. */
1706 return_label = NULL;
1707 naked_return_label = NULL;
1711 struct tree_opt_pass pass_expand =
1713 "expand", /* name */
1715 tree_expand_cfg, /* execute */
1718 0, /* static_pass_number */
1719 TV_EXPAND, /* tv_id */
1720 /* ??? If TER is enabled, we actually receive GENERIC. */
1721 PROP_gimple_leh | PROP_cfg, /* properties_required */
1722 PROP_rtl, /* properties_provided */
1723 PROP_trees, /* properties_destroyed */
1724 0, /* todo_flags_start */
1725 TODO_dump_func, /* todo_flags_finish */