1 /* A pass for lowering trees to RTL.
2 Copyright (C) 2004, 2005 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING. If not, write to
18 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
19 Boston, MA 02110-1301, USA. */
23 #include "coretypes.h"
28 #include "basic-block.h"
31 #include "langhooks.h"
32 #include "tree-flow.h"
34 #include "tree-dump.h"
35 #include "tree-pass.h"
38 #include "diagnostic.h"
43 /* Verify that there is exactly single jump instruction since last and attach
44 REG_BR_PROB note specifying probability.
45 ??? We really ought to pass the probability down to RTL expanders and let it
46 re-distribute it when the conditional expands into multiple conditionals.
47 This is however difficult to do. */
49 add_reg_br_prob_note (FILE *dump_file
, rtx last
, int probability
)
51 if (profile_status
== PROFILE_ABSENT
)
53 for (last
= NEXT_INSN (last
); last
&& NEXT_INSN (last
); last
= NEXT_INSN (last
))
56 /* It is common to emit condjump-around-jump sequence when we don't know
57 how to reverse the conditional. Special case this. */
58 if (!any_condjump_p (last
)
59 || !JUMP_P (NEXT_INSN (last
))
60 || !simplejump_p (NEXT_INSN (last
))
61 || !NEXT_INSN (NEXT_INSN (last
))
62 || !BARRIER_P (NEXT_INSN (NEXT_INSN (last
)))
63 || !NEXT_INSN (NEXT_INSN (NEXT_INSN (last
)))
64 || !LABEL_P (NEXT_INSN (NEXT_INSN (NEXT_INSN (last
))))
65 || NEXT_INSN (NEXT_INSN (NEXT_INSN (NEXT_INSN (last
)))))
67 gcc_assert (!find_reg_note (last
, REG_BR_PROB
, 0));
69 = gen_rtx_EXPR_LIST (REG_BR_PROB
,
70 GEN_INT (REG_BR_PROB_BASE
- probability
),
74 if (!last
|| !JUMP_P (last
) || !any_condjump_p (last
))
76 gcc_assert (!find_reg_note (last
, REG_BR_PROB
, 0));
78 = gen_rtx_EXPR_LIST (REG_BR_PROB
,
79 GEN_INT (probability
), REG_NOTES (last
));
83 fprintf (dump_file
, "Failed to add probability note\n");
87 #ifndef LOCAL_ALIGNMENT
88 #define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT
91 #ifndef STACK_ALIGNMENT_NEEDED
92 #define STACK_ALIGNMENT_NEEDED 1
96 /* This structure holds data relevant to one variable that will be
97 placed in a stack slot. */
103 /* The offset of the variable. During partitioning, this is the
104 offset relative to the partition. After partitioning, this
105 is relative to the stack frame. */
106 HOST_WIDE_INT offset
;
108 /* Initially, the size of the variable. Later, the size of the partition,
109 if this variable becomes it's partition's representative. */
112 /* The *byte* alignment required for this variable. Or as, with the
113 size, the alignment for this partition. */
116 /* The partition representative. */
117 size_t representative
;
119 /* The next stack variable in the partition, or EOC. */
123 #define EOC ((size_t)-1)
125 /* We have an array of such objects while deciding allocation. */
126 static struct stack_var
*stack_vars
;
127 static size_t stack_vars_alloc
;
128 static size_t stack_vars_num
;
130 /* An array of indicies such that stack_vars[stack_vars_sorted[i]].size
131 is non-decreasing. */
132 static size_t *stack_vars_sorted
;
134 /* We have an interference graph between such objects. This graph
135 is lower triangular. */
136 static bool *stack_vars_conflict
;
137 static size_t stack_vars_conflict_alloc
;
139 /* The phase of the stack frame. This is the known misalignment of
140 virtual_stack_vars_rtx from PREFERRED_STACK_BOUNDARY. That is,
141 (frame_offset+frame_phase) % PREFERRED_STACK_BOUNDARY == 0. */
142 static int frame_phase
;
144 /* Used during expand_used_vars to remember if we saw any decls for
145 which we'd like to enable stack smashing protection. */
146 static bool has_protected_decls
;
148 /* Used during expand_used_vars. Remember if we say a character buffer
149 smaller than our cutoff threshold. Used for -Wstack-protector. */
150 static bool has_short_buffer
;
152 /* Discover the byte alignment to use for DECL. Ignore alignment
153 we can't do with expected alignment of the stack boundary. */
156 get_decl_align_unit (tree decl
)
160 align
= DECL_ALIGN (decl
);
161 align
= LOCAL_ALIGNMENT (TREE_TYPE (decl
), align
);
162 if (align
> PREFERRED_STACK_BOUNDARY
)
163 align
= PREFERRED_STACK_BOUNDARY
;
164 if (cfun
->stack_alignment_needed
< align
)
165 cfun
->stack_alignment_needed
= align
;
167 return align
/ BITS_PER_UNIT
;
170 /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
171 Return the frame offset. */
174 alloc_stack_frame_space (HOST_WIDE_INT size
, HOST_WIDE_INT align
)
176 HOST_WIDE_INT offset
, new_frame_offset
;
178 new_frame_offset
= frame_offset
;
179 if (FRAME_GROWS_DOWNWARD
)
181 new_frame_offset
-= size
+ frame_phase
;
182 new_frame_offset
&= -align
;
183 new_frame_offset
+= frame_phase
;
184 offset
= new_frame_offset
;
188 new_frame_offset
-= frame_phase
;
189 new_frame_offset
+= align
- 1;
190 new_frame_offset
&= -align
;
191 new_frame_offset
+= frame_phase
;
192 offset
= new_frame_offset
;
193 new_frame_offset
+= size
;
195 frame_offset
= new_frame_offset
;
200 /* Accumulate DECL into STACK_VARS. */
203 add_stack_var (tree decl
)
205 if (stack_vars_num
>= stack_vars_alloc
)
207 if (stack_vars_alloc
)
208 stack_vars_alloc
= stack_vars_alloc
* 3 / 2;
210 stack_vars_alloc
= 32;
212 = XRESIZEVEC (struct stack_var
, stack_vars
, stack_vars_alloc
);
214 stack_vars
[stack_vars_num
].decl
= decl
;
215 stack_vars
[stack_vars_num
].offset
= 0;
216 stack_vars
[stack_vars_num
].size
= tree_low_cst (DECL_SIZE_UNIT (decl
), 1);
217 stack_vars
[stack_vars_num
].alignb
= get_decl_align_unit (decl
);
219 /* All variables are initially in their own partition. */
220 stack_vars
[stack_vars_num
].representative
= stack_vars_num
;
221 stack_vars
[stack_vars_num
].next
= EOC
;
223 /* Ensure that this decl doesn't get put onto the list twice. */
224 SET_DECL_RTL (decl
, pc_rtx
);
229 /* Compute the linear index of a lower-triangular coordinate (I, J). */
232 triangular_index (size_t i
, size_t j
)
239 return (i
* (i
+ 1)) / 2 + j
;
242 /* Ensure that STACK_VARS_CONFLICT is large enough for N objects. */
245 resize_stack_vars_conflict (size_t n
)
247 size_t size
= triangular_index (n
-1, n
-1) + 1;
249 if (size
<= stack_vars_conflict_alloc
)
252 stack_vars_conflict
= XRESIZEVEC (bool, stack_vars_conflict
, size
);
253 memset (stack_vars_conflict
+ stack_vars_conflict_alloc
, 0,
254 (size
- stack_vars_conflict_alloc
) * sizeof (bool));
255 stack_vars_conflict_alloc
= size
;
258 /* Make the decls associated with luid's X and Y conflict. */
261 add_stack_var_conflict (size_t x
, size_t y
)
263 size_t index
= triangular_index (x
, y
);
264 gcc_assert (index
< stack_vars_conflict_alloc
);
265 stack_vars_conflict
[index
] = true;
268 /* Check whether the decls associated with luid's X and Y conflict. */
271 stack_var_conflict_p (size_t x
, size_t y
)
273 size_t index
= triangular_index (x
, y
);
274 gcc_assert (index
< stack_vars_conflict_alloc
);
275 return stack_vars_conflict
[index
];
278 /* Returns true if TYPE is or contains a union type. */
281 aggregate_contains_union_type (tree type
)
285 if (TREE_CODE (type
) == UNION_TYPE
286 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
288 if (TREE_CODE (type
) == ARRAY_TYPE
)
289 return aggregate_contains_union_type (TREE_TYPE (type
));
290 if (TREE_CODE (type
) != RECORD_TYPE
)
293 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
294 if (TREE_CODE (field
) == FIELD_DECL
)
295 if (aggregate_contains_union_type (TREE_TYPE (field
)))
301 /* A subroutine of expand_used_vars. If two variables X and Y have alias
302 sets that do not conflict, then do add a conflict for these variables
303 in the interference graph. We also need to make sure to add conflicts
304 for union containing structures. Else RTL alias analysis comes along
305 and due to type based aliasing rules decides that for two overlapping
306 union temporaries { short s; int i; } accesses to the same mem through
307 different types may not alias and happily reorders stores across
308 life-time boundaries of the temporaries (See PR25654).
309 We also have to mind MEM_IN_STRUCT_P and MEM_SCALAR_P. */
312 add_alias_set_conflicts (void)
314 size_t i
, j
, n
= stack_vars_num
;
316 for (i
= 0; i
< n
; ++i
)
318 tree type_i
= TREE_TYPE (stack_vars
[i
].decl
);
319 bool aggr_i
= AGGREGATE_TYPE_P (type_i
);
322 contains_union
= aggregate_contains_union_type (type_i
);
323 for (j
= 0; j
< i
; ++j
)
325 tree type_j
= TREE_TYPE (stack_vars
[j
].decl
);
326 bool aggr_j
= AGGREGATE_TYPE_P (type_j
);
328 /* Either the objects conflict by means of type based
329 aliasing rules, or we need to add a conflict. */
330 || !objects_must_conflict_p (type_i
, type_j
)
331 /* In case the types do not conflict ensure that access
332 to elements will conflict. In case of unions we have
333 to be careful as type based aliasing rules may say
334 access to the same memory does not conflict. So play
335 safe and add a conflict in this case. */
337 add_stack_var_conflict (i
, j
);
342 /* A subroutine of partition_stack_vars. A comparison function for qsort,
343 sorting an array of indicies by the size of the object. */
346 stack_var_size_cmp (const void *a
, const void *b
)
348 HOST_WIDE_INT sa
= stack_vars
[*(const size_t *)a
].size
;
349 HOST_WIDE_INT sb
= stack_vars
[*(const size_t *)b
].size
;
358 /* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
359 partitioning algorithm. Partitions A and B are known to be non-conflicting.
360 Merge them into a single partition A.
362 At the same time, add OFFSET to all variables in partition B. At the end
363 of the partitioning process we've have a nice block easy to lay out within
367 union_stack_vars (size_t a
, size_t b
, HOST_WIDE_INT offset
)
371 /* Update each element of partition B with the given offset,
372 and merge them into partition A. */
373 for (last
= i
= b
; i
!= EOC
; last
= i
, i
= stack_vars
[i
].next
)
375 stack_vars
[i
].offset
+= offset
;
376 stack_vars
[i
].representative
= a
;
378 stack_vars
[last
].next
= stack_vars
[a
].next
;
379 stack_vars
[a
].next
= b
;
381 /* Update the required alignment of partition A to account for B. */
382 if (stack_vars
[a
].alignb
< stack_vars
[b
].alignb
)
383 stack_vars
[a
].alignb
= stack_vars
[b
].alignb
;
385 /* Update the interference graph and merge the conflicts. */
386 for (last
= stack_vars_num
, i
= 0; i
< last
; ++i
)
387 if (stack_var_conflict_p (b
, i
))
388 add_stack_var_conflict (a
, i
);
391 /* A subroutine of expand_used_vars. Binpack the variables into
392 partitions constrained by the interference graph. The overall
393 algorithm used is as follows:
395 Sort the objects by size.
400 Look for the largest non-conflicting object B with size <= S.
410 partition_stack_vars (void)
412 size_t si
, sj
, n
= stack_vars_num
;
414 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
415 for (si
= 0; si
< n
; ++si
)
416 stack_vars_sorted
[si
] = si
;
421 qsort (stack_vars_sorted
, n
, sizeof (size_t), stack_var_size_cmp
);
423 /* Special case: detect when all variables conflict, and thus we can't
424 do anything during the partitioning loop. It isn't uncommon (with
425 C code at least) to declare all variables at the top of the function,
426 and if we're not inlining, then all variables will be in the same scope.
427 Take advantage of very fast libc routines for this scan. */
428 gcc_assert (sizeof(bool) == sizeof(char));
429 if (memchr (stack_vars_conflict
, false, stack_vars_conflict_alloc
) == NULL
)
432 for (si
= 0; si
< n
; ++si
)
434 size_t i
= stack_vars_sorted
[si
];
435 HOST_WIDE_INT isize
= stack_vars
[i
].size
;
436 HOST_WIDE_INT offset
= 0;
438 for (sj
= si
; sj
-- > 0; )
440 size_t j
= stack_vars_sorted
[sj
];
441 HOST_WIDE_INT jsize
= stack_vars
[j
].size
;
442 unsigned int jalign
= stack_vars
[j
].alignb
;
444 /* Ignore objects that aren't partition representatives. */
445 if (stack_vars
[j
].representative
!= j
)
448 /* Ignore objects too large for the remaining space. */
452 /* Ignore conflicting objects. */
453 if (stack_var_conflict_p (i
, j
))
456 /* Refine the remaining space check to include alignment. */
457 if (offset
& (jalign
- 1))
459 HOST_WIDE_INT toff
= offset
;
461 toff
&= -(HOST_WIDE_INT
)jalign
;
462 if (isize
- (toff
- offset
) < jsize
)
465 isize
-= toff
- offset
;
469 /* UNION the objects, placing J at OFFSET. */
470 union_stack_vars (i
, j
, offset
);
479 /* A debugging aid for expand_used_vars. Dump the generated partitions. */
482 dump_stack_var_partition (void)
484 size_t si
, i
, j
, n
= stack_vars_num
;
486 for (si
= 0; si
< n
; ++si
)
488 i
= stack_vars_sorted
[si
];
490 /* Skip variables that aren't partition representatives, for now. */
491 if (stack_vars
[i
].representative
!= i
)
494 fprintf (dump_file
, "Partition %lu: size " HOST_WIDE_INT_PRINT_DEC
495 " align %u\n", (unsigned long) i
, stack_vars
[i
].size
,
496 stack_vars
[i
].alignb
);
498 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
500 fputc ('\t', dump_file
);
501 print_generic_expr (dump_file
, stack_vars
[j
].decl
, dump_flags
);
502 fprintf (dump_file
, ", offset " HOST_WIDE_INT_PRINT_DEC
"\n",
503 stack_vars
[i
].offset
);
508 /* Assign rtl to DECL at frame offset OFFSET. */
511 expand_one_stack_var_at (tree decl
, HOST_WIDE_INT offset
)
516 /* If this fails, we've overflowed the stack frame. Error nicely? */
517 gcc_assert (offset
== trunc_int_for_mode (offset
, Pmode
));
519 x
= plus_constant (virtual_stack_vars_rtx
, offset
);
520 x
= gen_rtx_MEM (DECL_MODE (decl
), x
);
522 /* Set alignment we actually gave this decl. */
523 offset
-= frame_phase
;
524 align
= offset
& -offset
;
525 align
*= BITS_PER_UNIT
;
526 if (align
> STACK_BOUNDARY
|| align
== 0)
527 align
= STACK_BOUNDARY
;
528 DECL_ALIGN (decl
) = align
;
529 DECL_USER_ALIGN (decl
) = 0;
531 set_mem_attributes (x
, decl
, true);
532 SET_DECL_RTL (decl
, x
);
535 /* A subroutine of expand_used_vars. Give each partition representative
536 a unique location within the stack frame. Update each partition member
537 with that location. */
540 expand_stack_vars (bool (*pred
) (tree
))
542 size_t si
, i
, j
, n
= stack_vars_num
;
544 for (si
= 0; si
< n
; ++si
)
546 HOST_WIDE_INT offset
;
548 i
= stack_vars_sorted
[si
];
550 /* Skip variables that aren't partition representatives, for now. */
551 if (stack_vars
[i
].representative
!= i
)
554 /* Skip variables that have already had rtl assigned. See also
555 add_stack_var where we perpetrate this pc_rtx hack. */
556 if (DECL_RTL (stack_vars
[i
].decl
) != pc_rtx
)
559 /* Check the predicate to see whether this variable should be
560 allocated in this pass. */
561 if (pred
&& !pred (stack_vars
[i
].decl
))
564 offset
= alloc_stack_frame_space (stack_vars
[i
].size
,
565 stack_vars
[i
].alignb
);
567 /* Create rtl for each variable based on their location within the
569 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
570 expand_one_stack_var_at (stack_vars
[j
].decl
,
571 stack_vars
[j
].offset
+ offset
);
575 /* A subroutine of expand_one_var. Called to immediately assign rtl
576 to a variable to be allocated in the stack frame. */
579 expand_one_stack_var (tree var
)
581 HOST_WIDE_INT size
, offset
, align
;
583 size
= tree_low_cst (DECL_SIZE_UNIT (var
), 1);
584 align
= get_decl_align_unit (var
);
585 offset
= alloc_stack_frame_space (size
, align
);
587 expand_one_stack_var_at (var
, offset
);
590 /* A subroutine of expand_one_var. Called to assign rtl
591 to a TREE_STATIC VAR_DECL. */
594 expand_one_static_var (tree var
)
596 /* In unit-at-a-time all the static variables are expanded at the end
597 of compilation process. */
598 if (flag_unit_at_a_time
)
600 /* If this is an inlined copy of a static local variable,
601 look up the original. */
602 var
= DECL_ORIGIN (var
);
604 /* If we've already processed this variable because of that, do nothing. */
605 if (TREE_ASM_WRITTEN (var
))
608 /* Give the front end a chance to do whatever. In practice, this is
609 resolving duplicate names for IMA in C. */
610 if (lang_hooks
.expand_decl (var
))
613 /* Otherwise, just emit the variable. */
614 rest_of_decl_compilation (var
, 0, 0);
617 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
618 that will reside in a hard register. */
621 expand_one_hard_reg_var (tree var
)
623 rest_of_decl_compilation (var
, 0, 0);
626 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
627 that will reside in a pseudo register. */
630 expand_one_register_var (tree var
)
632 tree type
= TREE_TYPE (var
);
633 int unsignedp
= TYPE_UNSIGNED (type
);
634 enum machine_mode reg_mode
635 = promote_mode (type
, DECL_MODE (var
), &unsignedp
, 0);
636 rtx x
= gen_reg_rtx (reg_mode
);
638 SET_DECL_RTL (var
, x
);
640 /* Note if the object is a user variable. */
641 if (!DECL_ARTIFICIAL (var
))
645 /* Trust user variables which have a pointer type to really
646 be pointers. Do not trust compiler generated temporaries
647 as our type system is totally busted as it relates to
648 pointer arithmetic which translates into lots of compiler
649 generated objects with pointer types, but which are not really
651 if (POINTER_TYPE_P (type
))
652 mark_reg_pointer (x
, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (var
))));
656 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
657 has some associated error, e.g. its type is error-mark. We just need
658 to pick something that won't crash the rest of the compiler. */
661 expand_one_error_var (tree var
)
663 enum machine_mode mode
= DECL_MODE (var
);
667 x
= gen_rtx_MEM (BLKmode
, const0_rtx
);
668 else if (mode
== VOIDmode
)
671 x
= gen_reg_rtx (mode
);
673 SET_DECL_RTL (var
, x
);
676 /* A subroutine of expand_one_var. VAR is a variable that will be
677 allocated to the local stack frame. Return true if we wish to
678 add VAR to STACK_VARS so that it will be coalesced with other
679 variables. Return false to allocate VAR immediately.
681 This function is used to reduce the number of variables considered
682 for coalescing, which reduces the size of the quadratic problem. */
685 defer_stack_allocation (tree var
, bool toplevel
)
687 /* If stack protection is enabled, *all* stack variables must be deferred,
688 so that we can re-order the strings to the top of the frame. */
689 if (flag_stack_protect
)
692 /* Variables in the outermost scope automatically conflict with
693 every other variable. The only reason to want to defer them
694 at all is that, after sorting, we can more efficiently pack
695 small variables in the stack frame. Continue to defer at -O2. */
696 if (toplevel
&& optimize
< 2)
699 /* Without optimization, *most* variables are allocated from the
700 stack, which makes the quadratic problem large exactly when we
701 want compilation to proceed as quickly as possible. On the
702 other hand, we don't want the function's stack frame size to
703 get completely out of hand. So we avoid adding scalars and
704 "small" aggregates to the list at all. */
705 if (optimize
== 0 && tree_low_cst (DECL_SIZE_UNIT (var
), 1) < 32)
711 /* A subroutine of expand_used_vars. Expand one variable according to
712 its flavor. Variables to be placed on the stack are not actually
713 expanded yet, merely recorded. */
716 expand_one_var (tree var
, bool toplevel
)
718 if (TREE_CODE (var
) != VAR_DECL
)
719 lang_hooks
.expand_decl (var
);
720 else if (DECL_EXTERNAL (var
))
722 else if (DECL_HAS_VALUE_EXPR_P (var
))
724 else if (TREE_STATIC (var
))
725 expand_one_static_var (var
);
726 else if (DECL_RTL_SET_P (var
))
728 else if (TREE_TYPE (var
) == error_mark_node
)
729 expand_one_error_var (var
);
730 else if (DECL_HARD_REGISTER (var
))
731 expand_one_hard_reg_var (var
);
732 else if (use_register_for_decl (var
))
733 expand_one_register_var (var
);
734 else if (defer_stack_allocation (var
, toplevel
))
737 expand_one_stack_var (var
);
740 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
741 expanding variables. Those variables that can be put into registers
742 are allocated pseudos; those that can't are put on the stack.
744 TOPLEVEL is true if this is the outermost BLOCK. */
747 expand_used_vars_for_block (tree block
, bool toplevel
)
749 size_t i
, j
, old_sv_num
, this_sv_num
, new_sv_num
;
752 old_sv_num
= toplevel
? 0 : stack_vars_num
;
754 /* Expand all variables at this level. */
755 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
757 expand_one_var (t
, toplevel
);
759 this_sv_num
= stack_vars_num
;
761 /* Expand all variables at containing levels. */
762 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
763 expand_used_vars_for_block (t
, false);
765 /* Since we do not track exact variable lifetimes (which is not even
766 possible for varibles whose address escapes), we mirror the block
767 tree in the interference graph. Here we cause all variables at this
768 level, and all sublevels, to conflict. Do make certain that a
769 variable conflicts with itself. */
770 if (old_sv_num
< this_sv_num
)
772 new_sv_num
= stack_vars_num
;
773 resize_stack_vars_conflict (new_sv_num
);
775 for (i
= old_sv_num
; i
< new_sv_num
; ++i
)
776 for (j
= i
< this_sv_num
? i
+1 : this_sv_num
; j
-- > old_sv_num
;)
777 add_stack_var_conflict (i
, j
);
781 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
782 and clear TREE_USED on all local variables. */
785 clear_tree_used (tree block
)
789 for (t
= BLOCK_VARS (block
); t
; t
= TREE_CHAIN (t
))
790 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
793 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
797 /* Examine TYPE and determine a bit mask of the following features. */
799 #define SPCT_HAS_LARGE_CHAR_ARRAY 1
800 #define SPCT_HAS_SMALL_CHAR_ARRAY 2
801 #define SPCT_HAS_ARRAY 4
802 #define SPCT_HAS_AGGREGATE 8
805 stack_protect_classify_type (tree type
)
807 unsigned int ret
= 0;
810 switch (TREE_CODE (type
))
813 t
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
814 if (t
== char_type_node
815 || t
== signed_char_type_node
816 || t
== unsigned_char_type_node
)
818 unsigned HOST_WIDE_INT max
= PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
);
819 unsigned HOST_WIDE_INT len
;
821 if (!TYPE_SIZE_UNIT (type
)
822 || !host_integerp (TYPE_SIZE_UNIT (type
), 1))
825 len
= tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
828 ret
= SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
830 ret
= SPCT_HAS_LARGE_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
833 ret
= SPCT_HAS_ARRAY
;
837 case QUAL_UNION_TYPE
:
839 ret
= SPCT_HAS_AGGREGATE
;
840 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
841 if (TREE_CODE (t
) == FIELD_DECL
)
842 ret
|= stack_protect_classify_type (TREE_TYPE (t
));
852 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
853 part of the local stack frame. Remember if we ever return nonzero for
854 any variable in this function. The return value is the phase number in
855 which the variable should be allocated. */
858 stack_protect_decl_phase (tree decl
)
860 unsigned int bits
= stack_protect_classify_type (TREE_TYPE (decl
));
863 if (bits
& SPCT_HAS_SMALL_CHAR_ARRAY
)
864 has_short_buffer
= true;
866 if (flag_stack_protect
== 2)
868 if ((bits
& (SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_LARGE_CHAR_ARRAY
))
869 && !(bits
& SPCT_HAS_AGGREGATE
))
871 else if (bits
& SPCT_HAS_ARRAY
)
875 ret
= (bits
& SPCT_HAS_LARGE_CHAR_ARRAY
) != 0;
878 has_protected_decls
= true;
883 /* Two helper routines that check for phase 1 and phase 2. These are used
884 as callbacks for expand_stack_vars. */
887 stack_protect_decl_phase_1 (tree decl
)
889 return stack_protect_decl_phase (decl
) == 1;
893 stack_protect_decl_phase_2 (tree decl
)
895 return stack_protect_decl_phase (decl
) == 2;
898 /* Ensure that variables in different stack protection phases conflict
899 so that they are not merged and share the same stack slot. */
902 add_stack_protection_conflicts (void)
904 size_t i
, j
, n
= stack_vars_num
;
905 unsigned char *phase
;
907 phase
= XNEWVEC (unsigned char, n
);
908 for (i
= 0; i
< n
; ++i
)
909 phase
[i
] = stack_protect_decl_phase (stack_vars
[i
].decl
);
911 for (i
= 0; i
< n
; ++i
)
913 unsigned char ph_i
= phase
[i
];
914 for (j
= 0; j
< i
; ++j
)
915 if (ph_i
!= phase
[j
])
916 add_stack_var_conflict (i
, j
);
922 /* Create a decl for the guard at the top of the stack frame. */
925 create_stack_guard (void)
927 tree guard
= build_decl (VAR_DECL
, NULL
, ptr_type_node
);
928 TREE_THIS_VOLATILE (guard
) = 1;
929 TREE_USED (guard
) = 1;
930 expand_one_stack_var (guard
);
931 cfun
->stack_protect_guard
= guard
;
934 /* Expand all variables used in the function. */
937 expand_used_vars (void)
939 tree t
, outer_block
= DECL_INITIAL (current_function_decl
);
941 /* Compute the phase of the stack frame for this function. */
943 int align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
944 int off
= STARTING_FRAME_OFFSET
% align
;
945 frame_phase
= off
? align
- off
: 0;
948 /* Set TREE_USED on all variables in the unexpanded_var_list. */
949 for (t
= cfun
->unexpanded_var_list
; t
; t
= TREE_CHAIN (t
))
950 TREE_USED (TREE_VALUE (t
)) = 1;
952 /* Clear TREE_USED on all variables associated with a block scope. */
953 clear_tree_used (outer_block
);
955 /* Initialize local stack smashing state. */
956 has_protected_decls
= false;
957 has_short_buffer
= false;
959 /* At this point all variables on the unexpanded_var_list with TREE_USED
960 set are not associated with any block scope. Lay them out. */
961 for (t
= cfun
->unexpanded_var_list
; t
; t
= TREE_CHAIN (t
))
963 tree var
= TREE_VALUE (t
);
964 bool expand_now
= false;
966 /* We didn't set a block for static or extern because it's hard
967 to tell the difference between a global variable (re)declared
968 in a local scope, and one that's really declared there to
969 begin with. And it doesn't really matter much, since we're
970 not giving them stack space. Expand them now. */
971 if (TREE_STATIC (var
) || DECL_EXTERNAL (var
))
974 /* Any variable that could have been hoisted into an SSA_NAME
975 will have been propagated anywhere the optimizers chose,
976 i.e. not confined to their original block. Allocate them
977 as if they were defined in the outermost scope. */
978 else if (is_gimple_reg (var
))
981 /* If the variable is not associated with any block, then it
982 was created by the optimizers, and could be live anywhere
984 else if (TREE_USED (var
))
987 /* Finally, mark all variables on the list as used. We'll use
988 this in a moment when we expand those associated with scopes. */
992 expand_one_var (var
, true);
994 cfun
->unexpanded_var_list
= NULL_TREE
;
996 /* At this point, all variables within the block tree with TREE_USED
997 set are actually used by the optimized function. Lay them out. */
998 expand_used_vars_for_block (outer_block
, true);
1000 if (stack_vars_num
> 0)
1002 /* Due to the way alias sets work, no variables with non-conflicting
1003 alias sets may be assigned the same address. Add conflicts to
1005 add_alias_set_conflicts ();
1007 /* If stack protection is enabled, we don't share space between
1008 vulnerable data and non-vulnerable data. */
1009 if (flag_stack_protect
)
1010 add_stack_protection_conflicts ();
1012 /* Now that we have collected all stack variables, and have computed a
1013 minimal interference graph, attempt to save some stack space. */
1014 partition_stack_vars ();
1016 dump_stack_var_partition ();
1019 /* There are several conditions under which we should create a
1020 stack guard: protect-all, alloca used, protected decls present. */
1021 if (flag_stack_protect
== 2
1022 || (flag_stack_protect
1023 && (current_function_calls_alloca
|| has_protected_decls
)))
1024 create_stack_guard ();
1026 /* Assign rtl to each variable based on these partitions. */
1027 if (stack_vars_num
> 0)
1029 /* Reorder decls to be protected by iterating over the variables
1030 array multiple times, and allocating out of each phase in turn. */
1031 /* ??? We could probably integrate this into the qsort we did
1032 earlier, such that we naturally see these variables first,
1033 and thus naturally allocate things in the right order. */
1034 if (has_protected_decls
)
1036 /* Phase 1 contains only character arrays. */
1037 expand_stack_vars (stack_protect_decl_phase_1
);
1039 /* Phase 2 contains other kinds of arrays. */
1040 if (flag_stack_protect
== 2)
1041 expand_stack_vars (stack_protect_decl_phase_2
);
1044 expand_stack_vars (NULL
);
1046 /* Free up stack variable graph data. */
1047 XDELETEVEC (stack_vars
);
1048 XDELETEVEC (stack_vars_sorted
);
1049 XDELETEVEC (stack_vars_conflict
);
1051 stack_vars_alloc
= stack_vars_num
= 0;
1052 stack_vars_conflict
= NULL
;
1053 stack_vars_conflict_alloc
= 0;
1056 /* If the target requires that FRAME_OFFSET be aligned, do it. */
1057 if (STACK_ALIGNMENT_NEEDED
)
1059 HOST_WIDE_INT align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
1060 if (!FRAME_GROWS_DOWNWARD
)
1061 frame_offset
+= align
- 1;
1062 frame_offset
&= -align
;
1067 /* If we need to produce a detailed dump, print the tree representation
1068 for STMT to the dump file. SINCE is the last RTX after which the RTL
1069 generated for STMT should have been appended. */
1072 maybe_dump_rtl_for_tree_stmt (tree stmt
, rtx since
)
1074 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1076 fprintf (dump_file
, "\n;; ");
1077 print_generic_expr (dump_file
, stmt
, TDF_SLIM
);
1078 fprintf (dump_file
, "\n");
1080 print_rtl (dump_file
, since
? NEXT_INSN (since
) : since
);
1084 /* A subroutine of expand_gimple_basic_block. Expand one COND_EXPR.
1085 Returns a new basic block if we've terminated the current basic
1086 block and created a new one. */
1089 expand_gimple_cond_expr (basic_block bb
, tree stmt
)
1091 basic_block new_bb
, dest
;
1095 tree pred
= COND_EXPR_COND (stmt
);
1096 tree then_exp
= COND_EXPR_THEN (stmt
);
1097 tree else_exp
= COND_EXPR_ELSE (stmt
);
1100 last2
= last
= get_last_insn ();
1102 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
1103 if (EXPR_LOCUS (stmt
))
1105 emit_line_note (*(EXPR_LOCUS (stmt
)));
1106 record_block_change (TREE_BLOCK (stmt
));
1109 /* These flags have no purpose in RTL land. */
1110 true_edge
->flags
&= ~EDGE_TRUE_VALUE
;
1111 false_edge
->flags
&= ~EDGE_FALSE_VALUE
;
1113 /* We can either have a pure conditional jump with one fallthru edge or
1114 two-way jump that needs to be decomposed into two basic blocks. */
1115 if (TREE_CODE (then_exp
) == GOTO_EXPR
&& IS_EMPTY_STMT (else_exp
))
1117 jumpif (pred
, label_rtx (GOTO_DESTINATION (then_exp
)));
1118 add_reg_br_prob_note (dump_file
, last
, true_edge
->probability
);
1119 maybe_dump_rtl_for_tree_stmt (stmt
, last
);
1120 if (EXPR_LOCUS (then_exp
))
1121 emit_line_note (*(EXPR_LOCUS (then_exp
)));
1124 if (TREE_CODE (else_exp
) == GOTO_EXPR
&& IS_EMPTY_STMT (then_exp
))
1126 jumpifnot (pred
, label_rtx (GOTO_DESTINATION (else_exp
)));
1127 add_reg_br_prob_note (dump_file
, last
, false_edge
->probability
);
1128 maybe_dump_rtl_for_tree_stmt (stmt
, last
);
1129 if (EXPR_LOCUS (else_exp
))
1130 emit_line_note (*(EXPR_LOCUS (else_exp
)));
1133 gcc_assert (TREE_CODE (then_exp
) == GOTO_EXPR
1134 && TREE_CODE (else_exp
) == GOTO_EXPR
);
1136 jumpif (pred
, label_rtx (GOTO_DESTINATION (then_exp
)));
1137 add_reg_br_prob_note (dump_file
, last
, true_edge
->probability
);
1138 last
= get_last_insn ();
1139 expand_expr (else_exp
, const0_rtx
, VOIDmode
, 0);
1142 if (BARRIER_P (BB_END (bb
)))
1143 BB_END (bb
) = PREV_INSN (BB_END (bb
));
1144 update_bb_for_insn (bb
);
1146 new_bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
1147 dest
= false_edge
->dest
;
1148 redirect_edge_succ (false_edge
, new_bb
);
1149 false_edge
->flags
|= EDGE_FALLTHRU
;
1150 new_bb
->count
= false_edge
->count
;
1151 new_bb
->frequency
= EDGE_FREQUENCY (false_edge
);
1152 new_edge
= make_edge (new_bb
, dest
, 0);
1153 new_edge
->probability
= REG_BR_PROB_BASE
;
1154 new_edge
->count
= new_bb
->count
;
1155 if (BARRIER_P (BB_END (new_bb
)))
1156 BB_END (new_bb
) = PREV_INSN (BB_END (new_bb
));
1157 update_bb_for_insn (new_bb
);
1159 maybe_dump_rtl_for_tree_stmt (stmt
, last2
);
1161 if (EXPR_LOCUS (else_exp
))
1162 emit_line_note (*(EXPR_LOCUS (else_exp
)));
1167 /* A subroutine of expand_gimple_basic_block. Expand one CALL_EXPR
1168 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
1169 generated a tail call (something that might be denied by the ABI
1170 rules governing the call; see calls.c).
1172 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
1173 can still reach the rest of BB. The case here is __builtin_sqrt,
1174 where the NaN result goes through the external function (with a
1175 tailcall) and the normal result happens via a sqrt instruction. */
1178 expand_gimple_tailcall (basic_block bb
, tree stmt
, bool *can_fallthru
)
1186 last2
= last
= get_last_insn ();
1188 expand_expr_stmt (stmt
);
1190 for (last
= NEXT_INSN (last
); last
; last
= NEXT_INSN (last
))
1191 if (CALL_P (last
) && SIBLING_CALL_P (last
))
1194 maybe_dump_rtl_for_tree_stmt (stmt
, last2
);
1196 *can_fallthru
= true;
1200 /* ??? Wouldn't it be better to just reset any pending stack adjust?
1201 Any instructions emitted here are about to be deleted. */
1202 do_pending_stack_adjust ();
1204 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
1205 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
1206 EH or abnormal edges, we shouldn't have created a tail call in
1207 the first place. So it seems to me we should just be removing
1208 all edges here, or redirecting the existing fallthru edge to
1214 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
1216 if (!(e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
)))
1218 if (e
->dest
!= EXIT_BLOCK_PTR
)
1220 e
->dest
->count
-= e
->count
;
1221 e
->dest
->frequency
-= EDGE_FREQUENCY (e
);
1222 if (e
->dest
->count
< 0)
1224 if (e
->dest
->frequency
< 0)
1225 e
->dest
->frequency
= 0;
1228 probability
+= e
->probability
;
1235 /* This is somewhat ugly: the call_expr expander often emits instructions
1236 after the sibcall (to perform the function return). These confuse the
1237 find_many_sub_basic_blocks code, so we need to get rid of these. */
1238 last
= NEXT_INSN (last
);
1239 gcc_assert (BARRIER_P (last
));
1241 *can_fallthru
= false;
1242 while (NEXT_INSN (last
))
1244 /* For instance an sqrt builtin expander expands if with
1245 sibcall in the then and label for `else`. */
1246 if (LABEL_P (NEXT_INSN (last
)))
1248 *can_fallthru
= true;
1251 delete_insn (NEXT_INSN (last
));
1254 e
= make_edge (bb
, EXIT_BLOCK_PTR
, EDGE_ABNORMAL
| EDGE_SIBCALL
);
1255 e
->probability
+= probability
;
1258 update_bb_for_insn (bb
);
1260 if (NEXT_INSN (last
))
1262 bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
1265 if (BARRIER_P (last
))
1266 BB_END (bb
) = PREV_INSN (last
);
1269 maybe_dump_rtl_for_tree_stmt (stmt
, last2
);
1274 /* Expand basic block BB from GIMPLE trees to RTL. */
1277 expand_gimple_basic_block (basic_block bb
, FILE * dump_file
)
1279 block_stmt_iterator bsi
= bsi_start (bb
);
1288 "\n;; Generating RTL for tree basic block %d\n",
1292 init_rtl_bb_info (bb
);
1293 bb
->flags
|= BB_RTL
;
1295 if (!bsi_end_p (bsi
))
1296 stmt
= bsi_stmt (bsi
);
1298 if (stmt
&& TREE_CODE (stmt
) == LABEL_EXPR
)
1300 last
= get_last_insn ();
1302 expand_expr_stmt (stmt
);
1304 /* Java emits line number notes in the top of labels.
1305 ??? Make this go away once line number notes are obsoleted. */
1306 BB_HEAD (bb
) = NEXT_INSN (last
);
1307 if (NOTE_P (BB_HEAD (bb
)))
1308 BB_HEAD (bb
) = NEXT_INSN (BB_HEAD (bb
));
1310 note
= emit_note_after (NOTE_INSN_BASIC_BLOCK
, BB_HEAD (bb
));
1312 maybe_dump_rtl_for_tree_stmt (stmt
, last
);
1315 note
= BB_HEAD (bb
) = emit_note (NOTE_INSN_BASIC_BLOCK
);
1317 NOTE_BASIC_BLOCK (note
) = bb
;
1319 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
1321 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
1322 e
->flags
&= ~EDGE_EXECUTABLE
;
1324 /* At the moment not all abnormal edges match the RTL representation.
1325 It is safe to remove them here as find_many_sub_basic_blocks will
1326 rediscover them. In the future we should get this fixed properly. */
1327 if (e
->flags
& EDGE_ABNORMAL
)
1333 for (; !bsi_end_p (bsi
); bsi_next (&bsi
))
1335 tree stmt
= bsi_stmt (bsi
);
1341 /* Expand this statement, then evaluate the resulting RTL and
1342 fixup the CFG accordingly. */
1343 if (TREE_CODE (stmt
) == COND_EXPR
)
1345 new_bb
= expand_gimple_cond_expr (bb
, stmt
);
1351 tree call
= get_call_expr_in (stmt
);
1352 if (call
&& CALL_EXPR_TAILCALL (call
))
1355 new_bb
= expand_gimple_tailcall (bb
, stmt
, &can_fallthru
);
1366 last
= get_last_insn ();
1367 expand_expr_stmt (stmt
);
1368 maybe_dump_rtl_for_tree_stmt (stmt
, last
);
1373 do_pending_stack_adjust ();
1375 /* Find the block tail. The last insn in the block is the insn
1376 before a barrier and/or table jump insn. */
1377 last
= get_last_insn ();
1378 if (BARRIER_P (last
))
1379 last
= PREV_INSN (last
);
1380 if (JUMP_TABLE_DATA_P (last
))
1381 last
= PREV_INSN (PREV_INSN (last
));
1384 update_bb_for_insn (bb
);
1390 /* Create a basic block for initialization code. */
1393 construct_init_block (void)
1395 basic_block init_block
, first_block
;
1399 /* Multiple entry points not supported yet. */
1400 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR
->succs
) == 1);
1401 init_rtl_bb_info (ENTRY_BLOCK_PTR
);
1402 init_rtl_bb_info (EXIT_BLOCK_PTR
);
1403 ENTRY_BLOCK_PTR
->flags
|= BB_RTL
;
1404 EXIT_BLOCK_PTR
->flags
|= BB_RTL
;
1406 e
= EDGE_SUCC (ENTRY_BLOCK_PTR
, 0);
1408 /* When entry edge points to first basic block, we don't need jump,
1409 otherwise we have to jump into proper target. */
1410 if (e
&& e
->dest
!= ENTRY_BLOCK_PTR
->next_bb
)
1412 tree label
= tree_block_label (e
->dest
);
1414 emit_jump (label_rtx (label
));
1418 flags
= EDGE_FALLTHRU
;
1420 init_block
= create_basic_block (NEXT_INSN (get_insns ()),
1423 init_block
->frequency
= ENTRY_BLOCK_PTR
->frequency
;
1424 init_block
->count
= ENTRY_BLOCK_PTR
->count
;
1427 first_block
= e
->dest
;
1428 redirect_edge_succ (e
, init_block
);
1429 e
= make_edge (init_block
, first_block
, flags
);
1432 e
= make_edge (init_block
, EXIT_BLOCK_PTR
, EDGE_FALLTHRU
);
1433 e
->probability
= REG_BR_PROB_BASE
;
1434 e
->count
= ENTRY_BLOCK_PTR
->count
;
1436 update_bb_for_insn (init_block
);
1441 /* Create a block containing landing pads and similar stuff. */
1444 construct_exit_block (void)
1446 rtx head
= get_last_insn ();
1448 basic_block exit_block
;
1453 /* Make sure the locus is set to the end of the function, so that
1454 epilogue line numbers and warnings are set properly. */
1455 #ifdef USE_MAPPED_LOCATION
1456 if (cfun
->function_end_locus
!= UNKNOWN_LOCATION
)
1458 if (cfun
->function_end_locus
.file
)
1460 input_location
= cfun
->function_end_locus
;
1462 /* The following insns belong to the top scope. */
1463 record_block_change (DECL_INITIAL (current_function_decl
));
1465 /* Generate rtl for function exit. */
1466 expand_function_end ();
1468 end
= get_last_insn ();
1471 while (NEXT_INSN (head
) && NOTE_P (NEXT_INSN (head
)))
1472 head
= NEXT_INSN (head
);
1473 exit_block
= create_basic_block (NEXT_INSN (head
), end
,
1474 EXIT_BLOCK_PTR
->prev_bb
);
1475 exit_block
->frequency
= EXIT_BLOCK_PTR
->frequency
;
1476 exit_block
->count
= EXIT_BLOCK_PTR
->count
;
1479 while (ix
< EDGE_COUNT (EXIT_BLOCK_PTR
->preds
))
1481 e
= EDGE_PRED (EXIT_BLOCK_PTR
, ix
);
1482 if (!(e
->flags
& EDGE_ABNORMAL
))
1483 redirect_edge_succ (e
, exit_block
);
1488 e
= make_edge (exit_block
, EXIT_BLOCK_PTR
, EDGE_FALLTHRU
);
1489 e
->probability
= REG_BR_PROB_BASE
;
1490 e
->count
= EXIT_BLOCK_PTR
->count
;
1491 FOR_EACH_EDGE (e2
, ei
, EXIT_BLOCK_PTR
->preds
)
1494 e
->count
-= e2
->count
;
1495 exit_block
->count
-= e2
->count
;
1496 exit_block
->frequency
-= EDGE_FREQUENCY (e2
);
1500 if (exit_block
->count
< 0)
1501 exit_block
->count
= 0;
1502 if (exit_block
->frequency
< 0)
1503 exit_block
->frequency
= 0;
1504 update_bb_for_insn (exit_block
);
1507 /* Helper function for discover_nonconstant_array_refs.
1508 Look for ARRAY_REF nodes with non-constant indexes and mark them
1512 discover_nonconstant_array_refs_r (tree
* tp
, int *walk_subtrees
,
1513 void *data ATTRIBUTE_UNUSED
)
1517 if (IS_TYPE_OR_DECL_P (t
))
1519 else if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
1521 while (((TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
1522 && is_gimple_min_invariant (TREE_OPERAND (t
, 1))
1523 && (!TREE_OPERAND (t
, 2)
1524 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
1525 || (TREE_CODE (t
) == COMPONENT_REF
1526 && (!TREE_OPERAND (t
,2)
1527 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
1528 || TREE_CODE (t
) == BIT_FIELD_REF
1529 || TREE_CODE (t
) == REALPART_EXPR
1530 || TREE_CODE (t
) == IMAGPART_EXPR
1531 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
1532 || TREE_CODE (t
) == NOP_EXPR
1533 || TREE_CODE (t
) == CONVERT_EXPR
)
1534 t
= TREE_OPERAND (t
, 0);
1536 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
1538 t
= get_base_address (t
);
1539 if (t
&& DECL_P (t
))
1540 TREE_ADDRESSABLE (t
) = 1;
1549 /* RTL expansion is not able to compile array references with variable
1550 offsets for arrays stored in single register. Discover such
1551 expressions and mark variables as addressable to avoid this
1555 discover_nonconstant_array_refs (void)
1558 block_stmt_iterator bsi
;
1562 for (bsi
= bsi_start (bb
); !bsi_end_p (bsi
); bsi_next (&bsi
))
1563 walk_tree (bsi_stmt_ptr (bsi
), discover_nonconstant_array_refs_r
,
1568 /* Translate the intermediate representation contained in the CFG
1569 from GIMPLE trees to RTL.
1571 We do conversion per basic block and preserve/update the tree CFG.
1572 This implies we have to do some magic as the CFG can simultaneously
1573 consist of basic blocks containing RTL and GIMPLE trees. This can
1574 confuse the CFG hooks, so be careful to not manipulate CFG during
1578 tree_expand_cfg (void)
1580 basic_block bb
, init_block
;
1583 /* Some backends want to know that we are expanding to RTL. */
1584 currently_expanding_to_rtl
= 1;
1586 /* Prepare the rtl middle end to start recording block changes. */
1587 reset_block_changes ();
1589 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
1590 discover_nonconstant_array_refs ();
1592 /* Expand the variables recorded during gimple lowering. */
1593 expand_used_vars ();
1595 /* Honor stack protection warnings. */
1596 if (warn_stack_protect
)
1598 if (current_function_calls_alloca
)
1599 warning (0, "not protecting local variables: variable length buffer");
1600 if (has_short_buffer
&& !cfun
->stack_protect_guard
)
1601 warning (0, "not protecting function: no buffer at least %d bytes long",
1602 (int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
));
1605 /* Set up parameters and prepare for return, for the function. */
1606 expand_function_start (current_function_decl
);
1608 /* If this function is `main', emit a call to `__main'
1609 to run global initializers, etc. */
1610 if (DECL_NAME (current_function_decl
)
1611 && MAIN_NAME_P (DECL_NAME (current_function_decl
))
1612 && DECL_FILE_SCOPE_P (current_function_decl
))
1613 expand_main_function ();
1615 /* Initialize the stack_protect_guard field. This must happen after the
1616 call to __main (if any) so that the external decl is initialized. */
1617 if (cfun
->stack_protect_guard
)
1618 stack_protect_prologue ();
1620 /* Register rtl specific functions for cfg. */
1621 rtl_register_cfg_hooks ();
1623 init_block
= construct_init_block ();
1625 FOR_BB_BETWEEN (bb
, init_block
->next_bb
, EXIT_BLOCK_PTR
, next_bb
)
1626 bb
= expand_gimple_basic_block (bb
, dump_file
);
1628 construct_exit_block ();
1630 /* We're done expanding trees to RTL. */
1631 currently_expanding_to_rtl
= 0;
1633 /* Convert tree EH labels to RTL EH labels, and clean out any unreachable
1635 convert_from_eh_region_ranges ();
1637 rebuild_jump_labels (get_insns ());
1638 find_exception_handler_labels ();
1640 blocks
= sbitmap_alloc (last_basic_block
);
1641 sbitmap_ones (blocks
);
1642 find_many_sub_basic_blocks (blocks
);
1643 purge_all_dead_edges ();
1644 sbitmap_free (blocks
);
1647 #ifdef ENABLE_CHECKING
1651 /* There's no need to defer outputting this function any more; we
1652 know we want to output it. */
1653 DECL_DEFER_OUTPUT (current_function_decl
) = 0;
1655 /* Now that we're done expanding trees to RTL, we shouldn't have any
1656 more CONCATs anywhere. */
1657 generating_concat_p
= 0;
1659 finalize_block_changes ();
1664 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
1665 /* And the pass manager will dump RTL for us. */
1668 /* If we're emitting a nested function, make sure its parent gets
1669 emitted as well. Doing otherwise confuses debug info. */
1672 for (parent
= DECL_CONTEXT (current_function_decl
);
1673 parent
!= NULL_TREE
;
1674 parent
= get_containing_scope (parent
))
1675 if (TREE_CODE (parent
) == FUNCTION_DECL
)
1676 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent
)) = 1;
1679 /* We are now committed to emitting code for this function. Do any
1680 preparation, such as emitting abstract debug info for the inline
1681 before it gets mangled by optimization. */
1682 if (cgraph_function_possibly_inlined_p (current_function_decl
))
1683 (*debug_hooks
->outlining_inline_function
) (current_function_decl
);
1685 TREE_ASM_WRITTEN (current_function_decl
) = 1;
1687 /* After expanding, the return labels are no longer needed. */
1688 return_label
= NULL
;
1689 naked_return_label
= NULL
;
1692 struct tree_opt_pass pass_expand
=
1694 "expand", /* name */
1696 tree_expand_cfg
, /* execute */
1699 0, /* static_pass_number */
1700 TV_EXPAND
, /* tv_id */
1701 /* ??? If TER is enabled, we actually receive GENERIC. */
1702 PROP_gimple_leh
| PROP_cfg
, /* properties_required */
1703 PROP_rtl
, /* properties_provided */
1704 PROP_gimple_leh
, /* properties_destroyed */
1705 0, /* todo_flags_start */
1706 TODO_dump_func
, /* todo_flags_finish */