1 /* A pass for lowering trees to RTL.
2 Copyright (C) 2004, 2005, 2006, 2007 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"
42 #include "tree-inline.h"
43 #include "value-prof.h"
45 /* Verify that there is exactly single jump instruction since last and attach
46 REG_BR_PROB note specifying probability.
47 ??? We really ought to pass the probability down to RTL expanders and let it
48 re-distribute it when the conditional expands into multiple conditionals.
49 This is however difficult to do. */
51 add_reg_br_prob_note (rtx last, int probability)
53 if (profile_status == PROFILE_ABSENT)
55 for (last = NEXT_INSN (last); last && NEXT_INSN (last); last = NEXT_INSN (last))
58 /* It is common to emit condjump-around-jump sequence when we don't know
59 how to reverse the conditional. Special case this. */
60 if (!any_condjump_p (last)
61 || !JUMP_P (NEXT_INSN (last))
62 || !simplejump_p (NEXT_INSN (last))
63 || !NEXT_INSN (NEXT_INSN (last))
64 || !BARRIER_P (NEXT_INSN (NEXT_INSN (last)))
65 || !NEXT_INSN (NEXT_INSN (NEXT_INSN (last)))
66 || !LABEL_P (NEXT_INSN (NEXT_INSN (NEXT_INSN (last))))
67 || NEXT_INSN (NEXT_INSN (NEXT_INSN (NEXT_INSN (last)))))
69 gcc_assert (!find_reg_note (last, REG_BR_PROB, 0));
71 = gen_rtx_EXPR_LIST (REG_BR_PROB,
72 GEN_INT (REG_BR_PROB_BASE - probability),
76 if (!last || !JUMP_P (last) || !any_condjump_p (last))
78 gcc_assert (!find_reg_note (last, REG_BR_PROB, 0));
80 = gen_rtx_EXPR_LIST (REG_BR_PROB,
81 GEN_INT (probability), REG_NOTES (last));
85 fprintf (dump_file, "Failed to add probability note\n");
89 #ifndef LOCAL_ALIGNMENT
90 #define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT
93 #ifndef STACK_ALIGNMENT_NEEDED
94 #define STACK_ALIGNMENT_NEEDED 1
98 /* This structure holds data relevant to one variable that will be
99 placed in a stack slot. */
105 /* The offset of the variable. During partitioning, this is the
106 offset relative to the partition. After partitioning, this
107 is relative to the stack frame. */
108 HOST_WIDE_INT offset;
110 /* Initially, the size of the variable. Later, the size of the partition,
111 if this variable becomes it's partition's representative. */
114 /* The *byte* alignment required for this variable. Or as, with the
115 size, the alignment for this partition. */
118 /* The partition representative. */
119 size_t representative;
121 /* The next stack variable in the partition, or EOC. */
125 #define EOC ((size_t)-1)
127 /* We have an array of such objects while deciding allocation. */
128 static struct stack_var *stack_vars;
129 static size_t stack_vars_alloc;
130 static size_t stack_vars_num;
132 /* An array of indicies such that stack_vars[stack_vars_sorted[i]].size
133 is non-decreasing. */
134 static size_t *stack_vars_sorted;
136 /* We have an interference graph between such objects. This graph
137 is lower triangular. */
138 static bool *stack_vars_conflict;
139 static size_t stack_vars_conflict_alloc;
141 /* The phase of the stack frame. This is the known misalignment of
142 virtual_stack_vars_rtx from PREFERRED_STACK_BOUNDARY. That is,
143 (frame_offset+frame_phase) % PREFERRED_STACK_BOUNDARY == 0. */
144 static int frame_phase;
146 /* Used during expand_used_vars to remember if we saw any decls for
147 which we'd like to enable stack smashing protection. */
148 static bool has_protected_decls;
150 /* Used during expand_used_vars. Remember if we say a character buffer
151 smaller than our cutoff threshold. Used for -Wstack-protector. */
152 static bool has_short_buffer;
154 /* Discover the byte alignment to use for DECL. Ignore alignment
155 we can't do with expected alignment of the stack boundary. */
158 get_decl_align_unit (tree decl)
162 align = DECL_ALIGN (decl);
163 align = LOCAL_ALIGNMENT (TREE_TYPE (decl), align);
164 if (align > PREFERRED_STACK_BOUNDARY)
165 align = PREFERRED_STACK_BOUNDARY;
166 if (cfun->stack_alignment_needed < align)
167 cfun->stack_alignment_needed = align;
169 return align / BITS_PER_UNIT;
172 /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
173 Return the frame offset. */
176 alloc_stack_frame_space (HOST_WIDE_INT size, HOST_WIDE_INT align)
178 HOST_WIDE_INT offset, new_frame_offset;
180 new_frame_offset = frame_offset;
181 if (FRAME_GROWS_DOWNWARD)
183 new_frame_offset -= size + frame_phase;
184 new_frame_offset &= -align;
185 new_frame_offset += frame_phase;
186 offset = new_frame_offset;
190 new_frame_offset -= frame_phase;
191 new_frame_offset += align - 1;
192 new_frame_offset &= -align;
193 new_frame_offset += frame_phase;
194 offset = new_frame_offset;
195 new_frame_offset += size;
197 frame_offset = new_frame_offset;
199 if (frame_offset_overflow (frame_offset, cfun->decl))
200 frame_offset = offset = 0;
205 /* Accumulate DECL into STACK_VARS. */
208 add_stack_var (tree decl)
210 if (stack_vars_num >= stack_vars_alloc)
212 if (stack_vars_alloc)
213 stack_vars_alloc = stack_vars_alloc * 3 / 2;
215 stack_vars_alloc = 32;
217 = XRESIZEVEC (struct stack_var, stack_vars, stack_vars_alloc);
219 stack_vars[stack_vars_num].decl = decl;
220 stack_vars[stack_vars_num].offset = 0;
221 stack_vars[stack_vars_num].size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
222 stack_vars[stack_vars_num].alignb = get_decl_align_unit (decl);
224 /* All variables are initially in their own partition. */
225 stack_vars[stack_vars_num].representative = stack_vars_num;
226 stack_vars[stack_vars_num].next = EOC;
228 /* Ensure that this decl doesn't get put onto the list twice. */
229 SET_DECL_RTL (decl, pc_rtx);
234 /* Compute the linear index of a lower-triangular coordinate (I, J). */
237 triangular_index (size_t i, size_t j)
244 return (i * (i + 1)) / 2 + j;
247 /* Ensure that STACK_VARS_CONFLICT is large enough for N objects. */
250 resize_stack_vars_conflict (size_t n)
252 size_t size = triangular_index (n-1, n-1) + 1;
254 if (size <= stack_vars_conflict_alloc)
257 stack_vars_conflict = XRESIZEVEC (bool, stack_vars_conflict, size);
258 memset (stack_vars_conflict + stack_vars_conflict_alloc, 0,
259 (size - stack_vars_conflict_alloc) * sizeof (bool));
260 stack_vars_conflict_alloc = size;
263 /* Make the decls associated with luid's X and Y conflict. */
266 add_stack_var_conflict (size_t x, size_t y)
268 size_t index = triangular_index (x, y);
269 gcc_assert (index < stack_vars_conflict_alloc);
270 stack_vars_conflict[index] = true;
273 /* Check whether the decls associated with luid's X and Y conflict. */
276 stack_var_conflict_p (size_t x, size_t y)
278 size_t index = triangular_index (x, y);
279 gcc_assert (index < stack_vars_conflict_alloc);
280 return stack_vars_conflict[index];
283 /* Returns true if TYPE is or contains a union type. */
286 aggregate_contains_union_type (tree type)
290 if (TREE_CODE (type) == UNION_TYPE
291 || TREE_CODE (type) == QUAL_UNION_TYPE)
293 if (TREE_CODE (type) == ARRAY_TYPE)
294 return aggregate_contains_union_type (TREE_TYPE (type));
295 if (TREE_CODE (type) != RECORD_TYPE)
298 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
299 if (TREE_CODE (field) == FIELD_DECL)
300 if (aggregate_contains_union_type (TREE_TYPE (field)))
306 /* A subroutine of expand_used_vars. If two variables X and Y have alias
307 sets that do not conflict, then do add a conflict for these variables
308 in the interference graph. We also need to make sure to add conflicts
309 for union containing structures. Else RTL alias analysis comes along
310 and due to type based aliasing rules decides that for two overlapping
311 union temporaries { short s; int i; } accesses to the same mem through
312 different types may not alias and happily reorders stores across
313 life-time boundaries of the temporaries (See PR25654).
314 We also have to mind MEM_IN_STRUCT_P and MEM_SCALAR_P. */
317 add_alias_set_conflicts (void)
319 size_t i, j, n = stack_vars_num;
321 for (i = 0; i < n; ++i)
323 tree type_i = TREE_TYPE (stack_vars[i].decl);
324 bool aggr_i = AGGREGATE_TYPE_P (type_i);
327 contains_union = aggregate_contains_union_type (type_i);
328 for (j = 0; j < i; ++j)
330 tree type_j = TREE_TYPE (stack_vars[j].decl);
331 bool aggr_j = AGGREGATE_TYPE_P (type_j);
333 /* Either the objects conflict by means of type based
334 aliasing rules, or we need to add a conflict. */
335 || !objects_must_conflict_p (type_i, type_j)
336 /* In case the types do not conflict ensure that access
337 to elements will conflict. In case of unions we have
338 to be careful as type based aliasing rules may say
339 access to the same memory does not conflict. So play
340 safe and add a conflict in this case. */
342 add_stack_var_conflict (i, j);
347 /* A subroutine of partition_stack_vars. A comparison function for qsort,
348 sorting an array of indicies by the size of the object. */
351 stack_var_size_cmp (const void *a, const void *b)
353 HOST_WIDE_INT sa = stack_vars[*(const size_t *)a].size;
354 HOST_WIDE_INT sb = stack_vars[*(const size_t *)b].size;
355 unsigned int uida = DECL_UID (stack_vars[*(const size_t *)a].decl);
356 unsigned int uidb = DECL_UID (stack_vars[*(const size_t *)b].decl);
362 /* For stack variables of the same size use the uid of the decl
363 to make the sort stable. */
371 /* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
372 partitioning algorithm. Partitions A and B are known to be non-conflicting.
373 Merge them into a single partition A.
375 At the same time, add OFFSET to all variables in partition B. At the end
376 of the partitioning process we've have a nice block easy to lay out within
380 union_stack_vars (size_t a, size_t b, HOST_WIDE_INT offset)
384 /* Update each element of partition B with the given offset,
385 and merge them into partition A. */
386 for (last = i = b; i != EOC; last = i, i = stack_vars[i].next)
388 stack_vars[i].offset += offset;
389 stack_vars[i].representative = a;
391 stack_vars[last].next = stack_vars[a].next;
392 stack_vars[a].next = b;
394 /* Update the required alignment of partition A to account for B. */
395 if (stack_vars[a].alignb < stack_vars[b].alignb)
396 stack_vars[a].alignb = stack_vars[b].alignb;
398 /* Update the interference graph and merge the conflicts. */
399 for (last = stack_vars_num, i = 0; i < last; ++i)
400 if (stack_var_conflict_p (b, i))
401 add_stack_var_conflict (a, i);
404 /* A subroutine of expand_used_vars. Binpack the variables into
405 partitions constrained by the interference graph. The overall
406 algorithm used is as follows:
408 Sort the objects by size.
413 Look for the largest non-conflicting object B with size <= S.
423 partition_stack_vars (void)
425 size_t si, sj, n = stack_vars_num;
427 stack_vars_sorted = XNEWVEC (size_t, stack_vars_num);
428 for (si = 0; si < n; ++si)
429 stack_vars_sorted[si] = si;
434 qsort (stack_vars_sorted, n, sizeof (size_t), stack_var_size_cmp);
436 /* Special case: detect when all variables conflict, and thus we can't
437 do anything during the partitioning loop. It isn't uncommon (with
438 C code at least) to declare all variables at the top of the function,
439 and if we're not inlining, then all variables will be in the same scope.
440 Take advantage of very fast libc routines for this scan. */
441 gcc_assert (sizeof(bool) == sizeof(char));
442 if (memchr (stack_vars_conflict, false, stack_vars_conflict_alloc) == NULL)
445 for (si = 0; si < n; ++si)
447 size_t i = stack_vars_sorted[si];
448 HOST_WIDE_INT isize = stack_vars[i].size;
449 HOST_WIDE_INT offset = 0;
451 for (sj = si; sj-- > 0; )
453 size_t j = stack_vars_sorted[sj];
454 HOST_WIDE_INT jsize = stack_vars[j].size;
455 unsigned int jalign = stack_vars[j].alignb;
457 /* Ignore objects that aren't partition representatives. */
458 if (stack_vars[j].representative != j)
461 /* Ignore objects too large for the remaining space. */
465 /* Ignore conflicting objects. */
466 if (stack_var_conflict_p (i, j))
469 /* Refine the remaining space check to include alignment. */
470 if (offset & (jalign - 1))
472 HOST_WIDE_INT toff = offset;
474 toff &= -(HOST_WIDE_INT)jalign;
475 if (isize - (toff - offset) < jsize)
478 isize -= toff - offset;
482 /* UNION the objects, placing J at OFFSET. */
483 union_stack_vars (i, j, offset);
492 /* A debugging aid for expand_used_vars. Dump the generated partitions. */
495 dump_stack_var_partition (void)
497 size_t si, i, j, n = stack_vars_num;
499 for (si = 0; si < n; ++si)
501 i = stack_vars_sorted[si];
503 /* Skip variables that aren't partition representatives, for now. */
504 if (stack_vars[i].representative != i)
507 fprintf (dump_file, "Partition %lu: size " HOST_WIDE_INT_PRINT_DEC
508 " align %u\n", (unsigned long) i, stack_vars[i].size,
509 stack_vars[i].alignb);
511 for (j = i; j != EOC; j = stack_vars[j].next)
513 fputc ('\t', dump_file);
514 print_generic_expr (dump_file, stack_vars[j].decl, dump_flags);
515 fprintf (dump_file, ", offset " HOST_WIDE_INT_PRINT_DEC "\n",
516 stack_vars[i].offset);
521 /* Assign rtl to DECL at frame offset OFFSET. */
524 expand_one_stack_var_at (tree decl, HOST_WIDE_INT offset)
529 /* If this fails, we've overflowed the stack frame. Error nicely? */
530 gcc_assert (offset == trunc_int_for_mode (offset, Pmode));
532 x = plus_constant (virtual_stack_vars_rtx, offset);
533 x = gen_rtx_MEM (DECL_MODE (decl), x);
535 /* Set alignment we actually gave this decl. */
536 offset -= frame_phase;
537 align = offset & -offset;
538 align *= BITS_PER_UNIT;
539 if (align > STACK_BOUNDARY || align == 0)
540 align = STACK_BOUNDARY;
541 DECL_ALIGN (decl) = align;
542 DECL_USER_ALIGN (decl) = 0;
544 set_mem_attributes (x, decl, true);
545 SET_DECL_RTL (decl, x);
548 /* A subroutine of expand_used_vars. Give each partition representative
549 a unique location within the stack frame. Update each partition member
550 with that location. */
553 expand_stack_vars (bool (*pred) (tree))
555 size_t si, i, j, n = stack_vars_num;
557 for (si = 0; si < n; ++si)
559 HOST_WIDE_INT offset;
561 i = stack_vars_sorted[si];
563 /* Skip variables that aren't partition representatives, for now. */
564 if (stack_vars[i].representative != i)
567 /* Skip variables that have already had rtl assigned. See also
568 add_stack_var where we perpetrate this pc_rtx hack. */
569 if (DECL_RTL (stack_vars[i].decl) != pc_rtx)
572 /* Check the predicate to see whether this variable should be
573 allocated in this pass. */
574 if (pred && !pred (stack_vars[i].decl))
577 offset = alloc_stack_frame_space (stack_vars[i].size,
578 stack_vars[i].alignb);
580 /* Create rtl for each variable based on their location within the
582 for (j = i; j != EOC; j = stack_vars[j].next)
583 expand_one_stack_var_at (stack_vars[j].decl,
584 stack_vars[j].offset + offset);
588 /* Take into account all sizes of partitions and reset DECL_RTLs. */
590 account_stack_vars (void)
592 size_t si, j, i, n = stack_vars_num;
593 HOST_WIDE_INT size = 0;
595 for (si = 0; si < n; ++si)
597 i = stack_vars_sorted[si];
599 /* Skip variables that aren't partition representatives, for now. */
600 if (stack_vars[i].representative != i)
603 size += stack_vars[i].size;
604 for (j = i; j != EOC; j = stack_vars[j].next)
605 SET_DECL_RTL (stack_vars[j].decl, NULL);
610 /* A subroutine of expand_one_var. Called to immediately assign rtl
611 to a variable to be allocated in the stack frame. */
614 expand_one_stack_var (tree var)
616 HOST_WIDE_INT size, offset, align;
618 size = tree_low_cst (DECL_SIZE_UNIT (var), 1);
619 align = get_decl_align_unit (var);
620 offset = alloc_stack_frame_space (size, align);
622 expand_one_stack_var_at (var, offset);
625 /* A subroutine of expand_one_var. Called to assign rtl
626 to a TREE_STATIC VAR_DECL. */
629 expand_one_static_var (tree var)
631 /* In unit-at-a-time all the static variables are expanded at the end
632 of compilation process. */
633 if (flag_unit_at_a_time)
635 /* If this is an inlined copy of a static local variable,
636 look up the original. */
637 var = DECL_ORIGIN (var);
639 /* If we've already processed this variable because of that, do nothing. */
640 if (TREE_ASM_WRITTEN (var))
643 /* Give the front end a chance to do whatever. In practice, this is
644 resolving duplicate names for IMA in C. */
645 if (lang_hooks.expand_decl (var))
648 /* Otherwise, just emit the variable. */
649 rest_of_decl_compilation (var, 0, 0);
652 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
653 that will reside in a hard register. */
656 expand_one_hard_reg_var (tree var)
658 rest_of_decl_compilation (var, 0, 0);
661 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
662 that will reside in a pseudo register. */
665 expand_one_register_var (tree var)
667 tree type = TREE_TYPE (var);
668 int unsignedp = TYPE_UNSIGNED (type);
669 enum machine_mode reg_mode
670 = promote_mode (type, DECL_MODE (var), &unsignedp, 0);
671 rtx x = gen_reg_rtx (reg_mode);
673 SET_DECL_RTL (var, x);
675 /* Note if the object is a user variable. */
676 if (!DECL_ARTIFICIAL (var))
680 /* Trust user variables which have a pointer type to really
681 be pointers. Do not trust compiler generated temporaries
682 as our type system is totally busted as it relates to
683 pointer arithmetic which translates into lots of compiler
684 generated objects with pointer types, but which are not really
686 if (POINTER_TYPE_P (type))
687 mark_reg_pointer (x, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (var))));
691 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
692 has some associated error, e.g. its type is error-mark. We just need
693 to pick something that won't crash the rest of the compiler. */
696 expand_one_error_var (tree var)
698 enum machine_mode mode = DECL_MODE (var);
702 x = gen_rtx_MEM (BLKmode, const0_rtx);
703 else if (mode == VOIDmode)
706 x = gen_reg_rtx (mode);
708 SET_DECL_RTL (var, x);
711 /* A subroutine of expand_one_var. VAR is a variable that will be
712 allocated to the local stack frame. Return true if we wish to
713 add VAR to STACK_VARS so that it will be coalesced with other
714 variables. Return false to allocate VAR immediately.
716 This function is used to reduce the number of variables considered
717 for coalescing, which reduces the size of the quadratic problem. */
720 defer_stack_allocation (tree var, bool toplevel)
722 /* If stack protection is enabled, *all* stack variables must be deferred,
723 so that we can re-order the strings to the top of the frame. */
724 if (flag_stack_protect)
727 /* Variables in the outermost scope automatically conflict with
728 every other variable. The only reason to want to defer them
729 at all is that, after sorting, we can more efficiently pack
730 small variables in the stack frame. Continue to defer at -O2. */
731 if (toplevel && optimize < 2)
734 /* Without optimization, *most* variables are allocated from the
735 stack, which makes the quadratic problem large exactly when we
736 want compilation to proceed as quickly as possible. On the
737 other hand, we don't want the function's stack frame size to
738 get completely out of hand. So we avoid adding scalars and
739 "small" aggregates to the list at all. */
740 if (optimize == 0 && tree_low_cst (DECL_SIZE_UNIT (var), 1) < 32)
746 /* A subroutine of expand_used_vars. Expand one variable according to
747 its flavor. Variables to be placed on the stack are not actually
748 expanded yet, merely recorded.
749 When REALLY_EXPAND is false, only add stack values to be allocated.
750 Return stack usage this variable is supposed to take.
754 expand_one_var (tree var, bool toplevel, bool really_expand)
756 if (TREE_CODE (var) != VAR_DECL)
759 lang_hooks.expand_decl (var);
761 else if (DECL_EXTERNAL (var))
763 else if (DECL_HAS_VALUE_EXPR_P (var))
765 else if (TREE_STATIC (var))
768 expand_one_static_var (var);
770 else if (DECL_RTL_SET_P (var))
772 else if (TREE_TYPE (var) == error_mark_node)
775 expand_one_error_var (var);
777 else if (DECL_HARD_REGISTER (var))
780 expand_one_hard_reg_var (var);
782 else if (use_register_for_decl (var))
785 expand_one_register_var (var);
787 else if (defer_stack_allocation (var, toplevel))
792 expand_one_stack_var (var);
793 return tree_low_cst (DECL_SIZE_UNIT (var), 1);
798 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
799 expanding variables. Those variables that can be put into registers
800 are allocated pseudos; those that can't are put on the stack.
802 TOPLEVEL is true if this is the outermost BLOCK. */
805 expand_used_vars_for_block (tree block, bool toplevel)
807 size_t i, j, old_sv_num, this_sv_num, new_sv_num;
810 old_sv_num = toplevel ? 0 : stack_vars_num;
812 /* Expand all variables at this level. */
813 for (t = BLOCK_VARS (block); t ; t = TREE_CHAIN (t))
815 /* Force local static variables to be output when marked by
816 used attribute. For unit-at-a-time, cgraph code already takes
818 || (!flag_unit_at_a_time && TREE_STATIC (t)
819 && DECL_PRESERVE_P (t)))
820 expand_one_var (t, toplevel, true);
822 this_sv_num = stack_vars_num;
824 /* Expand all variables at containing levels. */
825 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
826 expand_used_vars_for_block (t, false);
828 /* Since we do not track exact variable lifetimes (which is not even
829 possible for variables whose address escapes), we mirror the block
830 tree in the interference graph. Here we cause all variables at this
831 level, and all sublevels, to conflict. Do make certain that a
832 variable conflicts with itself. */
833 if (old_sv_num < this_sv_num)
835 new_sv_num = stack_vars_num;
836 resize_stack_vars_conflict (new_sv_num);
838 for (i = old_sv_num; i < new_sv_num; ++i)
839 for (j = i < this_sv_num ? i+1 : this_sv_num; j-- > old_sv_num ;)
840 add_stack_var_conflict (i, j);
844 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
845 and clear TREE_USED on all local variables. */
848 clear_tree_used (tree block)
852 for (t = BLOCK_VARS (block); t ; t = TREE_CHAIN (t))
853 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
856 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
860 /* Examine TYPE and determine a bit mask of the following features. */
862 #define SPCT_HAS_LARGE_CHAR_ARRAY 1
863 #define SPCT_HAS_SMALL_CHAR_ARRAY 2
864 #define SPCT_HAS_ARRAY 4
865 #define SPCT_HAS_AGGREGATE 8
868 stack_protect_classify_type (tree type)
870 unsigned int ret = 0;
873 switch (TREE_CODE (type))
876 t = TYPE_MAIN_VARIANT (TREE_TYPE (type));
877 if (t == char_type_node
878 || t == signed_char_type_node
879 || t == unsigned_char_type_node)
881 unsigned HOST_WIDE_INT max = PARAM_VALUE (PARAM_SSP_BUFFER_SIZE);
882 unsigned HOST_WIDE_INT len;
884 if (!TYPE_SIZE_UNIT (type)
885 || !host_integerp (TYPE_SIZE_UNIT (type), 1))
888 len = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
891 ret = SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_ARRAY;
893 ret = SPCT_HAS_LARGE_CHAR_ARRAY | SPCT_HAS_ARRAY;
896 ret = SPCT_HAS_ARRAY;
900 case QUAL_UNION_TYPE:
902 ret = SPCT_HAS_AGGREGATE;
903 for (t = TYPE_FIELDS (type); t ; t = TREE_CHAIN (t))
904 if (TREE_CODE (t) == FIELD_DECL)
905 ret |= stack_protect_classify_type (TREE_TYPE (t));
915 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
916 part of the local stack frame. Remember if we ever return nonzero for
917 any variable in this function. The return value is the phase number in
918 which the variable should be allocated. */
921 stack_protect_decl_phase (tree decl)
923 unsigned int bits = stack_protect_classify_type (TREE_TYPE (decl));
926 if (bits & SPCT_HAS_SMALL_CHAR_ARRAY)
927 has_short_buffer = true;
929 if (flag_stack_protect == 2)
931 if ((bits & (SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_LARGE_CHAR_ARRAY))
932 && !(bits & SPCT_HAS_AGGREGATE))
934 else if (bits & SPCT_HAS_ARRAY)
938 ret = (bits & SPCT_HAS_LARGE_CHAR_ARRAY) != 0;
941 has_protected_decls = true;
946 /* Two helper routines that check for phase 1 and phase 2. These are used
947 as callbacks for expand_stack_vars. */
950 stack_protect_decl_phase_1 (tree decl)
952 return stack_protect_decl_phase (decl) == 1;
956 stack_protect_decl_phase_2 (tree decl)
958 return stack_protect_decl_phase (decl) == 2;
961 /* Ensure that variables in different stack protection phases conflict
962 so that they are not merged and share the same stack slot. */
965 add_stack_protection_conflicts (void)
967 size_t i, j, n = stack_vars_num;
968 unsigned char *phase;
970 phase = XNEWVEC (unsigned char, n);
971 for (i = 0; i < n; ++i)
972 phase[i] = stack_protect_decl_phase (stack_vars[i].decl);
974 for (i = 0; i < n; ++i)
976 unsigned char ph_i = phase[i];
977 for (j = 0; j < i; ++j)
978 if (ph_i != phase[j])
979 add_stack_var_conflict (i, j);
985 /* Create a decl for the guard at the top of the stack frame. */
988 create_stack_guard (void)
990 tree guard = build_decl (VAR_DECL, NULL, ptr_type_node);
991 TREE_THIS_VOLATILE (guard) = 1;
992 TREE_USED (guard) = 1;
993 expand_one_stack_var (guard);
994 cfun->stack_protect_guard = guard;
997 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
998 expanding variables. Those variables that can be put into registers
999 are allocated pseudos; those that can't are put on the stack.
1001 TOPLEVEL is true if this is the outermost BLOCK. */
1003 static HOST_WIDE_INT
1004 account_used_vars_for_block (tree block, bool toplevel)
1006 size_t i, j, old_sv_num, this_sv_num, new_sv_num;
1008 HOST_WIDE_INT size = 0;
1010 old_sv_num = toplevel ? 0 : stack_vars_num;
1012 /* Expand all variables at this level. */
1013 for (t = BLOCK_VARS (block); t ; t = TREE_CHAIN (t))
1015 size += expand_one_var (t, toplevel, false);
1017 this_sv_num = stack_vars_num;
1019 /* Expand all variables at containing levels. */
1020 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
1021 size += account_used_vars_for_block (t, false);
1023 /* Since we do not track exact variable lifetimes (which is not even
1024 possible for variables whose address escapes), we mirror the block
1025 tree in the interference graph. Here we cause all variables at this
1026 level, and all sublevels, to conflict. Do make certain that a
1027 variable conflicts with itself. */
1028 if (old_sv_num < this_sv_num)
1030 new_sv_num = stack_vars_num;
1031 resize_stack_vars_conflict (new_sv_num);
1033 for (i = old_sv_num; i < new_sv_num; ++i)
1034 for (j = i < this_sv_num ? i+1 : this_sv_num; j-- > old_sv_num ;)
1035 add_stack_var_conflict (i, j);
1040 /* Prepare for expanding variables. */
1042 init_vars_expansion (void)
1045 /* Set TREE_USED on all variables in the unexpanded_var_list. */
1046 for (t = cfun->unexpanded_var_list; t; t = TREE_CHAIN (t))
1047 TREE_USED (TREE_VALUE (t)) = 1;
1049 /* Clear TREE_USED on all variables associated with a block scope. */
1050 clear_tree_used (DECL_INITIAL (current_function_decl));
1052 /* Initialize local stack smashing state. */
1053 has_protected_decls = false;
1054 has_short_buffer = false;
1057 /* Free up stack variable graph data. */
1059 fini_vars_expansion (void)
1061 XDELETEVEC (stack_vars);
1062 XDELETEVEC (stack_vars_sorted);
1063 XDELETEVEC (stack_vars_conflict);
1065 stack_vars_alloc = stack_vars_num = 0;
1066 stack_vars_conflict = NULL;
1067 stack_vars_conflict_alloc = 0;
1071 estimated_stack_frame_size (void)
1073 HOST_WIDE_INT size = 0;
1074 tree t, outer_block = DECL_INITIAL (current_function_decl);
1076 init_vars_expansion ();
1078 /* At this point all variables on the unexpanded_var_list with TREE_USED
1079 set are not associated with any block scope. Lay them out. */
1080 for (t = cfun->unexpanded_var_list; t; t = TREE_CHAIN (t))
1082 tree var = TREE_VALUE (t);
1084 if (TREE_USED (var))
1085 size += expand_one_var (var, true, false);
1086 TREE_USED (var) = 1;
1088 size += account_used_vars_for_block (outer_block, true);
1089 if (stack_vars_num > 0)
1091 /* Due to the way alias sets work, no variables with non-conflicting
1092 alias sets may be assigned the same address. Add conflicts to
1094 add_alias_set_conflicts ();
1096 /* If stack protection is enabled, we don't share space between
1097 vulnerable data and non-vulnerable data. */
1098 if (flag_stack_protect)
1099 add_stack_protection_conflicts ();
1101 /* Now that we have collected all stack variables, and have computed a
1102 minimal interference graph, attempt to save some stack space. */
1103 partition_stack_vars ();
1105 dump_stack_var_partition ();
1107 size += account_stack_vars ();
1108 fini_vars_expansion ();
1113 /* Expand all variables used in the function. */
1116 expand_used_vars (void)
1118 tree t, outer_block = DECL_INITIAL (current_function_decl);
1120 /* Compute the phase of the stack frame for this function. */
1122 int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
1123 int off = STARTING_FRAME_OFFSET % align;
1124 frame_phase = off ? align - off : 0;
1127 init_vars_expansion ();
1129 /* At this point all variables on the unexpanded_var_list with TREE_USED
1130 set are not associated with any block scope. Lay them out. */
1131 for (t = cfun->unexpanded_var_list; t; t = TREE_CHAIN (t))
1133 tree var = TREE_VALUE (t);
1134 bool expand_now = false;
1136 /* We didn't set a block for static or extern because it's hard
1137 to tell the difference between a global variable (re)declared
1138 in a local scope, and one that's really declared there to
1139 begin with. And it doesn't really matter much, since we're
1140 not giving them stack space. Expand them now. */
1141 if (TREE_STATIC (var) || DECL_EXTERNAL (var))
1144 /* Any variable that could have been hoisted into an SSA_NAME
1145 will have been propagated anywhere the optimizers chose,
1146 i.e. not confined to their original block. Allocate them
1147 as if they were defined in the outermost scope. */
1148 else if (is_gimple_reg (var))
1151 /* If the variable is not associated with any block, then it
1152 was created by the optimizers, and could be live anywhere
1154 else if (TREE_USED (var))
1157 /* Finally, mark all variables on the list as used. We'll use
1158 this in a moment when we expand those associated with scopes. */
1159 TREE_USED (var) = 1;
1162 expand_one_var (var, true, true);
1164 cfun->unexpanded_var_list = NULL_TREE;
1166 /* At this point, all variables within the block tree with TREE_USED
1167 set are actually used by the optimized function. Lay them out. */
1168 expand_used_vars_for_block (outer_block, true);
1170 if (stack_vars_num > 0)
1172 /* Due to the way alias sets work, no variables with non-conflicting
1173 alias sets may be assigned the same address. Add conflicts to
1175 add_alias_set_conflicts ();
1177 /* If stack protection is enabled, we don't share space between
1178 vulnerable data and non-vulnerable data. */
1179 if (flag_stack_protect)
1180 add_stack_protection_conflicts ();
1182 /* Now that we have collected all stack variables, and have computed a
1183 minimal interference graph, attempt to save some stack space. */
1184 partition_stack_vars ();
1186 dump_stack_var_partition ();
1189 /* There are several conditions under which we should create a
1190 stack guard: protect-all, alloca used, protected decls present. */
1191 if (flag_stack_protect == 2
1192 || (flag_stack_protect
1193 && (current_function_calls_alloca || has_protected_decls)))
1194 create_stack_guard ();
1196 /* Assign rtl to each variable based on these partitions. */
1197 if (stack_vars_num > 0)
1199 /* Reorder decls to be protected by iterating over the variables
1200 array multiple times, and allocating out of each phase in turn. */
1201 /* ??? We could probably integrate this into the qsort we did
1202 earlier, such that we naturally see these variables first,
1203 and thus naturally allocate things in the right order. */
1204 if (has_protected_decls)
1206 /* Phase 1 contains only character arrays. */
1207 expand_stack_vars (stack_protect_decl_phase_1);
1209 /* Phase 2 contains other kinds of arrays. */
1210 if (flag_stack_protect == 2)
1211 expand_stack_vars (stack_protect_decl_phase_2);
1214 expand_stack_vars (NULL);
1216 fini_vars_expansion ();
1219 /* If the target requires that FRAME_OFFSET be aligned, do it. */
1220 if (STACK_ALIGNMENT_NEEDED)
1222 HOST_WIDE_INT align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
1223 if (!FRAME_GROWS_DOWNWARD)
1224 frame_offset += align - 1;
1225 frame_offset &= -align;
1230 /* If we need to produce a detailed dump, print the tree representation
1231 for STMT to the dump file. SINCE is the last RTX after which the RTL
1232 generated for STMT should have been appended. */
1235 maybe_dump_rtl_for_tree_stmt (tree stmt, rtx since)
1237 if (dump_file && (dump_flags & TDF_DETAILS))
1239 fprintf (dump_file, "\n;; ");
1240 print_generic_expr (dump_file, stmt, TDF_SLIM);
1241 fprintf (dump_file, "\n");
1243 print_rtl (dump_file, since ? NEXT_INSN (since) : since);
1247 /* Maps the blocks that do not contain tree labels to rtx labels. */
1249 static struct pointer_map_t *lab_rtx_for_bb;
1251 /* Returns the label_rtx expression for a label starting basic block BB. */
1254 label_rtx_for_bb (basic_block bb)
1256 tree_stmt_iterator tsi;
1260 if (bb->flags & BB_RTL)
1261 return block_label (bb);
1263 elt = pointer_map_contains (lab_rtx_for_bb, bb);
1267 /* Find the tree label if it is present. */
1269 for (tsi = tsi_start (bb_stmt_list (bb)); !tsi_end_p (tsi); tsi_next (&tsi))
1271 lab_stmt = tsi_stmt (tsi);
1272 if (TREE_CODE (lab_stmt) != LABEL_EXPR)
1275 lab = LABEL_EXPR_LABEL (lab_stmt);
1276 if (DECL_NONLOCAL (lab))
1279 return label_rtx (lab);
1282 elt = pointer_map_insert (lab_rtx_for_bb, bb);
1283 *elt = gen_label_rtx ();
1287 /* A subroutine of expand_gimple_basic_block. Expand one COND_EXPR.
1288 Returns a new basic block if we've terminated the current basic
1289 block and created a new one. */
1292 expand_gimple_cond_expr (basic_block bb, tree stmt)
1294 basic_block new_bb, dest;
1298 tree pred = COND_EXPR_COND (stmt);
1301 gcc_assert (COND_EXPR_THEN (stmt) == NULL_TREE);
1302 gcc_assert (COND_EXPR_ELSE (stmt) == NULL_TREE);
1303 last2 = last = get_last_insn ();
1305 extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
1306 if (EXPR_LOCUS (stmt))
1308 set_curr_insn_source_location (*(EXPR_LOCUS (stmt)));
1309 set_curr_insn_block (TREE_BLOCK (stmt));
1312 /* These flags have no purpose in RTL land. */
1313 true_edge->flags &= ~EDGE_TRUE_VALUE;
1314 false_edge->flags &= ~EDGE_FALSE_VALUE;
1316 /* We can either have a pure conditional jump with one fallthru edge or
1317 two-way jump that needs to be decomposed into two basic blocks. */
1318 if (false_edge->dest == bb->next_bb)
1320 jumpif (pred, label_rtx_for_bb (true_edge->dest));
1321 add_reg_br_prob_note (last, true_edge->probability);
1322 maybe_dump_rtl_for_tree_stmt (stmt, last);
1323 if (true_edge->goto_locus)
1324 set_curr_insn_source_location (*true_edge->goto_locus);
1325 false_edge->flags |= EDGE_FALLTHRU;
1328 if (true_edge->dest == bb->next_bb)
1330 jumpifnot (pred, label_rtx_for_bb (false_edge->dest));
1331 add_reg_br_prob_note (last, false_edge->probability);
1332 maybe_dump_rtl_for_tree_stmt (stmt, last);
1333 if (false_edge->goto_locus)
1334 set_curr_insn_source_location (*false_edge->goto_locus);
1335 true_edge->flags |= EDGE_FALLTHRU;
1339 jumpif (pred, label_rtx_for_bb (true_edge->dest));
1340 add_reg_br_prob_note (last, true_edge->probability);
1341 last = get_last_insn ();
1342 emit_jump (label_rtx_for_bb (false_edge->dest));
1345 if (BARRIER_P (BB_END (bb)))
1346 BB_END (bb) = PREV_INSN (BB_END (bb));
1347 update_bb_for_insn (bb);
1349 new_bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
1350 dest = false_edge->dest;
1351 redirect_edge_succ (false_edge, new_bb);
1352 false_edge->flags |= EDGE_FALLTHRU;
1353 new_bb->count = false_edge->count;
1354 new_bb->frequency = EDGE_FREQUENCY (false_edge);
1355 new_edge = make_edge (new_bb, dest, 0);
1356 new_edge->probability = REG_BR_PROB_BASE;
1357 new_edge->count = new_bb->count;
1358 if (BARRIER_P (BB_END (new_bb)))
1359 BB_END (new_bb) = PREV_INSN (BB_END (new_bb));
1360 update_bb_for_insn (new_bb);
1362 maybe_dump_rtl_for_tree_stmt (stmt, last2);
1364 if (false_edge->goto_locus)
1365 set_curr_insn_source_location (*false_edge->goto_locus);
1370 /* A subroutine of expand_gimple_basic_block. Expand one CALL_EXPR
1371 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
1372 generated a tail call (something that might be denied by the ABI
1373 rules governing the call; see calls.c).
1375 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
1376 can still reach the rest of BB. The case here is __builtin_sqrt,
1377 where the NaN result goes through the external function (with a
1378 tailcall) and the normal result happens via a sqrt instruction. */
1381 expand_gimple_tailcall (basic_block bb, tree stmt, bool *can_fallthru)
1389 last2 = last = get_last_insn ();
1391 expand_expr_stmt (stmt);
1393 for (last = NEXT_INSN (last); last; last = NEXT_INSN (last))
1394 if (CALL_P (last) && SIBLING_CALL_P (last))
1397 maybe_dump_rtl_for_tree_stmt (stmt, last2);
1399 *can_fallthru = true;
1403 /* ??? Wouldn't it be better to just reset any pending stack adjust?
1404 Any instructions emitted here are about to be deleted. */
1405 do_pending_stack_adjust ();
1407 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
1408 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
1409 EH or abnormal edges, we shouldn't have created a tail call in
1410 the first place. So it seems to me we should just be removing
1411 all edges here, or redirecting the existing fallthru edge to
1417 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
1419 if (!(e->flags & (EDGE_ABNORMAL | EDGE_EH)))
1421 if (e->dest != EXIT_BLOCK_PTR)
1423 e->dest->count -= e->count;
1424 e->dest->frequency -= EDGE_FREQUENCY (e);
1425 if (e->dest->count < 0)
1427 if (e->dest->frequency < 0)
1428 e->dest->frequency = 0;
1431 probability += e->probability;
1438 /* This is somewhat ugly: the call_expr expander often emits instructions
1439 after the sibcall (to perform the function return). These confuse the
1440 find_many_sub_basic_blocks code, so we need to get rid of these. */
1441 last = NEXT_INSN (last);
1442 gcc_assert (BARRIER_P (last));
1444 *can_fallthru = false;
1445 while (NEXT_INSN (last))
1447 /* For instance an sqrt builtin expander expands if with
1448 sibcall in the then and label for `else`. */
1449 if (LABEL_P (NEXT_INSN (last)))
1451 *can_fallthru = true;
1454 delete_insn (NEXT_INSN (last));
1457 e = make_edge (bb, EXIT_BLOCK_PTR, EDGE_ABNORMAL | EDGE_SIBCALL);
1458 e->probability += probability;
1461 update_bb_for_insn (bb);
1463 if (NEXT_INSN (last))
1465 bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
1468 if (BARRIER_P (last))
1469 BB_END (bb) = PREV_INSN (last);
1472 maybe_dump_rtl_for_tree_stmt (stmt, last2);
1477 /* Expand basic block BB from GIMPLE trees to RTL. */
1480 expand_gimple_basic_block (basic_block bb)
1482 tree_stmt_iterator tsi;
1483 tree stmts = bb_stmt_list (bb);
1493 "\n;; Generating RTL for tree basic block %d\n",
1498 init_rtl_bb_info (bb);
1499 bb->flags |= BB_RTL;
1501 /* Remove the RETURN_EXPR if we may fall though to the exit
1503 tsi = tsi_last (stmts);
1504 if (!tsi_end_p (tsi)
1505 && TREE_CODE (tsi_stmt (tsi)) == RETURN_EXPR)
1507 tree ret_stmt = tsi_stmt (tsi);
1509 gcc_assert (single_succ_p (bb));
1510 gcc_assert (single_succ (bb) == EXIT_BLOCK_PTR);
1512 if (bb->next_bb == EXIT_BLOCK_PTR
1513 && !TREE_OPERAND (ret_stmt, 0))
1516 single_succ_edge (bb)->flags |= EDGE_FALLTHRU;
1520 tsi = tsi_start (stmts);
1521 if (!tsi_end_p (tsi))
1523 stmt = tsi_stmt (tsi);
1524 if (TREE_CODE (stmt) != LABEL_EXPR)
1528 elt = pointer_map_contains (lab_rtx_for_bb, bb);
1532 last = get_last_insn ();
1536 expand_expr_stmt (stmt);
1543 /* Java emits line number notes in the top of labels.
1544 ??? Make this go away once line number notes are obsoleted. */
1545 BB_HEAD (bb) = NEXT_INSN (last);
1546 if (NOTE_P (BB_HEAD (bb)))
1547 BB_HEAD (bb) = NEXT_INSN (BB_HEAD (bb));
1548 note = emit_note_after (NOTE_INSN_BASIC_BLOCK, BB_HEAD (bb));
1550 maybe_dump_rtl_for_tree_stmt (stmt, last);
1553 note = BB_HEAD (bb) = emit_note (NOTE_INSN_BASIC_BLOCK);
1555 NOTE_BASIC_BLOCK (note) = bb;
1557 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
1559 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
1560 e->flags &= ~EDGE_EXECUTABLE;
1562 /* At the moment not all abnormal edges match the RTL representation.
1563 It is safe to remove them here as find_many_sub_basic_blocks will
1564 rediscover them. In the future we should get this fixed properly. */
1565 if (e->flags & EDGE_ABNORMAL)
1571 for (; !tsi_end_p (tsi); tsi_next (&tsi))
1573 tree stmt = tsi_stmt (tsi);
1579 /* Expand this statement, then evaluate the resulting RTL and
1580 fixup the CFG accordingly. */
1581 if (TREE_CODE (stmt) == COND_EXPR)
1583 new_bb = expand_gimple_cond_expr (bb, stmt);
1589 tree call = get_call_expr_in (stmt);
1591 /* For the benefit of calls.c, converting all this to rtl,
1592 we need to record the call expression, not just the outer
1593 modify statement. */
1594 if (call && call != stmt)
1596 if ((region = lookup_stmt_eh_region (stmt)) > 0)
1597 add_stmt_to_eh_region (call, region);
1598 gimple_duplicate_stmt_histograms (cfun, call, cfun, stmt);
1600 if (call && CALL_EXPR_TAILCALL (call))
1603 new_bb = expand_gimple_tailcall (bb, stmt, &can_fallthru);
1614 last = get_last_insn ();
1615 expand_expr_stmt (stmt);
1616 maybe_dump_rtl_for_tree_stmt (stmt, last);
1621 /* Expand implicit goto. */
1622 FOR_EACH_EDGE (e, ei, bb->succs)
1624 if (e->flags & EDGE_FALLTHRU)
1628 if (e && e->dest != bb->next_bb)
1630 emit_jump (label_rtx_for_bb (e->dest));
1632 set_curr_insn_source_location (*e->goto_locus);
1633 e->flags &= ~EDGE_FALLTHRU;
1636 do_pending_stack_adjust ();
1638 /* Find the block tail. The last insn in the block is the insn
1639 before a barrier and/or table jump insn. */
1640 last = get_last_insn ();
1641 if (BARRIER_P (last))
1642 last = PREV_INSN (last);
1643 if (JUMP_TABLE_DATA_P (last))
1644 last = PREV_INSN (PREV_INSN (last));
1647 update_bb_for_insn (bb);
1653 /* Create a basic block for initialization code. */
1656 construct_init_block (void)
1658 basic_block init_block, first_block;
1662 /* Multiple entry points not supported yet. */
1663 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR->succs) == 1);
1664 init_rtl_bb_info (ENTRY_BLOCK_PTR);
1665 init_rtl_bb_info (EXIT_BLOCK_PTR);
1666 ENTRY_BLOCK_PTR->flags |= BB_RTL;
1667 EXIT_BLOCK_PTR->flags |= BB_RTL;
1669 e = EDGE_SUCC (ENTRY_BLOCK_PTR, 0);
1671 /* When entry edge points to first basic block, we don't need jump,
1672 otherwise we have to jump into proper target. */
1673 if (e && e->dest != ENTRY_BLOCK_PTR->next_bb)
1675 tree label = tree_block_label (e->dest);
1677 emit_jump (label_rtx (label));
1681 flags = EDGE_FALLTHRU;
1683 init_block = create_basic_block (NEXT_INSN (get_insns ()),
1686 init_block->frequency = ENTRY_BLOCK_PTR->frequency;
1687 init_block->count = ENTRY_BLOCK_PTR->count;
1690 first_block = e->dest;
1691 redirect_edge_succ (e, init_block);
1692 e = make_edge (init_block, first_block, flags);
1695 e = make_edge (init_block, EXIT_BLOCK_PTR, EDGE_FALLTHRU);
1696 e->probability = REG_BR_PROB_BASE;
1697 e->count = ENTRY_BLOCK_PTR->count;
1699 update_bb_for_insn (init_block);
1703 /* For each lexical block, set BLOCK_NUMBER to the depth at which it is
1704 found in the block tree. */
1707 set_block_levels (tree block, int level)
1711 BLOCK_NUMBER (block) = level;
1712 set_block_levels (BLOCK_SUBBLOCKS (block), level + 1);
1713 block = BLOCK_CHAIN (block);
1717 /* Create a block containing landing pads and similar stuff. */
1720 construct_exit_block (void)
1722 rtx head = get_last_insn ();
1724 basic_block exit_block;
1728 rtx orig_end = BB_END (EXIT_BLOCK_PTR->prev_bb);
1730 /* Make sure the locus is set to the end of the function, so that
1731 epilogue line numbers and warnings are set properly. */
1732 #ifdef USE_MAPPED_LOCATION
1733 if (cfun->function_end_locus != UNKNOWN_LOCATION)
1735 if (cfun->function_end_locus.file)
1737 input_location = cfun->function_end_locus;
1739 /* The following insns belong to the top scope. */
1740 set_curr_insn_block (DECL_INITIAL (current_function_decl));
1742 /* Generate rtl for function exit. */
1743 expand_function_end ();
1745 end = get_last_insn ();
1748 /* While emitting the function end we could move end of the last basic block.
1750 BB_END (EXIT_BLOCK_PTR->prev_bb) = orig_end;
1751 while (NEXT_INSN (head) && NOTE_P (NEXT_INSN (head)))
1752 head = NEXT_INSN (head);
1753 exit_block = create_basic_block (NEXT_INSN (head), end,
1754 EXIT_BLOCK_PTR->prev_bb);
1755 exit_block->frequency = EXIT_BLOCK_PTR->frequency;
1756 exit_block->count = EXIT_BLOCK_PTR->count;
1759 while (ix < EDGE_COUNT (EXIT_BLOCK_PTR->preds))
1761 e = EDGE_PRED (EXIT_BLOCK_PTR, ix);
1762 if (!(e->flags & EDGE_ABNORMAL))
1763 redirect_edge_succ (e, exit_block);
1768 e = make_edge (exit_block, EXIT_BLOCK_PTR, EDGE_FALLTHRU);
1769 e->probability = REG_BR_PROB_BASE;
1770 e->count = EXIT_BLOCK_PTR->count;
1771 FOR_EACH_EDGE (e2, ei, EXIT_BLOCK_PTR->preds)
1774 e->count -= e2->count;
1775 exit_block->count -= e2->count;
1776 exit_block->frequency -= EDGE_FREQUENCY (e2);
1780 if (exit_block->count < 0)
1781 exit_block->count = 0;
1782 if (exit_block->frequency < 0)
1783 exit_block->frequency = 0;
1784 update_bb_for_insn (exit_block);
1787 /* Helper function for discover_nonconstant_array_refs.
1788 Look for ARRAY_REF nodes with non-constant indexes and mark them
1792 discover_nonconstant_array_refs_r (tree * tp, int *walk_subtrees,
1793 void *data ATTRIBUTE_UNUSED)
1797 if (IS_TYPE_OR_DECL_P (t))
1799 else if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1801 while (((TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1802 && is_gimple_min_invariant (TREE_OPERAND (t, 1))
1803 && (!TREE_OPERAND (t, 2)
1804 || is_gimple_min_invariant (TREE_OPERAND (t, 2))))
1805 || (TREE_CODE (t) == COMPONENT_REF
1806 && (!TREE_OPERAND (t,2)
1807 || is_gimple_min_invariant (TREE_OPERAND (t, 2))))
1808 || TREE_CODE (t) == BIT_FIELD_REF
1809 || TREE_CODE (t) == REALPART_EXPR
1810 || TREE_CODE (t) == IMAGPART_EXPR
1811 || TREE_CODE (t) == VIEW_CONVERT_EXPR
1812 || TREE_CODE (t) == NOP_EXPR
1813 || TREE_CODE (t) == CONVERT_EXPR)
1814 t = TREE_OPERAND (t, 0);
1816 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1818 t = get_base_address (t);
1819 if (t && DECL_P (t))
1820 TREE_ADDRESSABLE (t) = 1;
1829 /* RTL expansion is not able to compile array references with variable
1830 offsets for arrays stored in single register. Discover such
1831 expressions and mark variables as addressable to avoid this
1835 discover_nonconstant_array_refs (void)
1838 block_stmt_iterator bsi;
1842 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
1843 walk_tree (bsi_stmt_ptr (bsi), discover_nonconstant_array_refs_r,
1848 /* Translate the intermediate representation contained in the CFG
1849 from GIMPLE trees to RTL.
1851 We do conversion per basic block and preserve/update the tree CFG.
1852 This implies we have to do some magic as the CFG can simultaneously
1853 consist of basic blocks containing RTL and GIMPLE trees. This can
1854 confuse the CFG hooks, so be careful to not manipulate CFG during
1858 tree_expand_cfg (void)
1860 basic_block bb, init_block;
1865 /* Some backends want to know that we are expanding to RTL. */
1866 currently_expanding_to_rtl = 1;
1868 insn_locators_alloc ();
1869 if (!DECL_BUILT_IN (current_function_decl))
1870 set_curr_insn_source_location (DECL_SOURCE_LOCATION (current_function_decl));
1871 set_curr_insn_block (DECL_INITIAL (current_function_decl));
1872 prologue_locator = curr_insn_locator ();
1874 /* Make sure first insn is a note even if we don't want linenums.
1875 This makes sure the first insn will never be deleted.
1876 Also, final expects a note to appear there. */
1877 emit_note (NOTE_INSN_DELETED);
1879 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
1880 discover_nonconstant_array_refs ();
1882 /* Expand the variables recorded during gimple lowering. */
1883 expand_used_vars ();
1885 /* Honor stack protection warnings. */
1886 if (warn_stack_protect)
1888 if (current_function_calls_alloca)
1889 warning (0, "not protecting local variables: variable length buffer");
1890 if (has_short_buffer && !cfun->stack_protect_guard)
1891 warning (0, "not protecting function: no buffer at least %d bytes long",
1892 (int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE));
1895 /* Set up parameters and prepare for return, for the function. */
1896 expand_function_start (current_function_decl);
1898 /* If this function is `main', emit a call to `__main'
1899 to run global initializers, etc. */
1900 if (DECL_NAME (current_function_decl)
1901 && MAIN_NAME_P (DECL_NAME (current_function_decl))
1902 && DECL_FILE_SCOPE_P (current_function_decl))
1903 expand_main_function ();
1905 /* Initialize the stack_protect_guard field. This must happen after the
1906 call to __main (if any) so that the external decl is initialized. */
1907 if (cfun->stack_protect_guard)
1908 stack_protect_prologue ();
1910 /* Register rtl specific functions for cfg. */
1911 rtl_register_cfg_hooks ();
1913 init_block = construct_init_block ();
1915 /* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
1916 remaining edges in expand_gimple_basic_block. */
1917 FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
1918 e->flags &= ~EDGE_EXECUTABLE;
1920 lab_rtx_for_bb = pointer_map_create ();
1921 FOR_BB_BETWEEN (bb, init_block->next_bb, EXIT_BLOCK_PTR, next_bb)
1922 bb = expand_gimple_basic_block (bb);
1923 pointer_map_destroy (lab_rtx_for_bb);
1925 construct_exit_block ();
1926 set_curr_insn_block (DECL_INITIAL (current_function_decl));
1927 insn_locators_finalize ();
1929 /* We're done expanding trees to RTL. */
1930 currently_expanding_to_rtl = 0;
1932 /* Convert tree EH labels to RTL EH labels, and clean out any unreachable
1934 convert_from_eh_region_ranges ();
1936 rebuild_jump_labels (get_insns ());
1937 find_exception_handler_labels ();
1939 blocks = sbitmap_alloc (last_basic_block);
1940 sbitmap_ones (blocks);
1941 find_many_sub_basic_blocks (blocks);
1942 purge_all_dead_edges ();
1943 sbitmap_free (blocks);
1946 #ifdef ENABLE_CHECKING
1947 verify_flow_info ();
1950 /* There's no need to defer outputting this function any more; we
1951 know we want to output it. */
1952 DECL_DEFER_OUTPUT (current_function_decl) = 0;
1954 /* Now that we're done expanding trees to RTL, we shouldn't have any
1955 more CONCATs anywhere. */
1956 generating_concat_p = 0;
1961 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
1962 /* And the pass manager will dump RTL for us. */
1965 /* If we're emitting a nested function, make sure its parent gets
1966 emitted as well. Doing otherwise confuses debug info. */
1969 for (parent = DECL_CONTEXT (current_function_decl);
1970 parent != NULL_TREE;
1971 parent = get_containing_scope (parent))
1972 if (TREE_CODE (parent) == FUNCTION_DECL)
1973 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent)) = 1;
1976 /* We are now committed to emitting code for this function. Do any
1977 preparation, such as emitting abstract debug info for the inline
1978 before it gets mangled by optimization. */
1979 if (cgraph_function_possibly_inlined_p (current_function_decl))
1980 (*debug_hooks->outlining_inline_function) (current_function_decl);
1982 TREE_ASM_WRITTEN (current_function_decl) = 1;
1984 /* After expanding, the return labels are no longer needed. */
1985 return_label = NULL;
1986 naked_return_label = NULL;
1988 /* Tag the blocks with a depth number so that change_scope can find
1989 the common parent easily. */
1990 set_block_levels (DECL_INITIAL (cfun->decl), 0);
1994 struct tree_opt_pass pass_expand =
1996 "expand", /* name */
1998 tree_expand_cfg, /* execute */
2001 0, /* static_pass_number */
2002 TV_EXPAND, /* tv_id */
2003 /* ??? If TER is enabled, we actually receive GENERIC. */
2004 PROP_gimple_leh | PROP_cfg, /* properties_required */
2005 PROP_rtl, /* properties_provided */
2006 PROP_trees, /* properties_destroyed */
2007 0, /* todo_flags_start */
2008 TODO_dump_func, /* todo_flags_finish */