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 3, 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 COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
27 #include "basic-block.h"
30 #include "langhooks.h"
31 #include "tree-flow.h"
33 #include "tree-dump.h"
34 #include "tree-pass.h"
37 #include "diagnostic.h"
41 #include "tree-inline.h"
42 #include "value-prof.h"
44 /* Verify that there is exactly single jump instruction since last and attach
45 REG_BR_PROB note specifying probability.
46 ??? We really ought to pass the probability down to RTL expanders and let it
47 re-distribute it when the conditional expands into multiple conditionals.
48 This is however difficult to do. */
50 add_reg_br_prob_note (rtx last, int probability)
52 if (profile_status == PROFILE_ABSENT)
54 for (last = NEXT_INSN (last); last && NEXT_INSN (last); last = NEXT_INSN (last))
57 /* It is common to emit condjump-around-jump sequence when we don't know
58 how to reverse the conditional. Special case this. */
59 if (!any_condjump_p (last)
60 || !JUMP_P (NEXT_INSN (last))
61 || !simplejump_p (NEXT_INSN (last))
62 || !NEXT_INSN (NEXT_INSN (last))
63 || !BARRIER_P (NEXT_INSN (NEXT_INSN (last)))
64 || !NEXT_INSN (NEXT_INSN (NEXT_INSN (last)))
65 || !LABEL_P (NEXT_INSN (NEXT_INSN (NEXT_INSN (last))))
66 || NEXT_INSN (NEXT_INSN (NEXT_INSN (NEXT_INSN (last)))))
68 gcc_assert (!find_reg_note (last, REG_BR_PROB, 0));
70 = gen_rtx_EXPR_LIST (REG_BR_PROB,
71 GEN_INT (REG_BR_PROB_BASE - probability),
75 if (!last || !JUMP_P (last) || !any_condjump_p (last))
77 gcc_assert (!find_reg_note (last, REG_BR_PROB, 0));
79 = gen_rtx_EXPR_LIST (REG_BR_PROB,
80 GEN_INT (probability), REG_NOTES (last));
84 fprintf (dump_file, "Failed to add probability note\n");
88 #ifndef LOCAL_ALIGNMENT
89 #define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT
92 #ifndef STACK_ALIGNMENT_NEEDED
93 #define STACK_ALIGNMENT_NEEDED 1
97 /* This structure holds data relevant to one variable that will be
98 placed in a stack slot. */
104 /* The offset of the variable. During partitioning, this is the
105 offset relative to the partition. After partitioning, this
106 is relative to the stack frame. */
107 HOST_WIDE_INT offset;
109 /* Initially, the size of the variable. Later, the size of the partition,
110 if this variable becomes it's partition's representative. */
113 /* The *byte* alignment required for this variable. Or as, with the
114 size, the alignment for this partition. */
117 /* The partition representative. */
118 size_t representative;
120 /* The next stack variable in the partition, or EOC. */
124 #define EOC ((size_t)-1)
126 /* We have an array of such objects while deciding allocation. */
127 static struct stack_var *stack_vars;
128 static size_t stack_vars_alloc;
129 static size_t stack_vars_num;
131 /* An array of indicies such that stack_vars[stack_vars_sorted[i]].size
132 is non-decreasing. */
133 static size_t *stack_vars_sorted;
135 /* We have an interference graph between such objects. This graph
136 is lower triangular. */
137 static bool *stack_vars_conflict;
138 static size_t stack_vars_conflict_alloc;
140 /* The phase of the stack frame. This is the known misalignment of
141 virtual_stack_vars_rtx from PREFERRED_STACK_BOUNDARY. That is,
142 (frame_offset+frame_phase) % PREFERRED_STACK_BOUNDARY == 0. */
143 static int frame_phase;
145 /* Used during expand_used_vars to remember if we saw any decls for
146 which we'd like to enable stack smashing protection. */
147 static bool has_protected_decls;
149 /* Used during expand_used_vars. Remember if we say a character buffer
150 smaller than our cutoff threshold. Used for -Wstack-protector. */
151 static bool has_short_buffer;
153 /* Discover the byte alignment to use for DECL. Ignore alignment
154 we can't do with expected alignment of the stack boundary. */
157 get_decl_align_unit (tree decl)
161 align = DECL_ALIGN (decl);
162 align = LOCAL_ALIGNMENT (TREE_TYPE (decl), align);
163 if (align > PREFERRED_STACK_BOUNDARY)
164 align = PREFERRED_STACK_BOUNDARY;
165 if (cfun->stack_alignment_needed < align)
166 cfun->stack_alignment_needed = align;
168 return align / BITS_PER_UNIT;
171 /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
172 Return the frame offset. */
175 alloc_stack_frame_space (HOST_WIDE_INT size, HOST_WIDE_INT align)
177 HOST_WIDE_INT offset, new_frame_offset;
179 new_frame_offset = frame_offset;
180 if (FRAME_GROWS_DOWNWARD)
182 new_frame_offset -= size + frame_phase;
183 new_frame_offset &= -align;
184 new_frame_offset += frame_phase;
185 offset = new_frame_offset;
189 new_frame_offset -= frame_phase;
190 new_frame_offset += align - 1;
191 new_frame_offset &= -align;
192 new_frame_offset += frame_phase;
193 offset = new_frame_offset;
194 new_frame_offset += size;
196 frame_offset = new_frame_offset;
198 if (frame_offset_overflow (frame_offset, cfun->decl))
199 frame_offset = offset = 0;
204 /* Accumulate DECL into STACK_VARS. */
207 add_stack_var (tree decl)
209 if (stack_vars_num >= stack_vars_alloc)
211 if (stack_vars_alloc)
212 stack_vars_alloc = stack_vars_alloc * 3 / 2;
214 stack_vars_alloc = 32;
216 = XRESIZEVEC (struct stack_var, stack_vars, stack_vars_alloc);
218 stack_vars[stack_vars_num].decl = decl;
219 stack_vars[stack_vars_num].offset = 0;
220 stack_vars[stack_vars_num].size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
221 stack_vars[stack_vars_num].alignb = get_decl_align_unit (decl);
223 /* All variables are initially in their own partition. */
224 stack_vars[stack_vars_num].representative = stack_vars_num;
225 stack_vars[stack_vars_num].next = EOC;
227 /* Ensure that this decl doesn't get put onto the list twice. */
228 SET_DECL_RTL (decl, pc_rtx);
233 /* Compute the linear index of a lower-triangular coordinate (I, J). */
236 triangular_index (size_t i, size_t j)
243 return (i * (i + 1)) / 2 + j;
246 /* Ensure that STACK_VARS_CONFLICT is large enough for N objects. */
249 resize_stack_vars_conflict (size_t n)
251 size_t size = triangular_index (n-1, n-1) + 1;
253 if (size <= stack_vars_conflict_alloc)
256 stack_vars_conflict = XRESIZEVEC (bool, stack_vars_conflict, size);
257 memset (stack_vars_conflict + stack_vars_conflict_alloc, 0,
258 (size - stack_vars_conflict_alloc) * sizeof (bool));
259 stack_vars_conflict_alloc = size;
262 /* Make the decls associated with luid's X and Y conflict. */
265 add_stack_var_conflict (size_t x, size_t y)
267 size_t index = triangular_index (x, y);
268 gcc_assert (index < stack_vars_conflict_alloc);
269 stack_vars_conflict[index] = true;
272 /* Check whether the decls associated with luid's X and Y conflict. */
275 stack_var_conflict_p (size_t x, size_t y)
277 size_t index = triangular_index (x, y);
278 gcc_assert (index < stack_vars_conflict_alloc);
279 return stack_vars_conflict[index];
282 /* Returns true if TYPE is or contains a union type. */
285 aggregate_contains_union_type (tree type)
289 if (TREE_CODE (type) == UNION_TYPE
290 || TREE_CODE (type) == QUAL_UNION_TYPE)
292 if (TREE_CODE (type) == ARRAY_TYPE)
293 return aggregate_contains_union_type (TREE_TYPE (type));
294 if (TREE_CODE (type) != RECORD_TYPE)
297 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
298 if (TREE_CODE (field) == FIELD_DECL)
299 if (aggregate_contains_union_type (TREE_TYPE (field)))
305 /* A subroutine of expand_used_vars. If two variables X and Y have alias
306 sets that do not conflict, then do add a conflict for these variables
307 in the interference graph. We also need to make sure to add conflicts
308 for union containing structures. Else RTL alias analysis comes along
309 and due to type based aliasing rules decides that for two overlapping
310 union temporaries { short s; int i; } accesses to the same mem through
311 different types may not alias and happily reorders stores across
312 life-time boundaries of the temporaries (See PR25654).
313 We also have to mind MEM_IN_STRUCT_P and MEM_SCALAR_P. */
316 add_alias_set_conflicts (void)
318 size_t i, j, n = stack_vars_num;
320 for (i = 0; i < n; ++i)
322 tree type_i = TREE_TYPE (stack_vars[i].decl);
323 bool aggr_i = AGGREGATE_TYPE_P (type_i);
326 contains_union = aggregate_contains_union_type (type_i);
327 for (j = 0; j < i; ++j)
329 tree type_j = TREE_TYPE (stack_vars[j].decl);
330 bool aggr_j = AGGREGATE_TYPE_P (type_j);
332 /* Either the objects conflict by means of type based
333 aliasing rules, or we need to add a conflict. */
334 || !objects_must_conflict_p (type_i, type_j)
335 /* In case the types do not conflict ensure that access
336 to elements will conflict. In case of unions we have
337 to be careful as type based aliasing rules may say
338 access to the same memory does not conflict. So play
339 safe and add a conflict in this case. */
341 add_stack_var_conflict (i, j);
346 /* A subroutine of partition_stack_vars. A comparison function for qsort,
347 sorting an array of indicies by the size of the object. */
350 stack_var_size_cmp (const void *a, const void *b)
352 HOST_WIDE_INT sa = stack_vars[*(const size_t *)a].size;
353 HOST_WIDE_INT sb = stack_vars[*(const size_t *)b].size;
354 unsigned int uida = DECL_UID (stack_vars[*(const size_t *)a].decl);
355 unsigned int uidb = DECL_UID (stack_vars[*(const size_t *)b].decl);
361 /* For stack variables of the same size use the uid of the decl
362 to make the sort stable. */
370 /* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
371 partitioning algorithm. Partitions A and B are known to be non-conflicting.
372 Merge them into a single partition A.
374 At the same time, add OFFSET to all variables in partition B. At the end
375 of the partitioning process we've have a nice block easy to lay out within
379 union_stack_vars (size_t a, size_t b, HOST_WIDE_INT offset)
383 /* Update each element of partition B with the given offset,
384 and merge them into partition A. */
385 for (last = i = b; i != EOC; last = i, i = stack_vars[i].next)
387 stack_vars[i].offset += offset;
388 stack_vars[i].representative = a;
390 stack_vars[last].next = stack_vars[a].next;
391 stack_vars[a].next = b;
393 /* Update the required alignment of partition A to account for B. */
394 if (stack_vars[a].alignb < stack_vars[b].alignb)
395 stack_vars[a].alignb = stack_vars[b].alignb;
397 /* Update the interference graph and merge the conflicts. */
398 for (last = stack_vars_num, i = 0; i < last; ++i)
399 if (stack_var_conflict_p (b, i))
400 add_stack_var_conflict (a, i);
403 /* A subroutine of expand_used_vars. Binpack the variables into
404 partitions constrained by the interference graph. The overall
405 algorithm used is as follows:
407 Sort the objects by size.
412 Look for the largest non-conflicting object B with size <= S.
422 partition_stack_vars (void)
424 size_t si, sj, n = stack_vars_num;
426 stack_vars_sorted = XNEWVEC (size_t, stack_vars_num);
427 for (si = 0; si < n; ++si)
428 stack_vars_sorted[si] = si;
433 qsort (stack_vars_sorted, n, sizeof (size_t), stack_var_size_cmp);
435 /* Special case: detect when all variables conflict, and thus we can't
436 do anything during the partitioning loop. It isn't uncommon (with
437 C code at least) to declare all variables at the top of the function,
438 and if we're not inlining, then all variables will be in the same scope.
439 Take advantage of very fast libc routines for this scan. */
440 gcc_assert (sizeof(bool) == sizeof(char));
441 if (memchr (stack_vars_conflict, false, stack_vars_conflict_alloc) == NULL)
444 for (si = 0; si < n; ++si)
446 size_t i = stack_vars_sorted[si];
447 HOST_WIDE_INT isize = stack_vars[i].size;
448 HOST_WIDE_INT offset = 0;
450 for (sj = si; sj-- > 0; )
452 size_t j = stack_vars_sorted[sj];
453 HOST_WIDE_INT jsize = stack_vars[j].size;
454 unsigned int jalign = stack_vars[j].alignb;
456 /* Ignore objects that aren't partition representatives. */
457 if (stack_vars[j].representative != j)
460 /* Ignore objects too large for the remaining space. */
464 /* Ignore conflicting objects. */
465 if (stack_var_conflict_p (i, j))
468 /* Refine the remaining space check to include alignment. */
469 if (offset & (jalign - 1))
471 HOST_WIDE_INT toff = offset;
473 toff &= -(HOST_WIDE_INT)jalign;
474 if (isize - (toff - offset) < jsize)
477 isize -= toff - offset;
481 /* UNION the objects, placing J at OFFSET. */
482 union_stack_vars (i, j, offset);
491 /* A debugging aid for expand_used_vars. Dump the generated partitions. */
494 dump_stack_var_partition (void)
496 size_t si, i, j, n = stack_vars_num;
498 for (si = 0; si < n; ++si)
500 i = stack_vars_sorted[si];
502 /* Skip variables that aren't partition representatives, for now. */
503 if (stack_vars[i].representative != i)
506 fprintf (dump_file, "Partition %lu: size " HOST_WIDE_INT_PRINT_DEC
507 " align %u\n", (unsigned long) i, stack_vars[i].size,
508 stack_vars[i].alignb);
510 for (j = i; j != EOC; j = stack_vars[j].next)
512 fputc ('\t', dump_file);
513 print_generic_expr (dump_file, stack_vars[j].decl, dump_flags);
514 fprintf (dump_file, ", offset " HOST_WIDE_INT_PRINT_DEC "\n",
515 stack_vars[j].offset);
520 /* Assign rtl to DECL at frame offset OFFSET. */
523 expand_one_stack_var_at (tree decl, HOST_WIDE_INT offset)
528 /* If this fails, we've overflowed the stack frame. Error nicely? */
529 gcc_assert (offset == trunc_int_for_mode (offset, Pmode));
531 x = plus_constant (virtual_stack_vars_rtx, offset);
532 x = gen_rtx_MEM (DECL_MODE (decl), x);
534 /* Set alignment we actually gave this decl. */
535 offset -= frame_phase;
536 align = offset & -offset;
537 align *= BITS_PER_UNIT;
538 if (align > STACK_BOUNDARY || align == 0)
539 align = STACK_BOUNDARY;
540 DECL_ALIGN (decl) = align;
541 DECL_USER_ALIGN (decl) = 0;
543 set_mem_attributes (x, decl, true);
544 SET_DECL_RTL (decl, x);
547 /* A subroutine of expand_used_vars. Give each partition representative
548 a unique location within the stack frame. Update each partition member
549 with that location. */
552 expand_stack_vars (bool (*pred) (tree))
554 size_t si, i, j, n = stack_vars_num;
556 for (si = 0; si < n; ++si)
558 HOST_WIDE_INT offset;
560 i = stack_vars_sorted[si];
562 /* Skip variables that aren't partition representatives, for now. */
563 if (stack_vars[i].representative != i)
566 /* Skip variables that have already had rtl assigned. See also
567 add_stack_var where we perpetrate this pc_rtx hack. */
568 if (DECL_RTL (stack_vars[i].decl) != pc_rtx)
571 /* Check the predicate to see whether this variable should be
572 allocated in this pass. */
573 if (pred && !pred (stack_vars[i].decl))
576 offset = alloc_stack_frame_space (stack_vars[i].size,
577 stack_vars[i].alignb);
579 /* Create rtl for each variable based on their location within the
581 for (j = i; j != EOC; j = stack_vars[j].next)
582 expand_one_stack_var_at (stack_vars[j].decl,
583 stack_vars[j].offset + offset);
587 /* Take into account all sizes of partitions and reset DECL_RTLs. */
589 account_stack_vars (void)
591 size_t si, j, i, n = stack_vars_num;
592 HOST_WIDE_INT size = 0;
594 for (si = 0; si < n; ++si)
596 i = stack_vars_sorted[si];
598 /* Skip variables that aren't partition representatives, for now. */
599 if (stack_vars[i].representative != i)
602 size += stack_vars[i].size;
603 for (j = i; j != EOC; j = stack_vars[j].next)
604 SET_DECL_RTL (stack_vars[j].decl, NULL);
609 /* A subroutine of expand_one_var. Called to immediately assign rtl
610 to a variable to be allocated in the stack frame. */
613 expand_one_stack_var (tree var)
615 HOST_WIDE_INT size, offset, align;
617 size = tree_low_cst (DECL_SIZE_UNIT (var), 1);
618 align = get_decl_align_unit (var);
619 offset = alloc_stack_frame_space (size, align);
621 expand_one_stack_var_at (var, offset);
624 /* A subroutine of expand_one_var. Called to assign rtl
625 to a TREE_STATIC VAR_DECL. */
628 expand_one_static_var (tree var)
630 /* In unit-at-a-time all the static variables are expanded at the end
631 of compilation process. */
632 if (flag_unit_at_a_time)
634 /* If this is an inlined copy of a static local variable,
635 look up the original. */
636 var = DECL_ORIGIN (var);
638 /* If we've already processed this variable because of that, do nothing. */
639 if (TREE_ASM_WRITTEN (var))
642 /* Give the front end a chance to do whatever. In practice, this is
643 resolving duplicate names for IMA in C. */
644 if (lang_hooks.expand_decl (var))
647 /* Otherwise, just emit the variable. */
648 rest_of_decl_compilation (var, 0, 0);
651 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
652 that will reside in a hard register. */
655 expand_one_hard_reg_var (tree var)
657 rest_of_decl_compilation (var, 0, 0);
660 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
661 that will reside in a pseudo register. */
664 expand_one_register_var (tree var)
666 tree type = TREE_TYPE (var);
667 int unsignedp = TYPE_UNSIGNED (type);
668 enum machine_mode reg_mode
669 = promote_mode (type, DECL_MODE (var), &unsignedp, 0);
670 rtx x = gen_reg_rtx (reg_mode);
672 SET_DECL_RTL (var, x);
674 /* Note if the object is a user variable. */
675 if (!DECL_ARTIFICIAL (var))
678 if (POINTER_TYPE_P (type))
679 mark_reg_pointer (x, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (var))));
682 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
683 has some associated error, e.g. its type is error-mark. We just need
684 to pick something that won't crash the rest of the compiler. */
687 expand_one_error_var (tree var)
689 enum machine_mode mode = DECL_MODE (var);
693 x = gen_rtx_MEM (BLKmode, const0_rtx);
694 else if (mode == VOIDmode)
697 x = gen_reg_rtx (mode);
699 SET_DECL_RTL (var, x);
702 /* A subroutine of expand_one_var. VAR is a variable that will be
703 allocated to the local stack frame. Return true if we wish to
704 add VAR to STACK_VARS so that it will be coalesced with other
705 variables. Return false to allocate VAR immediately.
707 This function is used to reduce the number of variables considered
708 for coalescing, which reduces the size of the quadratic problem. */
711 defer_stack_allocation (tree var, bool toplevel)
713 /* If stack protection is enabled, *all* stack variables must be deferred,
714 so that we can re-order the strings to the top of the frame. */
715 if (flag_stack_protect)
718 /* Variables in the outermost scope automatically conflict with
719 every other variable. The only reason to want to defer them
720 at all is that, after sorting, we can more efficiently pack
721 small variables in the stack frame. Continue to defer at -O2. */
722 if (toplevel && optimize < 2)
725 /* Without optimization, *most* variables are allocated from the
726 stack, which makes the quadratic problem large exactly when we
727 want compilation to proceed as quickly as possible. On the
728 other hand, we don't want the function's stack frame size to
729 get completely out of hand. So we avoid adding scalars and
730 "small" aggregates to the list at all. */
731 if (optimize == 0 && tree_low_cst (DECL_SIZE_UNIT (var), 1) < 32)
737 /* A subroutine of expand_used_vars. Expand one variable according to
738 its flavor. Variables to be placed on the stack are not actually
739 expanded yet, merely recorded.
740 When REALLY_EXPAND is false, only add stack values to be allocated.
741 Return stack usage this variable is supposed to take.
745 expand_one_var (tree var, bool toplevel, bool really_expand)
747 if (TREE_CODE (var) != VAR_DECL)
750 lang_hooks.expand_decl (var);
752 else if (DECL_EXTERNAL (var))
754 else if (DECL_HAS_VALUE_EXPR_P (var))
756 else if (TREE_STATIC (var))
759 expand_one_static_var (var);
761 else if (DECL_RTL_SET_P (var))
763 else if (TREE_TYPE (var) == error_mark_node)
766 expand_one_error_var (var);
768 else if (DECL_HARD_REGISTER (var))
771 expand_one_hard_reg_var (var);
773 else if (use_register_for_decl (var))
776 expand_one_register_var (var);
778 else if (defer_stack_allocation (var, toplevel))
783 expand_one_stack_var (var);
784 return tree_low_cst (DECL_SIZE_UNIT (var), 1);
789 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
790 expanding variables. Those variables that can be put into registers
791 are allocated pseudos; those that can't are put on the stack.
793 TOPLEVEL is true if this is the outermost BLOCK. */
796 expand_used_vars_for_block (tree block, bool toplevel)
798 size_t i, j, old_sv_num, this_sv_num, new_sv_num;
801 old_sv_num = toplevel ? 0 : stack_vars_num;
803 /* Expand all variables at this level. */
804 for (t = BLOCK_VARS (block); t ; t = TREE_CHAIN (t))
806 /* Force local static variables to be output when marked by
807 used attribute. For unit-at-a-time, cgraph code already takes
809 || (!flag_unit_at_a_time && TREE_STATIC (t)
810 && DECL_PRESERVE_P (t)))
811 expand_one_var (t, toplevel, true);
813 this_sv_num = stack_vars_num;
815 /* Expand all variables at containing levels. */
816 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
817 expand_used_vars_for_block (t, false);
819 /* Since we do not track exact variable lifetimes (which is not even
820 possible for variables whose address escapes), we mirror the block
821 tree in the interference graph. Here we cause all variables at this
822 level, and all sublevels, to conflict. Do make certain that a
823 variable conflicts with itself. */
824 if (old_sv_num < this_sv_num)
826 new_sv_num = stack_vars_num;
827 resize_stack_vars_conflict (new_sv_num);
829 for (i = old_sv_num; i < new_sv_num; ++i)
830 for (j = i < this_sv_num ? i+1 : this_sv_num; j-- > old_sv_num ;)
831 add_stack_var_conflict (i, j);
835 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
836 and clear TREE_USED on all local variables. */
839 clear_tree_used (tree block)
843 for (t = BLOCK_VARS (block); t ; t = TREE_CHAIN (t))
844 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
847 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
851 /* Examine TYPE and determine a bit mask of the following features. */
853 #define SPCT_HAS_LARGE_CHAR_ARRAY 1
854 #define SPCT_HAS_SMALL_CHAR_ARRAY 2
855 #define SPCT_HAS_ARRAY 4
856 #define SPCT_HAS_AGGREGATE 8
859 stack_protect_classify_type (tree type)
861 unsigned int ret = 0;
864 switch (TREE_CODE (type))
867 t = TYPE_MAIN_VARIANT (TREE_TYPE (type));
868 if (t == char_type_node
869 || t == signed_char_type_node
870 || t == unsigned_char_type_node)
872 unsigned HOST_WIDE_INT max = PARAM_VALUE (PARAM_SSP_BUFFER_SIZE);
873 unsigned HOST_WIDE_INT len;
875 if (!TYPE_SIZE_UNIT (type)
876 || !host_integerp (TYPE_SIZE_UNIT (type), 1))
879 len = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
882 ret = SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_ARRAY;
884 ret = SPCT_HAS_LARGE_CHAR_ARRAY | SPCT_HAS_ARRAY;
887 ret = SPCT_HAS_ARRAY;
891 case QUAL_UNION_TYPE:
893 ret = SPCT_HAS_AGGREGATE;
894 for (t = TYPE_FIELDS (type); t ; t = TREE_CHAIN (t))
895 if (TREE_CODE (t) == FIELD_DECL)
896 ret |= stack_protect_classify_type (TREE_TYPE (t));
906 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
907 part of the local stack frame. Remember if we ever return nonzero for
908 any variable in this function. The return value is the phase number in
909 which the variable should be allocated. */
912 stack_protect_decl_phase (tree decl)
914 unsigned int bits = stack_protect_classify_type (TREE_TYPE (decl));
917 if (bits & SPCT_HAS_SMALL_CHAR_ARRAY)
918 has_short_buffer = true;
920 if (flag_stack_protect == 2)
922 if ((bits & (SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_LARGE_CHAR_ARRAY))
923 && !(bits & SPCT_HAS_AGGREGATE))
925 else if (bits & SPCT_HAS_ARRAY)
929 ret = (bits & SPCT_HAS_LARGE_CHAR_ARRAY) != 0;
932 has_protected_decls = true;
937 /* Two helper routines that check for phase 1 and phase 2. These are used
938 as callbacks for expand_stack_vars. */
941 stack_protect_decl_phase_1 (tree decl)
943 return stack_protect_decl_phase (decl) == 1;
947 stack_protect_decl_phase_2 (tree decl)
949 return stack_protect_decl_phase (decl) == 2;
952 /* Ensure that variables in different stack protection phases conflict
953 so that they are not merged and share the same stack slot. */
956 add_stack_protection_conflicts (void)
958 size_t i, j, n = stack_vars_num;
959 unsigned char *phase;
961 phase = XNEWVEC (unsigned char, n);
962 for (i = 0; i < n; ++i)
963 phase[i] = stack_protect_decl_phase (stack_vars[i].decl);
965 for (i = 0; i < n; ++i)
967 unsigned char ph_i = phase[i];
968 for (j = 0; j < i; ++j)
969 if (ph_i != phase[j])
970 add_stack_var_conflict (i, j);
976 /* Create a decl for the guard at the top of the stack frame. */
979 create_stack_guard (void)
981 tree guard = build_decl (VAR_DECL, NULL, ptr_type_node);
982 TREE_THIS_VOLATILE (guard) = 1;
983 TREE_USED (guard) = 1;
984 expand_one_stack_var (guard);
985 cfun->stack_protect_guard = guard;
988 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
989 expanding variables. Those variables that can be put into registers
990 are allocated pseudos; those that can't are put on the stack.
992 TOPLEVEL is true if this is the outermost BLOCK. */
995 account_used_vars_for_block (tree block, bool toplevel)
997 size_t i, j, old_sv_num, this_sv_num, new_sv_num;
999 HOST_WIDE_INT size = 0;
1001 old_sv_num = toplevel ? 0 : stack_vars_num;
1003 /* Expand all variables at this level. */
1004 for (t = BLOCK_VARS (block); t ; t = TREE_CHAIN (t))
1006 size += expand_one_var (t, toplevel, false);
1008 this_sv_num = stack_vars_num;
1010 /* Expand all variables at containing levels. */
1011 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
1012 size += account_used_vars_for_block (t, false);
1014 /* Since we do not track exact variable lifetimes (which is not even
1015 possible for variables whose address escapes), we mirror the block
1016 tree in the interference graph. Here we cause all variables at this
1017 level, and all sublevels, to conflict. Do make certain that a
1018 variable conflicts with itself. */
1019 if (old_sv_num < this_sv_num)
1021 new_sv_num = stack_vars_num;
1022 resize_stack_vars_conflict (new_sv_num);
1024 for (i = old_sv_num; i < new_sv_num; ++i)
1025 for (j = i < this_sv_num ? i+1 : this_sv_num; j-- > old_sv_num ;)
1026 add_stack_var_conflict (i, j);
1031 /* Prepare for expanding variables. */
1033 init_vars_expansion (void)
1036 /* Set TREE_USED on all variables in the unexpanded_var_list. */
1037 for (t = cfun->unexpanded_var_list; t; t = TREE_CHAIN (t))
1038 TREE_USED (TREE_VALUE (t)) = 1;
1040 /* Clear TREE_USED on all variables associated with a block scope. */
1041 clear_tree_used (DECL_INITIAL (current_function_decl));
1043 /* Initialize local stack smashing state. */
1044 has_protected_decls = false;
1045 has_short_buffer = false;
1048 /* Free up stack variable graph data. */
1050 fini_vars_expansion (void)
1052 XDELETEVEC (stack_vars);
1053 XDELETEVEC (stack_vars_sorted);
1054 XDELETEVEC (stack_vars_conflict);
1056 stack_vars_alloc = stack_vars_num = 0;
1057 stack_vars_conflict = NULL;
1058 stack_vars_conflict_alloc = 0;
1062 estimated_stack_frame_size (void)
1064 HOST_WIDE_INT size = 0;
1065 tree t, outer_block = DECL_INITIAL (current_function_decl);
1067 init_vars_expansion ();
1069 /* At this point all variables on the unexpanded_var_list with TREE_USED
1070 set are not associated with any block scope. Lay them out. */
1071 for (t = cfun->unexpanded_var_list; t; t = TREE_CHAIN (t))
1073 tree var = TREE_VALUE (t);
1075 if (TREE_USED (var))
1076 size += expand_one_var (var, true, false);
1077 TREE_USED (var) = 1;
1079 size += account_used_vars_for_block (outer_block, true);
1080 if (stack_vars_num > 0)
1082 /* Due to the way alias sets work, no variables with non-conflicting
1083 alias sets may be assigned the same address. Add conflicts to
1085 add_alias_set_conflicts ();
1087 /* If stack protection is enabled, we don't share space between
1088 vulnerable data and non-vulnerable data. */
1089 if (flag_stack_protect)
1090 add_stack_protection_conflicts ();
1092 /* Now that we have collected all stack variables, and have computed a
1093 minimal interference graph, attempt to save some stack space. */
1094 partition_stack_vars ();
1096 dump_stack_var_partition ();
1098 size += account_stack_vars ();
1099 fini_vars_expansion ();
1104 /* Expand all variables used in the function. */
1107 expand_used_vars (void)
1109 tree t, outer_block = DECL_INITIAL (current_function_decl);
1111 /* Compute the phase of the stack frame for this function. */
1113 int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
1114 int off = STARTING_FRAME_OFFSET % align;
1115 frame_phase = off ? align - off : 0;
1118 init_vars_expansion ();
1120 /* At this point all variables on the unexpanded_var_list with TREE_USED
1121 set are not associated with any block scope. Lay them out. */
1122 for (t = cfun->unexpanded_var_list; t; t = TREE_CHAIN (t))
1124 tree var = TREE_VALUE (t);
1125 bool expand_now = false;
1127 /* We didn't set a block for static or extern because it's hard
1128 to tell the difference between a global variable (re)declared
1129 in a local scope, and one that's really declared there to
1130 begin with. And it doesn't really matter much, since we're
1131 not giving them stack space. Expand them now. */
1132 if (TREE_STATIC (var) || DECL_EXTERNAL (var))
1135 /* Any variable that could have been hoisted into an SSA_NAME
1136 will have been propagated anywhere the optimizers chose,
1137 i.e. not confined to their original block. Allocate them
1138 as if they were defined in the outermost scope. */
1139 else if (is_gimple_reg (var))
1142 /* If the variable is not associated with any block, then it
1143 was created by the optimizers, and could be live anywhere
1145 else if (TREE_USED (var))
1148 /* Finally, mark all variables on the list as used. We'll use
1149 this in a moment when we expand those associated with scopes. */
1150 TREE_USED (var) = 1;
1153 expand_one_var (var, true, true);
1155 cfun->unexpanded_var_list = NULL_TREE;
1157 /* At this point, all variables within the block tree with TREE_USED
1158 set are actually used by the optimized function. Lay them out. */
1159 expand_used_vars_for_block (outer_block, true);
1161 if (stack_vars_num > 0)
1163 /* Due to the way alias sets work, no variables with non-conflicting
1164 alias sets may be assigned the same address. Add conflicts to
1166 add_alias_set_conflicts ();
1168 /* If stack protection is enabled, we don't share space between
1169 vulnerable data and non-vulnerable data. */
1170 if (flag_stack_protect)
1171 add_stack_protection_conflicts ();
1173 /* Now that we have collected all stack variables, and have computed a
1174 minimal interference graph, attempt to save some stack space. */
1175 partition_stack_vars ();
1177 dump_stack_var_partition ();
1180 /* There are several conditions under which we should create a
1181 stack guard: protect-all, alloca used, protected decls present. */
1182 if (flag_stack_protect == 2
1183 || (flag_stack_protect
1184 && (current_function_calls_alloca || has_protected_decls)))
1185 create_stack_guard ();
1187 /* Assign rtl to each variable based on these partitions. */
1188 if (stack_vars_num > 0)
1190 /* Reorder decls to be protected by iterating over the variables
1191 array multiple times, and allocating out of each phase in turn. */
1192 /* ??? We could probably integrate this into the qsort we did
1193 earlier, such that we naturally see these variables first,
1194 and thus naturally allocate things in the right order. */
1195 if (has_protected_decls)
1197 /* Phase 1 contains only character arrays. */
1198 expand_stack_vars (stack_protect_decl_phase_1);
1200 /* Phase 2 contains other kinds of arrays. */
1201 if (flag_stack_protect == 2)
1202 expand_stack_vars (stack_protect_decl_phase_2);
1205 expand_stack_vars (NULL);
1207 fini_vars_expansion ();
1210 /* If the target requires that FRAME_OFFSET be aligned, do it. */
1211 if (STACK_ALIGNMENT_NEEDED)
1213 HOST_WIDE_INT align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
1214 if (!FRAME_GROWS_DOWNWARD)
1215 frame_offset += align - 1;
1216 frame_offset &= -align;
1221 /* If we need to produce a detailed dump, print the tree representation
1222 for STMT to the dump file. SINCE is the last RTX after which the RTL
1223 generated for STMT should have been appended. */
1226 maybe_dump_rtl_for_tree_stmt (tree stmt, rtx since)
1228 if (dump_file && (dump_flags & TDF_DETAILS))
1230 fprintf (dump_file, "\n;; ");
1231 print_generic_expr (dump_file, stmt, TDF_SLIM);
1232 fprintf (dump_file, "\n");
1234 print_rtl (dump_file, since ? NEXT_INSN (since) : since);
1238 /* Maps the blocks that do not contain tree labels to rtx labels. */
1240 static struct pointer_map_t *lab_rtx_for_bb;
1242 /* Returns the label_rtx expression for a label starting basic block BB. */
1245 label_rtx_for_bb (basic_block bb)
1247 tree_stmt_iterator tsi;
1251 if (bb->flags & BB_RTL)
1252 return block_label (bb);
1254 elt = pointer_map_contains (lab_rtx_for_bb, bb);
1258 /* Find the tree label if it is present. */
1260 for (tsi = tsi_start (bb_stmt_list (bb)); !tsi_end_p (tsi); tsi_next (&tsi))
1262 lab_stmt = tsi_stmt (tsi);
1263 if (TREE_CODE (lab_stmt) != LABEL_EXPR)
1266 lab = LABEL_EXPR_LABEL (lab_stmt);
1267 if (DECL_NONLOCAL (lab))
1270 return label_rtx (lab);
1273 elt = pointer_map_insert (lab_rtx_for_bb, bb);
1274 *elt = gen_label_rtx ();
1278 /* A subroutine of expand_gimple_basic_block. Expand one COND_EXPR.
1279 Returns a new basic block if we've terminated the current basic
1280 block and created a new one. */
1283 expand_gimple_cond_expr (basic_block bb, tree stmt)
1285 basic_block new_bb, dest;
1289 tree pred = COND_EXPR_COND (stmt);
1292 gcc_assert (COND_EXPR_THEN (stmt) == NULL_TREE);
1293 gcc_assert (COND_EXPR_ELSE (stmt) == NULL_TREE);
1294 last2 = last = get_last_insn ();
1296 extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
1297 if (EXPR_LOCUS (stmt))
1299 set_curr_insn_source_location (*(EXPR_LOCUS (stmt)));
1300 set_curr_insn_block (TREE_BLOCK (stmt));
1303 /* These flags have no purpose in RTL land. */
1304 true_edge->flags &= ~EDGE_TRUE_VALUE;
1305 false_edge->flags &= ~EDGE_FALSE_VALUE;
1307 /* We can either have a pure conditional jump with one fallthru edge or
1308 two-way jump that needs to be decomposed into two basic blocks. */
1309 if (false_edge->dest == bb->next_bb)
1311 jumpif (pred, label_rtx_for_bb (true_edge->dest));
1312 add_reg_br_prob_note (last, true_edge->probability);
1313 maybe_dump_rtl_for_tree_stmt (stmt, last);
1314 if (true_edge->goto_locus)
1315 set_curr_insn_source_location (location_from_locus (true_edge->goto_locus));
1316 false_edge->flags |= EDGE_FALLTHRU;
1319 if (true_edge->dest == bb->next_bb)
1321 jumpifnot (pred, label_rtx_for_bb (false_edge->dest));
1322 add_reg_br_prob_note (last, false_edge->probability);
1323 maybe_dump_rtl_for_tree_stmt (stmt, last);
1324 if (false_edge->goto_locus)
1325 set_curr_insn_source_location (location_from_locus (false_edge->goto_locus));
1326 true_edge->flags |= EDGE_FALLTHRU;
1330 jumpif (pred, label_rtx_for_bb (true_edge->dest));
1331 add_reg_br_prob_note (last, true_edge->probability);
1332 last = get_last_insn ();
1333 emit_jump (label_rtx_for_bb (false_edge->dest));
1336 if (BARRIER_P (BB_END (bb)))
1337 BB_END (bb) = PREV_INSN (BB_END (bb));
1338 update_bb_for_insn (bb);
1340 new_bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
1341 dest = false_edge->dest;
1342 redirect_edge_succ (false_edge, new_bb);
1343 false_edge->flags |= EDGE_FALLTHRU;
1344 new_bb->count = false_edge->count;
1345 new_bb->frequency = EDGE_FREQUENCY (false_edge);
1346 new_edge = make_edge (new_bb, dest, 0);
1347 new_edge->probability = REG_BR_PROB_BASE;
1348 new_edge->count = new_bb->count;
1349 if (BARRIER_P (BB_END (new_bb)))
1350 BB_END (new_bb) = PREV_INSN (BB_END (new_bb));
1351 update_bb_for_insn (new_bb);
1353 maybe_dump_rtl_for_tree_stmt (stmt, last2);
1355 if (false_edge->goto_locus)
1356 set_curr_insn_source_location (location_from_locus (false_edge->goto_locus));
1361 /* A subroutine of expand_gimple_basic_block. Expand one CALL_EXPR
1362 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
1363 generated a tail call (something that might be denied by the ABI
1364 rules governing the call; see calls.c).
1366 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
1367 can still reach the rest of BB. The case here is __builtin_sqrt,
1368 where the NaN result goes through the external function (with a
1369 tailcall) and the normal result happens via a sqrt instruction. */
1372 expand_gimple_tailcall (basic_block bb, tree stmt, bool *can_fallthru)
1380 last2 = last = get_last_insn ();
1382 expand_expr_stmt (stmt);
1384 for (last = NEXT_INSN (last); last; last = NEXT_INSN (last))
1385 if (CALL_P (last) && SIBLING_CALL_P (last))
1388 maybe_dump_rtl_for_tree_stmt (stmt, last2);
1390 *can_fallthru = true;
1394 /* ??? Wouldn't it be better to just reset any pending stack adjust?
1395 Any instructions emitted here are about to be deleted. */
1396 do_pending_stack_adjust ();
1398 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
1399 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
1400 EH or abnormal edges, we shouldn't have created a tail call in
1401 the first place. So it seems to me we should just be removing
1402 all edges here, or redirecting the existing fallthru edge to
1408 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
1410 if (!(e->flags & (EDGE_ABNORMAL | EDGE_EH)))
1412 if (e->dest != EXIT_BLOCK_PTR)
1414 e->dest->count -= e->count;
1415 e->dest->frequency -= EDGE_FREQUENCY (e);
1416 if (e->dest->count < 0)
1418 if (e->dest->frequency < 0)
1419 e->dest->frequency = 0;
1422 probability += e->probability;
1429 /* This is somewhat ugly: the call_expr expander often emits instructions
1430 after the sibcall (to perform the function return). These confuse the
1431 find_many_sub_basic_blocks code, so we need to get rid of these. */
1432 last = NEXT_INSN (last);
1433 gcc_assert (BARRIER_P (last));
1435 *can_fallthru = false;
1436 while (NEXT_INSN (last))
1438 /* For instance an sqrt builtin expander expands if with
1439 sibcall in the then and label for `else`. */
1440 if (LABEL_P (NEXT_INSN (last)))
1442 *can_fallthru = true;
1445 delete_insn (NEXT_INSN (last));
1448 e = make_edge (bb, EXIT_BLOCK_PTR, EDGE_ABNORMAL | EDGE_SIBCALL);
1449 e->probability += probability;
1452 update_bb_for_insn (bb);
1454 if (NEXT_INSN (last))
1456 bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
1459 if (BARRIER_P (last))
1460 BB_END (bb) = PREV_INSN (last);
1463 maybe_dump_rtl_for_tree_stmt (stmt, last2);
1468 /* Expand basic block BB from GIMPLE trees to RTL. */
1471 expand_gimple_basic_block (basic_block bb)
1473 tree_stmt_iterator tsi;
1474 tree stmts = bb_stmt_list (bb);
1484 "\n;; Generating RTL for tree basic block %d\n",
1489 init_rtl_bb_info (bb);
1490 bb->flags |= BB_RTL;
1492 /* Remove the RETURN_EXPR if we may fall though to the exit
1494 tsi = tsi_last (stmts);
1495 if (!tsi_end_p (tsi)
1496 && TREE_CODE (tsi_stmt (tsi)) == RETURN_EXPR)
1498 tree ret_stmt = tsi_stmt (tsi);
1500 gcc_assert (single_succ_p (bb));
1501 gcc_assert (single_succ (bb) == EXIT_BLOCK_PTR);
1503 if (bb->next_bb == EXIT_BLOCK_PTR
1504 && !TREE_OPERAND (ret_stmt, 0))
1507 single_succ_edge (bb)->flags |= EDGE_FALLTHRU;
1511 tsi = tsi_start (stmts);
1512 if (!tsi_end_p (tsi))
1514 stmt = tsi_stmt (tsi);
1515 if (TREE_CODE (stmt) != LABEL_EXPR)
1519 elt = pointer_map_contains (lab_rtx_for_bb, bb);
1523 last = get_last_insn ();
1527 expand_expr_stmt (stmt);
1532 emit_label ((rtx) *elt);
1534 /* Java emits line number notes in the top of labels.
1535 ??? Make this go away once line number notes are obsoleted. */
1536 BB_HEAD (bb) = NEXT_INSN (last);
1537 if (NOTE_P (BB_HEAD (bb)))
1538 BB_HEAD (bb) = NEXT_INSN (BB_HEAD (bb));
1539 note = emit_note_after (NOTE_INSN_BASIC_BLOCK, BB_HEAD (bb));
1541 maybe_dump_rtl_for_tree_stmt (stmt, last);
1544 note = BB_HEAD (bb) = emit_note (NOTE_INSN_BASIC_BLOCK);
1546 NOTE_BASIC_BLOCK (note) = bb;
1548 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
1550 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
1551 e->flags &= ~EDGE_EXECUTABLE;
1553 /* At the moment not all abnormal edges match the RTL representation.
1554 It is safe to remove them here as find_many_sub_basic_blocks will
1555 rediscover them. In the future we should get this fixed properly. */
1556 if (e->flags & EDGE_ABNORMAL)
1562 for (; !tsi_end_p (tsi); tsi_next (&tsi))
1564 tree stmt = tsi_stmt (tsi);
1570 /* Expand this statement, then evaluate the resulting RTL and
1571 fixup the CFG accordingly. */
1572 if (TREE_CODE (stmt) == COND_EXPR)
1574 new_bb = expand_gimple_cond_expr (bb, stmt);
1580 tree call = get_call_expr_in (stmt);
1582 /* For the benefit of calls.c, converting all this to rtl,
1583 we need to record the call expression, not just the outer
1584 modify statement. */
1585 if (call && call != stmt)
1587 if ((region = lookup_stmt_eh_region (stmt)) > 0)
1588 add_stmt_to_eh_region (call, region);
1589 gimple_duplicate_stmt_histograms (cfun, call, cfun, stmt);
1591 if (call && CALL_EXPR_TAILCALL (call))
1594 new_bb = expand_gimple_tailcall (bb, stmt, &can_fallthru);
1605 last = get_last_insn ();
1606 expand_expr_stmt (stmt);
1607 maybe_dump_rtl_for_tree_stmt (stmt, last);
1612 /* Expand implicit goto. */
1613 FOR_EACH_EDGE (e, ei, bb->succs)
1615 if (e->flags & EDGE_FALLTHRU)
1619 if (e && e->dest != bb->next_bb)
1621 emit_jump (label_rtx_for_bb (e->dest));
1623 set_curr_insn_source_location (location_from_locus (e->goto_locus));
1624 e->flags &= ~EDGE_FALLTHRU;
1627 do_pending_stack_adjust ();
1629 /* Find the block tail. The last insn in the block is the insn
1630 before a barrier and/or table jump insn. */
1631 last = get_last_insn ();
1632 if (BARRIER_P (last))
1633 last = PREV_INSN (last);
1634 if (JUMP_TABLE_DATA_P (last))
1635 last = PREV_INSN (PREV_INSN (last));
1638 update_bb_for_insn (bb);
1644 /* Create a basic block for initialization code. */
1647 construct_init_block (void)
1649 basic_block init_block, first_block;
1653 /* Multiple entry points not supported yet. */
1654 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR->succs) == 1);
1655 init_rtl_bb_info (ENTRY_BLOCK_PTR);
1656 init_rtl_bb_info (EXIT_BLOCK_PTR);
1657 ENTRY_BLOCK_PTR->flags |= BB_RTL;
1658 EXIT_BLOCK_PTR->flags |= BB_RTL;
1660 e = EDGE_SUCC (ENTRY_BLOCK_PTR, 0);
1662 /* When entry edge points to first basic block, we don't need jump,
1663 otherwise we have to jump into proper target. */
1664 if (e && e->dest != ENTRY_BLOCK_PTR->next_bb)
1666 tree label = tree_block_label (e->dest);
1668 emit_jump (label_rtx (label));
1672 flags = EDGE_FALLTHRU;
1674 init_block = create_basic_block (NEXT_INSN (get_insns ()),
1677 init_block->frequency = ENTRY_BLOCK_PTR->frequency;
1678 init_block->count = ENTRY_BLOCK_PTR->count;
1681 first_block = e->dest;
1682 redirect_edge_succ (e, init_block);
1683 e = make_edge (init_block, first_block, flags);
1686 e = make_edge (init_block, EXIT_BLOCK_PTR, EDGE_FALLTHRU);
1687 e->probability = REG_BR_PROB_BASE;
1688 e->count = ENTRY_BLOCK_PTR->count;
1690 update_bb_for_insn (init_block);
1694 /* For each lexical block, set BLOCK_NUMBER to the depth at which it is
1695 found in the block tree. */
1698 set_block_levels (tree block, int level)
1702 BLOCK_NUMBER (block) = level;
1703 set_block_levels (BLOCK_SUBBLOCKS (block), level + 1);
1704 block = BLOCK_CHAIN (block);
1708 /* Create a block containing landing pads and similar stuff. */
1711 construct_exit_block (void)
1713 rtx head = get_last_insn ();
1715 basic_block exit_block;
1719 rtx orig_end = BB_END (EXIT_BLOCK_PTR->prev_bb);
1721 /* Make sure the locus is set to the end of the function, so that
1722 epilogue line numbers and warnings are set properly. */
1723 #ifdef USE_MAPPED_LOCATION
1724 if (cfun->function_end_locus != UNKNOWN_LOCATION)
1726 if (cfun->function_end_locus.file)
1728 input_location = cfun->function_end_locus;
1730 /* The following insns belong to the top scope. */
1731 set_curr_insn_block (DECL_INITIAL (current_function_decl));
1733 /* Generate rtl for function exit. */
1734 expand_function_end ();
1736 end = get_last_insn ();
1739 /* While emitting the function end we could move end of the last basic block.
1741 BB_END (EXIT_BLOCK_PTR->prev_bb) = orig_end;
1742 while (NEXT_INSN (head) && NOTE_P (NEXT_INSN (head)))
1743 head = NEXT_INSN (head);
1744 exit_block = create_basic_block (NEXT_INSN (head), end,
1745 EXIT_BLOCK_PTR->prev_bb);
1746 exit_block->frequency = EXIT_BLOCK_PTR->frequency;
1747 exit_block->count = EXIT_BLOCK_PTR->count;
1750 while (ix < EDGE_COUNT (EXIT_BLOCK_PTR->preds))
1752 e = EDGE_PRED (EXIT_BLOCK_PTR, ix);
1753 if (!(e->flags & EDGE_ABNORMAL))
1754 redirect_edge_succ (e, exit_block);
1759 e = make_edge (exit_block, EXIT_BLOCK_PTR, EDGE_FALLTHRU);
1760 e->probability = REG_BR_PROB_BASE;
1761 e->count = EXIT_BLOCK_PTR->count;
1762 FOR_EACH_EDGE (e2, ei, EXIT_BLOCK_PTR->preds)
1765 e->count -= e2->count;
1766 exit_block->count -= e2->count;
1767 exit_block->frequency -= EDGE_FREQUENCY (e2);
1771 if (exit_block->count < 0)
1772 exit_block->count = 0;
1773 if (exit_block->frequency < 0)
1774 exit_block->frequency = 0;
1775 update_bb_for_insn (exit_block);
1778 /* Helper function for discover_nonconstant_array_refs.
1779 Look for ARRAY_REF nodes with non-constant indexes and mark them
1783 discover_nonconstant_array_refs_r (tree * tp, int *walk_subtrees,
1784 void *data ATTRIBUTE_UNUSED)
1788 if (IS_TYPE_OR_DECL_P (t))
1790 else if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1792 while (((TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1793 && is_gimple_min_invariant (TREE_OPERAND (t, 1))
1794 && (!TREE_OPERAND (t, 2)
1795 || is_gimple_min_invariant (TREE_OPERAND (t, 2))))
1796 || (TREE_CODE (t) == COMPONENT_REF
1797 && (!TREE_OPERAND (t,2)
1798 || is_gimple_min_invariant (TREE_OPERAND (t, 2))))
1799 || TREE_CODE (t) == BIT_FIELD_REF
1800 || TREE_CODE (t) == REALPART_EXPR
1801 || TREE_CODE (t) == IMAGPART_EXPR
1802 || TREE_CODE (t) == VIEW_CONVERT_EXPR
1803 || TREE_CODE (t) == NOP_EXPR
1804 || TREE_CODE (t) == CONVERT_EXPR)
1805 t = TREE_OPERAND (t, 0);
1807 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1809 t = get_base_address (t);
1810 if (t && DECL_P (t))
1811 TREE_ADDRESSABLE (t) = 1;
1820 /* RTL expansion is not able to compile array references with variable
1821 offsets for arrays stored in single register. Discover such
1822 expressions and mark variables as addressable to avoid this
1826 discover_nonconstant_array_refs (void)
1829 block_stmt_iterator bsi;
1833 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
1834 walk_tree (bsi_stmt_ptr (bsi), discover_nonconstant_array_refs_r,
1839 /* Translate the intermediate representation contained in the CFG
1840 from GIMPLE trees to RTL.
1842 We do conversion per basic block and preserve/update the tree CFG.
1843 This implies we have to do some magic as the CFG can simultaneously
1844 consist of basic blocks containing RTL and GIMPLE trees. This can
1845 confuse the CFG hooks, so be careful to not manipulate CFG during
1849 tree_expand_cfg (void)
1851 basic_block bb, init_block;
1856 /* Some backends want to know that we are expanding to RTL. */
1857 currently_expanding_to_rtl = 1;
1859 insn_locators_alloc ();
1860 if (!DECL_BUILT_IN (current_function_decl))
1861 set_curr_insn_source_location (DECL_SOURCE_LOCATION (current_function_decl));
1862 set_curr_insn_block (DECL_INITIAL (current_function_decl));
1863 prologue_locator = curr_insn_locator ();
1865 /* Make sure first insn is a note even if we don't want linenums.
1866 This makes sure the first insn will never be deleted.
1867 Also, final expects a note to appear there. */
1868 emit_note (NOTE_INSN_DELETED);
1870 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
1871 discover_nonconstant_array_refs ();
1873 /* Expand the variables recorded during gimple lowering. */
1874 expand_used_vars ();
1876 /* Honor stack protection warnings. */
1877 if (warn_stack_protect)
1879 if (current_function_calls_alloca)
1880 warning (0, "not protecting local variables: variable length buffer");
1881 if (has_short_buffer && !cfun->stack_protect_guard)
1882 warning (0, "not protecting function: no buffer at least %d bytes long",
1883 (int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE));
1886 /* Set up parameters and prepare for return, for the function. */
1887 expand_function_start (current_function_decl);
1889 /* If this function is `main', emit a call to `__main'
1890 to run global initializers, etc. */
1891 if (DECL_NAME (current_function_decl)
1892 && MAIN_NAME_P (DECL_NAME (current_function_decl))
1893 && DECL_FILE_SCOPE_P (current_function_decl))
1894 expand_main_function ();
1896 /* Initialize the stack_protect_guard field. This must happen after the
1897 call to __main (if any) so that the external decl is initialized. */
1898 if (cfun->stack_protect_guard)
1899 stack_protect_prologue ();
1901 /* Register rtl specific functions for cfg. */
1902 rtl_register_cfg_hooks ();
1904 init_block = construct_init_block ();
1906 /* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
1907 remaining edges in expand_gimple_basic_block. */
1908 FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
1909 e->flags &= ~EDGE_EXECUTABLE;
1911 lab_rtx_for_bb = pointer_map_create ();
1912 FOR_BB_BETWEEN (bb, init_block->next_bb, EXIT_BLOCK_PTR, next_bb)
1913 bb = expand_gimple_basic_block (bb);
1914 pointer_map_destroy (lab_rtx_for_bb);
1916 construct_exit_block ();
1917 set_curr_insn_block (DECL_INITIAL (current_function_decl));
1918 insn_locators_finalize ();
1920 /* We're done expanding trees to RTL. */
1921 currently_expanding_to_rtl = 0;
1923 /* Convert tree EH labels to RTL EH labels, and clean out any unreachable
1925 convert_from_eh_region_ranges ();
1927 rebuild_jump_labels (get_insns ());
1928 find_exception_handler_labels ();
1930 blocks = sbitmap_alloc (last_basic_block);
1931 sbitmap_ones (blocks);
1932 find_many_sub_basic_blocks (blocks);
1933 purge_all_dead_edges ();
1934 sbitmap_free (blocks);
1937 #ifdef ENABLE_CHECKING
1938 verify_flow_info ();
1941 /* There's no need to defer outputting this function any more; we
1942 know we want to output it. */
1943 DECL_DEFER_OUTPUT (current_function_decl) = 0;
1945 /* Now that we're done expanding trees to RTL, we shouldn't have any
1946 more CONCATs anywhere. */
1947 generating_concat_p = 0;
1952 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
1953 /* And the pass manager will dump RTL for us. */
1956 /* If we're emitting a nested function, make sure its parent gets
1957 emitted as well. Doing otherwise confuses debug info. */
1960 for (parent = DECL_CONTEXT (current_function_decl);
1961 parent != NULL_TREE;
1962 parent = get_containing_scope (parent))
1963 if (TREE_CODE (parent) == FUNCTION_DECL)
1964 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent)) = 1;
1967 /* We are now committed to emitting code for this function. Do any
1968 preparation, such as emitting abstract debug info for the inline
1969 before it gets mangled by optimization. */
1970 if (cgraph_function_possibly_inlined_p (current_function_decl))
1971 (*debug_hooks->outlining_inline_function) (current_function_decl);
1973 TREE_ASM_WRITTEN (current_function_decl) = 1;
1975 /* After expanding, the return labels are no longer needed. */
1976 return_label = NULL;
1977 naked_return_label = NULL;
1979 /* Tag the blocks with a depth number so that change_scope can find
1980 the common parent easily. */
1981 set_block_levels (DECL_INITIAL (cfun->decl), 0);
1985 struct tree_opt_pass pass_expand =
1987 "expand", /* name */
1989 tree_expand_cfg, /* execute */
1992 0, /* static_pass_number */
1993 TV_EXPAND, /* tv_id */
1994 /* ??? If TER is enabled, we actually receive GENERIC. */
1995 PROP_gimple_leh | PROP_cfg, /* properties_required */
1996 PROP_rtl, /* properties_provided */
1997 PROP_trees, /* properties_destroyed */
1998 0, /* todo_flags_start */
1999 TODO_dump_func, /* todo_flags_finish */