1 /* A pass for lowering trees to RTL.
2 Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
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"
39 #include "tree-pretty-print.h"
40 #include "gimple-pretty-print.h"
44 #include "tree-inline.h"
45 #include "value-prof.h"
47 #include "ssaexpand.h"
50 #include "insn-attr.h" /* For INSN_SCHEDULING. */
52 /* This variable holds information helping the rewriting of SSA trees
56 /* This variable holds the currently expanded gimple statement for purposes
57 of comminucating the profile info to the builtin expanders. */
58 gimple currently_expanding_gimple_stmt;
60 static rtx expand_debug_expr (tree);
62 /* Return an expression tree corresponding to the RHS of GIMPLE
66 gimple_assign_rhs_to_tree (gimple stmt)
69 enum gimple_rhs_class grhs_class;
71 grhs_class = get_gimple_rhs_class (gimple_expr_code (stmt));
73 if (grhs_class == GIMPLE_TERNARY_RHS)
74 t = build3 (gimple_assign_rhs_code (stmt),
75 TREE_TYPE (gimple_assign_lhs (stmt)),
76 gimple_assign_rhs1 (stmt),
77 gimple_assign_rhs2 (stmt),
78 gimple_assign_rhs3 (stmt));
79 else if (grhs_class == GIMPLE_BINARY_RHS)
80 t = build2 (gimple_assign_rhs_code (stmt),
81 TREE_TYPE (gimple_assign_lhs (stmt)),
82 gimple_assign_rhs1 (stmt),
83 gimple_assign_rhs2 (stmt));
84 else if (grhs_class == GIMPLE_UNARY_RHS)
85 t = build1 (gimple_assign_rhs_code (stmt),
86 TREE_TYPE (gimple_assign_lhs (stmt)),
87 gimple_assign_rhs1 (stmt));
88 else if (grhs_class == GIMPLE_SINGLE_RHS)
90 t = gimple_assign_rhs1 (stmt);
91 /* Avoid modifying this tree in place below. */
92 if ((gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (t)
93 && gimple_location (stmt) != EXPR_LOCATION (t))
94 || (gimple_block (stmt)
95 && currently_expanding_to_rtl
97 && gimple_block (stmt) != TREE_BLOCK (t)))
103 if (gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (t))
104 SET_EXPR_LOCATION (t, gimple_location (stmt));
105 if (gimple_block (stmt) && currently_expanding_to_rtl && EXPR_P (t))
106 TREE_BLOCK (t) = gimple_block (stmt);
112 #ifndef STACK_ALIGNMENT_NEEDED
113 #define STACK_ALIGNMENT_NEEDED 1
116 #define SSAVAR(x) (TREE_CODE (x) == SSA_NAME ? SSA_NAME_VAR (x) : x)
118 /* Associate declaration T with storage space X. If T is no
119 SSA name this is exactly SET_DECL_RTL, otherwise make the
120 partition of T associated with X. */
122 set_rtl (tree t, rtx x)
124 if (TREE_CODE (t) == SSA_NAME)
126 SA.partition_to_pseudo[var_to_partition (SA.map, t)] = x;
128 set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (t), x);
129 /* For the benefit of debug information at -O0 (where vartracking
130 doesn't run) record the place also in the base DECL if it's
131 a normal variable (not a parameter). */
132 if (x && x != pc_rtx && TREE_CODE (SSA_NAME_VAR (t)) == VAR_DECL)
134 tree var = SSA_NAME_VAR (t);
135 /* If we don't yet have something recorded, just record it now. */
136 if (!DECL_RTL_SET_P (var))
137 SET_DECL_RTL (var, x);
138 /* If we have it set already to "multiple places" don't
140 else if (DECL_RTL (var) == pc_rtx)
142 /* If we have something recorded and it's not the same place
143 as we want to record now, we have multiple partitions for the
144 same base variable, with different places. We can't just
145 randomly chose one, hence we have to say that we don't know.
146 This only happens with optimization, and there var-tracking
147 will figure out the right thing. */
148 else if (DECL_RTL (var) != x)
149 SET_DECL_RTL (var, pc_rtx);
156 /* This structure holds data relevant to one variable that will be
157 placed in a stack slot. */
163 /* Initially, the size of the variable. Later, the size of the partition,
164 if this variable becomes it's partition's representative. */
167 /* The *byte* alignment required for this variable. Or as, with the
168 size, the alignment for this partition. */
171 /* The partition representative. */
172 size_t representative;
174 /* The next stack variable in the partition, or EOC. */
177 /* The numbers of conflicting stack variables. */
181 #define EOC ((size_t)-1)
183 /* We have an array of such objects while deciding allocation. */
184 static struct stack_var *stack_vars;
185 static size_t stack_vars_alloc;
186 static size_t stack_vars_num;
187 static struct pointer_map_t *decl_to_stack_part;
189 /* An array of indices such that stack_vars[stack_vars_sorted[i]].size
190 is non-decreasing. */
191 static size_t *stack_vars_sorted;
193 /* The phase of the stack frame. This is the known misalignment of
194 virtual_stack_vars_rtx from PREFERRED_STACK_BOUNDARY. That is,
195 (frame_offset+frame_phase) % PREFERRED_STACK_BOUNDARY == 0. */
196 static int frame_phase;
198 /* Used during expand_used_vars to remember if we saw any decls for
199 which we'd like to enable stack smashing protection. */
200 static bool has_protected_decls;
202 /* Used during expand_used_vars. Remember if we say a character buffer
203 smaller than our cutoff threshold. Used for -Wstack-protector. */
204 static bool has_short_buffer;
206 /* Compute the byte alignment to use for DECL. Ignore alignment
207 we can't do with expected alignment of the stack boundary. */
210 align_local_variable (tree decl)
212 unsigned int align = LOCAL_DECL_ALIGNMENT (decl);
213 DECL_ALIGN (decl) = align;
214 return align / BITS_PER_UNIT;
217 /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
218 Return the frame offset. */
221 alloc_stack_frame_space (HOST_WIDE_INT size, unsigned HOST_WIDE_INT align)
223 HOST_WIDE_INT offset, new_frame_offset;
225 new_frame_offset = frame_offset;
226 if (FRAME_GROWS_DOWNWARD)
228 new_frame_offset -= size + frame_phase;
229 new_frame_offset &= -align;
230 new_frame_offset += frame_phase;
231 offset = new_frame_offset;
235 new_frame_offset -= frame_phase;
236 new_frame_offset += align - 1;
237 new_frame_offset &= -align;
238 new_frame_offset += frame_phase;
239 offset = new_frame_offset;
240 new_frame_offset += size;
242 frame_offset = new_frame_offset;
244 if (frame_offset_overflow (frame_offset, cfun->decl))
245 frame_offset = offset = 0;
250 /* Accumulate DECL into STACK_VARS. */
253 add_stack_var (tree decl)
257 if (stack_vars_num >= stack_vars_alloc)
259 if (stack_vars_alloc)
260 stack_vars_alloc = stack_vars_alloc * 3 / 2;
262 stack_vars_alloc = 32;
264 = XRESIZEVEC (struct stack_var, stack_vars, stack_vars_alloc);
266 if (!decl_to_stack_part)
267 decl_to_stack_part = pointer_map_create ();
269 v = &stack_vars[stack_vars_num];
270 * (size_t *)pointer_map_insert (decl_to_stack_part, decl) = stack_vars_num;
273 v->size = tree_low_cst (DECL_SIZE_UNIT (SSAVAR (decl)), 1);
274 /* Ensure that all variables have size, so that &a != &b for any two
275 variables that are simultaneously live. */
278 v->alignb = align_local_variable (SSAVAR (decl));
279 /* An alignment of zero can mightily confuse us later. */
280 gcc_assert (v->alignb != 0);
282 /* All variables are initially in their own partition. */
283 v->representative = stack_vars_num;
286 /* All variables initially conflict with no other. */
289 /* Ensure that this decl doesn't get put onto the list twice. */
290 set_rtl (decl, pc_rtx);
295 /* Make the decls associated with luid's X and Y conflict. */
298 add_stack_var_conflict (size_t x, size_t y)
300 struct stack_var *a = &stack_vars[x];
301 struct stack_var *b = &stack_vars[y];
303 a->conflicts = BITMAP_ALLOC (NULL);
305 b->conflicts = BITMAP_ALLOC (NULL);
306 bitmap_set_bit (a->conflicts, y);
307 bitmap_set_bit (b->conflicts, x);
310 /* Check whether the decls associated with luid's X and Y conflict. */
313 stack_var_conflict_p (size_t x, size_t y)
315 struct stack_var *a = &stack_vars[x];
316 struct stack_var *b = &stack_vars[y];
319 /* Partitions containing an SSA name result from gimple registers
320 with things like unsupported modes. They are top-level and
321 hence conflict with everything else. */
322 if (TREE_CODE (a->decl) == SSA_NAME || TREE_CODE (b->decl) == SSA_NAME)
325 if (!a->conflicts || !b->conflicts)
327 return bitmap_bit_p (a->conflicts, y);
330 /* Returns true if TYPE is or contains a union type. */
333 aggregate_contains_union_type (tree type)
337 if (TREE_CODE (type) == UNION_TYPE
338 || TREE_CODE (type) == QUAL_UNION_TYPE)
340 if (TREE_CODE (type) == ARRAY_TYPE)
341 return aggregate_contains_union_type (TREE_TYPE (type));
342 if (TREE_CODE (type) != RECORD_TYPE)
345 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
346 if (TREE_CODE (field) == FIELD_DECL)
347 if (aggregate_contains_union_type (TREE_TYPE (field)))
353 /* A subroutine of expand_used_vars. If two variables X and Y have alias
354 sets that do not conflict, then do add a conflict for these variables
355 in the interference graph. We also need to make sure to add conflicts
356 for union containing structures. Else RTL alias analysis comes along
357 and due to type based aliasing rules decides that for two overlapping
358 union temporaries { short s; int i; } accesses to the same mem through
359 different types may not alias and happily reorders stores across
360 life-time boundaries of the temporaries (See PR25654). */
363 add_alias_set_conflicts (void)
365 size_t i, j, n = stack_vars_num;
367 for (i = 0; i < n; ++i)
369 tree type_i = TREE_TYPE (stack_vars[i].decl);
370 bool aggr_i = AGGREGATE_TYPE_P (type_i);
373 contains_union = aggregate_contains_union_type (type_i);
374 for (j = 0; j < i; ++j)
376 tree type_j = TREE_TYPE (stack_vars[j].decl);
377 bool aggr_j = AGGREGATE_TYPE_P (type_j);
379 /* Either the objects conflict by means of type based
380 aliasing rules, or we need to add a conflict. */
381 || !objects_must_conflict_p (type_i, type_j)
382 /* In case the types do not conflict ensure that access
383 to elements will conflict. In case of unions we have
384 to be careful as type based aliasing rules may say
385 access to the same memory does not conflict. So play
386 safe and add a conflict in this case when
387 -fstrict-aliasing is used. */
388 || (contains_union && flag_strict_aliasing))
389 add_stack_var_conflict (i, j);
394 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
395 enter its partition number into bitmap DATA. */
398 visit_op (gimple stmt ATTRIBUTE_UNUSED, tree op, void *data)
400 bitmap active = (bitmap)data;
401 op = get_base_address (op);
404 && DECL_RTL_IF_SET (op) == pc_rtx)
406 size_t *v = (size_t *) pointer_map_contains (decl_to_stack_part, op);
408 bitmap_set_bit (active, *v);
413 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
414 record conflicts between it and all currently active other partitions
418 visit_conflict (gimple stmt ATTRIBUTE_UNUSED, tree op, void *data)
420 bitmap active = (bitmap)data;
421 op = get_base_address (op);
424 && DECL_RTL_IF_SET (op) == pc_rtx)
427 (size_t *) pointer_map_contains (decl_to_stack_part, op);
428 if (v && bitmap_set_bit (active, *v))
433 gcc_assert (num < stack_vars_num);
434 EXECUTE_IF_SET_IN_BITMAP (active, 0, i, bi)
435 add_stack_var_conflict (num, i);
441 /* Helper routine for add_scope_conflicts, calculating the active partitions
442 at the end of BB, leaving the result in WORK. We're called to generate
443 conflicts when FOR_CONFLICT is true, otherwise we're just tracking
447 add_scope_conflicts_1 (basic_block bb, bitmap work, bool for_conflict)
451 gimple_stmt_iterator gsi;
452 bool (*visit)(gimple, tree, void *);
455 FOR_EACH_EDGE (e, ei, bb->preds)
456 bitmap_ior_into (work, (bitmap)e->src->aux);
460 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
462 gimple stmt = gsi_stmt (gsi);
463 walk_stmt_load_store_addr_ops (stmt, work, NULL, NULL, visit);
465 for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi); gsi_next (&gsi))
467 gimple stmt = gsi_stmt (gsi);
469 if (gimple_clobber_p (stmt))
471 tree lhs = gimple_assign_lhs (stmt);
473 /* Nested function lowering might introduce LHSs
474 that are COMPONENT_REFs. */
475 if (TREE_CODE (lhs) != VAR_DECL)
477 if (DECL_RTL_IF_SET (lhs) == pc_rtx
479 pointer_map_contains (decl_to_stack_part, lhs)))
480 bitmap_clear_bit (work, *v);
482 else if (!is_gimple_debug (stmt))
485 && visit == visit_op)
487 /* If this is the first real instruction in this BB we need
488 to add conflicts for everything live at this point now.
489 Unlike classical liveness for named objects we can't
490 rely on seeing a def/use of the names we're interested in.
491 There might merely be indirect loads/stores. We'd not add any
492 conflicts for such partitions. */
495 EXECUTE_IF_SET_IN_BITMAP (work, 0, i, bi)
499 EXECUTE_IF_SET_IN_BITMAP (work, i + 1, j, bj)
500 add_stack_var_conflict (i, j);
502 visit = visit_conflict;
504 walk_stmt_load_store_addr_ops (stmt, work, visit, visit, visit);
509 /* Generate stack partition conflicts between all partitions that are
510 simultaneously live. */
513 add_scope_conflicts (void)
517 bitmap work = BITMAP_ALLOC (NULL);
519 /* We approximate the live range of a stack variable by taking the first
520 mention of its name as starting point(s), and by the end-of-scope
521 death clobber added by gimplify as ending point(s) of the range.
522 This overapproximates in the case we for instance moved an address-taken
523 operation upward, without also moving a dereference to it upwards.
524 But it's conservatively correct as a variable never can hold values
525 before its name is mentioned at least once.
527 We then do a mostly classical bitmap liveness algorithm. */
530 bb->aux = BITMAP_ALLOC (NULL);
538 bitmap active = (bitmap)bb->aux;
539 add_scope_conflicts_1 (bb, work, false);
540 if (bitmap_ior_into (active, work))
546 add_scope_conflicts_1 (bb, work, true);
550 BITMAP_FREE (bb->aux);
553 /* A subroutine of partition_stack_vars. A comparison function for qsort,
554 sorting an array of indices by the properties of the object. */
557 stack_var_cmp (const void *a, const void *b)
559 size_t ia = *(const size_t *)a;
560 size_t ib = *(const size_t *)b;
561 unsigned int aligna = stack_vars[ia].alignb;
562 unsigned int alignb = stack_vars[ib].alignb;
563 HOST_WIDE_INT sizea = stack_vars[ia].size;
564 HOST_WIDE_INT sizeb = stack_vars[ib].size;
565 tree decla = stack_vars[ia].decl;
566 tree declb = stack_vars[ib].decl;
568 unsigned int uida, uidb;
570 /* Primary compare on "large" alignment. Large comes first. */
571 largea = (aligna * BITS_PER_UNIT > MAX_SUPPORTED_STACK_ALIGNMENT);
572 largeb = (alignb * BITS_PER_UNIT > MAX_SUPPORTED_STACK_ALIGNMENT);
573 if (largea != largeb)
574 return (int)largeb - (int)largea;
576 /* Secondary compare on size, decreasing */
582 /* Tertiary compare on true alignment, decreasing. */
588 /* Final compare on ID for sort stability, increasing.
589 Two SSA names are compared by their version, SSA names come before
590 non-SSA names, and two normal decls are compared by their DECL_UID. */
591 if (TREE_CODE (decla) == SSA_NAME)
593 if (TREE_CODE (declb) == SSA_NAME)
594 uida = SSA_NAME_VERSION (decla), uidb = SSA_NAME_VERSION (declb);
598 else if (TREE_CODE (declb) == SSA_NAME)
601 uida = DECL_UID (decla), uidb = DECL_UID (declb);
610 /* If the points-to solution *PI points to variables that are in a partition
611 together with other variables add all partition members to the pointed-to
615 add_partitioned_vars_to_ptset (struct pt_solution *pt,
616 struct pointer_map_t *decls_to_partitions,
617 struct pointer_set_t *visited, bitmap temp)
625 /* The pointed-to vars bitmap is shared, it is enough to
627 || pointer_set_insert(visited, pt->vars))
632 /* By using a temporary bitmap to store all members of the partitions
633 we have to add we make sure to visit each of the partitions only
635 EXECUTE_IF_SET_IN_BITMAP (pt->vars, 0, i, bi)
637 || !bitmap_bit_p (temp, i))
638 && (part = (bitmap *) pointer_map_contains (decls_to_partitions,
639 (void *)(size_t) i)))
640 bitmap_ior_into (temp, *part);
641 if (!bitmap_empty_p (temp))
642 bitmap_ior_into (pt->vars, temp);
645 /* Update points-to sets based on partition info, so we can use them on RTL.
646 The bitmaps representing stack partitions will be saved until expand,
647 where partitioned decls used as bases in memory expressions will be
651 update_alias_info_with_stack_vars (void)
653 struct pointer_map_t *decls_to_partitions = NULL;
655 tree var = NULL_TREE;
657 for (i = 0; i < stack_vars_num; i++)
661 struct ptr_info_def *pi;
663 /* Not interested in partitions with single variable. */
664 if (stack_vars[i].representative != i
665 || stack_vars[i].next == EOC)
668 if (!decls_to_partitions)
670 decls_to_partitions = pointer_map_create ();
671 cfun->gimple_df->decls_to_pointers = pointer_map_create ();
674 /* Create an SSA_NAME that points to the partition for use
675 as base during alias-oracle queries on RTL for bases that
676 have been partitioned. */
677 if (var == NULL_TREE)
678 var = create_tmp_var (ptr_type_node, NULL);
679 name = make_ssa_name (var, NULL);
681 /* Create bitmaps representing partitions. They will be used for
682 points-to sets later, so use GGC alloc. */
683 part = BITMAP_GGC_ALLOC ();
684 for (j = i; j != EOC; j = stack_vars[j].next)
686 tree decl = stack_vars[j].decl;
687 unsigned int uid = DECL_PT_UID (decl);
688 /* We should never end up partitioning SSA names (though they
689 may end up on the stack). Neither should we allocate stack
690 space to something that is unused and thus unreferenced, except
691 for -O0 where we are preserving even unreferenced variables. */
692 gcc_assert (DECL_P (decl)
694 || referenced_var_lookup (cfun, DECL_UID (decl))));
695 bitmap_set_bit (part, uid);
696 *((bitmap *) pointer_map_insert (decls_to_partitions,
697 (void *)(size_t) uid)) = part;
698 *((tree *) pointer_map_insert (cfun->gimple_df->decls_to_pointers,
700 if (TREE_ADDRESSABLE (decl))
701 TREE_ADDRESSABLE (name) = 1;
704 /* Make the SSA name point to all partition members. */
705 pi = get_ptr_info (name);
706 pt_solution_set (&pi->pt, part, false);
709 /* Make all points-to sets that contain one member of a partition
710 contain all members of the partition. */
711 if (decls_to_partitions)
714 struct pointer_set_t *visited = pointer_set_create ();
715 bitmap temp = BITMAP_ALLOC (NULL);
717 for (i = 1; i < num_ssa_names; i++)
719 tree name = ssa_name (i);
720 struct ptr_info_def *pi;
723 && POINTER_TYPE_P (TREE_TYPE (name))
724 && ((pi = SSA_NAME_PTR_INFO (name)) != NULL))
725 add_partitioned_vars_to_ptset (&pi->pt, decls_to_partitions,
729 add_partitioned_vars_to_ptset (&cfun->gimple_df->escaped,
730 decls_to_partitions, visited, temp);
732 pointer_set_destroy (visited);
733 pointer_map_destroy (decls_to_partitions);
738 /* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
739 partitioning algorithm. Partitions A and B are known to be non-conflicting.
740 Merge them into a single partition A. */
743 union_stack_vars (size_t a, size_t b)
745 struct stack_var *vb = &stack_vars[b];
749 gcc_assert (stack_vars[b].next == EOC);
750 /* Add B to A's partition. */
751 stack_vars[b].next = stack_vars[a].next;
752 stack_vars[b].representative = a;
753 stack_vars[a].next = b;
755 /* Update the required alignment of partition A to account for B. */
756 if (stack_vars[a].alignb < stack_vars[b].alignb)
757 stack_vars[a].alignb = stack_vars[b].alignb;
759 /* Update the interference graph and merge the conflicts. */
762 EXECUTE_IF_SET_IN_BITMAP (vb->conflicts, 0, u, bi)
763 add_stack_var_conflict (a, stack_vars[u].representative);
764 BITMAP_FREE (vb->conflicts);
768 /* A subroutine of expand_used_vars. Binpack the variables into
769 partitions constrained by the interference graph. The overall
770 algorithm used is as follows:
772 Sort the objects by size in descending order.
777 Look for the largest non-conflicting object B with size <= S.
784 partition_stack_vars (void)
786 size_t si, sj, n = stack_vars_num;
788 stack_vars_sorted = XNEWVEC (size_t, stack_vars_num);
789 for (si = 0; si < n; ++si)
790 stack_vars_sorted[si] = si;
795 qsort (stack_vars_sorted, n, sizeof (size_t), stack_var_cmp);
797 for (si = 0; si < n; ++si)
799 size_t i = stack_vars_sorted[si];
800 unsigned int ialign = stack_vars[i].alignb;
802 /* Ignore objects that aren't partition representatives. If we
803 see a var that is not a partition representative, it must
804 have been merged earlier. */
805 if (stack_vars[i].representative != i)
808 for (sj = si + 1; sj < n; ++sj)
810 size_t j = stack_vars_sorted[sj];
811 unsigned int jalign = stack_vars[j].alignb;
813 /* Ignore objects that aren't partition representatives. */
814 if (stack_vars[j].representative != j)
817 /* Ignore conflicting objects. */
818 if (stack_var_conflict_p (i, j))
821 /* Do not mix objects of "small" (supported) alignment
822 and "large" (unsupported) alignment. */
823 if ((ialign * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)
824 != (jalign * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT))
827 /* UNION the objects, placing J at OFFSET. */
828 union_stack_vars (i, j);
832 update_alias_info_with_stack_vars ();
835 /* A debugging aid for expand_used_vars. Dump the generated partitions. */
838 dump_stack_var_partition (void)
840 size_t si, i, j, n = stack_vars_num;
842 for (si = 0; si < n; ++si)
844 i = stack_vars_sorted[si];
846 /* Skip variables that aren't partition representatives, for now. */
847 if (stack_vars[i].representative != i)
850 fprintf (dump_file, "Partition %lu: size " HOST_WIDE_INT_PRINT_DEC
851 " align %u\n", (unsigned long) i, stack_vars[i].size,
852 stack_vars[i].alignb);
854 for (j = i; j != EOC; j = stack_vars[j].next)
856 fputc ('\t', dump_file);
857 print_generic_expr (dump_file, stack_vars[j].decl, dump_flags);
859 fputc ('\n', dump_file);
863 /* Assign rtl to DECL at BASE + OFFSET. */
866 expand_one_stack_var_at (tree decl, rtx base, unsigned base_align,
867 HOST_WIDE_INT offset)
872 /* If this fails, we've overflowed the stack frame. Error nicely? */
873 gcc_assert (offset == trunc_int_for_mode (offset, Pmode));
875 x = plus_constant (base, offset);
876 x = gen_rtx_MEM (DECL_MODE (SSAVAR (decl)), x);
878 if (TREE_CODE (decl) != SSA_NAME)
880 /* Set alignment we actually gave this decl if it isn't an SSA name.
881 If it is we generate stack slots only accidentally so it isn't as
882 important, we'll simply use the alignment that is already set. */
883 if (base == virtual_stack_vars_rtx)
884 offset -= frame_phase;
885 align = offset & -offset;
886 align *= BITS_PER_UNIT;
887 if (align == 0 || align > base_align)
890 /* One would think that we could assert that we're not decreasing
891 alignment here, but (at least) the i386 port does exactly this
892 via the MINIMUM_ALIGNMENT hook. */
894 DECL_ALIGN (decl) = align;
895 DECL_USER_ALIGN (decl) = 0;
898 set_mem_attributes (x, SSAVAR (decl), true);
902 /* A subroutine of expand_used_vars. Give each partition representative
903 a unique location within the stack frame. Update each partition member
904 with that location. */
907 expand_stack_vars (bool (*pred) (tree))
909 size_t si, i, j, n = stack_vars_num;
910 HOST_WIDE_INT large_size = 0, large_alloc = 0;
911 rtx large_base = NULL;
912 unsigned large_align = 0;
915 /* Determine if there are any variables requiring "large" alignment.
916 Since these are dynamically allocated, we only process these if
917 no predicate involved. */
918 large_align = stack_vars[stack_vars_sorted[0]].alignb * BITS_PER_UNIT;
919 if (pred == NULL && large_align > MAX_SUPPORTED_STACK_ALIGNMENT)
921 /* Find the total size of these variables. */
922 for (si = 0; si < n; ++si)
926 i = stack_vars_sorted[si];
927 alignb = stack_vars[i].alignb;
929 /* Stop when we get to the first decl with "small" alignment. */
930 if (alignb * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)
933 /* Skip variables that aren't partition representatives. */
934 if (stack_vars[i].representative != i)
937 /* Skip variables that have already had rtl assigned. See also
938 add_stack_var where we perpetrate this pc_rtx hack. */
939 decl = stack_vars[i].decl;
940 if ((TREE_CODE (decl) == SSA_NAME
941 ? SA.partition_to_pseudo[var_to_partition (SA.map, decl)]
942 : DECL_RTL (decl)) != pc_rtx)
945 large_size += alignb - 1;
946 large_size &= -(HOST_WIDE_INT)alignb;
947 large_size += stack_vars[i].size;
950 /* If there were any, allocate space. */
952 large_base = allocate_dynamic_stack_space (GEN_INT (large_size), 0,
956 for (si = 0; si < n; ++si)
959 unsigned base_align, alignb;
960 HOST_WIDE_INT offset;
962 i = stack_vars_sorted[si];
964 /* Skip variables that aren't partition representatives, for now. */
965 if (stack_vars[i].representative != i)
968 /* Skip variables that have already had rtl assigned. See also
969 add_stack_var where we perpetrate this pc_rtx hack. */
970 decl = stack_vars[i].decl;
971 if ((TREE_CODE (decl) == SSA_NAME
972 ? SA.partition_to_pseudo[var_to_partition (SA.map, decl)]
973 : DECL_RTL (decl)) != pc_rtx)
976 /* Check the predicate to see whether this variable should be
977 allocated in this pass. */
978 if (pred && !pred (decl))
981 alignb = stack_vars[i].alignb;
982 if (alignb * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)
984 offset = alloc_stack_frame_space (stack_vars[i].size, alignb);
985 base = virtual_stack_vars_rtx;
986 base_align = crtl->max_used_stack_slot_alignment;
990 /* Large alignment is only processed in the last pass. */
993 gcc_assert (large_base != NULL);
995 large_alloc += alignb - 1;
996 large_alloc &= -(HOST_WIDE_INT)alignb;
997 offset = large_alloc;
998 large_alloc += stack_vars[i].size;
1001 base_align = large_align;
1004 /* Create rtl for each variable based on their location within the
1006 for (j = i; j != EOC; j = stack_vars[j].next)
1008 expand_one_stack_var_at (stack_vars[j].decl,
1014 gcc_assert (large_alloc == large_size);
1017 /* Take into account all sizes of partitions and reset DECL_RTLs. */
1018 static HOST_WIDE_INT
1019 account_stack_vars (void)
1021 size_t si, j, i, n = stack_vars_num;
1022 HOST_WIDE_INT size = 0;
1024 for (si = 0; si < n; ++si)
1026 i = stack_vars_sorted[si];
1028 /* Skip variables that aren't partition representatives, for now. */
1029 if (stack_vars[i].representative != i)
1032 size += stack_vars[i].size;
1033 for (j = i; j != EOC; j = stack_vars[j].next)
1034 set_rtl (stack_vars[j].decl, NULL);
1039 /* A subroutine of expand_one_var. Called to immediately assign rtl
1040 to a variable to be allocated in the stack frame. */
1043 expand_one_stack_var (tree var)
1045 HOST_WIDE_INT size, offset;
1046 unsigned byte_align;
1048 size = tree_low_cst (DECL_SIZE_UNIT (SSAVAR (var)), 1);
1049 byte_align = align_local_variable (SSAVAR (var));
1051 /* We handle highly aligned variables in expand_stack_vars. */
1052 gcc_assert (byte_align * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT);
1054 offset = alloc_stack_frame_space (size, byte_align);
1056 expand_one_stack_var_at (var, virtual_stack_vars_rtx,
1057 crtl->max_used_stack_slot_alignment, offset);
1060 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1061 that will reside in a hard register. */
1064 expand_one_hard_reg_var (tree var)
1066 rest_of_decl_compilation (var, 0, 0);
1069 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1070 that will reside in a pseudo register. */
1073 expand_one_register_var (tree var)
1075 tree decl = SSAVAR (var);
1076 tree type = TREE_TYPE (decl);
1077 enum machine_mode reg_mode = promote_decl_mode (decl, NULL);
1078 rtx x = gen_reg_rtx (reg_mode);
1082 /* Note if the object is a user variable. */
1083 if (!DECL_ARTIFICIAL (decl))
1086 if (POINTER_TYPE_P (type))
1087 mark_reg_pointer (x, get_pointer_alignment (var));
1090 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
1091 has some associated error, e.g. its type is error-mark. We just need
1092 to pick something that won't crash the rest of the compiler. */
1095 expand_one_error_var (tree var)
1097 enum machine_mode mode = DECL_MODE (var);
1100 if (mode == BLKmode)
1101 x = gen_rtx_MEM (BLKmode, const0_rtx);
1102 else if (mode == VOIDmode)
1105 x = gen_reg_rtx (mode);
1107 SET_DECL_RTL (var, x);
1110 /* A subroutine of expand_one_var. VAR is a variable that will be
1111 allocated to the local stack frame. Return true if we wish to
1112 add VAR to STACK_VARS so that it will be coalesced with other
1113 variables. Return false to allocate VAR immediately.
1115 This function is used to reduce the number of variables considered
1116 for coalescing, which reduces the size of the quadratic problem. */
1119 defer_stack_allocation (tree var, bool toplevel)
1121 /* If stack protection is enabled, *all* stack variables must be deferred,
1122 so that we can re-order the strings to the top of the frame. */
1123 if (flag_stack_protect)
1126 /* We handle "large" alignment via dynamic allocation. We want to handle
1127 this extra complication in only one place, so defer them. */
1128 if (DECL_ALIGN (var) > MAX_SUPPORTED_STACK_ALIGNMENT)
1131 /* Variables in the outermost scope automatically conflict with
1132 every other variable. The only reason to want to defer them
1133 at all is that, after sorting, we can more efficiently pack
1134 small variables in the stack frame. Continue to defer at -O2. */
1135 if (toplevel && optimize < 2)
1138 /* Without optimization, *most* variables are allocated from the
1139 stack, which makes the quadratic problem large exactly when we
1140 want compilation to proceed as quickly as possible. On the
1141 other hand, we don't want the function's stack frame size to
1142 get completely out of hand. So we avoid adding scalars and
1143 "small" aggregates to the list at all. */
1144 if (optimize == 0 && tree_low_cst (DECL_SIZE_UNIT (var), 1) < 32)
1150 /* A subroutine of expand_used_vars. Expand one variable according to
1151 its flavor. Variables to be placed on the stack are not actually
1152 expanded yet, merely recorded.
1153 When REALLY_EXPAND is false, only add stack values to be allocated.
1154 Return stack usage this variable is supposed to take.
1157 static HOST_WIDE_INT
1158 expand_one_var (tree var, bool toplevel, bool really_expand)
1160 unsigned int align = BITS_PER_UNIT;
1165 if (TREE_TYPE (var) != error_mark_node && TREE_CODE (var) == VAR_DECL)
1167 /* Because we don't know if VAR will be in register or on stack,
1168 we conservatively assume it will be on stack even if VAR is
1169 eventually put into register after RA pass. For non-automatic
1170 variables, which won't be on stack, we collect alignment of
1171 type and ignore user specified alignment. */
1172 if (TREE_STATIC (var) || DECL_EXTERNAL (var))
1173 align = MINIMUM_ALIGNMENT (TREE_TYPE (var),
1174 TYPE_MODE (TREE_TYPE (var)),
1175 TYPE_ALIGN (TREE_TYPE (var)));
1176 else if (DECL_HAS_VALUE_EXPR_P (var)
1177 || (DECL_RTL_SET_P (var) && MEM_P (DECL_RTL (var))))
1178 /* Don't consider debug only variables with DECL_HAS_VALUE_EXPR_P set
1179 or variables which were assigned a stack slot already by
1180 expand_one_stack_var_at - in the latter case DECL_ALIGN has been
1181 changed from the offset chosen to it. */
1182 align = crtl->stack_alignment_estimated;
1184 align = MINIMUM_ALIGNMENT (var, DECL_MODE (var), DECL_ALIGN (var));
1186 /* If the variable alignment is very large we'll dynamicaly allocate
1187 it, which means that in-frame portion is just a pointer. */
1188 if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
1189 align = POINTER_SIZE;
1192 if (SUPPORTS_STACK_ALIGNMENT
1193 && crtl->stack_alignment_estimated < align)
1195 /* stack_alignment_estimated shouldn't change after stack
1196 realign decision made */
1197 gcc_assert(!crtl->stack_realign_processed);
1198 crtl->stack_alignment_estimated = align;
1201 /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
1202 So here we only make sure stack_alignment_needed >= align. */
1203 if (crtl->stack_alignment_needed < align)
1204 crtl->stack_alignment_needed = align;
1205 if (crtl->max_used_stack_slot_alignment < align)
1206 crtl->max_used_stack_slot_alignment = align;
1208 if (TREE_CODE (origvar) == SSA_NAME)
1210 gcc_assert (TREE_CODE (var) != VAR_DECL
1211 || (!DECL_EXTERNAL (var)
1212 && !DECL_HAS_VALUE_EXPR_P (var)
1213 && !TREE_STATIC (var)
1214 && TREE_TYPE (var) != error_mark_node
1215 && !DECL_HARD_REGISTER (var)
1218 if (TREE_CODE (var) != VAR_DECL && TREE_CODE (origvar) != SSA_NAME)
1220 else if (DECL_EXTERNAL (var))
1222 else if (DECL_HAS_VALUE_EXPR_P (var))
1224 else if (TREE_STATIC (var))
1226 else if (TREE_CODE (origvar) != SSA_NAME && DECL_RTL_SET_P (var))
1228 else if (TREE_TYPE (var) == error_mark_node)
1231 expand_one_error_var (var);
1233 else if (TREE_CODE (var) == VAR_DECL && DECL_HARD_REGISTER (var))
1236 expand_one_hard_reg_var (var);
1238 else if (use_register_for_decl (var))
1241 expand_one_register_var (origvar);
1243 else if (!host_integerp (DECL_SIZE_UNIT (var), 1))
1247 error ("size of variable %q+D is too large", var);
1248 expand_one_error_var (var);
1251 else if (defer_stack_allocation (var, toplevel))
1252 add_stack_var (origvar);
1256 expand_one_stack_var (origvar);
1257 return tree_low_cst (DECL_SIZE_UNIT (var), 1);
1262 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1263 expanding variables. Those variables that can be put into registers
1264 are allocated pseudos; those that can't are put on the stack.
1266 TOPLEVEL is true if this is the outermost BLOCK. */
1269 expand_used_vars_for_block (tree block, bool toplevel)
1273 /* Expand all variables at this level. */
1274 for (t = BLOCK_VARS (block); t ; t = DECL_CHAIN (t))
1276 && ((TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != RESULT_DECL)
1277 || !DECL_NONSHAREABLE (t)))
1278 expand_one_var (t, toplevel, true);
1280 /* Expand all variables at containing levels. */
1281 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
1282 expand_used_vars_for_block (t, false);
1285 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1286 and clear TREE_USED on all local variables. */
1289 clear_tree_used (tree block)
1293 for (t = BLOCK_VARS (block); t ; t = DECL_CHAIN (t))
1294 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
1295 if ((TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != RESULT_DECL)
1296 || !DECL_NONSHAREABLE (t))
1299 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
1300 clear_tree_used (t);
1303 /* Examine TYPE and determine a bit mask of the following features. */
1305 #define SPCT_HAS_LARGE_CHAR_ARRAY 1
1306 #define SPCT_HAS_SMALL_CHAR_ARRAY 2
1307 #define SPCT_HAS_ARRAY 4
1308 #define SPCT_HAS_AGGREGATE 8
1311 stack_protect_classify_type (tree type)
1313 unsigned int ret = 0;
1316 switch (TREE_CODE (type))
1319 t = TYPE_MAIN_VARIANT (TREE_TYPE (type));
1320 if (t == char_type_node
1321 || t == signed_char_type_node
1322 || t == unsigned_char_type_node)
1324 unsigned HOST_WIDE_INT max = PARAM_VALUE (PARAM_SSP_BUFFER_SIZE);
1325 unsigned HOST_WIDE_INT len;
1327 if (!TYPE_SIZE_UNIT (type)
1328 || !host_integerp (TYPE_SIZE_UNIT (type), 1))
1331 len = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
1334 ret = SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_ARRAY;
1336 ret = SPCT_HAS_LARGE_CHAR_ARRAY | SPCT_HAS_ARRAY;
1339 ret = SPCT_HAS_ARRAY;
1343 case QUAL_UNION_TYPE:
1345 ret = SPCT_HAS_AGGREGATE;
1346 for (t = TYPE_FIELDS (type); t ; t = TREE_CHAIN (t))
1347 if (TREE_CODE (t) == FIELD_DECL)
1348 ret |= stack_protect_classify_type (TREE_TYPE (t));
1358 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
1359 part of the local stack frame. Remember if we ever return nonzero for
1360 any variable in this function. The return value is the phase number in
1361 which the variable should be allocated. */
1364 stack_protect_decl_phase (tree decl)
1366 unsigned int bits = stack_protect_classify_type (TREE_TYPE (decl));
1369 if (bits & SPCT_HAS_SMALL_CHAR_ARRAY)
1370 has_short_buffer = true;
1372 if (flag_stack_protect == 2)
1374 if ((bits & (SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_LARGE_CHAR_ARRAY))
1375 && !(bits & SPCT_HAS_AGGREGATE))
1377 else if (bits & SPCT_HAS_ARRAY)
1381 ret = (bits & SPCT_HAS_LARGE_CHAR_ARRAY) != 0;
1384 has_protected_decls = true;
1389 /* Two helper routines that check for phase 1 and phase 2. These are used
1390 as callbacks for expand_stack_vars. */
1393 stack_protect_decl_phase_1 (tree decl)
1395 return stack_protect_decl_phase (decl) == 1;
1399 stack_protect_decl_phase_2 (tree decl)
1401 return stack_protect_decl_phase (decl) == 2;
1404 /* Ensure that variables in different stack protection phases conflict
1405 so that they are not merged and share the same stack slot. */
1408 add_stack_protection_conflicts (void)
1410 size_t i, j, n = stack_vars_num;
1411 unsigned char *phase;
1413 phase = XNEWVEC (unsigned char, n);
1414 for (i = 0; i < n; ++i)
1415 phase[i] = stack_protect_decl_phase (stack_vars[i].decl);
1417 for (i = 0; i < n; ++i)
1419 unsigned char ph_i = phase[i];
1420 for (j = 0; j < i; ++j)
1421 if (ph_i != phase[j])
1422 add_stack_var_conflict (i, j);
1428 /* Create a decl for the guard at the top of the stack frame. */
1431 create_stack_guard (void)
1433 tree guard = build_decl (DECL_SOURCE_LOCATION (current_function_decl),
1434 VAR_DECL, NULL, ptr_type_node);
1435 TREE_THIS_VOLATILE (guard) = 1;
1436 TREE_USED (guard) = 1;
1437 expand_one_stack_var (guard);
1438 crtl->stack_protect_guard = guard;
1441 /* Prepare for expanding variables. */
1443 init_vars_expansion (void)
1447 /* Set TREE_USED on all variables in the local_decls. */
1448 FOR_EACH_LOCAL_DECL (cfun, ix, t)
1451 /* Clear TREE_USED on all variables associated with a block scope. */
1452 clear_tree_used (DECL_INITIAL (current_function_decl));
1454 /* Initialize local stack smashing state. */
1455 has_protected_decls = false;
1456 has_short_buffer = false;
1459 /* Free up stack variable graph data. */
1461 fini_vars_expansion (void)
1463 size_t i, n = stack_vars_num;
1464 for (i = 0; i < n; i++)
1465 BITMAP_FREE (stack_vars[i].conflicts);
1466 XDELETEVEC (stack_vars);
1467 XDELETEVEC (stack_vars_sorted);
1469 stack_vars_alloc = stack_vars_num = 0;
1470 pointer_map_destroy (decl_to_stack_part);
1471 decl_to_stack_part = NULL;
1474 /* Make a fair guess for the size of the stack frame of the function
1475 in NODE. This doesn't have to be exact, the result is only used in
1476 the inline heuristics. So we don't want to run the full stack var
1477 packing algorithm (which is quadratic in the number of stack vars).
1478 Instead, we calculate the total size of all stack vars. This turns
1479 out to be a pretty fair estimate -- packing of stack vars doesn't
1480 happen very often. */
1483 estimated_stack_frame_size (struct cgraph_node *node)
1485 HOST_WIDE_INT size = 0;
1488 tree old_cur_fun_decl = current_function_decl;
1489 referenced_var_iterator rvi;
1490 struct function *fn = DECL_STRUCT_FUNCTION (node->decl);
1492 current_function_decl = node->decl;
1495 gcc_checking_assert (gimple_referenced_vars (fn));
1496 FOR_EACH_REFERENCED_VAR (fn, var, rvi)
1497 size += expand_one_var (var, true, false);
1499 if (stack_vars_num > 0)
1501 /* Fake sorting the stack vars for account_stack_vars (). */
1502 stack_vars_sorted = XNEWVEC (size_t, stack_vars_num);
1503 for (i = 0; i < stack_vars_num; ++i)
1504 stack_vars_sorted[i] = i;
1505 size += account_stack_vars ();
1506 fini_vars_expansion ();
1509 current_function_decl = old_cur_fun_decl;
1513 /* Expand all variables used in the function. */
1516 expand_used_vars (void)
1518 tree var, outer_block = DECL_INITIAL (current_function_decl);
1519 VEC(tree,heap) *maybe_local_decls = NULL;
1523 /* Compute the phase of the stack frame for this function. */
1525 int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
1526 int off = STARTING_FRAME_OFFSET % align;
1527 frame_phase = off ? align - off : 0;
1530 init_vars_expansion ();
1532 for (i = 0; i < SA.map->num_partitions; i++)
1534 tree var = partition_to_var (SA.map, i);
1536 gcc_assert (is_gimple_reg (var));
1537 if (TREE_CODE (SSA_NAME_VAR (var)) == VAR_DECL)
1538 expand_one_var (var, true, true);
1541 /* This is a PARM_DECL or RESULT_DECL. For those partitions that
1542 contain the default def (representing the parm or result itself)
1543 we don't do anything here. But those which don't contain the
1544 default def (representing a temporary based on the parm/result)
1545 we need to allocate space just like for normal VAR_DECLs. */
1546 if (!bitmap_bit_p (SA.partition_has_default_def, i))
1548 expand_one_var (var, true, true);
1549 gcc_assert (SA.partition_to_pseudo[i]);
1554 /* At this point all variables on the local_decls with TREE_USED
1555 set are not associated with any block scope. Lay them out. */
1557 len = VEC_length (tree, cfun->local_decls);
1558 FOR_EACH_LOCAL_DECL (cfun, i, var)
1560 bool expand_now = false;
1562 /* Expanded above already. */
1563 if (is_gimple_reg (var))
1565 TREE_USED (var) = 0;
1568 /* We didn't set a block for static or extern because it's hard
1569 to tell the difference between a global variable (re)declared
1570 in a local scope, and one that's really declared there to
1571 begin with. And it doesn't really matter much, since we're
1572 not giving them stack space. Expand them now. */
1573 else if (TREE_STATIC (var) || DECL_EXTERNAL (var))
1576 /* If the variable is not associated with any block, then it
1577 was created by the optimizers, and could be live anywhere
1579 else if (TREE_USED (var))
1582 /* Finally, mark all variables on the list as used. We'll use
1583 this in a moment when we expand those associated with scopes. */
1584 TREE_USED (var) = 1;
1587 expand_one_var (var, true, true);
1590 if (DECL_ARTIFICIAL (var) && !DECL_IGNORED_P (var))
1592 rtx rtl = DECL_RTL_IF_SET (var);
1594 /* Keep artificial non-ignored vars in cfun->local_decls
1595 chain until instantiate_decls. */
1596 if (rtl && (MEM_P (rtl) || GET_CODE (rtl) == CONCAT))
1597 add_local_decl (cfun, var);
1598 else if (rtl == NULL_RTX)
1599 /* If rtl isn't set yet, which can happen e.g. with
1600 -fstack-protector, retry before returning from this
1602 VEC_safe_push (tree, heap, maybe_local_decls, var);
1606 /* We duplicated some of the decls in CFUN->LOCAL_DECLS.
1608 +-----------------+-----------------+
1609 | ...processed... | ...duplicates...|
1610 +-----------------+-----------------+
1612 +-- LEN points here.
1614 We just want the duplicates, as those are the artificial
1615 non-ignored vars that we want to keep until instantiate_decls.
1616 Move them down and truncate the array. */
1617 if (!VEC_empty (tree, cfun->local_decls))
1618 VEC_block_remove (tree, cfun->local_decls, 0, len);
1620 /* At this point, all variables within the block tree with TREE_USED
1621 set are actually used by the optimized function. Lay them out. */
1622 expand_used_vars_for_block (outer_block, true);
1624 if (stack_vars_num > 0)
1626 add_scope_conflicts ();
1627 /* Due to the way alias sets work, no variables with non-conflicting
1628 alias sets may be assigned the same address. Add conflicts to
1630 add_alias_set_conflicts ();
1632 /* If stack protection is enabled, we don't share space between
1633 vulnerable data and non-vulnerable data. */
1634 if (flag_stack_protect)
1635 add_stack_protection_conflicts ();
1637 /* Now that we have collected all stack variables, and have computed a
1638 minimal interference graph, attempt to save some stack space. */
1639 partition_stack_vars ();
1641 dump_stack_var_partition ();
1644 /* There are several conditions under which we should create a
1645 stack guard: protect-all, alloca used, protected decls present. */
1646 if (flag_stack_protect == 2
1647 || (flag_stack_protect
1648 && (cfun->calls_alloca || has_protected_decls)))
1649 create_stack_guard ();
1651 /* Assign rtl to each variable based on these partitions. */
1652 if (stack_vars_num > 0)
1654 /* Reorder decls to be protected by iterating over the variables
1655 array multiple times, and allocating out of each phase in turn. */
1656 /* ??? We could probably integrate this into the qsort we did
1657 earlier, such that we naturally see these variables first,
1658 and thus naturally allocate things in the right order. */
1659 if (has_protected_decls)
1661 /* Phase 1 contains only character arrays. */
1662 expand_stack_vars (stack_protect_decl_phase_1);
1664 /* Phase 2 contains other kinds of arrays. */
1665 if (flag_stack_protect == 2)
1666 expand_stack_vars (stack_protect_decl_phase_2);
1669 expand_stack_vars (NULL);
1671 fini_vars_expansion ();
1674 /* If there were any artificial non-ignored vars without rtl
1675 found earlier, see if deferred stack allocation hasn't assigned
1677 FOR_EACH_VEC_ELT_REVERSE (tree, maybe_local_decls, i, var)
1679 rtx rtl = DECL_RTL_IF_SET (var);
1681 /* Keep artificial non-ignored vars in cfun->local_decls
1682 chain until instantiate_decls. */
1683 if (rtl && (MEM_P (rtl) || GET_CODE (rtl) == CONCAT))
1684 add_local_decl (cfun, var);
1686 VEC_free (tree, heap, maybe_local_decls);
1688 /* If the target requires that FRAME_OFFSET be aligned, do it. */
1689 if (STACK_ALIGNMENT_NEEDED)
1691 HOST_WIDE_INT align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
1692 if (!FRAME_GROWS_DOWNWARD)
1693 frame_offset += align - 1;
1694 frame_offset &= -align;
1699 /* If we need to produce a detailed dump, print the tree representation
1700 for STMT to the dump file. SINCE is the last RTX after which the RTL
1701 generated for STMT should have been appended. */
1704 maybe_dump_rtl_for_gimple_stmt (gimple stmt, rtx since)
1706 if (dump_file && (dump_flags & TDF_DETAILS))
1708 fprintf (dump_file, "\n;; ");
1709 print_gimple_stmt (dump_file, stmt, 0,
1710 TDF_SLIM | (dump_flags & TDF_LINENO));
1711 fprintf (dump_file, "\n");
1713 print_rtl (dump_file, since ? NEXT_INSN (since) : since);
1717 /* Maps the blocks that do not contain tree labels to rtx labels. */
1719 static struct pointer_map_t *lab_rtx_for_bb;
1721 /* Returns the label_rtx expression for a label starting basic block BB. */
1724 label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED)
1726 gimple_stmt_iterator gsi;
1731 if (bb->flags & BB_RTL)
1732 return block_label (bb);
1734 elt = pointer_map_contains (lab_rtx_for_bb, bb);
1738 /* Find the tree label if it is present. */
1740 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1742 lab_stmt = gsi_stmt (gsi);
1743 if (gimple_code (lab_stmt) != GIMPLE_LABEL)
1746 lab = gimple_label_label (lab_stmt);
1747 if (DECL_NONLOCAL (lab))
1750 return label_rtx (lab);
1753 elt = pointer_map_insert (lab_rtx_for_bb, bb);
1754 *elt = gen_label_rtx ();
1759 /* A subroutine of expand_gimple_cond. Given E, a fallthrough edge
1760 of a basic block where we just expanded the conditional at the end,
1761 possibly clean up the CFG and instruction sequence. LAST is the
1762 last instruction before the just emitted jump sequence. */
1765 maybe_cleanup_end_of_block (edge e, rtx last)
1767 /* Special case: when jumpif decides that the condition is
1768 trivial it emits an unconditional jump (and the necessary
1769 barrier). But we still have two edges, the fallthru one is
1770 wrong. purge_dead_edges would clean this up later. Unfortunately
1771 we have to insert insns (and split edges) before
1772 find_many_sub_basic_blocks and hence before purge_dead_edges.
1773 But splitting edges might create new blocks which depend on the
1774 fact that if there are two edges there's no barrier. So the
1775 barrier would get lost and verify_flow_info would ICE. Instead
1776 of auditing all edge splitters to care for the barrier (which
1777 normally isn't there in a cleaned CFG), fix it here. */
1778 if (BARRIER_P (get_last_insn ()))
1782 /* Now, we have a single successor block, if we have insns to
1783 insert on the remaining edge we potentially will insert
1784 it at the end of this block (if the dest block isn't feasible)
1785 in order to avoid splitting the edge. This insertion will take
1786 place in front of the last jump. But we might have emitted
1787 multiple jumps (conditional and one unconditional) to the
1788 same destination. Inserting in front of the last one then
1789 is a problem. See PR 40021. We fix this by deleting all
1790 jumps except the last unconditional one. */
1791 insn = PREV_INSN (get_last_insn ());
1792 /* Make sure we have an unconditional jump. Otherwise we're
1794 gcc_assert (JUMP_P (insn) && !any_condjump_p (insn));
1795 for (insn = PREV_INSN (insn); insn != last;)
1797 insn = PREV_INSN (insn);
1798 if (JUMP_P (NEXT_INSN (insn)))
1800 if (!any_condjump_p (NEXT_INSN (insn)))
1802 gcc_assert (BARRIER_P (NEXT_INSN (NEXT_INSN (insn))));
1803 delete_insn (NEXT_INSN (NEXT_INSN (insn)));
1805 delete_insn (NEXT_INSN (insn));
1811 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_COND.
1812 Returns a new basic block if we've terminated the current basic
1813 block and created a new one. */
1816 expand_gimple_cond (basic_block bb, gimple stmt)
1818 basic_block new_bb, dest;
1823 enum tree_code code;
1826 code = gimple_cond_code (stmt);
1827 op0 = gimple_cond_lhs (stmt);
1828 op1 = gimple_cond_rhs (stmt);
1829 /* We're sometimes presented with such code:
1833 This would expand to two comparisons which then later might
1834 be cleaned up by combine. But some pattern matchers like if-conversion
1835 work better when there's only one compare, so make up for this
1836 here as special exception if TER would have made the same change. */
1837 if (gimple_cond_single_var_p (stmt)
1839 && TREE_CODE (op0) == SSA_NAME
1840 && bitmap_bit_p (SA.values, SSA_NAME_VERSION (op0)))
1842 gimple second = SSA_NAME_DEF_STMT (op0);
1843 if (gimple_code (second) == GIMPLE_ASSIGN)
1845 enum tree_code code2 = gimple_assign_rhs_code (second);
1846 if (TREE_CODE_CLASS (code2) == tcc_comparison)
1849 op0 = gimple_assign_rhs1 (second);
1850 op1 = gimple_assign_rhs2 (second);
1852 /* If jumps are cheap turn some more codes into
1854 else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4)
1856 if ((code2 == BIT_AND_EXPR
1857 && TYPE_PRECISION (TREE_TYPE (op0)) == 1
1858 && TREE_CODE (gimple_assign_rhs2 (second)) != INTEGER_CST)
1859 || code2 == TRUTH_AND_EXPR)
1861 code = TRUTH_ANDIF_EXPR;
1862 op0 = gimple_assign_rhs1 (second);
1863 op1 = gimple_assign_rhs2 (second);
1865 else if (code2 == BIT_IOR_EXPR || code2 == TRUTH_OR_EXPR)
1867 code = TRUTH_ORIF_EXPR;
1868 op0 = gimple_assign_rhs1 (second);
1869 op1 = gimple_assign_rhs2 (second);
1875 last2 = last = get_last_insn ();
1877 extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
1878 set_curr_insn_source_location (gimple_location (stmt));
1879 set_curr_insn_block (gimple_block (stmt));
1881 /* These flags have no purpose in RTL land. */
1882 true_edge->flags &= ~EDGE_TRUE_VALUE;
1883 false_edge->flags &= ~EDGE_FALSE_VALUE;
1885 /* We can either have a pure conditional jump with one fallthru edge or
1886 two-way jump that needs to be decomposed into two basic blocks. */
1887 if (false_edge->dest == bb->next_bb)
1889 jumpif_1 (code, op0, op1, label_rtx_for_bb (true_edge->dest),
1890 true_edge->probability);
1891 maybe_dump_rtl_for_gimple_stmt (stmt, last);
1892 if (true_edge->goto_locus)
1894 set_curr_insn_source_location (true_edge->goto_locus);
1895 set_curr_insn_block (true_edge->goto_block);
1896 true_edge->goto_locus = curr_insn_locator ();
1898 true_edge->goto_block = NULL;
1899 false_edge->flags |= EDGE_FALLTHRU;
1900 maybe_cleanup_end_of_block (false_edge, last);
1903 if (true_edge->dest == bb->next_bb)
1905 jumpifnot_1 (code, op0, op1, label_rtx_for_bb (false_edge->dest),
1906 false_edge->probability);
1907 maybe_dump_rtl_for_gimple_stmt (stmt, last);
1908 if (false_edge->goto_locus)
1910 set_curr_insn_source_location (false_edge->goto_locus);
1911 set_curr_insn_block (false_edge->goto_block);
1912 false_edge->goto_locus = curr_insn_locator ();
1914 false_edge->goto_block = NULL;
1915 true_edge->flags |= EDGE_FALLTHRU;
1916 maybe_cleanup_end_of_block (true_edge, last);
1920 jumpif_1 (code, op0, op1, label_rtx_for_bb (true_edge->dest),
1921 true_edge->probability);
1922 last = get_last_insn ();
1923 if (false_edge->goto_locus)
1925 set_curr_insn_source_location (false_edge->goto_locus);
1926 set_curr_insn_block (false_edge->goto_block);
1927 false_edge->goto_locus = curr_insn_locator ();
1929 false_edge->goto_block = NULL;
1930 emit_jump (label_rtx_for_bb (false_edge->dest));
1933 if (BARRIER_P (BB_END (bb)))
1934 BB_END (bb) = PREV_INSN (BB_END (bb));
1935 update_bb_for_insn (bb);
1937 new_bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
1938 dest = false_edge->dest;
1939 redirect_edge_succ (false_edge, new_bb);
1940 false_edge->flags |= EDGE_FALLTHRU;
1941 new_bb->count = false_edge->count;
1942 new_bb->frequency = EDGE_FREQUENCY (false_edge);
1943 new_edge = make_edge (new_bb, dest, 0);
1944 new_edge->probability = REG_BR_PROB_BASE;
1945 new_edge->count = new_bb->count;
1946 if (BARRIER_P (BB_END (new_bb)))
1947 BB_END (new_bb) = PREV_INSN (BB_END (new_bb));
1948 update_bb_for_insn (new_bb);
1950 maybe_dump_rtl_for_gimple_stmt (stmt, last2);
1952 if (true_edge->goto_locus)
1954 set_curr_insn_source_location (true_edge->goto_locus);
1955 set_curr_insn_block (true_edge->goto_block);
1956 true_edge->goto_locus = curr_insn_locator ();
1958 true_edge->goto_block = NULL;
1963 /* Mark all calls that can have a transaction restart. */
1966 mark_transaction_restart_calls (gimple stmt)
1968 struct tm_restart_node dummy;
1971 if (!cfun->gimple_df->tm_restart)
1975 slot = htab_find_slot (cfun->gimple_df->tm_restart, &dummy, NO_INSERT);
1978 struct tm_restart_node *n = (struct tm_restart_node *) *slot;
1979 tree list = n->label_or_list;
1982 for (insn = next_real_insn (get_last_insn ());
1984 insn = next_real_insn (insn))
1987 if (TREE_CODE (list) == LABEL_DECL)
1988 add_reg_note (insn, REG_TM, label_rtx (list));
1990 for (; list ; list = TREE_CHAIN (list))
1991 add_reg_note (insn, REG_TM, label_rtx (TREE_VALUE (list)));
1995 /* A subroutine of expand_gimple_stmt_1, expanding one GIMPLE_CALL
1999 expand_call_stmt (gimple stmt)
2001 tree exp, decl, lhs;
2005 if (gimple_call_internal_p (stmt))
2007 expand_internal_call (stmt);
2011 exp = build_vl_exp (CALL_EXPR, gimple_call_num_args (stmt) + 3);
2013 CALL_EXPR_FN (exp) = gimple_call_fn (stmt);
2014 decl = gimple_call_fndecl (stmt);
2015 builtin_p = decl && DECL_BUILT_IN (decl);
2017 /* If this is not a builtin function, the function type through which the
2018 call is made may be different from the type of the function. */
2021 = fold_convert (build_pointer_type (gimple_call_fntype (stmt)),
2022 CALL_EXPR_FN (exp));
2024 TREE_TYPE (exp) = gimple_call_return_type (stmt);
2025 CALL_EXPR_STATIC_CHAIN (exp) = gimple_call_chain (stmt);
2027 for (i = 0; i < gimple_call_num_args (stmt); i++)
2029 tree arg = gimple_call_arg (stmt, i);
2031 /* TER addresses into arguments of builtin functions so we have a
2032 chance to infer more correct alignment information. See PR39954. */
2034 && TREE_CODE (arg) == SSA_NAME
2035 && (def = get_gimple_for_ssa_name (arg))
2036 && gimple_assign_rhs_code (def) == ADDR_EXPR)
2037 arg = gimple_assign_rhs1 (def);
2038 CALL_EXPR_ARG (exp, i) = arg;
2041 if (gimple_has_side_effects (stmt))
2042 TREE_SIDE_EFFECTS (exp) = 1;
2044 if (gimple_call_nothrow_p (stmt))
2045 TREE_NOTHROW (exp) = 1;
2047 CALL_EXPR_TAILCALL (exp) = gimple_call_tail_p (stmt);
2048 CALL_EXPR_RETURN_SLOT_OPT (exp) = gimple_call_return_slot_opt_p (stmt);
2050 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
2051 && (DECL_FUNCTION_CODE (decl) == BUILT_IN_ALLOCA
2052 || DECL_FUNCTION_CODE (decl) == BUILT_IN_ALLOCA_WITH_ALIGN))
2053 CALL_ALLOCA_FOR_VAR_P (exp) = gimple_call_alloca_for_var_p (stmt);
2055 CALL_FROM_THUNK_P (exp) = gimple_call_from_thunk_p (stmt);
2056 CALL_EXPR_VA_ARG_PACK (exp) = gimple_call_va_arg_pack_p (stmt);
2057 SET_EXPR_LOCATION (exp, gimple_location (stmt));
2058 TREE_BLOCK (exp) = gimple_block (stmt);
2060 /* Ensure RTL is created for debug args. */
2061 if (decl && DECL_HAS_DEBUG_ARGS_P (decl))
2063 VEC(tree, gc) **debug_args = decl_debug_args_lookup (decl);
2068 for (ix = 1; VEC_iterate (tree, *debug_args, ix, dtemp); ix += 2)
2070 gcc_assert (TREE_CODE (dtemp) == DEBUG_EXPR_DECL);
2071 expand_debug_expr (dtemp);
2075 lhs = gimple_call_lhs (stmt);
2077 expand_assignment (lhs, exp, false);
2079 expand_expr_real_1 (exp, const0_rtx, VOIDmode, EXPAND_NORMAL, NULL);
2081 mark_transaction_restart_calls (stmt);
2084 /* A subroutine of expand_gimple_stmt, expanding one gimple statement
2085 STMT that doesn't require special handling for outgoing edges. That
2086 is no tailcalls and no GIMPLE_COND. */
2089 expand_gimple_stmt_1 (gimple stmt)
2093 set_curr_insn_source_location (gimple_location (stmt));
2094 set_curr_insn_block (gimple_block (stmt));
2096 switch (gimple_code (stmt))
2099 op0 = gimple_goto_dest (stmt);
2100 if (TREE_CODE (op0) == LABEL_DECL)
2103 expand_computed_goto (op0);
2106 expand_label (gimple_label_label (stmt));
2109 case GIMPLE_PREDICT:
2115 expand_asm_stmt (stmt);
2118 expand_call_stmt (stmt);
2122 op0 = gimple_return_retval (stmt);
2124 if (op0 && op0 != error_mark_node)
2126 tree result = DECL_RESULT (current_function_decl);
2128 /* If we are not returning the current function's RESULT_DECL,
2129 build an assignment to it. */
2132 /* I believe that a function's RESULT_DECL is unique. */
2133 gcc_assert (TREE_CODE (op0) != RESULT_DECL);
2135 /* ??? We'd like to use simply expand_assignment here,
2136 but this fails if the value is of BLKmode but the return
2137 decl is a register. expand_return has special handling
2138 for this combination, which eventually should move
2139 to common code. See comments there. Until then, let's
2140 build a modify expression :-/ */
2141 op0 = build2 (MODIFY_EXPR, TREE_TYPE (result),
2146 expand_null_return ();
2148 expand_return (op0);
2153 tree lhs = gimple_assign_lhs (stmt);
2155 /* Tree expand used to fiddle with |= and &= of two bitfield
2156 COMPONENT_REFs here. This can't happen with gimple, the LHS
2157 of binary assigns must be a gimple reg. */
2159 if (TREE_CODE (lhs) != SSA_NAME
2160 || get_gimple_rhs_class (gimple_expr_code (stmt))
2161 == GIMPLE_SINGLE_RHS)
2163 tree rhs = gimple_assign_rhs1 (stmt);
2164 gcc_assert (get_gimple_rhs_class (gimple_expr_code (stmt))
2165 == GIMPLE_SINGLE_RHS);
2166 if (gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (rhs))
2167 SET_EXPR_LOCATION (rhs, gimple_location (stmt));
2168 if (TREE_CLOBBER_P (rhs))
2169 /* This is a clobber to mark the going out of scope for
2173 expand_assignment (lhs, rhs,
2174 gimple_assign_nontemporal_move_p (stmt));
2179 bool nontemporal = gimple_assign_nontemporal_move_p (stmt);
2180 struct separate_ops ops;
2181 bool promoted = false;
2183 target = expand_expr (lhs, NULL_RTX, VOIDmode, EXPAND_WRITE);
2184 if (GET_CODE (target) == SUBREG && SUBREG_PROMOTED_VAR_P (target))
2187 ops.code = gimple_assign_rhs_code (stmt);
2188 ops.type = TREE_TYPE (lhs);
2189 switch (get_gimple_rhs_class (gimple_expr_code (stmt)))
2191 case GIMPLE_TERNARY_RHS:
2192 ops.op2 = gimple_assign_rhs3 (stmt);
2194 case GIMPLE_BINARY_RHS:
2195 ops.op1 = gimple_assign_rhs2 (stmt);
2197 case GIMPLE_UNARY_RHS:
2198 ops.op0 = gimple_assign_rhs1 (stmt);
2203 ops.location = gimple_location (stmt);
2205 /* If we want to use a nontemporal store, force the value to
2206 register first. If we store into a promoted register,
2207 don't directly expand to target. */
2208 temp = nontemporal || promoted ? NULL_RTX : target;
2209 temp = expand_expr_real_2 (&ops, temp, GET_MODE (target),
2216 int unsignedp = SUBREG_PROMOTED_UNSIGNED_P (target);
2217 /* If TEMP is a VOIDmode constant, use convert_modes to make
2218 sure that we properly convert it. */
2219 if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode)
2221 temp = convert_modes (GET_MODE (target),
2222 TYPE_MODE (ops.type),
2224 temp = convert_modes (GET_MODE (SUBREG_REG (target)),
2225 GET_MODE (target), temp, unsignedp);
2228 convert_move (SUBREG_REG (target), temp, unsignedp);
2230 else if (nontemporal && emit_storent_insn (target, temp))
2234 temp = force_operand (temp, target);
2236 emit_move_insn (target, temp);
2247 /* Expand one gimple statement STMT and return the last RTL instruction
2248 before any of the newly generated ones.
2250 In addition to generating the necessary RTL instructions this also
2251 sets REG_EH_REGION notes if necessary and sets the current source
2252 location for diagnostics. */
2255 expand_gimple_stmt (gimple stmt)
2257 location_t saved_location = input_location;
2258 rtx last = get_last_insn ();
2263 /* We need to save and restore the current source location so that errors
2264 discovered during expansion are emitted with the right location. But
2265 it would be better if the diagnostic routines used the source location
2266 embedded in the tree nodes rather than globals. */
2267 if (gimple_has_location (stmt))
2268 input_location = gimple_location (stmt);
2270 expand_gimple_stmt_1 (stmt);
2272 /* Free any temporaries used to evaluate this statement. */
2275 input_location = saved_location;
2277 /* Mark all insns that may trap. */
2278 lp_nr = lookup_stmt_eh_lp (stmt);
2282 for (insn = next_real_insn (last); insn;
2283 insn = next_real_insn (insn))
2285 if (! find_reg_note (insn, REG_EH_REGION, NULL_RTX)
2286 /* If we want exceptions for non-call insns, any
2287 may_trap_p instruction may throw. */
2288 && GET_CODE (PATTERN (insn)) != CLOBBER
2289 && GET_CODE (PATTERN (insn)) != USE
2290 && insn_could_throw_p (insn))
2291 make_reg_eh_region_note (insn, 0, lp_nr);
2298 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_CALL
2299 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
2300 generated a tail call (something that might be denied by the ABI
2301 rules governing the call; see calls.c).
2303 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
2304 can still reach the rest of BB. The case here is __builtin_sqrt,
2305 where the NaN result goes through the external function (with a
2306 tailcall) and the normal result happens via a sqrt instruction. */
2309 expand_gimple_tailcall (basic_block bb, gimple stmt, bool *can_fallthru)
2317 last2 = last = expand_gimple_stmt (stmt);
2319 for (last = NEXT_INSN (last); last; last = NEXT_INSN (last))
2320 if (CALL_P (last) && SIBLING_CALL_P (last))
2323 maybe_dump_rtl_for_gimple_stmt (stmt, last2);
2325 *can_fallthru = true;
2329 /* ??? Wouldn't it be better to just reset any pending stack adjust?
2330 Any instructions emitted here are about to be deleted. */
2331 do_pending_stack_adjust ();
2333 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
2334 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
2335 EH or abnormal edges, we shouldn't have created a tail call in
2336 the first place. So it seems to me we should just be removing
2337 all edges here, or redirecting the existing fallthru edge to
2343 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
2345 if (!(e->flags & (EDGE_ABNORMAL | EDGE_EH)))
2347 if (e->dest != EXIT_BLOCK_PTR)
2349 e->dest->count -= e->count;
2350 e->dest->frequency -= EDGE_FREQUENCY (e);
2351 if (e->dest->count < 0)
2353 if (e->dest->frequency < 0)
2354 e->dest->frequency = 0;
2357 probability += e->probability;
2364 /* This is somewhat ugly: the call_expr expander often emits instructions
2365 after the sibcall (to perform the function return). These confuse the
2366 find_many_sub_basic_blocks code, so we need to get rid of these. */
2367 last = NEXT_INSN (last);
2368 gcc_assert (BARRIER_P (last));
2370 *can_fallthru = false;
2371 while (NEXT_INSN (last))
2373 /* For instance an sqrt builtin expander expands if with
2374 sibcall in the then and label for `else`. */
2375 if (LABEL_P (NEXT_INSN (last)))
2377 *can_fallthru = true;
2380 delete_insn (NEXT_INSN (last));
2383 e = make_edge (bb, EXIT_BLOCK_PTR, EDGE_ABNORMAL | EDGE_SIBCALL);
2384 e->probability += probability;
2387 update_bb_for_insn (bb);
2389 if (NEXT_INSN (last))
2391 bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
2394 if (BARRIER_P (last))
2395 BB_END (bb) = PREV_INSN (last);
2398 maybe_dump_rtl_for_gimple_stmt (stmt, last2);
2403 /* Return the difference between the floor and the truncated result of
2404 a signed division by OP1 with remainder MOD. */
2406 floor_sdiv_adjust (enum machine_mode mode, rtx mod, rtx op1)
2408 /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
2409 return gen_rtx_IF_THEN_ELSE
2410 (mode, gen_rtx_NE (BImode, mod, const0_rtx),
2411 gen_rtx_IF_THEN_ELSE
2412 (mode, gen_rtx_LT (BImode,
2413 gen_rtx_DIV (mode, op1, mod),
2415 constm1_rtx, const0_rtx),
2419 /* Return the difference between the ceil and the truncated result of
2420 a signed division by OP1 with remainder MOD. */
2422 ceil_sdiv_adjust (enum machine_mode mode, rtx mod, rtx op1)
2424 /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
2425 return gen_rtx_IF_THEN_ELSE
2426 (mode, gen_rtx_NE (BImode, mod, const0_rtx),
2427 gen_rtx_IF_THEN_ELSE
2428 (mode, gen_rtx_GT (BImode,
2429 gen_rtx_DIV (mode, op1, mod),
2431 const1_rtx, const0_rtx),
2435 /* Return the difference between the ceil and the truncated result of
2436 an unsigned division by OP1 with remainder MOD. */
2438 ceil_udiv_adjust (enum machine_mode mode, rtx mod, rtx op1 ATTRIBUTE_UNUSED)
2440 /* (mod != 0 ? 1 : 0) */
2441 return gen_rtx_IF_THEN_ELSE
2442 (mode, gen_rtx_NE (BImode, mod, const0_rtx),
2443 const1_rtx, const0_rtx);
2446 /* Return the difference between the rounded and the truncated result
2447 of a signed division by OP1 with remainder MOD. Halfway cases are
2448 rounded away from zero, rather than to the nearest even number. */
2450 round_sdiv_adjust (enum machine_mode mode, rtx mod, rtx op1)
2452 /* (abs (mod) >= abs (op1) - abs (mod)
2453 ? (op1 / mod > 0 ? 1 : -1)
2455 return gen_rtx_IF_THEN_ELSE
2456 (mode, gen_rtx_GE (BImode, gen_rtx_ABS (mode, mod),
2457 gen_rtx_MINUS (mode,
2458 gen_rtx_ABS (mode, op1),
2459 gen_rtx_ABS (mode, mod))),
2460 gen_rtx_IF_THEN_ELSE
2461 (mode, gen_rtx_GT (BImode,
2462 gen_rtx_DIV (mode, op1, mod),
2464 const1_rtx, constm1_rtx),
2468 /* Return the difference between the rounded and the truncated result
2469 of a unsigned division by OP1 with remainder MOD. Halfway cases
2470 are rounded away from zero, rather than to the nearest even
2473 round_udiv_adjust (enum machine_mode mode, rtx mod, rtx op1)
2475 /* (mod >= op1 - mod ? 1 : 0) */
2476 return gen_rtx_IF_THEN_ELSE
2477 (mode, gen_rtx_GE (BImode, mod,
2478 gen_rtx_MINUS (mode, op1, mod)),
2479 const1_rtx, const0_rtx);
2482 /* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
2486 convert_debug_memory_address (enum machine_mode mode, rtx x,
2489 enum machine_mode xmode = GET_MODE (x);
2491 #ifndef POINTERS_EXTEND_UNSIGNED
2492 gcc_assert (mode == Pmode
2493 || mode == targetm.addr_space.address_mode (as));
2494 gcc_assert (xmode == mode || xmode == VOIDmode);
2498 gcc_assert (targetm.addr_space.valid_pointer_mode (mode, as));
2500 if (GET_MODE (x) == mode || GET_MODE (x) == VOIDmode)
2503 if (GET_MODE_PRECISION (mode) < GET_MODE_PRECISION (xmode))
2504 x = simplify_gen_subreg (mode, x, xmode,
2505 subreg_lowpart_offset
2507 else if (POINTERS_EXTEND_UNSIGNED > 0)
2508 x = gen_rtx_ZERO_EXTEND (mode, x);
2509 else if (!POINTERS_EXTEND_UNSIGNED)
2510 x = gen_rtx_SIGN_EXTEND (mode, x);
2513 switch (GET_CODE (x))
2516 if ((SUBREG_PROMOTED_VAR_P (x)
2517 || (REG_P (SUBREG_REG (x)) && REG_POINTER (SUBREG_REG (x)))
2518 || (GET_CODE (SUBREG_REG (x)) == PLUS
2519 && REG_P (XEXP (SUBREG_REG (x), 0))
2520 && REG_POINTER (XEXP (SUBREG_REG (x), 0))
2521 && CONST_INT_P (XEXP (SUBREG_REG (x), 1))))
2522 && GET_MODE (SUBREG_REG (x)) == mode)
2523 return SUBREG_REG (x);
2526 temp = gen_rtx_LABEL_REF (mode, XEXP (x, 0));
2527 LABEL_REF_NONLOCAL_P (temp) = LABEL_REF_NONLOCAL_P (x);
2530 temp = shallow_copy_rtx (x);
2531 PUT_MODE (temp, mode);
2534 temp = convert_debug_memory_address (mode, XEXP (x, 0), as);
2536 temp = gen_rtx_CONST (mode, temp);
2540 if (CONST_INT_P (XEXP (x, 1)))
2542 temp = convert_debug_memory_address (mode, XEXP (x, 0), as);
2544 return gen_rtx_fmt_ee (GET_CODE (x), mode, temp, XEXP (x, 1));
2550 /* Don't know how to express ptr_extend as operation in debug info. */
2553 #endif /* POINTERS_EXTEND_UNSIGNED */
2558 /* Return an RTX equivalent to the value of the parameter DECL. */
2561 expand_debug_parm_decl (tree decl)
2563 rtx incoming = DECL_INCOMING_RTL (decl);
2566 && GET_MODE (incoming) != BLKmode
2567 && ((REG_P (incoming) && HARD_REGISTER_P (incoming))
2568 || (MEM_P (incoming)
2569 && REG_P (XEXP (incoming, 0))
2570 && HARD_REGISTER_P (XEXP (incoming, 0)))))
2572 rtx rtl = gen_rtx_ENTRY_VALUE (GET_MODE (incoming));
2574 #ifdef HAVE_window_save
2575 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
2576 If the target machine has an explicit window save instruction, the
2577 actual entry value is the corresponding OUTGOING_REGNO instead. */
2578 if (REG_P (incoming)
2579 && OUTGOING_REGNO (REGNO (incoming)) != REGNO (incoming))
2581 = gen_rtx_REG_offset (incoming, GET_MODE (incoming),
2582 OUTGOING_REGNO (REGNO (incoming)), 0);
2583 else if (MEM_P (incoming))
2585 rtx reg = XEXP (incoming, 0);
2586 if (OUTGOING_REGNO (REGNO (reg)) != REGNO (reg))
2588 reg = gen_raw_REG (GET_MODE (reg), OUTGOING_REGNO (REGNO (reg)));
2589 incoming = replace_equiv_address_nv (incoming, reg);
2594 ENTRY_VALUE_EXP (rtl) = incoming;
2599 && GET_MODE (incoming) != BLKmode
2600 && !TREE_ADDRESSABLE (decl)
2602 && (XEXP (incoming, 0) == virtual_incoming_args_rtx
2603 || (GET_CODE (XEXP (incoming, 0)) == PLUS
2604 && XEXP (XEXP (incoming, 0), 0) == virtual_incoming_args_rtx
2605 && CONST_INT_P (XEXP (XEXP (incoming, 0), 1)))))
2611 /* Return an RTX equivalent to the value of the tree expression EXP. */
2614 expand_debug_expr (tree exp)
2616 rtx op0 = NULL_RTX, op1 = NULL_RTX, op2 = NULL_RTX;
2617 enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
2618 enum machine_mode inner_mode = VOIDmode;
2619 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (exp));
2622 switch (TREE_CODE_CLASS (TREE_CODE (exp)))
2624 case tcc_expression:
2625 switch (TREE_CODE (exp))
2629 case WIDEN_MULT_PLUS_EXPR:
2630 case WIDEN_MULT_MINUS_EXPR:
2634 case TRUTH_ANDIF_EXPR:
2635 case TRUTH_ORIF_EXPR:
2636 case TRUTH_AND_EXPR:
2638 case TRUTH_XOR_EXPR:
2641 case TRUTH_NOT_EXPR:
2650 op2 = expand_debug_expr (TREE_OPERAND (exp, 2));
2657 case tcc_comparison:
2658 op1 = expand_debug_expr (TREE_OPERAND (exp, 1));
2665 inner_mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
2666 op0 = expand_debug_expr (TREE_OPERAND (exp, 0));
2676 case tcc_exceptional:
2677 case tcc_declaration:
2683 switch (TREE_CODE (exp))
2686 if (!lookup_constant_def (exp))
2688 if (strlen (TREE_STRING_POINTER (exp)) + 1
2689 != (size_t) TREE_STRING_LENGTH (exp))
2691 op0 = gen_rtx_CONST_STRING (Pmode, TREE_STRING_POINTER (exp));
2692 op0 = gen_rtx_MEM (BLKmode, op0);
2693 set_mem_attributes (op0, exp, 0);
2696 /* Fall through... */
2701 op0 = expand_expr (exp, NULL_RTX, mode, EXPAND_INITIALIZER);
2705 gcc_assert (COMPLEX_MODE_P (mode));
2706 op0 = expand_debug_expr (TREE_REALPART (exp));
2707 op1 = expand_debug_expr (TREE_IMAGPART (exp));
2708 return gen_rtx_CONCAT (mode, op0, op1);
2710 case DEBUG_EXPR_DECL:
2711 op0 = DECL_RTL_IF_SET (exp);
2716 op0 = gen_rtx_DEBUG_EXPR (mode);
2717 DEBUG_EXPR_TREE_DECL (op0) = exp;
2718 SET_DECL_RTL (exp, op0);
2728 op0 = DECL_RTL_IF_SET (exp);
2730 /* This decl was probably optimized away. */
2733 if (TREE_CODE (exp) != VAR_DECL
2734 || DECL_EXTERNAL (exp)
2735 || !TREE_STATIC (exp)
2737 || DECL_HARD_REGISTER (exp)
2738 || DECL_IN_CONSTANT_POOL (exp)
2739 || mode == VOIDmode)
2742 op0 = make_decl_rtl_for_debug (exp);
2744 || GET_CODE (XEXP (op0, 0)) != SYMBOL_REF
2745 || SYMBOL_REF_DECL (XEXP (op0, 0)) != exp)
2749 op0 = copy_rtx (op0);
2751 if (GET_MODE (op0) == BLKmode
2752 /* If op0 is not BLKmode, but BLKmode is, adjust_mode
2753 below would ICE. While it is likely a FE bug,
2754 try to be robust here. See PR43166. */
2756 || (mode == VOIDmode && GET_MODE (op0) != VOIDmode))
2758 gcc_assert (MEM_P (op0));
2759 op0 = adjust_address_nv (op0, mode, 0);
2770 inner_mode = GET_MODE (op0);
2772 if (mode == inner_mode)
2775 if (inner_mode == VOIDmode)
2777 if (TREE_CODE (exp) == SSA_NAME)
2778 inner_mode = TYPE_MODE (TREE_TYPE (exp));
2780 inner_mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
2781 if (mode == inner_mode)
2785 if (FLOAT_MODE_P (mode) && FLOAT_MODE_P (inner_mode))
2787 if (GET_MODE_BITSIZE (mode) == GET_MODE_BITSIZE (inner_mode))
2788 op0 = simplify_gen_subreg (mode, op0, inner_mode, 0);
2789 else if (GET_MODE_BITSIZE (mode) < GET_MODE_BITSIZE (inner_mode))
2790 op0 = simplify_gen_unary (FLOAT_TRUNCATE, mode, op0, inner_mode);
2792 op0 = simplify_gen_unary (FLOAT_EXTEND, mode, op0, inner_mode);
2794 else if (FLOAT_MODE_P (mode))
2796 gcc_assert (TREE_CODE (exp) != SSA_NAME);
2797 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))))
2798 op0 = simplify_gen_unary (UNSIGNED_FLOAT, mode, op0, inner_mode);
2800 op0 = simplify_gen_unary (FLOAT, mode, op0, inner_mode);
2802 else if (FLOAT_MODE_P (inner_mode))
2805 op0 = simplify_gen_unary (UNSIGNED_FIX, mode, op0, inner_mode);
2807 op0 = simplify_gen_unary (FIX, mode, op0, inner_mode);
2809 else if (CONSTANT_P (op0)
2810 || GET_MODE_PRECISION (mode) <= GET_MODE_PRECISION (inner_mode))
2811 op0 = simplify_gen_subreg (mode, op0, inner_mode,
2812 subreg_lowpart_offset (mode,
2814 else if (TREE_CODE_CLASS (TREE_CODE (exp)) == tcc_unary
2815 ? TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)))
2817 op0 = simplify_gen_unary (ZERO_EXTEND, mode, op0, inner_mode);
2819 op0 = simplify_gen_unary (SIGN_EXTEND, mode, op0, inner_mode);
2825 if (!is_gimple_mem_ref_addr (TREE_OPERAND (exp, 0)))
2827 tree newexp = fold_binary (MEM_REF, TREE_TYPE (exp),
2828 TREE_OPERAND (exp, 0),
2829 TREE_OPERAND (exp, 1));
2831 return expand_debug_expr (newexp);
2835 op0 = expand_debug_expr (TREE_OPERAND (exp, 0));
2839 if (TREE_CODE (exp) == MEM_REF)
2841 if (GET_CODE (op0) == DEBUG_IMPLICIT_PTR
2842 || (GET_CODE (op0) == PLUS
2843 && GET_CODE (XEXP (op0, 0)) == DEBUG_IMPLICIT_PTR))
2844 /* (mem (debug_implicit_ptr)) might confuse aliasing.
2845 Instead just use get_inner_reference. */
2848 op1 = expand_debug_expr (TREE_OPERAND (exp, 1));
2849 if (!op1 || !CONST_INT_P (op1))
2852 op0 = plus_constant (op0, INTVAL (op1));
2855 if (POINTER_TYPE_P (TREE_TYPE (exp)))
2856 as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp)));
2858 as = ADDR_SPACE_GENERIC;
2860 op0 = convert_debug_memory_address (targetm.addr_space.address_mode (as),
2862 if (op0 == NULL_RTX)
2865 op0 = gen_rtx_MEM (mode, op0);
2866 set_mem_attributes (op0, exp, 0);
2867 if (TREE_CODE (exp) == MEM_REF
2868 && !is_gimple_mem_ref_addr (TREE_OPERAND (exp, 0)))
2869 set_mem_expr (op0, NULL_TREE);
2870 set_mem_addr_space (op0, as);
2874 case TARGET_MEM_REF:
2875 if (TREE_CODE (TMR_BASE (exp)) == ADDR_EXPR
2876 && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp), 0)))
2879 op0 = expand_debug_expr
2880 (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp)), exp));
2884 if (POINTER_TYPE_P (TREE_TYPE (exp)))
2885 as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp)));
2887 as = ADDR_SPACE_GENERIC;
2889 op0 = convert_debug_memory_address (targetm.addr_space.address_mode (as),
2891 if (op0 == NULL_RTX)
2894 op0 = gen_rtx_MEM (mode, op0);
2896 set_mem_attributes (op0, exp, 0);
2897 set_mem_addr_space (op0, as);
2903 case ARRAY_RANGE_REF:
2908 case VIEW_CONVERT_EXPR:
2910 enum machine_mode mode1;
2911 HOST_WIDE_INT bitsize, bitpos;
2914 tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset,
2915 &mode1, &unsignedp, &volatilep, false);
2921 orig_op0 = op0 = expand_debug_expr (tem);
2928 enum machine_mode addrmode, offmode;
2933 op0 = XEXP (op0, 0);
2934 addrmode = GET_MODE (op0);
2935 if (addrmode == VOIDmode)
2938 op1 = expand_debug_expr (offset);
2942 offmode = GET_MODE (op1);
2943 if (offmode == VOIDmode)
2944 offmode = TYPE_MODE (TREE_TYPE (offset));
2946 if (addrmode != offmode)
2947 op1 = simplify_gen_subreg (addrmode, op1, offmode,
2948 subreg_lowpart_offset (addrmode,
2951 /* Don't use offset_address here, we don't need a
2952 recognizable address, and we don't want to generate
2954 op0 = gen_rtx_MEM (mode, simplify_gen_binary (PLUS, addrmode,
2960 if (mode1 == VOIDmode)
2962 mode1 = smallest_mode_for_size (bitsize, MODE_INT);
2963 if (bitpos >= BITS_PER_UNIT)
2965 op0 = adjust_address_nv (op0, mode1, bitpos / BITS_PER_UNIT);
2966 bitpos %= BITS_PER_UNIT;
2968 else if (bitpos < 0)
2971 = (-bitpos + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
2972 op0 = adjust_address_nv (op0, mode1, units);
2973 bitpos += units * BITS_PER_UNIT;
2975 else if (bitpos == 0 && bitsize == GET_MODE_BITSIZE (mode))
2976 op0 = adjust_address_nv (op0, mode, 0);
2977 else if (GET_MODE (op0) != mode1)
2978 op0 = adjust_address_nv (op0, mode1, 0);
2980 op0 = copy_rtx (op0);
2981 if (op0 == orig_op0)
2982 op0 = shallow_copy_rtx (op0);
2983 set_mem_attributes (op0, exp, 0);
2986 if (bitpos == 0 && mode == GET_MODE (op0))
2992 if (GET_MODE (op0) == BLKmode)
2995 if ((bitpos % BITS_PER_UNIT) == 0
2996 && bitsize == GET_MODE_BITSIZE (mode1))
2998 enum machine_mode opmode = GET_MODE (op0);
3000 if (opmode == VOIDmode)
3001 opmode = TYPE_MODE (TREE_TYPE (tem));
3003 /* This condition may hold if we're expanding the address
3004 right past the end of an array that turned out not to
3005 be addressable (i.e., the address was only computed in
3006 debug stmts). The gen_subreg below would rightfully
3007 crash, and the address doesn't really exist, so just
3009 if (bitpos >= GET_MODE_BITSIZE (opmode))
3012 if ((bitpos % GET_MODE_BITSIZE (mode)) == 0)
3013 return simplify_gen_subreg (mode, op0, opmode,
3014 bitpos / BITS_PER_UNIT);
3017 return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0))
3018 && TYPE_UNSIGNED (TREE_TYPE (exp))
3020 : ZERO_EXTRACT, mode,
3021 GET_MODE (op0) != VOIDmode
3023 : TYPE_MODE (TREE_TYPE (tem)),
3024 op0, GEN_INT (bitsize), GEN_INT (bitpos));
3028 return simplify_gen_unary (ABS, mode, op0, mode);
3031 return simplify_gen_unary (NEG, mode, op0, mode);
3034 return simplify_gen_unary (NOT, mode, op0, mode);
3037 return simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp,
3039 ? UNSIGNED_FLOAT : FLOAT, mode, op0,
3042 case FIX_TRUNC_EXPR:
3043 return simplify_gen_unary (unsignedp ? UNSIGNED_FIX : FIX, mode, op0,
3046 case POINTER_PLUS_EXPR:
3047 /* For the rare target where pointers are not the same size as
3048 size_t, we need to check for mis-matched modes and correct
3051 && GET_MODE (op0) != VOIDmode && GET_MODE (op1) != VOIDmode
3052 && GET_MODE (op0) != GET_MODE (op1))
3054 if (GET_MODE_BITSIZE (GET_MODE (op0)) < GET_MODE_BITSIZE (GET_MODE (op1)))
3055 op1 = simplify_gen_unary (TRUNCATE, GET_MODE (op0), op1,
3058 /* We always sign-extend, regardless of the signedness of
3059 the operand, because the operand is always unsigned
3060 here even if the original C expression is signed. */
3061 op1 = simplify_gen_unary (SIGN_EXTEND, GET_MODE (op0), op1,
3066 return simplify_gen_binary (PLUS, mode, op0, op1);
3069 return simplify_gen_binary (MINUS, mode, op0, op1);
3072 return simplify_gen_binary (MULT, mode, op0, op1);
3075 case TRUNC_DIV_EXPR:
3076 case EXACT_DIV_EXPR:
3078 return simplify_gen_binary (UDIV, mode, op0, op1);
3080 return simplify_gen_binary (DIV, mode, op0, op1);
3082 case TRUNC_MOD_EXPR:
3083 return simplify_gen_binary (unsignedp ? UMOD : MOD, mode, op0, op1);
3085 case FLOOR_DIV_EXPR:
3087 return simplify_gen_binary (UDIV, mode, op0, op1);
3090 rtx div = simplify_gen_binary (DIV, mode, op0, op1);
3091 rtx mod = simplify_gen_binary (MOD, mode, op0, op1);
3092 rtx adj = floor_sdiv_adjust (mode, mod, op1);
3093 return simplify_gen_binary (PLUS, mode, div, adj);
3096 case FLOOR_MOD_EXPR:
3098 return simplify_gen_binary (UMOD, mode, op0, op1);
3101 rtx mod = simplify_gen_binary (MOD, mode, op0, op1);
3102 rtx adj = floor_sdiv_adjust (mode, mod, op1);
3103 adj = simplify_gen_unary (NEG, mode,
3104 simplify_gen_binary (MULT, mode, adj, op1),
3106 return simplify_gen_binary (PLUS, mode, mod, adj);
3112 rtx div = simplify_gen_binary (UDIV, mode, op0, op1);
3113 rtx mod = simplify_gen_binary (UMOD, mode, op0, op1);
3114 rtx adj = ceil_udiv_adjust (mode, mod, op1);
3115 return simplify_gen_binary (PLUS, mode, div, adj);
3119 rtx div = simplify_gen_binary (DIV, mode, op0, op1);
3120 rtx mod = simplify_gen_binary (MOD, mode, op0, op1);
3121 rtx adj = ceil_sdiv_adjust (mode, mod, op1);
3122 return simplify_gen_binary (PLUS, mode, div, adj);
3128 rtx mod = simplify_gen_binary (UMOD, mode, op0, op1);
3129 rtx adj = ceil_udiv_adjust (mode, mod, op1);
3130 adj = simplify_gen_unary (NEG, mode,
3131 simplify_gen_binary (MULT, mode, adj, op1),
3133 return simplify_gen_binary (PLUS, mode, mod, adj);
3137 rtx mod = simplify_gen_binary (MOD, mode, op0, op1);
3138 rtx adj = ceil_sdiv_adjust (mode, mod, op1);
3139 adj = simplify_gen_unary (NEG, mode,
3140 simplify_gen_binary (MULT, mode, adj, op1),
3142 return simplify_gen_binary (PLUS, mode, mod, adj);
3145 case ROUND_DIV_EXPR:
3148 rtx div = simplify_gen_binary (UDIV, mode, op0, op1);
3149 rtx mod = simplify_gen_binary (UMOD, mode, op0, op1);
3150 rtx adj = round_udiv_adjust (mode, mod, op1);
3151 return simplify_gen_binary (PLUS, mode, div, adj);
3155 rtx div = simplify_gen_binary (DIV, mode, op0, op1);
3156 rtx mod = simplify_gen_binary (MOD, mode, op0, op1);
3157 rtx adj = round_sdiv_adjust (mode, mod, op1);
3158 return simplify_gen_binary (PLUS, mode, div, adj);
3161 case ROUND_MOD_EXPR:
3164 rtx mod = simplify_gen_binary (UMOD, mode, op0, op1);
3165 rtx adj = round_udiv_adjust (mode, mod, op1);
3166 adj = simplify_gen_unary (NEG, mode,
3167 simplify_gen_binary (MULT, mode, adj, op1),
3169 return simplify_gen_binary (PLUS, mode, mod, adj);
3173 rtx mod = simplify_gen_binary (MOD, mode, op0, op1);
3174 rtx adj = round_sdiv_adjust (mode, mod, op1);
3175 adj = simplify_gen_unary (NEG, mode,
3176 simplify_gen_binary (MULT, mode, adj, op1),
3178 return simplify_gen_binary (PLUS, mode, mod, adj);
3182 return simplify_gen_binary (ASHIFT, mode, op0, op1);
3186 return simplify_gen_binary (LSHIFTRT, mode, op0, op1);
3188 return simplify_gen_binary (ASHIFTRT, mode, op0, op1);
3191 return simplify_gen_binary (ROTATE, mode, op0, op1);
3194 return simplify_gen_binary (ROTATERT, mode, op0, op1);
3197 return simplify_gen_binary (unsignedp ? UMIN : SMIN, mode, op0, op1);
3200 return simplify_gen_binary (unsignedp ? UMAX : SMAX, mode, op0, op1);
3203 case TRUTH_AND_EXPR:
3204 return simplify_gen_binary (AND, mode, op0, op1);
3208 return simplify_gen_binary (IOR, mode, op0, op1);
3211 case TRUTH_XOR_EXPR:
3212 return simplify_gen_binary (XOR, mode, op0, op1);
3214 case TRUTH_ANDIF_EXPR:
3215 return gen_rtx_IF_THEN_ELSE (mode, op0, op1, const0_rtx);
3217 case TRUTH_ORIF_EXPR:
3218 return gen_rtx_IF_THEN_ELSE (mode, op0, const_true_rtx, op1);
3220 case TRUTH_NOT_EXPR:
3221 return simplify_gen_relational (EQ, mode, inner_mode, op0, const0_rtx);
3224 return simplify_gen_relational (unsignedp ? LTU : LT, mode, inner_mode,
3228 return simplify_gen_relational (unsignedp ? LEU : LE, mode, inner_mode,
3232 return simplify_gen_relational (unsignedp ? GTU : GT, mode, inner_mode,
3236 return simplify_gen_relational (unsignedp ? GEU : GE, mode, inner_mode,
3240 return simplify_gen_relational (EQ, mode, inner_mode, op0, op1);
3243 return simplify_gen_relational (NE, mode, inner_mode, op0, op1);
3245 case UNORDERED_EXPR:
3246 return simplify_gen_relational (UNORDERED, mode, inner_mode, op0, op1);
3249 return simplify_gen_relational (ORDERED, mode, inner_mode, op0, op1);
3252 return simplify_gen_relational (UNLT, mode, inner_mode, op0, op1);
3255 return simplify_gen_relational (UNLE, mode, inner_mode, op0, op1);
3258 return simplify_gen_relational (UNGT, mode, inner_mode, op0, op1);
3261 return simplify_gen_relational (UNGE, mode, inner_mode, op0, op1);
3264 return simplify_gen_relational (UNEQ, mode, inner_mode, op0, op1);
3267 return simplify_gen_relational (LTGT, mode, inner_mode, op0, op1);
3270 return gen_rtx_IF_THEN_ELSE (mode, op0, op1, op2);
3273 gcc_assert (COMPLEX_MODE_P (mode));
3274 if (GET_MODE (op0) == VOIDmode)
3275 op0 = gen_rtx_CONST (GET_MODE_INNER (mode), op0);
3276 if (GET_MODE (op1) == VOIDmode)
3277 op1 = gen_rtx_CONST (GET_MODE_INNER (mode), op1);
3278 return gen_rtx_CONCAT (mode, op0, op1);
3281 if (GET_CODE (op0) == CONCAT)
3282 return gen_rtx_CONCAT (mode, XEXP (op0, 0),
3283 simplify_gen_unary (NEG, GET_MODE_INNER (mode),
3285 GET_MODE_INNER (mode)));
3288 enum machine_mode imode = GET_MODE_INNER (mode);
3293 re = adjust_address_nv (op0, imode, 0);
3294 im = adjust_address_nv (op0, imode, GET_MODE_SIZE (imode));
3298 enum machine_mode ifmode = int_mode_for_mode (mode);
3299 enum machine_mode ihmode = int_mode_for_mode (imode);
3301 if (ifmode == BLKmode || ihmode == BLKmode)
3303 halfsize = GEN_INT (GET_MODE_BITSIZE (ihmode));
3306 re = gen_rtx_SUBREG (ifmode, re, 0);
3307 re = gen_rtx_ZERO_EXTRACT (ihmode, re, halfsize, const0_rtx);
3308 if (imode != ihmode)
3309 re = gen_rtx_SUBREG (imode, re, 0);
3310 im = copy_rtx (op0);
3312 im = gen_rtx_SUBREG (ifmode, im, 0);
3313 im = gen_rtx_ZERO_EXTRACT (ihmode, im, halfsize, halfsize);
3314 if (imode != ihmode)
3315 im = gen_rtx_SUBREG (imode, im, 0);
3317 im = gen_rtx_NEG (imode, im);
3318 return gen_rtx_CONCAT (mode, re, im);
3322 op0 = expand_debug_expr (TREE_OPERAND (exp, 0));
3323 if (!op0 || !MEM_P (op0))
3325 if ((TREE_CODE (TREE_OPERAND (exp, 0)) == VAR_DECL
3326 || TREE_CODE (TREE_OPERAND (exp, 0)) == PARM_DECL
3327 || TREE_CODE (TREE_OPERAND (exp, 0)) == RESULT_DECL)
3328 && (!TREE_ADDRESSABLE (TREE_OPERAND (exp, 0))
3329 || target_for_debug_bind (TREE_OPERAND (exp, 0))))
3330 return gen_rtx_DEBUG_IMPLICIT_PTR (mode, TREE_OPERAND (exp, 0));
3332 if (handled_component_p (TREE_OPERAND (exp, 0)))
3334 HOST_WIDE_INT bitoffset, bitsize, maxsize;
3336 = get_ref_base_and_extent (TREE_OPERAND (exp, 0),
3337 &bitoffset, &bitsize, &maxsize);
3338 if ((TREE_CODE (decl) == VAR_DECL
3339 || TREE_CODE (decl) == PARM_DECL
3340 || TREE_CODE (decl) == RESULT_DECL)
3341 && (!TREE_ADDRESSABLE (decl)
3342 || target_for_debug_bind (decl))
3343 && (bitoffset % BITS_PER_UNIT) == 0
3345 && bitsize == maxsize)
3346 return plus_constant (gen_rtx_DEBUG_IMPLICIT_PTR (mode, decl),
3347 bitoffset / BITS_PER_UNIT);
3353 as = TYPE_ADDR_SPACE (TREE_TYPE (exp));
3354 op0 = convert_debug_memory_address (mode, XEXP (op0, 0), as);
3359 exp = build_constructor_from_list (TREE_TYPE (exp),
3360 TREE_VECTOR_CST_ELTS (exp));
3364 if (TREE_CLOBBER_P (exp))
3366 else if (TREE_CODE (TREE_TYPE (exp)) == VECTOR_TYPE)
3371 op0 = gen_rtx_CONCATN
3372 (mode, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp))));
3374 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), i, val)
3376 op1 = expand_debug_expr (val);
3379 XVECEXP (op0, 0, i) = op1;
3382 if (i < TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp)))
3384 op1 = expand_debug_expr
3385 (build_zero_cst (TREE_TYPE (TREE_TYPE (exp))));
3390 for (; i < TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp)); i++)
3391 XVECEXP (op0, 0, i) = op1;
3397 goto flag_unsupported;
3400 /* ??? Maybe handle some builtins? */
3405 gimple g = get_gimple_for_ssa_name (exp);
3408 op0 = expand_debug_expr (gimple_assign_rhs_to_tree (g));
3414 int part = var_to_partition (SA.map, exp);
3416 if (part == NO_PARTITION)
3418 /* If this is a reference to an incoming value of parameter
3419 that is never used in the code or where the incoming
3420 value is never used in the code, use PARM_DECL's
3422 if (SSA_NAME_IS_DEFAULT_DEF (exp)
3423 && TREE_CODE (SSA_NAME_VAR (exp)) == PARM_DECL)
3425 op0 = expand_debug_parm_decl (SSA_NAME_VAR (exp));
3428 op0 = expand_debug_expr (SSA_NAME_VAR (exp));
3435 gcc_assert (part >= 0 && (unsigned)part < SA.map->num_partitions);
3437 op0 = copy_rtx (SA.partition_to_pseudo[part]);
3445 /* Vector stuff. For most of the codes we don't have rtl codes. */
3446 case REALIGN_LOAD_EXPR:
3447 case REDUC_MAX_EXPR:
3448 case REDUC_MIN_EXPR:
3449 case REDUC_PLUS_EXPR:
3451 case VEC_LSHIFT_EXPR:
3452 case VEC_PACK_FIX_TRUNC_EXPR:
3453 case VEC_PACK_SAT_EXPR:
3454 case VEC_PACK_TRUNC_EXPR:
3455 case VEC_RSHIFT_EXPR:
3456 case VEC_UNPACK_FLOAT_HI_EXPR:
3457 case VEC_UNPACK_FLOAT_LO_EXPR:
3458 case VEC_UNPACK_HI_EXPR:
3459 case VEC_UNPACK_LO_EXPR:
3460 case VEC_WIDEN_MULT_HI_EXPR:
3461 case VEC_WIDEN_MULT_LO_EXPR:
3462 case VEC_WIDEN_LSHIFT_HI_EXPR:
3463 case VEC_WIDEN_LSHIFT_LO_EXPR:
3468 case ADDR_SPACE_CONVERT_EXPR:
3469 case FIXED_CONVERT_EXPR:
3471 case WITH_SIZE_EXPR:
3475 if (SCALAR_INT_MODE_P (GET_MODE (op0))
3476 && SCALAR_INT_MODE_P (mode))
3479 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp,
3481 ? ZERO_EXTEND : SIGN_EXTEND, mode, op0,
3484 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp,
3486 ? ZERO_EXTEND : SIGN_EXTEND, mode, op1,
3488 op0 = simplify_gen_binary (MULT, mode, op0, op1);
3489 return simplify_gen_binary (PLUS, mode, op0, op2);
3493 case WIDEN_MULT_EXPR:
3494 case WIDEN_MULT_PLUS_EXPR:
3495 case WIDEN_MULT_MINUS_EXPR:
3496 if (SCALAR_INT_MODE_P (GET_MODE (op0))
3497 && SCALAR_INT_MODE_P (mode))
3499 inner_mode = GET_MODE (op0);
3500 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))))
3501 op0 = simplify_gen_unary (ZERO_EXTEND, mode, op0, inner_mode);
3503 op0 = simplify_gen_unary (SIGN_EXTEND, mode, op0, inner_mode);
3504 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 1))))
3505 op1 = simplify_gen_unary (ZERO_EXTEND, mode, op1, inner_mode);
3507 op1 = simplify_gen_unary (SIGN_EXTEND, mode, op1, inner_mode);
3508 op0 = simplify_gen_binary (MULT, mode, op0, op1);
3509 if (TREE_CODE (exp) == WIDEN_MULT_EXPR)
3511 else if (TREE_CODE (exp) == WIDEN_MULT_PLUS_EXPR)
3512 return simplify_gen_binary (PLUS, mode, op0, op2);
3514 return simplify_gen_binary (MINUS, mode, op2, op0);
3518 case WIDEN_SUM_EXPR:
3519 case WIDEN_LSHIFT_EXPR:
3520 if (SCALAR_INT_MODE_P (GET_MODE (op0))
3521 && SCALAR_INT_MODE_P (mode))
3524 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp,
3526 ? ZERO_EXTEND : SIGN_EXTEND, mode, op0,
3528 return simplify_gen_binary (TREE_CODE (exp) == WIDEN_LSHIFT_EXPR
3529 ? ASHIFT : PLUS, mode, op0, op1);
3534 return simplify_gen_ternary (FMA, mode, inner_mode, op0, op1, op2);
3538 #ifdef ENABLE_CHECKING
3547 /* Return an RTX equivalent to the source bind value of the tree expression
3551 expand_debug_source_expr (tree exp)
3554 enum machine_mode mode = VOIDmode, inner_mode;
3556 switch (TREE_CODE (exp))
3560 mode = DECL_MODE (exp);
3561 op0 = expand_debug_parm_decl (exp);
3564 /* See if this isn't an argument that has been completely
3566 if (!DECL_RTL_SET_P (exp)
3567 && !DECL_INCOMING_RTL (exp)
3568 && DECL_ABSTRACT_ORIGIN (current_function_decl))
3571 if (DECL_ABSTRACT_ORIGIN (exp))
3572 aexp = DECL_ABSTRACT_ORIGIN (exp);
3573 if (DECL_CONTEXT (aexp)
3574 == DECL_ABSTRACT_ORIGIN (current_function_decl))
3576 VEC(tree, gc) **debug_args;
3579 #ifdef ENABLE_CHECKING
3581 for (parm = DECL_ARGUMENTS (current_function_decl);
3582 parm; parm = DECL_CHAIN (parm))
3583 gcc_assert (parm != exp
3584 && DECL_ABSTRACT_ORIGIN (parm) != aexp);
3586 debug_args = decl_debug_args_lookup (current_function_decl);
3587 if (debug_args != NULL)
3589 for (ix = 0; VEC_iterate (tree, *debug_args, ix, ddecl);
3592 return gen_rtx_DEBUG_PARAMETER_REF (mode, aexp);
3602 if (op0 == NULL_RTX)
3605 inner_mode = GET_MODE (op0);
3606 if (mode == inner_mode)
3609 if (FLOAT_MODE_P (mode) && FLOAT_MODE_P (inner_mode))
3611 if (GET_MODE_BITSIZE (mode) == GET_MODE_BITSIZE (inner_mode))
3612 op0 = simplify_gen_subreg (mode, op0, inner_mode, 0);
3613 else if (GET_MODE_BITSIZE (mode) < GET_MODE_BITSIZE (inner_mode))
3614 op0 = simplify_gen_unary (FLOAT_TRUNCATE, mode, op0, inner_mode);
3616 op0 = simplify_gen_unary (FLOAT_EXTEND, mode, op0, inner_mode);
3618 else if (FLOAT_MODE_P (mode))
3620 else if (FLOAT_MODE_P (inner_mode))
3622 if (TYPE_UNSIGNED (TREE_TYPE (exp)))
3623 op0 = simplify_gen_unary (UNSIGNED_FIX, mode, op0, inner_mode);
3625 op0 = simplify_gen_unary (FIX, mode, op0, inner_mode);
3627 else if (CONSTANT_P (op0)
3628 || GET_MODE_BITSIZE (mode) <= GET_MODE_BITSIZE (inner_mode))
3629 op0 = simplify_gen_subreg (mode, op0, inner_mode,
3630 subreg_lowpart_offset (mode, inner_mode));
3631 else if (TYPE_UNSIGNED (TREE_TYPE (exp)))
3632 op0 = simplify_gen_unary (ZERO_EXTEND, mode, op0, inner_mode);
3634 op0 = simplify_gen_unary (SIGN_EXTEND, mode, op0, inner_mode);
3639 /* Expand the _LOCs in debug insns. We run this after expanding all
3640 regular insns, so that any variables referenced in the function
3641 will have their DECL_RTLs set. */
3644 expand_debug_locations (void)
3647 rtx last = get_last_insn ();
3648 int save_strict_alias = flag_strict_aliasing;
3650 /* New alias sets while setting up memory attributes cause
3651 -fcompare-debug failures, even though it doesn't bring about any
3653 flag_strict_aliasing = 0;
3655 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3656 if (DEBUG_INSN_P (insn))
3658 tree value = (tree)INSN_VAR_LOCATION_LOC (insn);
3660 enum machine_mode mode;
3662 if (value == NULL_TREE)
3666 if (INSN_VAR_LOCATION_STATUS (insn)
3667 == VAR_INIT_STATUS_UNINITIALIZED)
3668 val = expand_debug_source_expr (value);
3670 val = expand_debug_expr (value);
3671 gcc_assert (last == get_last_insn ());
3675 val = gen_rtx_UNKNOWN_VAR_LOC ();
3678 mode = GET_MODE (INSN_VAR_LOCATION (insn));
3680 gcc_assert (mode == GET_MODE (val)
3681 || (GET_MODE (val) == VOIDmode
3682 && (CONST_INT_P (val)
3683 || GET_CODE (val) == CONST_FIXED
3684 || GET_CODE (val) == CONST_DOUBLE
3685 || GET_CODE (val) == LABEL_REF)));
3688 INSN_VAR_LOCATION_LOC (insn) = val;
3691 flag_strict_aliasing = save_strict_alias;
3694 /* Expand basic block BB from GIMPLE trees to RTL. */
3697 expand_gimple_basic_block (basic_block bb)
3699 gimple_stmt_iterator gsi;
3708 fprintf (dump_file, "\n;; Generating RTL for gimple basic block %d\n",
3711 /* Note that since we are now transitioning from GIMPLE to RTL, we
3712 cannot use the gsi_*_bb() routines because they expect the basic
3713 block to be in GIMPLE, instead of RTL. Therefore, we need to
3714 access the BB sequence directly. */
3715 stmts = bb_seq (bb);
3716 bb->il.gimple = NULL;
3717 rtl_profile_for_bb (bb);
3718 init_rtl_bb_info (bb);
3719 bb->flags |= BB_RTL;
3721 /* Remove the RETURN_EXPR if we may fall though to the exit
3723 gsi = gsi_last (stmts);
3724 if (!gsi_end_p (gsi)
3725 && gimple_code (gsi_stmt (gsi)) == GIMPLE_RETURN)
3727 gimple ret_stmt = gsi_stmt (gsi);
3729 gcc_assert (single_succ_p (bb));
3730 gcc_assert (single_succ (bb) == EXIT_BLOCK_PTR);
3732 if (bb->next_bb == EXIT_BLOCK_PTR
3733 && !gimple_return_retval (ret_stmt))
3735 gsi_remove (&gsi, false);
3736 single_succ_edge (bb)->flags |= EDGE_FALLTHRU;
3740 gsi = gsi_start (stmts);
3741 if (!gsi_end_p (gsi))
3743 stmt = gsi_stmt (gsi);
3744 if (gimple_code (stmt) != GIMPLE_LABEL)
3748 elt = pointer_map_contains (lab_rtx_for_bb, bb);
3752 last = get_last_insn ();
3756 expand_gimple_stmt (stmt);
3761 emit_label ((rtx) *elt);
3763 /* Java emits line number notes in the top of labels.
3764 ??? Make this go away once line number notes are obsoleted. */
3765 BB_HEAD (bb) = NEXT_INSN (last);
3766 if (NOTE_P (BB_HEAD (bb)))
3767 BB_HEAD (bb) = NEXT_INSN (BB_HEAD (bb));
3768 note = emit_note_after (NOTE_INSN_BASIC_BLOCK, BB_HEAD (bb));
3770 maybe_dump_rtl_for_gimple_stmt (stmt, last);
3773 note = BB_HEAD (bb) = emit_note (NOTE_INSN_BASIC_BLOCK);
3775 NOTE_BASIC_BLOCK (note) = bb;
3777 for (; !gsi_end_p (gsi); gsi_next (&gsi))
3781 stmt = gsi_stmt (gsi);
3783 /* If this statement is a non-debug one, and we generate debug
3784 insns, then this one might be the last real use of a TERed
3785 SSA_NAME, but where there are still some debug uses further
3786 down. Expanding the current SSA name in such further debug
3787 uses by their RHS might lead to wrong debug info, as coalescing
3788 might make the operands of such RHS be placed into the same
3789 pseudo as something else. Like so:
3790 a_1 = a_0 + 1; // Assume a_1 is TERed and a_0 is dead
3794 As a_0 and a_2 don't overlap in lifetime, assume they are coalesced.
3795 If we now would expand a_1 by it's RHS (a_0 + 1) in the debug use,
3796 the write to a_2 would actually have clobbered the place which
3799 So, instead of that, we recognize the situation, and generate
3800 debug temporaries at the last real use of TERed SSA names:
3807 if (MAY_HAVE_DEBUG_INSNS
3809 && !is_gimple_debug (stmt))
3815 location_t sloc = get_curr_insn_source_location ();
3816 tree sblock = get_curr_insn_block ();
3818 /* Look for SSA names that have their last use here (TERed
3819 names always have only one real use). */
3820 FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
3821 if ((def = get_gimple_for_ssa_name (op)))
3823 imm_use_iterator imm_iter;
3824 use_operand_p use_p;
3825 bool have_debug_uses = false;
3827 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, op)
3829 if (gimple_debug_bind_p (USE_STMT (use_p)))
3831 have_debug_uses = true;
3836 if (have_debug_uses)
3838 /* OP is a TERed SSA name, with DEF it's defining
3839 statement, and where OP is used in further debug
3840 instructions. Generate a debug temporary, and
3841 replace all uses of OP in debug insns with that
3844 tree value = gimple_assign_rhs_to_tree (def);
3845 tree vexpr = make_node (DEBUG_EXPR_DECL);
3847 enum machine_mode mode;
3849 set_curr_insn_source_location (gimple_location (def));
3850 set_curr_insn_block (gimple_block (def));
3852 DECL_ARTIFICIAL (vexpr) = 1;
3853 TREE_TYPE (vexpr) = TREE_TYPE (value);
3855 mode = DECL_MODE (value);
3857 mode = TYPE_MODE (TREE_TYPE (value));
3858 DECL_MODE (vexpr) = mode;
3860 val = gen_rtx_VAR_LOCATION
3861 (mode, vexpr, (rtx)value, VAR_INIT_STATUS_INITIALIZED);
3863 emit_debug_insn (val);
3865 FOR_EACH_IMM_USE_STMT (debugstmt, imm_iter, op)
3867 if (!gimple_debug_bind_p (debugstmt))
3870 FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter)
3871 SET_USE (use_p, vexpr);
3873 update_stmt (debugstmt);
3877 set_curr_insn_source_location (sloc);
3878 set_curr_insn_block (sblock);
3881 currently_expanding_gimple_stmt = stmt;
3883 /* Expand this statement, then evaluate the resulting RTL and
3884 fixup the CFG accordingly. */
3885 if (gimple_code (stmt) == GIMPLE_COND)
3887 new_bb = expand_gimple_cond (bb, stmt);
3891 else if (gimple_debug_bind_p (stmt))
3893 location_t sloc = get_curr_insn_source_location ();
3894 tree sblock = get_curr_insn_block ();
3895 gimple_stmt_iterator nsi = gsi;
3899 tree var = gimple_debug_bind_get_var (stmt);
3902 enum machine_mode mode;
3904 if (TREE_CODE (var) != DEBUG_EXPR_DECL
3905 && TREE_CODE (var) != LABEL_DECL
3906 && !target_for_debug_bind (var))
3907 goto delink_debug_stmt;
3909 if (gimple_debug_bind_has_value_p (stmt))
3910 value = gimple_debug_bind_get_value (stmt);
3914 last = get_last_insn ();
3916 set_curr_insn_source_location (gimple_location (stmt));
3917 set_curr_insn_block (gimple_block (stmt));
3920 mode = DECL_MODE (var);
3922 mode = TYPE_MODE (TREE_TYPE (var));
3924 val = gen_rtx_VAR_LOCATION
3925 (mode, var, (rtx)value, VAR_INIT_STATUS_INITIALIZED);
3927 emit_debug_insn (val);
3929 if (dump_file && (dump_flags & TDF_DETAILS))
3931 /* We can't dump the insn with a TREE where an RTX
3933 PAT_VAR_LOCATION_LOC (val) = const0_rtx;
3934 maybe_dump_rtl_for_gimple_stmt (stmt, last);
3935 PAT_VAR_LOCATION_LOC (val) = (rtx)value;
3939 /* In order not to generate too many debug temporaries,
3940 we delink all uses of debug statements we already expanded.
3941 Therefore debug statements between definition and real
3942 use of TERed SSA names will continue to use the SSA name,
3943 and not be replaced with debug temps. */
3944 delink_stmt_imm_use (stmt);
3948 if (gsi_end_p (nsi))
3950 stmt = gsi_stmt (nsi);
3951 if (!gimple_debug_bind_p (stmt))
3955 set_curr_insn_source_location (sloc);
3956 set_curr_insn_block (sblock);
3958 else if (gimple_debug_source_bind_p (stmt))
3960 location_t sloc = get_curr_insn_source_location ();
3961 tree sblock = get_curr_insn_block ();
3962 tree var = gimple_debug_source_bind_get_var (stmt);
3963 tree value = gimple_debug_source_bind_get_value (stmt);
3965 enum machine_mode mode;
3967 last = get_last_insn ();
3969 set_curr_insn_source_location (gimple_location (stmt));
3970 set_curr_insn_block (gimple_block (stmt));
3972 mode = DECL_MODE (var);
3974 val = gen_rtx_VAR_LOCATION (mode, var, (rtx)value,
3975 VAR_INIT_STATUS_UNINITIALIZED);
3977 emit_debug_insn (val);
3979 if (dump_file && (dump_flags & TDF_DETAILS))
3981 /* We can't dump the insn with a TREE where an RTX
3983 PAT_VAR_LOCATION_LOC (val) = const0_rtx;
3984 maybe_dump_rtl_for_gimple_stmt (stmt, last);
3985 PAT_VAR_LOCATION_LOC (val) = (rtx)value;
3988 set_curr_insn_source_location (sloc);
3989 set_curr_insn_block (sblock);
3993 if (is_gimple_call (stmt) && gimple_call_tail_p (stmt))
3996 new_bb = expand_gimple_tailcall (bb, stmt, &can_fallthru);
4007 def_operand_p def_p;
4008 def_p = SINGLE_SSA_DEF_OPERAND (stmt, SSA_OP_DEF);
4012 /* Ignore this stmt if it is in the list of
4013 replaceable expressions. */
4015 && bitmap_bit_p (SA.values,
4016 SSA_NAME_VERSION (DEF_FROM_PTR (def_p))))
4019 last = expand_gimple_stmt (stmt);
4020 maybe_dump_rtl_for_gimple_stmt (stmt, last);
4025 currently_expanding_gimple_stmt = NULL;
4027 /* Expand implicit goto and convert goto_locus. */
4028 FOR_EACH_EDGE (e, ei, bb->succs)
4030 if (e->goto_locus && e->goto_block)
4032 set_curr_insn_source_location (e->goto_locus);
4033 set_curr_insn_block (e->goto_block);
4034 e->goto_locus = curr_insn_locator ();
4036 e->goto_block = NULL;
4037 if ((e->flags & EDGE_FALLTHRU) && e->dest != bb->next_bb)
4039 emit_jump (label_rtx_for_bb (e->dest));
4040 e->flags &= ~EDGE_FALLTHRU;
4044 /* Expanded RTL can create a jump in the last instruction of block.
4045 This later might be assumed to be a jump to successor and break edge insertion.
4046 We need to insert dummy move to prevent this. PR41440. */
4047 if (single_succ_p (bb)
4048 && (single_succ_edge (bb)->flags & EDGE_FALLTHRU)
4049 && (last = get_last_insn ())
4052 rtx dummy = gen_reg_rtx (SImode);
4053 emit_insn_after_noloc (gen_move_insn (dummy, dummy), last, NULL);
4056 do_pending_stack_adjust ();
4058 /* Find the block tail. The last insn in the block is the insn
4059 before a barrier and/or table jump insn. */
4060 last = get_last_insn ();
4061 if (BARRIER_P (last))
4062 last = PREV_INSN (last);
4063 if (JUMP_TABLE_DATA_P (last))
4064 last = PREV_INSN (PREV_INSN (last));
4067 update_bb_for_insn (bb);
4073 /* Create a basic block for initialization code. */
4076 construct_init_block (void)
4078 basic_block init_block, first_block;
4082 /* Multiple entry points not supported yet. */
4083 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR->succs) == 1);
4084 init_rtl_bb_info (ENTRY_BLOCK_PTR);
4085 init_rtl_bb_info (EXIT_BLOCK_PTR);
4086 ENTRY_BLOCK_PTR->flags |= BB_RTL;
4087 EXIT_BLOCK_PTR->flags |= BB_RTL;
4089 e = EDGE_SUCC (ENTRY_BLOCK_PTR, 0);
4091 /* When entry edge points to first basic block, we don't need jump,
4092 otherwise we have to jump into proper target. */
4093 if (e && e->dest != ENTRY_BLOCK_PTR->next_bb)
4095 tree label = gimple_block_label (e->dest);
4097 emit_jump (label_rtx (label));
4101 flags = EDGE_FALLTHRU;
4103 init_block = create_basic_block (NEXT_INSN (get_insns ()),
4106 init_block->frequency = ENTRY_BLOCK_PTR->frequency;
4107 init_block->count = ENTRY_BLOCK_PTR->count;
4110 first_block = e->dest;
4111 redirect_edge_succ (e, init_block);
4112 e = make_edge (init_block, first_block, flags);
4115 e = make_edge (init_block, EXIT_BLOCK_PTR, EDGE_FALLTHRU);
4116 e->probability = REG_BR_PROB_BASE;
4117 e->count = ENTRY_BLOCK_PTR->count;
4119 update_bb_for_insn (init_block);
4123 /* For each lexical block, set BLOCK_NUMBER to the depth at which it is
4124 found in the block tree. */
4127 set_block_levels (tree block, int level)
4131 BLOCK_NUMBER (block) = level;
4132 set_block_levels (BLOCK_SUBBLOCKS (block), level + 1);
4133 block = BLOCK_CHAIN (block);
4137 /* Create a block containing landing pads and similar stuff. */
4140 construct_exit_block (void)
4142 rtx head = get_last_insn ();
4144 basic_block exit_block;
4148 rtx orig_end = BB_END (EXIT_BLOCK_PTR->prev_bb);
4150 rtl_profile_for_bb (EXIT_BLOCK_PTR);
4152 /* Make sure the locus is set to the end of the function, so that
4153 epilogue line numbers and warnings are set properly. */
4154 if (cfun->function_end_locus != UNKNOWN_LOCATION)
4155 input_location = cfun->function_end_locus;
4157 /* The following insns belong to the top scope. */
4158 set_curr_insn_block (DECL_INITIAL (current_function_decl));
4160 /* Generate rtl for function exit. */
4161 expand_function_end ();
4163 end = get_last_insn ();
4166 /* While emitting the function end we could move end of the last basic block.
4168 BB_END (EXIT_BLOCK_PTR->prev_bb) = orig_end;
4169 while (NEXT_INSN (head) && NOTE_P (NEXT_INSN (head)))
4170 head = NEXT_INSN (head);
4171 exit_block = create_basic_block (NEXT_INSN (head), end,
4172 EXIT_BLOCK_PTR->prev_bb);
4173 exit_block->frequency = EXIT_BLOCK_PTR->frequency;
4174 exit_block->count = EXIT_BLOCK_PTR->count;
4177 while (ix < EDGE_COUNT (EXIT_BLOCK_PTR->preds))
4179 e = EDGE_PRED (EXIT_BLOCK_PTR, ix);
4180 if (!(e->flags & EDGE_ABNORMAL))
4181 redirect_edge_succ (e, exit_block);
4186 e = make_edge (exit_block, EXIT_BLOCK_PTR, EDGE_FALLTHRU);
4187 e->probability = REG_BR_PROB_BASE;
4188 e->count = EXIT_BLOCK_PTR->count;
4189 FOR_EACH_EDGE (e2, ei, EXIT_BLOCK_PTR->preds)
4192 e->count -= e2->count;
4193 exit_block->count -= e2->count;
4194 exit_block->frequency -= EDGE_FREQUENCY (e2);
4198 if (exit_block->count < 0)
4199 exit_block->count = 0;
4200 if (exit_block->frequency < 0)
4201 exit_block->frequency = 0;
4202 update_bb_for_insn (exit_block);
4205 /* Helper function for discover_nonconstant_array_refs.
4206 Look for ARRAY_REF nodes with non-constant indexes and mark them
4210 discover_nonconstant_array_refs_r (tree * tp, int *walk_subtrees,
4211 void *data ATTRIBUTE_UNUSED)
4215 if (IS_TYPE_OR_DECL_P (t))
4217 else if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
4219 while (((TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
4220 && is_gimple_min_invariant (TREE_OPERAND (t, 1))
4221 && (!TREE_OPERAND (t, 2)
4222 || is_gimple_min_invariant (TREE_OPERAND (t, 2))))
4223 || (TREE_CODE (t) == COMPONENT_REF
4224 && (!TREE_OPERAND (t,2)
4225 || is_gimple_min_invariant (TREE_OPERAND (t, 2))))
4226 || TREE_CODE (t) == BIT_FIELD_REF
4227 || TREE_CODE (t) == REALPART_EXPR
4228 || TREE_CODE (t) == IMAGPART_EXPR
4229 || TREE_CODE (t) == VIEW_CONVERT_EXPR
4230 || CONVERT_EXPR_P (t))
4231 t = TREE_OPERAND (t, 0);
4233 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
4235 t = get_base_address (t);
4237 && DECL_MODE (t) != BLKmode)
4238 TREE_ADDRESSABLE (t) = 1;
4247 /* RTL expansion is not able to compile array references with variable
4248 offsets for arrays stored in single register. Discover such
4249 expressions and mark variables as addressable to avoid this
4253 discover_nonconstant_array_refs (void)
4256 gimple_stmt_iterator gsi;
4259 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
4261 gimple stmt = gsi_stmt (gsi);
4262 if (!is_gimple_debug (stmt))
4263 walk_gimple_op (stmt, discover_nonconstant_array_refs_r, NULL);
4267 /* This function sets crtl->args.internal_arg_pointer to a virtual
4268 register if DRAP is needed. Local register allocator will replace
4269 virtual_incoming_args_rtx with the virtual register. */
4272 expand_stack_alignment (void)
4275 unsigned int preferred_stack_boundary;
4277 if (! SUPPORTS_STACK_ALIGNMENT)
4280 if (cfun->calls_alloca
4281 || cfun->has_nonlocal_label
4282 || crtl->has_nonlocal_goto)
4283 crtl->need_drap = true;
4285 /* Call update_stack_boundary here again to update incoming stack
4286 boundary. It may set incoming stack alignment to a different
4287 value after RTL expansion. TARGET_FUNCTION_OK_FOR_SIBCALL may
4288 use the minimum incoming stack alignment to check if it is OK
4289 to perform sibcall optimization since sibcall optimization will
4290 only align the outgoing stack to incoming stack boundary. */
4291 if (targetm.calls.update_stack_boundary)
4292 targetm.calls.update_stack_boundary ();
4294 /* The incoming stack frame has to be aligned at least at
4295 parm_stack_boundary. */
4296 gcc_assert (crtl->parm_stack_boundary <= INCOMING_STACK_BOUNDARY);
4298 /* Update crtl->stack_alignment_estimated and use it later to align
4299 stack. We check PREFERRED_STACK_BOUNDARY if there may be non-call
4300 exceptions since callgraph doesn't collect incoming stack alignment
4302 if (cfun->can_throw_non_call_exceptions
4303 && PREFERRED_STACK_BOUNDARY > crtl->preferred_stack_boundary)
4304 preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
4306 preferred_stack_boundary = crtl->preferred_stack_boundary;
4307 if (preferred_stack_boundary > crtl->stack_alignment_estimated)
4308 crtl->stack_alignment_estimated = preferred_stack_boundary;
4309 if (preferred_stack_boundary > crtl->stack_alignment_needed)
4310 crtl->stack_alignment_needed = preferred_stack_boundary;
4312 gcc_assert (crtl->stack_alignment_needed
4313 <= crtl->stack_alignment_estimated);
4315 crtl->stack_realign_needed
4316 = INCOMING_STACK_BOUNDARY < crtl->stack_alignment_estimated;
4317 crtl->stack_realign_tried = crtl->stack_realign_needed;
4319 crtl->stack_realign_processed = true;
4321 /* Target has to redefine TARGET_GET_DRAP_RTX to support stack
4323 gcc_assert (targetm.calls.get_drap_rtx != NULL);
4324 drap_rtx = targetm.calls.get_drap_rtx ();
4326 /* stack_realign_drap and drap_rtx must match. */
4327 gcc_assert ((stack_realign_drap != 0) == (drap_rtx != NULL));
4329 /* Do nothing if NULL is returned, which means DRAP is not needed. */
4330 if (NULL != drap_rtx)
4332 crtl->args.internal_arg_pointer = drap_rtx;
4334 /* Call fixup_tail_calls to clean up REG_EQUIV note if DRAP is
4336 fixup_tail_calls ();
4340 /* Translate the intermediate representation contained in the CFG
4341 from GIMPLE trees to RTL.
4343 We do conversion per basic block and preserve/update the tree CFG.
4344 This implies we have to do some magic as the CFG can simultaneously
4345 consist of basic blocks containing RTL and GIMPLE trees. This can
4346 confuse the CFG hooks, so be careful to not manipulate CFG during
4350 gimple_expand_cfg (void)
4352 basic_block bb, init_block;
4359 timevar_push (TV_OUT_OF_SSA);
4360 rewrite_out_of_ssa (&SA);
4361 timevar_pop (TV_OUT_OF_SSA);
4362 SA.partition_to_pseudo = (rtx *)xcalloc (SA.map->num_partitions,
4365 /* Some backends want to know that we are expanding to RTL. */
4366 currently_expanding_to_rtl = 1;
4368 rtl_profile_for_bb (ENTRY_BLOCK_PTR);
4370 insn_locators_alloc ();
4371 if (!DECL_IS_BUILTIN (current_function_decl))
4373 /* Eventually, all FEs should explicitly set function_start_locus. */
4374 if (cfun->function_start_locus == UNKNOWN_LOCATION)
4375 set_curr_insn_source_location
4376 (DECL_SOURCE_LOCATION (current_function_decl));
4378 set_curr_insn_source_location (cfun->function_start_locus);
4381 set_curr_insn_source_location (UNKNOWN_LOCATION);
4382 set_curr_insn_block (DECL_INITIAL (current_function_decl));
4383 prologue_locator = curr_insn_locator ();
4385 #ifdef INSN_SCHEDULING
4386 init_sched_attrs ();
4389 /* Make sure first insn is a note even if we don't want linenums.
4390 This makes sure the first insn will never be deleted.
4391 Also, final expects a note to appear there. */
4392 emit_note (NOTE_INSN_DELETED);
4394 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
4395 discover_nonconstant_array_refs ();
4397 targetm.expand_to_rtl_hook ();
4398 crtl->stack_alignment_needed = STACK_BOUNDARY;
4399 crtl->max_used_stack_slot_alignment = STACK_BOUNDARY;
4400 crtl->stack_alignment_estimated = 0;
4401 crtl->preferred_stack_boundary = STACK_BOUNDARY;
4402 cfun->cfg->max_jumptable_ents = 0;
4404 /* Resovle the function section. Some targets, like ARM EABI rely on knowledge
4405 of the function section at exapnsion time to predict distance of calls. */
4406 resolve_unique_section (current_function_decl, 0, flag_function_sections);
4408 /* Expand the variables recorded during gimple lowering. */
4409 timevar_push (TV_VAR_EXPAND);
4412 expand_used_vars ();
4414 var_seq = get_insns ();
4416 timevar_pop (TV_VAR_EXPAND);
4418 /* Honor stack protection warnings. */
4419 if (warn_stack_protect)
4421 if (cfun->calls_alloca)
4422 warning (OPT_Wstack_protector,
4423 "stack protector not protecting local variables: "
4424 "variable length buffer");
4425 if (has_short_buffer && !crtl->stack_protect_guard)
4426 warning (OPT_Wstack_protector,
4427 "stack protector not protecting function: "
4428 "all local arrays are less than %d bytes long",
4429 (int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE));
4432 /* Set up parameters and prepare for return, for the function. */
4433 expand_function_start (current_function_decl);
4435 /* If we emitted any instructions for setting up the variables,
4436 emit them before the FUNCTION_START note. */
4439 emit_insn_before (var_seq, parm_birth_insn);
4441 /* In expand_function_end we'll insert the alloca save/restore
4442 before parm_birth_insn. We've just insertted an alloca call.
4443 Adjust the pointer to match. */
4444 parm_birth_insn = var_seq;
4447 /* Now that we also have the parameter RTXs, copy them over to our
4449 for (i = 0; i < SA.map->num_partitions; i++)
4451 tree var = SSA_NAME_VAR (partition_to_var (SA.map, i));
4453 if (TREE_CODE (var) != VAR_DECL
4454 && !SA.partition_to_pseudo[i])
4455 SA.partition_to_pseudo[i] = DECL_RTL_IF_SET (var);
4456 gcc_assert (SA.partition_to_pseudo[i]);
4458 /* If this decl was marked as living in multiple places, reset
4459 this now to NULL. */
4460 if (DECL_RTL_IF_SET (var) == pc_rtx)
4461 SET_DECL_RTL (var, NULL);
4463 /* Some RTL parts really want to look at DECL_RTL(x) when x
4464 was a decl marked in REG_ATTR or MEM_ATTR. We could use
4465 SET_DECL_RTL here making this available, but that would mean
4466 to select one of the potentially many RTLs for one DECL. Instead
4467 of doing that we simply reset the MEM_EXPR of the RTL in question,
4468 then nobody can get at it and hence nobody can call DECL_RTL on it. */
4469 if (!DECL_RTL_SET_P (var))
4471 if (MEM_P (SA.partition_to_pseudo[i]))
4472 set_mem_expr (SA.partition_to_pseudo[i], NULL);
4476 /* If we have a class containing differently aligned pointers
4477 we need to merge those into the corresponding RTL pointer
4479 for (i = 1; i < num_ssa_names; i++)
4481 tree name = ssa_name (i);
4486 || !POINTER_TYPE_P (TREE_TYPE (name))
4487 /* We might have generated new SSA names in
4488 update_alias_info_with_stack_vars. They will have a NULL
4489 defining statements, and won't be part of the partitioning,
4491 || !SSA_NAME_DEF_STMT (name))
4493 part = var_to_partition (SA.map, name);
4494 if (part == NO_PARTITION)
4496 r = SA.partition_to_pseudo[part];
4498 mark_reg_pointer (r, get_pointer_alignment (name));
4501 /* If this function is `main', emit a call to `__main'
4502 to run global initializers, etc. */
4503 if (DECL_NAME (current_function_decl)
4504 && MAIN_NAME_P (DECL_NAME (current_function_decl))
4505 && DECL_FILE_SCOPE_P (current_function_decl))
4506 expand_main_function ();
4508 /* Initialize the stack_protect_guard field. This must happen after the
4509 call to __main (if any) so that the external decl is initialized. */
4510 if (crtl->stack_protect_guard)
4511 stack_protect_prologue ();
4513 expand_phi_nodes (&SA);
4515 /* Register rtl specific functions for cfg. */
4516 rtl_register_cfg_hooks ();
4518 init_block = construct_init_block ();
4520 /* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
4521 remaining edges later. */
4522 FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
4523 e->flags &= ~EDGE_EXECUTABLE;
4525 lab_rtx_for_bb = pointer_map_create ();
4526 FOR_BB_BETWEEN (bb, init_block->next_bb, EXIT_BLOCK_PTR, next_bb)
4527 bb = expand_gimple_basic_block (bb);
4529 if (MAY_HAVE_DEBUG_INSNS)
4530 expand_debug_locations ();
4532 execute_free_datastructures ();
4533 timevar_push (TV_OUT_OF_SSA);
4534 finish_out_of_ssa (&SA);
4535 timevar_pop (TV_OUT_OF_SSA);
4537 timevar_push (TV_POST_EXPAND);
4538 /* We are no longer in SSA form. */
4539 cfun->gimple_df->in_ssa_p = false;
4541 /* Expansion is used by optimization passes too, set maybe_hot_insn_p
4542 conservatively to true until they are all profile aware. */
4543 pointer_map_destroy (lab_rtx_for_bb);
4546 construct_exit_block ();
4547 set_curr_insn_block (DECL_INITIAL (current_function_decl));
4548 insn_locators_finalize ();
4550 /* Zap the tree EH table. */
4551 set_eh_throw_stmt_table (cfun, NULL);
4553 /* We need JUMP_LABEL be set in order to redirect jumps, and hence
4554 split edges which edge insertions might do. */
4555 rebuild_jump_labels (get_insns ());
4557 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
4561 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
4565 rebuild_jump_labels_chain (e->insns.r);
4566 /* Avoid putting insns before parm_birth_insn. */
4567 if (e->src == ENTRY_BLOCK_PTR
4568 && single_succ_p (ENTRY_BLOCK_PTR)
4571 rtx insns = e->insns.r;
4572 e->insns.r = NULL_RTX;
4573 emit_insn_after_noloc (insns, parm_birth_insn, e->dest);
4576 commit_one_edge_insertion (e);
4583 /* We're done expanding trees to RTL. */
4584 currently_expanding_to_rtl = 0;
4586 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR->next_bb, EXIT_BLOCK_PTR, next_bb)
4590 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
4592 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
4593 e->flags &= ~EDGE_EXECUTABLE;
4595 /* At the moment not all abnormal edges match the RTL
4596 representation. It is safe to remove them here as
4597 find_many_sub_basic_blocks will rediscover them.
4598 In the future we should get this fixed properly. */
4599 if ((e->flags & EDGE_ABNORMAL)
4600 && !(e->flags & EDGE_SIBCALL))
4607 blocks = sbitmap_alloc (last_basic_block);
4608 sbitmap_ones (blocks);
4609 find_many_sub_basic_blocks (blocks);
4610 sbitmap_free (blocks);
4611 purge_all_dead_edges ();
4615 expand_stack_alignment ();
4617 #ifdef ENABLE_CHECKING
4618 verify_flow_info ();
4621 /* There's no need to defer outputting this function any more; we
4622 know we want to output it. */
4623 DECL_DEFER_OUTPUT (current_function_decl) = 0;
4625 /* Now that we're done expanding trees to RTL, we shouldn't have any
4626 more CONCATs anywhere. */
4627 generating_concat_p = 0;
4632 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
4633 /* And the pass manager will dump RTL for us. */
4636 /* If we're emitting a nested function, make sure its parent gets
4637 emitted as well. Doing otherwise confuses debug info. */
4640 for (parent = DECL_CONTEXT (current_function_decl);
4641 parent != NULL_TREE;
4642 parent = get_containing_scope (parent))
4643 if (TREE_CODE (parent) == FUNCTION_DECL)
4644 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent)) = 1;
4647 /* We are now committed to emitting code for this function. Do any
4648 preparation, such as emitting abstract debug info for the inline
4649 before it gets mangled by optimization. */
4650 if (cgraph_function_possibly_inlined_p (current_function_decl))
4651 (*debug_hooks->outlining_inline_function) (current_function_decl);
4653 TREE_ASM_WRITTEN (current_function_decl) = 1;
4655 /* After expanding, the return labels are no longer needed. */
4656 return_label = NULL;
4657 naked_return_label = NULL;
4659 /* After expanding, the tm_restart map is no longer needed. */
4660 if (cfun->gimple_df->tm_restart)
4662 htab_delete (cfun->gimple_df->tm_restart);
4663 cfun->gimple_df->tm_restart = NULL;
4666 /* Tag the blocks with a depth number so that change_scope can find
4667 the common parent easily. */
4668 set_block_levels (DECL_INITIAL (cfun->decl), 0);
4669 default_rtl_profile ();
4670 timevar_pop (TV_POST_EXPAND);
4674 struct rtl_opt_pass pass_expand =
4678 "expand", /* name */
4680 gimple_expand_cfg, /* execute */
4683 0, /* static_pass_number */
4684 TV_EXPAND, /* tv_id */
4685 PROP_ssa | PROP_gimple_leh | PROP_cfg
4686 | PROP_gimple_lcx, /* properties_required */
4687 PROP_rtl, /* properties_provided */
4688 PROP_ssa | PROP_trees, /* properties_destroyed */
4689 TODO_verify_ssa | TODO_verify_flow
4690 | TODO_verify_stmts, /* todo_flags_start */
4691 TODO_ggc_collect /* todo_flags_finish */