2006-02-09 Kaz Kojima <kkojima@gcc.gnu.org>
[official-gcc.git] / gcc / cfgexpand.c
blobc0bf209d9d8f321b52990b2d210e5d18495e4685
1 /* A pass for lowering trees to RTL.
2 Copyright (C) 2004, 2005 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
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. */
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "tm.h"
25 #include "tree.h"
26 #include "rtl.h"
27 #include "tm_p.h"
28 #include "basic-block.h"
29 #include "function.h"
30 #include "expr.h"
31 #include "langhooks.h"
32 #include "tree-flow.h"
33 #include "timevar.h"
34 #include "tree-dump.h"
35 #include "tree-pass.h"
36 #include "except.h"
37 #include "flags.h"
38 #include "diagnostic.h"
39 #include "toplev.h"
40 #include "debug.h"
41 #include "params.h"
43 /* Verify that there is exactly single jump instruction since last and attach
44 REG_BR_PROB note specifying probability.
45 ??? We really ought to pass the probability down to RTL expanders and let it
46 re-distribute it when the conditional expands into multiple conditionals.
47 This is however difficult to do. */
48 static void
49 add_reg_br_prob_note (rtx last, int probability)
51 if (profile_status == PROFILE_ABSENT)
52 return;
53 for (last = NEXT_INSN (last); last && NEXT_INSN (last); last = NEXT_INSN (last))
54 if (JUMP_P (last))
56 /* It is common to emit condjump-around-jump sequence when we don't know
57 how to reverse the conditional. Special case this. */
58 if (!any_condjump_p (last)
59 || !JUMP_P (NEXT_INSN (last))
60 || !simplejump_p (NEXT_INSN (last))
61 || !BARRIER_P (NEXT_INSN (NEXT_INSN (last)))
62 || !LABEL_P (NEXT_INSN (NEXT_INSN (NEXT_INSN (last))))
63 || NEXT_INSN (NEXT_INSN (NEXT_INSN (NEXT_INSN (last)))))
64 goto failed;
65 gcc_assert (!find_reg_note (last, REG_BR_PROB, 0));
66 REG_NOTES (last)
67 = gen_rtx_EXPR_LIST (REG_BR_PROB,
68 GEN_INT (REG_BR_PROB_BASE - probability),
69 REG_NOTES (last));
70 return;
72 if (!last || !JUMP_P (last) || !any_condjump_p (last))
73 goto failed;
74 gcc_assert (!find_reg_note (last, REG_BR_PROB, 0));
75 REG_NOTES (last)
76 = gen_rtx_EXPR_LIST (REG_BR_PROB,
77 GEN_INT (probability), REG_NOTES (last));
78 return;
79 failed:
80 if (dump_file)
81 fprintf (dump_file, "Failed to add probability note\n");
85 #ifndef LOCAL_ALIGNMENT
86 #define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT
87 #endif
89 #ifndef STACK_ALIGNMENT_NEEDED
90 #define STACK_ALIGNMENT_NEEDED 1
91 #endif
94 /* This structure holds data relevant to one variable that will be
95 placed in a stack slot. */
96 struct stack_var
98 /* The Variable. */
99 tree decl;
101 /* The offset of the variable. During partitioning, this is the
102 offset relative to the partition. After partitioning, this
103 is relative to the stack frame. */
104 HOST_WIDE_INT offset;
106 /* Initially, the size of the variable. Later, the size of the partition,
107 if this variable becomes it's partition's representative. */
108 HOST_WIDE_INT size;
110 /* The *byte* alignment required for this variable. Or as, with the
111 size, the alignment for this partition. */
112 unsigned int alignb;
114 /* The partition representative. */
115 size_t representative;
117 /* The next stack variable in the partition, or EOC. */
118 size_t next;
121 #define EOC ((size_t)-1)
123 /* We have an array of such objects while deciding allocation. */
124 static struct stack_var *stack_vars;
125 static size_t stack_vars_alloc;
126 static size_t stack_vars_num;
128 /* An array of indicies such that stack_vars[stack_vars_sorted[i]].size
129 is non-decreasing. */
130 static size_t *stack_vars_sorted;
132 /* We have an interference graph between such objects. This graph
133 is lower triangular. */
134 static bool *stack_vars_conflict;
135 static size_t stack_vars_conflict_alloc;
137 /* The phase of the stack frame. This is the known misalignment of
138 virtual_stack_vars_rtx from PREFERRED_STACK_BOUNDARY. That is,
139 (frame_offset+frame_phase) % PREFERRED_STACK_BOUNDARY == 0. */
140 static int frame_phase;
142 /* Used during expand_used_vars to remember if we saw any decls for
143 which we'd like to enable stack smashing protection. */
144 static bool has_protected_decls;
146 /* Used during expand_used_vars. Remember if we say a character buffer
147 smaller than our cutoff threshold. Used for -Wstack-protector. */
148 static bool has_short_buffer;
150 /* Discover the byte alignment to use for DECL. Ignore alignment
151 we can't do with expected alignment of the stack boundary. */
153 static unsigned int
154 get_decl_align_unit (tree decl)
156 unsigned int align;
158 align = DECL_ALIGN (decl);
159 align = LOCAL_ALIGNMENT (TREE_TYPE (decl), align);
160 if (align > PREFERRED_STACK_BOUNDARY)
161 align = PREFERRED_STACK_BOUNDARY;
162 if (cfun->stack_alignment_needed < align)
163 cfun->stack_alignment_needed = align;
165 return align / BITS_PER_UNIT;
168 /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
169 Return the frame offset. */
171 static HOST_WIDE_INT
172 alloc_stack_frame_space (HOST_WIDE_INT size, HOST_WIDE_INT align)
174 HOST_WIDE_INT offset, new_frame_offset;
176 new_frame_offset = frame_offset;
177 if (FRAME_GROWS_DOWNWARD)
179 new_frame_offset -= size + frame_phase;
180 new_frame_offset &= -align;
181 new_frame_offset += frame_phase;
182 offset = new_frame_offset;
184 else
186 new_frame_offset -= frame_phase;
187 new_frame_offset += align - 1;
188 new_frame_offset &= -align;
189 new_frame_offset += frame_phase;
190 offset = new_frame_offset;
191 new_frame_offset += size;
193 frame_offset = new_frame_offset;
195 return offset;
198 /* Accumulate DECL into STACK_VARS. */
200 static void
201 add_stack_var (tree decl)
203 if (stack_vars_num >= stack_vars_alloc)
205 if (stack_vars_alloc)
206 stack_vars_alloc = stack_vars_alloc * 3 / 2;
207 else
208 stack_vars_alloc = 32;
209 stack_vars
210 = XRESIZEVEC (struct stack_var, stack_vars, stack_vars_alloc);
212 stack_vars[stack_vars_num].decl = decl;
213 stack_vars[stack_vars_num].offset = 0;
214 stack_vars[stack_vars_num].size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
215 stack_vars[stack_vars_num].alignb = get_decl_align_unit (decl);
217 /* All variables are initially in their own partition. */
218 stack_vars[stack_vars_num].representative = stack_vars_num;
219 stack_vars[stack_vars_num].next = EOC;
221 /* Ensure that this decl doesn't get put onto the list twice. */
222 SET_DECL_RTL (decl, pc_rtx);
224 stack_vars_num++;
227 /* Compute the linear index of a lower-triangular coordinate (I, J). */
229 static size_t
230 triangular_index (size_t i, size_t j)
232 if (i < j)
234 size_t t;
235 t = i, i = j, j = t;
237 return (i * (i + 1)) / 2 + j;
240 /* Ensure that STACK_VARS_CONFLICT is large enough for N objects. */
242 static void
243 resize_stack_vars_conflict (size_t n)
245 size_t size = triangular_index (n-1, n-1) + 1;
247 if (size <= stack_vars_conflict_alloc)
248 return;
250 stack_vars_conflict = XRESIZEVEC (bool, stack_vars_conflict, size);
251 memset (stack_vars_conflict + stack_vars_conflict_alloc, 0,
252 (size - stack_vars_conflict_alloc) * sizeof (bool));
253 stack_vars_conflict_alloc = size;
256 /* Make the decls associated with luid's X and Y conflict. */
258 static void
259 add_stack_var_conflict (size_t x, size_t y)
261 size_t index = triangular_index (x, y);
262 gcc_assert (index < stack_vars_conflict_alloc);
263 stack_vars_conflict[index] = true;
266 /* Check whether the decls associated with luid's X and Y conflict. */
268 static bool
269 stack_var_conflict_p (size_t x, size_t y)
271 size_t index = triangular_index (x, y);
272 gcc_assert (index < stack_vars_conflict_alloc);
273 return stack_vars_conflict[index];
276 /* Returns true if TYPE is or contains a union type. */
278 static bool
279 aggregate_contains_union_type (tree type)
281 tree field;
283 if (TREE_CODE (type) == UNION_TYPE
284 || TREE_CODE (type) == QUAL_UNION_TYPE)
285 return true;
286 if (TREE_CODE (type) == ARRAY_TYPE)
287 return aggregate_contains_union_type (TREE_TYPE (type));
288 if (TREE_CODE (type) != RECORD_TYPE)
289 return false;
291 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
292 if (TREE_CODE (field) == FIELD_DECL)
293 if (aggregate_contains_union_type (TREE_TYPE (field)))
294 return true;
296 return false;
299 /* A subroutine of expand_used_vars. If two variables X and Y have alias
300 sets that do not conflict, then do add a conflict for these variables
301 in the interference graph. We also need to make sure to add conflicts
302 for union containing structures. Else RTL alias analysis comes along
303 and due to type based aliasing rules decides that for two overlapping
304 union temporaries { short s; int i; } accesses to the same mem through
305 different types may not alias and happily reorders stores across
306 life-time boundaries of the temporaries (See PR25654).
307 We also have to mind MEM_IN_STRUCT_P and MEM_SCALAR_P. */
309 static void
310 add_alias_set_conflicts (void)
312 size_t i, j, n = stack_vars_num;
314 for (i = 0; i < n; ++i)
316 tree type_i = TREE_TYPE (stack_vars[i].decl);
317 bool aggr_i = AGGREGATE_TYPE_P (type_i);
318 bool contains_union;
320 contains_union = aggregate_contains_union_type (type_i);
321 for (j = 0; j < i; ++j)
323 tree type_j = TREE_TYPE (stack_vars[j].decl);
324 bool aggr_j = AGGREGATE_TYPE_P (type_j);
325 if (aggr_i != aggr_j
326 /* Either the objects conflict by means of type based
327 aliasing rules, or we need to add a conflict. */
328 || !objects_must_conflict_p (type_i, type_j)
329 /* In case the types do not conflict ensure that access
330 to elements will conflict. In case of unions we have
331 to be careful as type based aliasing rules may say
332 access to the same memory does not conflict. So play
333 safe and add a conflict in this case. */
334 || contains_union)
335 add_stack_var_conflict (i, j);
340 /* A subroutine of partition_stack_vars. A comparison function for qsort,
341 sorting an array of indicies by the size of the object. */
343 static int
344 stack_var_size_cmp (const void *a, const void *b)
346 HOST_WIDE_INT sa = stack_vars[*(const size_t *)a].size;
347 HOST_WIDE_INT sb = stack_vars[*(const size_t *)b].size;
349 if (sa < sb)
350 return -1;
351 if (sa > sb)
352 return 1;
353 return 0;
356 /* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
357 partitioning algorithm. Partitions A and B are known to be non-conflicting.
358 Merge them into a single partition A.
360 At the same time, add OFFSET to all variables in partition B. At the end
361 of the partitioning process we've have a nice block easy to lay out within
362 the stack frame. */
364 static void
365 union_stack_vars (size_t a, size_t b, HOST_WIDE_INT offset)
367 size_t i, last;
369 /* Update each element of partition B with the given offset,
370 and merge them into partition A. */
371 for (last = i = b; i != EOC; last = i, i = stack_vars[i].next)
373 stack_vars[i].offset += offset;
374 stack_vars[i].representative = a;
376 stack_vars[last].next = stack_vars[a].next;
377 stack_vars[a].next = b;
379 /* Update the required alignment of partition A to account for B. */
380 if (stack_vars[a].alignb < stack_vars[b].alignb)
381 stack_vars[a].alignb = stack_vars[b].alignb;
383 /* Update the interference graph and merge the conflicts. */
384 for (last = stack_vars_num, i = 0; i < last; ++i)
385 if (stack_var_conflict_p (b, i))
386 add_stack_var_conflict (a, i);
389 /* A subroutine of expand_used_vars. Binpack the variables into
390 partitions constrained by the interference graph. The overall
391 algorithm used is as follows:
393 Sort the objects by size.
394 For each object A {
395 S = size(A)
396 O = 0
397 loop {
398 Look for the largest non-conflicting object B with size <= S.
399 UNION (A, B)
400 offset(B) = O
401 O += size(B)
402 S -= size(B)
407 static void
408 partition_stack_vars (void)
410 size_t si, sj, n = stack_vars_num;
412 stack_vars_sorted = XNEWVEC (size_t, stack_vars_num);
413 for (si = 0; si < n; ++si)
414 stack_vars_sorted[si] = si;
416 if (n == 1)
417 return;
419 qsort (stack_vars_sorted, n, sizeof (size_t), stack_var_size_cmp);
421 /* Special case: detect when all variables conflict, and thus we can't
422 do anything during the partitioning loop. It isn't uncommon (with
423 C code at least) to declare all variables at the top of the function,
424 and if we're not inlining, then all variables will be in the same scope.
425 Take advantage of very fast libc routines for this scan. */
426 gcc_assert (sizeof(bool) == sizeof(char));
427 if (memchr (stack_vars_conflict, false, stack_vars_conflict_alloc) == NULL)
428 return;
430 for (si = 0; si < n; ++si)
432 size_t i = stack_vars_sorted[si];
433 HOST_WIDE_INT isize = stack_vars[i].size;
434 HOST_WIDE_INT offset = 0;
436 for (sj = si; sj-- > 0; )
438 size_t j = stack_vars_sorted[sj];
439 HOST_WIDE_INT jsize = stack_vars[j].size;
440 unsigned int jalign = stack_vars[j].alignb;
442 /* Ignore objects that aren't partition representatives. */
443 if (stack_vars[j].representative != j)
444 continue;
446 /* Ignore objects too large for the remaining space. */
447 if (isize < jsize)
448 continue;
450 /* Ignore conflicting objects. */
451 if (stack_var_conflict_p (i, j))
452 continue;
454 /* Refine the remaining space check to include alignment. */
455 if (offset & (jalign - 1))
457 HOST_WIDE_INT toff = offset;
458 toff += jalign - 1;
459 toff &= -(HOST_WIDE_INT)jalign;
460 if (isize - (toff - offset) < jsize)
461 continue;
463 isize -= toff - offset;
464 offset = toff;
467 /* UNION the objects, placing J at OFFSET. */
468 union_stack_vars (i, j, offset);
470 isize -= jsize;
471 if (isize == 0)
472 break;
477 /* A debugging aid for expand_used_vars. Dump the generated partitions. */
479 static void
480 dump_stack_var_partition (void)
482 size_t si, i, j, n = stack_vars_num;
484 for (si = 0; si < n; ++si)
486 i = stack_vars_sorted[si];
488 /* Skip variables that aren't partition representatives, for now. */
489 if (stack_vars[i].representative != i)
490 continue;
492 fprintf (dump_file, "Partition %lu: size " HOST_WIDE_INT_PRINT_DEC
493 " align %u\n", (unsigned long) i, stack_vars[i].size,
494 stack_vars[i].alignb);
496 for (j = i; j != EOC; j = stack_vars[j].next)
498 fputc ('\t', dump_file);
499 print_generic_expr (dump_file, stack_vars[j].decl, dump_flags);
500 fprintf (dump_file, ", offset " HOST_WIDE_INT_PRINT_DEC "\n",
501 stack_vars[i].offset);
506 /* Assign rtl to DECL at frame offset OFFSET. */
508 static void
509 expand_one_stack_var_at (tree decl, HOST_WIDE_INT offset)
511 HOST_WIDE_INT align;
512 rtx x;
514 /* If this fails, we've overflowed the stack frame. Error nicely? */
515 gcc_assert (offset == trunc_int_for_mode (offset, Pmode));
517 x = plus_constant (virtual_stack_vars_rtx, offset);
518 x = gen_rtx_MEM (DECL_MODE (decl), x);
520 /* Set alignment we actually gave this decl. */
521 offset -= frame_phase;
522 align = offset & -offset;
523 align *= BITS_PER_UNIT;
524 if (align > STACK_BOUNDARY || align == 0)
525 align = STACK_BOUNDARY;
526 DECL_ALIGN (decl) = align;
527 DECL_USER_ALIGN (decl) = 0;
529 set_mem_attributes (x, decl, true);
530 SET_DECL_RTL (decl, x);
533 /* A subroutine of expand_used_vars. Give each partition representative
534 a unique location within the stack frame. Update each partition member
535 with that location. */
537 static void
538 expand_stack_vars (bool (*pred) (tree))
540 size_t si, i, j, n = stack_vars_num;
542 for (si = 0; si < n; ++si)
544 HOST_WIDE_INT offset;
546 i = stack_vars_sorted[si];
548 /* Skip variables that aren't partition representatives, for now. */
549 if (stack_vars[i].representative != i)
550 continue;
552 /* Skip variables that have already had rtl assigned. See also
553 add_stack_var where we perpetrate this pc_rtx hack. */
554 if (DECL_RTL (stack_vars[i].decl) != pc_rtx)
555 continue;
557 /* Check the predicate to see whether this variable should be
558 allocated in this pass. */
559 if (pred && !pred (stack_vars[i].decl))
560 continue;
562 offset = alloc_stack_frame_space (stack_vars[i].size,
563 stack_vars[i].alignb);
565 /* Create rtl for each variable based on their location within the
566 partition. */
567 for (j = i; j != EOC; j = stack_vars[j].next)
568 expand_one_stack_var_at (stack_vars[j].decl,
569 stack_vars[j].offset + offset);
573 /* A subroutine of expand_one_var. Called to immediately assign rtl
574 to a variable to be allocated in the stack frame. */
576 static void
577 expand_one_stack_var (tree var)
579 HOST_WIDE_INT size, offset, align;
581 size = tree_low_cst (DECL_SIZE_UNIT (var), 1);
582 align = get_decl_align_unit (var);
583 offset = alloc_stack_frame_space (size, align);
585 expand_one_stack_var_at (var, offset);
588 /* A subroutine of expand_one_var. Called to assign rtl
589 to a TREE_STATIC VAR_DECL. */
591 static void
592 expand_one_static_var (tree var)
594 /* In unit-at-a-time all the static variables are expanded at the end
595 of compilation process. */
596 if (flag_unit_at_a_time)
597 return;
598 /* If this is an inlined copy of a static local variable,
599 look up the original. */
600 var = DECL_ORIGIN (var);
602 /* If we've already processed this variable because of that, do nothing. */
603 if (TREE_ASM_WRITTEN (var))
604 return;
606 /* Give the front end a chance to do whatever. In practice, this is
607 resolving duplicate names for IMA in C. */
608 if (lang_hooks.expand_decl (var))
609 return;
611 /* Otherwise, just emit the variable. */
612 rest_of_decl_compilation (var, 0, 0);
615 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
616 that will reside in a hard register. */
618 static void
619 expand_one_hard_reg_var (tree var)
621 rest_of_decl_compilation (var, 0, 0);
624 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
625 that will reside in a pseudo register. */
627 static void
628 expand_one_register_var (tree var)
630 tree type = TREE_TYPE (var);
631 int unsignedp = TYPE_UNSIGNED (type);
632 enum machine_mode reg_mode
633 = promote_mode (type, DECL_MODE (var), &unsignedp, 0);
634 rtx x = gen_reg_rtx (reg_mode);
636 SET_DECL_RTL (var, x);
638 /* Note if the object is a user variable. */
639 if (!DECL_ARTIFICIAL (var))
641 mark_user_reg (x);
643 /* Trust user variables which have a pointer type to really
644 be pointers. Do not trust compiler generated temporaries
645 as our type system is totally busted as it relates to
646 pointer arithmetic which translates into lots of compiler
647 generated objects with pointer types, but which are not really
648 pointers. */
649 if (POINTER_TYPE_P (type))
650 mark_reg_pointer (x, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (var))));
654 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
655 has some associated error, e.g. its type is error-mark. We just need
656 to pick something that won't crash the rest of the compiler. */
658 static void
659 expand_one_error_var (tree var)
661 enum machine_mode mode = DECL_MODE (var);
662 rtx x;
664 if (mode == BLKmode)
665 x = gen_rtx_MEM (BLKmode, const0_rtx);
666 else if (mode == VOIDmode)
667 x = const0_rtx;
668 else
669 x = gen_reg_rtx (mode);
671 SET_DECL_RTL (var, x);
674 /* A subroutine of expand_one_var. VAR is a variable that will be
675 allocated to the local stack frame. Return true if we wish to
676 add VAR to STACK_VARS so that it will be coalesced with other
677 variables. Return false to allocate VAR immediately.
679 This function is used to reduce the number of variables considered
680 for coalescing, which reduces the size of the quadratic problem. */
682 static bool
683 defer_stack_allocation (tree var, bool toplevel)
685 /* If stack protection is enabled, *all* stack variables must be deferred,
686 so that we can re-order the strings to the top of the frame. */
687 if (flag_stack_protect)
688 return true;
690 /* Variables in the outermost scope automatically conflict with
691 every other variable. The only reason to want to defer them
692 at all is that, after sorting, we can more efficiently pack
693 small variables in the stack frame. Continue to defer at -O2. */
694 if (toplevel && optimize < 2)
695 return false;
697 /* Without optimization, *most* variables are allocated from the
698 stack, which makes the quadratic problem large exactly when we
699 want compilation to proceed as quickly as possible. On the
700 other hand, we don't want the function's stack frame size to
701 get completely out of hand. So we avoid adding scalars and
702 "small" aggregates to the list at all. */
703 if (optimize == 0 && tree_low_cst (DECL_SIZE_UNIT (var), 1) < 32)
704 return false;
706 return true;
709 /* A subroutine of expand_used_vars. Expand one variable according to
710 its flavor. Variables to be placed on the stack are not actually
711 expanded yet, merely recorded. */
713 static void
714 expand_one_var (tree var, bool toplevel)
716 if (TREE_CODE (var) != VAR_DECL)
717 lang_hooks.expand_decl (var);
718 else if (DECL_EXTERNAL (var))
720 else if (DECL_HAS_VALUE_EXPR_P (var))
722 else if (TREE_STATIC (var))
723 expand_one_static_var (var);
724 else if (DECL_RTL_SET_P (var))
726 else if (TREE_TYPE (var) == error_mark_node)
727 expand_one_error_var (var);
728 else if (DECL_HARD_REGISTER (var))
729 expand_one_hard_reg_var (var);
730 else if (use_register_for_decl (var))
731 expand_one_register_var (var);
732 else if (defer_stack_allocation (var, toplevel))
733 add_stack_var (var);
734 else
735 expand_one_stack_var (var);
738 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
739 expanding variables. Those variables that can be put into registers
740 are allocated pseudos; those that can't are put on the stack.
742 TOPLEVEL is true if this is the outermost BLOCK. */
744 static void
745 expand_used_vars_for_block (tree block, bool toplevel)
747 size_t i, j, old_sv_num, this_sv_num, new_sv_num;
748 tree t;
750 old_sv_num = toplevel ? 0 : stack_vars_num;
752 /* Expand all variables at this level. */
753 for (t = BLOCK_VARS (block); t ; t = TREE_CHAIN (t))
754 if (TREE_USED (t))
755 expand_one_var (t, toplevel);
757 this_sv_num = stack_vars_num;
759 /* Expand all variables at containing levels. */
760 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
761 expand_used_vars_for_block (t, false);
763 /* Since we do not track exact variable lifetimes (which is not even
764 possible for varibles whose address escapes), we mirror the block
765 tree in the interference graph. Here we cause all variables at this
766 level, and all sublevels, to conflict. Do make certain that a
767 variable conflicts with itself. */
768 if (old_sv_num < this_sv_num)
770 new_sv_num = stack_vars_num;
771 resize_stack_vars_conflict (new_sv_num);
773 for (i = old_sv_num; i < new_sv_num; ++i)
774 for (j = i < this_sv_num ? i+1 : this_sv_num; j-- > old_sv_num ;)
775 add_stack_var_conflict (i, j);
779 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
780 and clear TREE_USED on all local variables. */
782 static void
783 clear_tree_used (tree block)
785 tree t;
787 for (t = BLOCK_VARS (block); t ; t = TREE_CHAIN (t))
788 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
789 TREE_USED (t) = 0;
791 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
792 clear_tree_used (t);
795 /* Examine TYPE and determine a bit mask of the following features. */
797 #define SPCT_HAS_LARGE_CHAR_ARRAY 1
798 #define SPCT_HAS_SMALL_CHAR_ARRAY 2
799 #define SPCT_HAS_ARRAY 4
800 #define SPCT_HAS_AGGREGATE 8
802 static unsigned int
803 stack_protect_classify_type (tree type)
805 unsigned int ret = 0;
806 tree t;
808 switch (TREE_CODE (type))
810 case ARRAY_TYPE:
811 t = TYPE_MAIN_VARIANT (TREE_TYPE (type));
812 if (t == char_type_node
813 || t == signed_char_type_node
814 || t == unsigned_char_type_node)
816 unsigned HOST_WIDE_INT max = PARAM_VALUE (PARAM_SSP_BUFFER_SIZE);
817 unsigned HOST_WIDE_INT len;
819 if (!TYPE_SIZE_UNIT (type)
820 || !host_integerp (TYPE_SIZE_UNIT (type), 1))
821 len = max;
822 else
823 len = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
825 if (len < max)
826 ret = SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_ARRAY;
827 else
828 ret = SPCT_HAS_LARGE_CHAR_ARRAY | SPCT_HAS_ARRAY;
830 else
831 ret = SPCT_HAS_ARRAY;
832 break;
834 case UNION_TYPE:
835 case QUAL_UNION_TYPE:
836 case RECORD_TYPE:
837 ret = SPCT_HAS_AGGREGATE;
838 for (t = TYPE_FIELDS (type); t ; t = TREE_CHAIN (t))
839 if (TREE_CODE (t) == FIELD_DECL)
840 ret |= stack_protect_classify_type (TREE_TYPE (t));
841 break;
843 default:
844 break;
847 return ret;
850 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
851 part of the local stack frame. Remember if we ever return nonzero for
852 any variable in this function. The return value is the phase number in
853 which the variable should be allocated. */
855 static int
856 stack_protect_decl_phase (tree decl)
858 unsigned int bits = stack_protect_classify_type (TREE_TYPE (decl));
859 int ret = 0;
861 if (bits & SPCT_HAS_SMALL_CHAR_ARRAY)
862 has_short_buffer = true;
864 if (flag_stack_protect == 2)
866 if ((bits & (SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_LARGE_CHAR_ARRAY))
867 && !(bits & SPCT_HAS_AGGREGATE))
868 ret = 1;
869 else if (bits & SPCT_HAS_ARRAY)
870 ret = 2;
872 else
873 ret = (bits & SPCT_HAS_LARGE_CHAR_ARRAY) != 0;
875 if (ret)
876 has_protected_decls = true;
878 return ret;
881 /* Two helper routines that check for phase 1 and phase 2. These are used
882 as callbacks for expand_stack_vars. */
884 static bool
885 stack_protect_decl_phase_1 (tree decl)
887 return stack_protect_decl_phase (decl) == 1;
890 static bool
891 stack_protect_decl_phase_2 (tree decl)
893 return stack_protect_decl_phase (decl) == 2;
896 /* Ensure that variables in different stack protection phases conflict
897 so that they are not merged and share the same stack slot. */
899 static void
900 add_stack_protection_conflicts (void)
902 size_t i, j, n = stack_vars_num;
903 unsigned char *phase;
905 phase = XNEWVEC (unsigned char, n);
906 for (i = 0; i < n; ++i)
907 phase[i] = stack_protect_decl_phase (stack_vars[i].decl);
909 for (i = 0; i < n; ++i)
911 unsigned char ph_i = phase[i];
912 for (j = 0; j < i; ++j)
913 if (ph_i != phase[j])
914 add_stack_var_conflict (i, j);
917 XDELETEVEC (phase);
920 /* Create a decl for the guard at the top of the stack frame. */
922 static void
923 create_stack_guard (void)
925 tree guard = build_decl (VAR_DECL, NULL, ptr_type_node);
926 TREE_THIS_VOLATILE (guard) = 1;
927 TREE_USED (guard) = 1;
928 expand_one_stack_var (guard);
929 cfun->stack_protect_guard = guard;
932 /* Expand all variables used in the function. */
934 static void
935 expand_used_vars (void)
937 tree t, outer_block = DECL_INITIAL (current_function_decl);
939 /* Compute the phase of the stack frame for this function. */
941 int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
942 int off = STARTING_FRAME_OFFSET % align;
943 frame_phase = off ? align - off : 0;
946 /* Set TREE_USED on all variables in the unexpanded_var_list. */
947 for (t = cfun->unexpanded_var_list; t; t = TREE_CHAIN (t))
948 TREE_USED (TREE_VALUE (t)) = 1;
950 /* Clear TREE_USED on all variables associated with a block scope. */
951 clear_tree_used (outer_block);
953 /* Initialize local stack smashing state. */
954 has_protected_decls = false;
955 has_short_buffer = false;
957 /* At this point all variables on the unexpanded_var_list with TREE_USED
958 set are not associated with any block scope. Lay them out. */
959 for (t = cfun->unexpanded_var_list; t; t = TREE_CHAIN (t))
961 tree var = TREE_VALUE (t);
962 bool expand_now = false;
964 /* We didn't set a block for static or extern because it's hard
965 to tell the difference between a global variable (re)declared
966 in a local scope, and one that's really declared there to
967 begin with. And it doesn't really matter much, since we're
968 not giving them stack space. Expand them now. */
969 if (TREE_STATIC (var) || DECL_EXTERNAL (var))
970 expand_now = true;
972 /* Any variable that could have been hoisted into an SSA_NAME
973 will have been propagated anywhere the optimizers chose,
974 i.e. not confined to their original block. Allocate them
975 as if they were defined in the outermost scope. */
976 else if (is_gimple_reg (var))
977 expand_now = true;
979 /* If the variable is not associated with any block, then it
980 was created by the optimizers, and could be live anywhere
981 in the function. */
982 else if (TREE_USED (var))
983 expand_now = true;
985 /* Finally, mark all variables on the list as used. We'll use
986 this in a moment when we expand those associated with scopes. */
987 TREE_USED (var) = 1;
989 if (expand_now)
990 expand_one_var (var, true);
992 cfun->unexpanded_var_list = NULL_TREE;
994 /* At this point, all variables within the block tree with TREE_USED
995 set are actually used by the optimized function. Lay them out. */
996 expand_used_vars_for_block (outer_block, true);
998 if (stack_vars_num > 0)
1000 /* Due to the way alias sets work, no variables with non-conflicting
1001 alias sets may be assigned the same address. Add conflicts to
1002 reflect this. */
1003 add_alias_set_conflicts ();
1005 /* If stack protection is enabled, we don't share space between
1006 vulnerable data and non-vulnerable data. */
1007 if (flag_stack_protect)
1008 add_stack_protection_conflicts ();
1010 /* Now that we have collected all stack variables, and have computed a
1011 minimal interference graph, attempt to save some stack space. */
1012 partition_stack_vars ();
1013 if (dump_file)
1014 dump_stack_var_partition ();
1017 /* There are several conditions under which we should create a
1018 stack guard: protect-all, alloca used, protected decls present. */
1019 if (flag_stack_protect == 2
1020 || (flag_stack_protect
1021 && (current_function_calls_alloca || has_protected_decls)))
1022 create_stack_guard ();
1024 /* Assign rtl to each variable based on these partitions. */
1025 if (stack_vars_num > 0)
1027 /* Reorder decls to be protected by iterating over the variables
1028 array multiple times, and allocating out of each phase in turn. */
1029 /* ??? We could probably integrate this into the qsort we did
1030 earlier, such that we naturally see these variables first,
1031 and thus naturally allocate things in the right order. */
1032 if (has_protected_decls)
1034 /* Phase 1 contains only character arrays. */
1035 expand_stack_vars (stack_protect_decl_phase_1);
1037 /* Phase 2 contains other kinds of arrays. */
1038 if (flag_stack_protect == 2)
1039 expand_stack_vars (stack_protect_decl_phase_2);
1042 expand_stack_vars (NULL);
1044 /* Free up stack variable graph data. */
1045 XDELETEVEC (stack_vars);
1046 XDELETEVEC (stack_vars_sorted);
1047 XDELETEVEC (stack_vars_conflict);
1048 stack_vars = NULL;
1049 stack_vars_alloc = stack_vars_num = 0;
1050 stack_vars_conflict = NULL;
1051 stack_vars_conflict_alloc = 0;
1054 /* If the target requires that FRAME_OFFSET be aligned, do it. */
1055 if (STACK_ALIGNMENT_NEEDED)
1057 HOST_WIDE_INT align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
1058 if (!FRAME_GROWS_DOWNWARD)
1059 frame_offset += align - 1;
1060 frame_offset &= -align;
1065 /* If we need to produce a detailed dump, print the tree representation
1066 for STMT to the dump file. SINCE is the last RTX after which the RTL
1067 generated for STMT should have been appended. */
1069 static void
1070 maybe_dump_rtl_for_tree_stmt (tree stmt, rtx since)
1072 if (dump_file && (dump_flags & TDF_DETAILS))
1074 fprintf (dump_file, "\n;; ");
1075 print_generic_expr (dump_file, stmt, TDF_SLIM);
1076 fprintf (dump_file, "\n");
1078 print_rtl (dump_file, since ? NEXT_INSN (since) : since);
1082 /* A subroutine of expand_gimple_basic_block. Expand one COND_EXPR.
1083 Returns a new basic block if we've terminated the current basic
1084 block and created a new one. */
1086 static basic_block
1087 expand_gimple_cond_expr (basic_block bb, tree stmt)
1089 basic_block new_bb, dest;
1090 edge new_edge;
1091 edge true_edge;
1092 edge false_edge;
1093 tree pred = COND_EXPR_COND (stmt);
1094 tree then_exp = COND_EXPR_THEN (stmt);
1095 tree else_exp = COND_EXPR_ELSE (stmt);
1096 rtx last2, last;
1098 last2 = last = get_last_insn ();
1100 extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
1101 if (EXPR_LOCUS (stmt))
1103 emit_line_note (*(EXPR_LOCUS (stmt)));
1104 record_block_change (TREE_BLOCK (stmt));
1107 /* These flags have no purpose in RTL land. */
1108 true_edge->flags &= ~EDGE_TRUE_VALUE;
1109 false_edge->flags &= ~EDGE_FALSE_VALUE;
1111 /* We can either have a pure conditional jump with one fallthru edge or
1112 two-way jump that needs to be decomposed into two basic blocks. */
1113 if (TREE_CODE (then_exp) == GOTO_EXPR && IS_EMPTY_STMT (else_exp))
1115 jumpif (pred, label_rtx (GOTO_DESTINATION (then_exp)));
1116 add_reg_br_prob_note (last, true_edge->probability);
1117 maybe_dump_rtl_for_tree_stmt (stmt, last);
1118 if (EXPR_LOCUS (then_exp))
1119 emit_line_note (*(EXPR_LOCUS (then_exp)));
1120 return NULL;
1122 if (TREE_CODE (else_exp) == GOTO_EXPR && IS_EMPTY_STMT (then_exp))
1124 jumpifnot (pred, label_rtx (GOTO_DESTINATION (else_exp)));
1125 add_reg_br_prob_note (last, false_edge->probability);
1126 maybe_dump_rtl_for_tree_stmt (stmt, last);
1127 if (EXPR_LOCUS (else_exp))
1128 emit_line_note (*(EXPR_LOCUS (else_exp)));
1129 return NULL;
1131 gcc_assert (TREE_CODE (then_exp) == GOTO_EXPR
1132 && TREE_CODE (else_exp) == GOTO_EXPR);
1134 jumpif (pred, label_rtx (GOTO_DESTINATION (then_exp)));
1135 add_reg_br_prob_note (last, true_edge->probability);
1136 last = get_last_insn ();
1137 expand_expr (else_exp, const0_rtx, VOIDmode, 0);
1139 BB_END (bb) = last;
1140 if (BARRIER_P (BB_END (bb)))
1141 BB_END (bb) = PREV_INSN (BB_END (bb));
1142 update_bb_for_insn (bb);
1144 new_bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
1145 dest = false_edge->dest;
1146 redirect_edge_succ (false_edge, new_bb);
1147 false_edge->flags |= EDGE_FALLTHRU;
1148 new_bb->count = false_edge->count;
1149 new_bb->frequency = EDGE_FREQUENCY (false_edge);
1150 new_edge = make_edge (new_bb, dest, 0);
1151 new_edge->probability = REG_BR_PROB_BASE;
1152 new_edge->count = new_bb->count;
1153 if (BARRIER_P (BB_END (new_bb)))
1154 BB_END (new_bb) = PREV_INSN (BB_END (new_bb));
1155 update_bb_for_insn (new_bb);
1157 maybe_dump_rtl_for_tree_stmt (stmt, last2);
1159 if (EXPR_LOCUS (else_exp))
1160 emit_line_note (*(EXPR_LOCUS (else_exp)));
1162 return new_bb;
1165 /* A subroutine of expand_gimple_basic_block. Expand one CALL_EXPR
1166 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
1167 generated a tail call (something that might be denied by the ABI
1168 rules governing the call; see calls.c).
1170 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
1171 can still reach the rest of BB. The case here is __builtin_sqrt,
1172 where the NaN result goes through the external function (with a
1173 tailcall) and the normal result happens via a sqrt instruction. */
1175 static basic_block
1176 expand_gimple_tailcall (basic_block bb, tree stmt, bool *can_fallthru)
1178 rtx last2, last;
1179 edge e;
1180 edge_iterator ei;
1181 int probability;
1182 gcov_type count;
1184 last2 = last = get_last_insn ();
1186 expand_expr_stmt (stmt);
1188 for (last = NEXT_INSN (last); last; last = NEXT_INSN (last))
1189 if (CALL_P (last) && SIBLING_CALL_P (last))
1190 goto found;
1192 maybe_dump_rtl_for_tree_stmt (stmt, last2);
1194 *can_fallthru = true;
1195 return NULL;
1197 found:
1198 /* ??? Wouldn't it be better to just reset any pending stack adjust?
1199 Any instructions emitted here are about to be deleted. */
1200 do_pending_stack_adjust ();
1202 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
1203 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
1204 EH or abnormal edges, we shouldn't have created a tail call in
1205 the first place. So it seems to me we should just be removing
1206 all edges here, or redirecting the existing fallthru edge to
1207 the exit block. */
1209 probability = 0;
1210 count = 0;
1212 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
1214 if (!(e->flags & (EDGE_ABNORMAL | EDGE_EH)))
1216 if (e->dest != EXIT_BLOCK_PTR)
1218 e->dest->count -= e->count;
1219 e->dest->frequency -= EDGE_FREQUENCY (e);
1220 if (e->dest->count < 0)
1221 e->dest->count = 0;
1222 if (e->dest->frequency < 0)
1223 e->dest->frequency = 0;
1225 count += e->count;
1226 probability += e->probability;
1227 remove_edge (e);
1229 else
1230 ei_next (&ei);
1233 /* This is somewhat ugly: the call_expr expander often emits instructions
1234 after the sibcall (to perform the function return). These confuse the
1235 find_many_sub_basic_blocks code, so we need to get rid of these. */
1236 last = NEXT_INSN (last);
1237 gcc_assert (BARRIER_P (last));
1239 *can_fallthru = false;
1240 while (NEXT_INSN (last))
1242 /* For instance an sqrt builtin expander expands if with
1243 sibcall in the then and label for `else`. */
1244 if (LABEL_P (NEXT_INSN (last)))
1246 *can_fallthru = true;
1247 break;
1249 delete_insn (NEXT_INSN (last));
1252 e = make_edge (bb, EXIT_BLOCK_PTR, EDGE_ABNORMAL | EDGE_SIBCALL);
1253 e->probability += probability;
1254 e->count += count;
1255 BB_END (bb) = last;
1256 update_bb_for_insn (bb);
1258 if (NEXT_INSN (last))
1260 bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
1262 last = BB_END (bb);
1263 if (BARRIER_P (last))
1264 BB_END (bb) = PREV_INSN (last);
1267 maybe_dump_rtl_for_tree_stmt (stmt, last2);
1269 return bb;
1272 /* Expand basic block BB from GIMPLE trees to RTL. */
1274 static basic_block
1275 expand_gimple_basic_block (basic_block bb)
1277 block_stmt_iterator bsi = bsi_start (bb);
1278 tree stmt = NULL;
1279 rtx note, last;
1280 edge e;
1281 edge_iterator ei;
1283 if (dump_file)
1285 fprintf (dump_file,
1286 "\n;; Generating RTL for tree basic block %d\n",
1287 bb->index);
1290 init_rtl_bb_info (bb);
1291 bb->flags |= BB_RTL;
1293 if (!bsi_end_p (bsi))
1294 stmt = bsi_stmt (bsi);
1296 if (stmt && TREE_CODE (stmt) == LABEL_EXPR)
1298 last = get_last_insn ();
1300 expand_expr_stmt (stmt);
1302 /* Java emits line number notes in the top of labels.
1303 ??? Make this go away once line number notes are obsoleted. */
1304 BB_HEAD (bb) = NEXT_INSN (last);
1305 if (NOTE_P (BB_HEAD (bb)))
1306 BB_HEAD (bb) = NEXT_INSN (BB_HEAD (bb));
1307 bsi_next (&bsi);
1308 note = emit_note_after (NOTE_INSN_BASIC_BLOCK, BB_HEAD (bb));
1310 maybe_dump_rtl_for_tree_stmt (stmt, last);
1312 else
1313 note = BB_HEAD (bb) = emit_note (NOTE_INSN_BASIC_BLOCK);
1315 NOTE_BASIC_BLOCK (note) = bb;
1317 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
1319 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
1320 e->flags &= ~EDGE_EXECUTABLE;
1322 /* At the moment not all abnormal edges match the RTL representation.
1323 It is safe to remove them here as find_many_sub_basic_blocks will
1324 rediscover them. In the future we should get this fixed properly. */
1325 if (e->flags & EDGE_ABNORMAL)
1326 remove_edge (e);
1327 else
1328 ei_next (&ei);
1331 for (; !bsi_end_p (bsi); bsi_next (&bsi))
1333 tree stmt = bsi_stmt (bsi);
1334 basic_block new_bb;
1336 if (!stmt)
1337 continue;
1339 /* Expand this statement, then evaluate the resulting RTL and
1340 fixup the CFG accordingly. */
1341 if (TREE_CODE (stmt) == COND_EXPR)
1343 new_bb = expand_gimple_cond_expr (bb, stmt);
1344 if (new_bb)
1345 return new_bb;
1347 else
1349 tree call = get_call_expr_in (stmt);
1350 if (call && CALL_EXPR_TAILCALL (call))
1352 bool can_fallthru;
1353 new_bb = expand_gimple_tailcall (bb, stmt, &can_fallthru);
1354 if (new_bb)
1356 if (can_fallthru)
1357 bb = new_bb;
1358 else
1359 return new_bb;
1362 else
1364 last = get_last_insn ();
1365 expand_expr_stmt (stmt);
1366 maybe_dump_rtl_for_tree_stmt (stmt, last);
1371 do_pending_stack_adjust ();
1373 /* Find the block tail. The last insn in the block is the insn
1374 before a barrier and/or table jump insn. */
1375 last = get_last_insn ();
1376 if (BARRIER_P (last))
1377 last = PREV_INSN (last);
1378 if (JUMP_TABLE_DATA_P (last))
1379 last = PREV_INSN (PREV_INSN (last));
1380 BB_END (bb) = last;
1382 update_bb_for_insn (bb);
1384 return bb;
1388 /* Create a basic block for initialization code. */
1390 static basic_block
1391 construct_init_block (void)
1393 basic_block init_block, first_block;
1394 edge e = NULL;
1395 int flags;
1397 /* Multiple entry points not supported yet. */
1398 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR->succs) == 1);
1399 init_rtl_bb_info (ENTRY_BLOCK_PTR);
1400 init_rtl_bb_info (EXIT_BLOCK_PTR);
1401 ENTRY_BLOCK_PTR->flags |= BB_RTL;
1402 EXIT_BLOCK_PTR->flags |= BB_RTL;
1404 e = EDGE_SUCC (ENTRY_BLOCK_PTR, 0);
1406 /* When entry edge points to first basic block, we don't need jump,
1407 otherwise we have to jump into proper target. */
1408 if (e && e->dest != ENTRY_BLOCK_PTR->next_bb)
1410 tree label = tree_block_label (e->dest);
1412 emit_jump (label_rtx (label));
1413 flags = 0;
1415 else
1416 flags = EDGE_FALLTHRU;
1418 init_block = create_basic_block (NEXT_INSN (get_insns ()),
1419 get_last_insn (),
1420 ENTRY_BLOCK_PTR);
1421 init_block->frequency = ENTRY_BLOCK_PTR->frequency;
1422 init_block->count = ENTRY_BLOCK_PTR->count;
1423 if (e)
1425 first_block = e->dest;
1426 redirect_edge_succ (e, init_block);
1427 e = make_edge (init_block, first_block, flags);
1429 else
1430 e = make_edge (init_block, EXIT_BLOCK_PTR, EDGE_FALLTHRU);
1431 e->probability = REG_BR_PROB_BASE;
1432 e->count = ENTRY_BLOCK_PTR->count;
1434 update_bb_for_insn (init_block);
1435 return init_block;
1439 /* Create a block containing landing pads and similar stuff. */
1441 static void
1442 construct_exit_block (void)
1444 rtx head = get_last_insn ();
1445 rtx end;
1446 basic_block exit_block;
1447 edge e, e2;
1448 unsigned ix;
1449 edge_iterator ei;
1451 /* Make sure the locus is set to the end of the function, so that
1452 epilogue line numbers and warnings are set properly. */
1453 #ifdef USE_MAPPED_LOCATION
1454 if (cfun->function_end_locus != UNKNOWN_LOCATION)
1455 #else
1456 if (cfun->function_end_locus.file)
1457 #endif
1458 input_location = cfun->function_end_locus;
1460 /* The following insns belong to the top scope. */
1461 record_block_change (DECL_INITIAL (current_function_decl));
1463 /* Generate rtl for function exit. */
1464 expand_function_end ();
1466 end = get_last_insn ();
1467 if (head == end)
1468 return;
1469 while (NEXT_INSN (head) && NOTE_P (NEXT_INSN (head)))
1470 head = NEXT_INSN (head);
1471 exit_block = create_basic_block (NEXT_INSN (head), end,
1472 EXIT_BLOCK_PTR->prev_bb);
1473 exit_block->frequency = EXIT_BLOCK_PTR->frequency;
1474 exit_block->count = EXIT_BLOCK_PTR->count;
1476 ix = 0;
1477 while (ix < EDGE_COUNT (EXIT_BLOCK_PTR->preds))
1479 e = EDGE_PRED (EXIT_BLOCK_PTR, ix);
1480 if (!(e->flags & EDGE_ABNORMAL))
1481 redirect_edge_succ (e, exit_block);
1482 else
1483 ix++;
1486 e = make_edge (exit_block, EXIT_BLOCK_PTR, EDGE_FALLTHRU);
1487 e->probability = REG_BR_PROB_BASE;
1488 e->count = EXIT_BLOCK_PTR->count;
1489 FOR_EACH_EDGE (e2, ei, EXIT_BLOCK_PTR->preds)
1490 if (e2 != e)
1492 e->count -= e2->count;
1493 exit_block->count -= e2->count;
1494 exit_block->frequency -= EDGE_FREQUENCY (e2);
1496 if (e->count < 0)
1497 e->count = 0;
1498 if (exit_block->count < 0)
1499 exit_block->count = 0;
1500 if (exit_block->frequency < 0)
1501 exit_block->frequency = 0;
1502 update_bb_for_insn (exit_block);
1505 /* Helper function for discover_nonconstant_array_refs.
1506 Look for ARRAY_REF nodes with non-constant indexes and mark them
1507 addressable. */
1509 static tree
1510 discover_nonconstant_array_refs_r (tree * tp, int *walk_subtrees,
1511 void *data ATTRIBUTE_UNUSED)
1513 tree t = *tp;
1515 if (IS_TYPE_OR_DECL_P (t))
1516 *walk_subtrees = 0;
1517 else if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1519 while (((TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1520 && is_gimple_min_invariant (TREE_OPERAND (t, 1))
1521 && (!TREE_OPERAND (t, 2)
1522 || is_gimple_min_invariant (TREE_OPERAND (t, 2))))
1523 || (TREE_CODE (t) == COMPONENT_REF
1524 && (!TREE_OPERAND (t,2)
1525 || is_gimple_min_invariant (TREE_OPERAND (t, 2))))
1526 || TREE_CODE (t) == BIT_FIELD_REF
1527 || TREE_CODE (t) == REALPART_EXPR
1528 || TREE_CODE (t) == IMAGPART_EXPR
1529 || TREE_CODE (t) == VIEW_CONVERT_EXPR
1530 || TREE_CODE (t) == NOP_EXPR
1531 || TREE_CODE (t) == CONVERT_EXPR)
1532 t = TREE_OPERAND (t, 0);
1534 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1536 t = get_base_address (t);
1537 if (t && DECL_P (t))
1538 TREE_ADDRESSABLE (t) = 1;
1541 *walk_subtrees = 0;
1544 return NULL_TREE;
1547 /* RTL expansion is not able to compile array references with variable
1548 offsets for arrays stored in single register. Discover such
1549 expressions and mark variables as addressable to avoid this
1550 scenario. */
1552 static void
1553 discover_nonconstant_array_refs (void)
1555 basic_block bb;
1556 block_stmt_iterator bsi;
1558 FOR_EACH_BB (bb)
1560 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
1561 walk_tree (bsi_stmt_ptr (bsi), discover_nonconstant_array_refs_r,
1562 NULL , NULL);
1566 /* Translate the intermediate representation contained in the CFG
1567 from GIMPLE trees to RTL.
1569 We do conversion per basic block and preserve/update the tree CFG.
1570 This implies we have to do some magic as the CFG can simultaneously
1571 consist of basic blocks containing RTL and GIMPLE trees. This can
1572 confuse the CFG hooks, so be careful to not manipulate CFG during
1573 the expansion. */
1575 static void
1576 tree_expand_cfg (void)
1578 basic_block bb, init_block;
1579 sbitmap blocks;
1581 /* Some backends want to know that we are expanding to RTL. */
1582 currently_expanding_to_rtl = 1;
1584 /* Prepare the rtl middle end to start recording block changes. */
1585 reset_block_changes ();
1587 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
1588 discover_nonconstant_array_refs ();
1590 /* Expand the variables recorded during gimple lowering. */
1591 expand_used_vars ();
1593 /* Honor stack protection warnings. */
1594 if (warn_stack_protect)
1596 if (current_function_calls_alloca)
1597 warning (0, "not protecting local variables: variable length buffer");
1598 if (has_short_buffer && !cfun->stack_protect_guard)
1599 warning (0, "not protecting function: no buffer at least %d bytes long",
1600 (int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE));
1603 /* Set up parameters and prepare for return, for the function. */
1604 expand_function_start (current_function_decl);
1606 /* If this function is `main', emit a call to `__main'
1607 to run global initializers, etc. */
1608 if (DECL_NAME (current_function_decl)
1609 && MAIN_NAME_P (DECL_NAME (current_function_decl))
1610 && DECL_FILE_SCOPE_P (current_function_decl))
1611 expand_main_function ();
1613 /* Initialize the stack_protect_guard field. This must happen after the
1614 call to __main (if any) so that the external decl is initialized. */
1615 if (cfun->stack_protect_guard)
1616 stack_protect_prologue ();
1618 /* Register rtl specific functions for cfg. */
1619 rtl_register_cfg_hooks ();
1621 init_block = construct_init_block ();
1623 FOR_BB_BETWEEN (bb, init_block->next_bb, EXIT_BLOCK_PTR, next_bb)
1624 bb = expand_gimple_basic_block (bb);
1626 construct_exit_block ();
1628 /* We're done expanding trees to RTL. */
1629 currently_expanding_to_rtl = 0;
1631 /* Convert tree EH labels to RTL EH labels, and clean out any unreachable
1632 EH regions. */
1633 convert_from_eh_region_ranges ();
1635 rebuild_jump_labels (get_insns ());
1636 find_exception_handler_labels ();
1638 blocks = sbitmap_alloc (last_basic_block);
1639 sbitmap_ones (blocks);
1640 find_many_sub_basic_blocks (blocks);
1641 purge_all_dead_edges ();
1642 sbitmap_free (blocks);
1644 compact_blocks ();
1645 #ifdef ENABLE_CHECKING
1646 verify_flow_info();
1647 #endif
1649 /* There's no need to defer outputting this function any more; we
1650 know we want to output it. */
1651 DECL_DEFER_OUTPUT (current_function_decl) = 0;
1653 /* Now that we're done expanding trees to RTL, we shouldn't have any
1654 more CONCATs anywhere. */
1655 generating_concat_p = 0;
1657 finalize_block_changes ();
1659 if (dump_file)
1661 fprintf (dump_file,
1662 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
1663 /* And the pass manager will dump RTL for us. */
1666 /* If we're emitting a nested function, make sure its parent gets
1667 emitted as well. Doing otherwise confuses debug info. */
1669 tree parent;
1670 for (parent = DECL_CONTEXT (current_function_decl);
1671 parent != NULL_TREE;
1672 parent = get_containing_scope (parent))
1673 if (TREE_CODE (parent) == FUNCTION_DECL)
1674 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent)) = 1;
1677 /* We are now committed to emitting code for this function. Do any
1678 preparation, such as emitting abstract debug info for the inline
1679 before it gets mangled by optimization. */
1680 if (cgraph_function_possibly_inlined_p (current_function_decl))
1681 (*debug_hooks->outlining_inline_function) (current_function_decl);
1683 TREE_ASM_WRITTEN (current_function_decl) = 1;
1685 /* After expanding, the return labels are no longer needed. */
1686 return_label = NULL;
1687 naked_return_label = NULL;
1690 struct tree_opt_pass pass_expand =
1692 "expand", /* name */
1693 NULL, /* gate */
1694 tree_expand_cfg, /* execute */
1695 NULL, /* sub */
1696 NULL, /* next */
1697 0, /* static_pass_number */
1698 TV_EXPAND, /* tv_id */
1699 /* ??? If TER is enabled, we actually receive GENERIC. */
1700 PROP_gimple_leh | PROP_cfg, /* properties_required */
1701 PROP_rtl, /* properties_provided */
1702 PROP_trees, /* properties_destroyed */
1703 0, /* todo_flags_start */
1704 TODO_dump_func, /* todo_flags_finish */
1705 'r' /* letter */