1 /* A pass for lowering trees to RTL.
2 Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010
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 /* Return an expression tree corresponding to the RHS of GIMPLE
64 gimple_assign_rhs_to_tree (gimple stmt)
67 enum gimple_rhs_class grhs_class;
69 grhs_class = get_gimple_rhs_class (gimple_expr_code (stmt));
71 if (grhs_class == GIMPLE_TERNARY_RHS)
72 t = build3 (gimple_assign_rhs_code (stmt),
73 TREE_TYPE (gimple_assign_lhs (stmt)),
74 gimple_assign_rhs1 (stmt),
75 gimple_assign_rhs2 (stmt),
76 gimple_assign_rhs3 (stmt));
77 else if (grhs_class == GIMPLE_BINARY_RHS)
78 t = build2 (gimple_assign_rhs_code (stmt),
79 TREE_TYPE (gimple_assign_lhs (stmt)),
80 gimple_assign_rhs1 (stmt),
81 gimple_assign_rhs2 (stmt));
82 else if (grhs_class == GIMPLE_UNARY_RHS)
83 t = build1 (gimple_assign_rhs_code (stmt),
84 TREE_TYPE (gimple_assign_lhs (stmt)),
85 gimple_assign_rhs1 (stmt));
86 else if (grhs_class == GIMPLE_SINGLE_RHS)
88 t = gimple_assign_rhs1 (stmt);
89 /* Avoid modifying this tree in place below. */
90 if ((gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (t)
91 && gimple_location (stmt) != EXPR_LOCATION (t))
92 || (gimple_block (stmt)
93 && currently_expanding_to_rtl
95 && gimple_block (stmt) != TREE_BLOCK (t)))
101 if (gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (t))
102 SET_EXPR_LOCATION (t, gimple_location (stmt));
103 if (gimple_block (stmt) && currently_expanding_to_rtl && EXPR_P (t))
104 TREE_BLOCK (t) = gimple_block (stmt);
110 #ifndef STACK_ALIGNMENT_NEEDED
111 #define STACK_ALIGNMENT_NEEDED 1
114 #define SSAVAR(x) (TREE_CODE (x) == SSA_NAME ? SSA_NAME_VAR (x) : x)
116 /* Associate declaration T with storage space X. If T is no
117 SSA name this is exactly SET_DECL_RTL, otherwise make the
118 partition of T associated with X. */
120 set_rtl (tree t, rtx x)
122 if (TREE_CODE (t) == SSA_NAME)
124 SA.partition_to_pseudo[var_to_partition (SA.map, t)] = x;
126 set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (t), x);
127 /* For the benefit of debug information at -O0 (where vartracking
128 doesn't run) record the place also in the base DECL if it's
129 a normal variable (not a parameter). */
130 if (x && x != pc_rtx && TREE_CODE (SSA_NAME_VAR (t)) == VAR_DECL)
132 tree var = SSA_NAME_VAR (t);
133 /* If we don't yet have something recorded, just record it now. */
134 if (!DECL_RTL_SET_P (var))
135 SET_DECL_RTL (var, x);
136 /* If we have it set alrady to "multiple places" don't
138 else if (DECL_RTL (var) == pc_rtx)
140 /* If we have something recorded and it's not the same place
141 as we want to record now, we have multiple partitions for the
142 same base variable, with different places. We can't just
143 randomly chose one, hence we have to say that we don't know.
144 This only happens with optimization, and there var-tracking
145 will figure out the right thing. */
146 else if (DECL_RTL (var) != x)
147 SET_DECL_RTL (var, pc_rtx);
154 /* This structure holds data relevant to one variable that will be
155 placed in a stack slot. */
161 /* The offset of the variable. During partitioning, this is the
162 offset relative to the partition. After partitioning, this
163 is relative to the stack frame. */
164 HOST_WIDE_INT offset;
166 /* Initially, the size of the variable. Later, the size of the partition,
167 if this variable becomes it's partition's representative. */
170 /* The *byte* alignment required for this variable. Or as, with the
171 size, the alignment for this partition. */
174 /* The partition representative. */
175 size_t representative;
177 /* The next stack variable in the partition, or EOC. */
180 /* The numbers of conflicting stack variables. */
184 #define EOC ((size_t)-1)
186 /* We have an array of such objects while deciding allocation. */
187 static struct stack_var *stack_vars;
188 static size_t stack_vars_alloc;
189 static size_t stack_vars_num;
191 /* An array of indices such that stack_vars[stack_vars_sorted[i]].size
192 is non-decreasing. */
193 static size_t *stack_vars_sorted;
195 /* The phase of the stack frame. This is the known misalignment of
196 virtual_stack_vars_rtx from PREFERRED_STACK_BOUNDARY. That is,
197 (frame_offset+frame_phase) % PREFERRED_STACK_BOUNDARY == 0. */
198 static int frame_phase;
200 /* Used during expand_used_vars to remember if we saw any decls for
201 which we'd like to enable stack smashing protection. */
202 static bool has_protected_decls;
204 /* Used during expand_used_vars. Remember if we say a character buffer
205 smaller than our cutoff threshold. Used for -Wstack-protector. */
206 static bool has_short_buffer;
208 /* Discover the byte alignment to use for DECL. Ignore alignment
209 we can't do with expected alignment of the stack boundary. */
212 get_decl_align_unit (tree decl)
214 unsigned int align = LOCAL_DECL_ALIGNMENT (decl);
215 return align / BITS_PER_UNIT;
218 /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
219 Return the frame offset. */
222 alloc_stack_frame_space (HOST_WIDE_INT size, unsigned HOST_WIDE_INT align)
224 HOST_WIDE_INT offset, new_frame_offset;
226 new_frame_offset = frame_offset;
227 if (FRAME_GROWS_DOWNWARD)
229 new_frame_offset -= size + frame_phase;
230 new_frame_offset &= -align;
231 new_frame_offset += frame_phase;
232 offset = new_frame_offset;
236 new_frame_offset -= frame_phase;
237 new_frame_offset += align - 1;
238 new_frame_offset &= -align;
239 new_frame_offset += frame_phase;
240 offset = new_frame_offset;
241 new_frame_offset += size;
243 frame_offset = new_frame_offset;
245 if (frame_offset_overflow (frame_offset, cfun->decl))
246 frame_offset = offset = 0;
251 /* Accumulate DECL into STACK_VARS. */
254 add_stack_var (tree decl)
258 if (stack_vars_num >= stack_vars_alloc)
260 if (stack_vars_alloc)
261 stack_vars_alloc = stack_vars_alloc * 3 / 2;
263 stack_vars_alloc = 32;
265 = XRESIZEVEC (struct stack_var, stack_vars, stack_vars_alloc);
267 v = &stack_vars[stack_vars_num];
271 v->size = tree_low_cst (DECL_SIZE_UNIT (SSAVAR (decl)), 1);
272 /* Ensure that all variables have size, so that &a != &b for any two
273 variables that are simultaneously live. */
276 v->alignb = get_decl_align_unit (SSAVAR (decl));
278 /* All variables are initially in their own partition. */
279 v->representative = stack_vars_num;
282 /* All variables initially conflict with no other. */
285 /* Ensure that this decl doesn't get put onto the list twice. */
286 set_rtl (decl, pc_rtx);
291 /* Make the decls associated with luid's X and Y conflict. */
294 add_stack_var_conflict (size_t x, size_t y)
296 struct stack_var *a = &stack_vars[x];
297 struct stack_var *b = &stack_vars[y];
299 a->conflicts = BITMAP_ALLOC (NULL);
301 b->conflicts = BITMAP_ALLOC (NULL);
302 bitmap_set_bit (a->conflicts, y);
303 bitmap_set_bit (b->conflicts, x);
306 /* Check whether the decls associated with luid's X and Y conflict. */
309 stack_var_conflict_p (size_t x, size_t y)
311 struct stack_var *a = &stack_vars[x];
312 struct stack_var *b = &stack_vars[y];
313 if (!a->conflicts || !b->conflicts)
315 return bitmap_bit_p (a->conflicts, y);
318 /* Returns true if TYPE is or contains a union type. */
321 aggregate_contains_union_type (tree type)
325 if (TREE_CODE (type) == UNION_TYPE
326 || TREE_CODE (type) == QUAL_UNION_TYPE)
328 if (TREE_CODE (type) == ARRAY_TYPE)
329 return aggregate_contains_union_type (TREE_TYPE (type));
330 if (TREE_CODE (type) != RECORD_TYPE)
333 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
334 if (TREE_CODE (field) == FIELD_DECL)
335 if (aggregate_contains_union_type (TREE_TYPE (field)))
341 /* A subroutine of expand_used_vars. If two variables X and Y have alias
342 sets that do not conflict, then do add a conflict for these variables
343 in the interference graph. We also need to make sure to add conflicts
344 for union containing structures. Else RTL alias analysis comes along
345 and due to type based aliasing rules decides that for two overlapping
346 union temporaries { short s; int i; } accesses to the same mem through
347 different types may not alias and happily reorders stores across
348 life-time boundaries of the temporaries (See PR25654).
349 We also have to mind MEM_IN_STRUCT_P and MEM_SCALAR_P. */
352 add_alias_set_conflicts (void)
354 size_t i, j, n = stack_vars_num;
356 for (i = 0; i < n; ++i)
358 tree type_i = TREE_TYPE (stack_vars[i].decl);
359 bool aggr_i = AGGREGATE_TYPE_P (type_i);
362 contains_union = aggregate_contains_union_type (type_i);
363 for (j = 0; j < i; ++j)
365 tree type_j = TREE_TYPE (stack_vars[j].decl);
366 bool aggr_j = AGGREGATE_TYPE_P (type_j);
368 /* Either the objects conflict by means of type based
369 aliasing rules, or we need to add a conflict. */
370 || !objects_must_conflict_p (type_i, type_j)
371 /* In case the types do not conflict ensure that access
372 to elements will conflict. In case of unions we have
373 to be careful as type based aliasing rules may say
374 access to the same memory does not conflict. So play
375 safe and add a conflict in this case. */
377 add_stack_var_conflict (i, j);
382 /* A subroutine of partition_stack_vars. A comparison function for qsort,
383 sorting an array of indices by the properties of the object. */
386 stack_var_cmp (const void *a, const void *b)
388 size_t ia = *(const size_t *)a;
389 size_t ib = *(const size_t *)b;
390 unsigned int aligna = stack_vars[ia].alignb;
391 unsigned int alignb = stack_vars[ib].alignb;
392 HOST_WIDE_INT sizea = stack_vars[ia].size;
393 HOST_WIDE_INT sizeb = stack_vars[ib].size;
394 tree decla = stack_vars[ia].decl;
395 tree declb = stack_vars[ib].decl;
397 unsigned int uida, uidb;
399 /* Primary compare on "large" alignment. Large comes first. */
400 largea = (aligna * BITS_PER_UNIT > MAX_SUPPORTED_STACK_ALIGNMENT);
401 largeb = (alignb * BITS_PER_UNIT > MAX_SUPPORTED_STACK_ALIGNMENT);
402 if (largea != largeb)
403 return (int)largeb - (int)largea;
405 /* Secondary compare on size, decreasing */
411 /* Tertiary compare on true alignment, decreasing. */
417 /* Final compare on ID for sort stability, increasing.
418 Two SSA names are compared by their version, SSA names come before
419 non-SSA names, and two normal decls are compared by their DECL_UID. */
420 if (TREE_CODE (decla) == SSA_NAME)
422 if (TREE_CODE (declb) == SSA_NAME)
423 uida = SSA_NAME_VERSION (decla), uidb = SSA_NAME_VERSION (declb);
427 else if (TREE_CODE (declb) == SSA_NAME)
430 uida = DECL_UID (decla), uidb = DECL_UID (declb);
439 /* If the points-to solution *PI points to variables that are in a partition
440 together with other variables add all partition members to the pointed-to
444 add_partitioned_vars_to_ptset (struct pt_solution *pt,
445 struct pointer_map_t *decls_to_partitions,
446 struct pointer_set_t *visited, bitmap temp)
454 /* The pointed-to vars bitmap is shared, it is enough to
456 || pointer_set_insert(visited, pt->vars))
461 /* By using a temporary bitmap to store all members of the partitions
462 we have to add we make sure to visit each of the partitions only
464 EXECUTE_IF_SET_IN_BITMAP (pt->vars, 0, i, bi)
466 || !bitmap_bit_p (temp, i))
467 && (part = (bitmap *) pointer_map_contains (decls_to_partitions,
468 (void *)(size_t) i)))
469 bitmap_ior_into (temp, *part);
470 if (!bitmap_empty_p (temp))
471 bitmap_ior_into (pt->vars, temp);
474 /* Update points-to sets based on partition info, so we can use them on RTL.
475 The bitmaps representing stack partitions will be saved until expand,
476 where partitioned decls used as bases in memory expressions will be
480 update_alias_info_with_stack_vars (void)
482 struct pointer_map_t *decls_to_partitions = NULL;
484 tree var = NULL_TREE;
486 for (i = 0; i < stack_vars_num; i++)
490 struct ptr_info_def *pi;
492 /* Not interested in partitions with single variable. */
493 if (stack_vars[i].representative != i
494 || stack_vars[i].next == EOC)
497 if (!decls_to_partitions)
499 decls_to_partitions = pointer_map_create ();
500 cfun->gimple_df->decls_to_pointers = pointer_map_create ();
503 /* Create an SSA_NAME that points to the partition for use
504 as base during alias-oracle queries on RTL for bases that
505 have been partitioned. */
506 if (var == NULL_TREE)
507 var = create_tmp_var (ptr_type_node, NULL);
508 name = make_ssa_name (var, NULL);
510 /* Create bitmaps representing partitions. They will be used for
511 points-to sets later, so use GGC alloc. */
512 part = BITMAP_GGC_ALLOC ();
513 for (j = i; j != EOC; j = stack_vars[j].next)
515 tree decl = stack_vars[j].decl;
516 unsigned int uid = DECL_PT_UID (decl);
517 /* We should never end up partitioning SSA names (though they
518 may end up on the stack). Neither should we allocate stack
519 space to something that is unused and thus unreferenced. */
520 gcc_assert (DECL_P (decl)
521 && referenced_var_lookup (DECL_UID (decl)));
522 bitmap_set_bit (part, uid);
523 *((bitmap *) pointer_map_insert (decls_to_partitions,
524 (void *)(size_t) uid)) = part;
525 *((tree *) pointer_map_insert (cfun->gimple_df->decls_to_pointers,
529 /* Make the SSA name point to all partition members. */
530 pi = get_ptr_info (name);
531 pt_solution_set (&pi->pt, part, false, false);
534 /* Make all points-to sets that contain one member of a partition
535 contain all members of the partition. */
536 if (decls_to_partitions)
539 struct pointer_set_t *visited = pointer_set_create ();
540 bitmap temp = BITMAP_ALLOC (NULL);
542 for (i = 1; i < num_ssa_names; i++)
544 tree name = ssa_name (i);
545 struct ptr_info_def *pi;
548 && POINTER_TYPE_P (TREE_TYPE (name))
549 && ((pi = SSA_NAME_PTR_INFO (name)) != NULL))
550 add_partitioned_vars_to_ptset (&pi->pt, decls_to_partitions,
554 add_partitioned_vars_to_ptset (&cfun->gimple_df->escaped,
555 decls_to_partitions, visited, temp);
557 pointer_set_destroy (visited);
558 pointer_map_destroy (decls_to_partitions);
563 /* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
564 partitioning algorithm. Partitions A and B are known to be non-conflicting.
565 Merge them into a single partition A.
567 At the same time, add OFFSET to all variables in partition B. At the end
568 of the partitioning process we've have a nice block easy to lay out within
572 union_stack_vars (size_t a, size_t b, HOST_WIDE_INT offset)
575 struct stack_var *vb = &stack_vars[b];
579 /* Update each element of partition B with the given offset,
580 and merge them into partition A. */
581 for (last = i = b; i != EOC; last = i, i = stack_vars[i].next)
583 stack_vars[i].offset += offset;
584 stack_vars[i].representative = a;
586 stack_vars[last].next = stack_vars[a].next;
587 stack_vars[a].next = b;
589 /* Update the required alignment of partition A to account for B. */
590 if (stack_vars[a].alignb < stack_vars[b].alignb)
591 stack_vars[a].alignb = stack_vars[b].alignb;
593 /* Update the interference graph and merge the conflicts. */
596 EXECUTE_IF_SET_IN_BITMAP (vb->conflicts, 0, u, bi)
597 add_stack_var_conflict (a, stack_vars[u].representative);
598 BITMAP_FREE (vb->conflicts);
602 /* A subroutine of expand_used_vars. Binpack the variables into
603 partitions constrained by the interference graph. The overall
604 algorithm used is as follows:
606 Sort the objects by size.
611 Look for the largest non-conflicting object B with size <= S.
621 partition_stack_vars (void)
623 size_t si, sj, n = stack_vars_num;
625 stack_vars_sorted = XNEWVEC (size_t, stack_vars_num);
626 for (si = 0; si < n; ++si)
627 stack_vars_sorted[si] = si;
632 qsort (stack_vars_sorted, n, sizeof (size_t), stack_var_cmp);
634 for (si = 0; si < n; ++si)
636 size_t i = stack_vars_sorted[si];
637 HOST_WIDE_INT isize = stack_vars[i].size;
638 unsigned int ialign = stack_vars[i].alignb;
639 HOST_WIDE_INT offset = 0;
641 for (sj = si; sj-- > 0; )
643 size_t j = stack_vars_sorted[sj];
644 HOST_WIDE_INT jsize = stack_vars[j].size;
645 unsigned int jalign = stack_vars[j].alignb;
647 /* Ignore objects that aren't partition representatives. */
648 if (stack_vars[j].representative != j)
651 /* Ignore objects too large for the remaining space. */
655 /* Ignore conflicting objects. */
656 if (stack_var_conflict_p (i, j))
659 /* Do not mix objects of "small" (supported) alignment
660 and "large" (unsupported) alignment. */
661 if ((ialign * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)
662 != (jalign * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT))
665 /* Refine the remaining space check to include alignment. */
666 if (offset & (jalign - 1))
668 HOST_WIDE_INT toff = offset;
670 toff &= -(HOST_WIDE_INT)jalign;
671 if (isize - (toff - offset) < jsize)
674 isize -= toff - offset;
678 /* UNION the objects, placing J at OFFSET. */
679 union_stack_vars (i, j, offset);
688 update_alias_info_with_stack_vars ();
691 /* A debugging aid for expand_used_vars. Dump the generated partitions. */
694 dump_stack_var_partition (void)
696 size_t si, i, j, n = stack_vars_num;
698 for (si = 0; si < n; ++si)
700 i = stack_vars_sorted[si];
702 /* Skip variables that aren't partition representatives, for now. */
703 if (stack_vars[i].representative != i)
706 fprintf (dump_file, "Partition %lu: size " HOST_WIDE_INT_PRINT_DEC
707 " align %u\n", (unsigned long) i, stack_vars[i].size,
708 stack_vars[i].alignb);
710 for (j = i; j != EOC; j = stack_vars[j].next)
712 fputc ('\t', dump_file);
713 print_generic_expr (dump_file, stack_vars[j].decl, dump_flags);
714 fprintf (dump_file, ", offset " HOST_WIDE_INT_PRINT_DEC "\n",
715 stack_vars[j].offset);
720 /* Assign rtl to DECL at BASE + OFFSET. */
723 expand_one_stack_var_at (tree decl, rtx base, unsigned base_align,
724 HOST_WIDE_INT offset)
729 /* If this fails, we've overflowed the stack frame. Error nicely? */
730 gcc_assert (offset == trunc_int_for_mode (offset, Pmode));
732 x = plus_constant (base, offset);
733 x = gen_rtx_MEM (DECL_MODE (SSAVAR (decl)), x);
735 if (TREE_CODE (decl) != SSA_NAME)
737 /* Set alignment we actually gave this decl if it isn't an SSA name.
738 If it is we generate stack slots only accidentally so it isn't as
739 important, we'll simply use the alignment that is already set. */
740 if (base == virtual_stack_vars_rtx)
741 offset -= frame_phase;
742 align = offset & -offset;
743 align *= BITS_PER_UNIT;
744 if (align == 0 || align > base_align)
747 /* One would think that we could assert that we're not decreasing
748 alignment here, but (at least) the i386 port does exactly this
749 via the MINIMUM_ALIGNMENT hook. */
751 DECL_ALIGN (decl) = align;
752 DECL_USER_ALIGN (decl) = 0;
755 set_mem_attributes (x, SSAVAR (decl), true);
759 /* A subroutine of expand_used_vars. Give each partition representative
760 a unique location within the stack frame. Update each partition member
761 with that location. */
764 expand_stack_vars (bool (*pred) (tree))
766 size_t si, i, j, n = stack_vars_num;
767 HOST_WIDE_INT large_size = 0, large_alloc = 0;
768 rtx large_base = NULL;
769 unsigned large_align = 0;
772 /* Determine if there are any variables requiring "large" alignment.
773 Since these are dynamically allocated, we only process these if
774 no predicate involved. */
775 large_align = stack_vars[stack_vars_sorted[0]].alignb * BITS_PER_UNIT;
776 if (pred == NULL && large_align > MAX_SUPPORTED_STACK_ALIGNMENT)
778 /* Find the total size of these variables. */
779 for (si = 0; si < n; ++si)
783 i = stack_vars_sorted[si];
784 alignb = stack_vars[i].alignb;
786 /* Stop when we get to the first decl with "small" alignment. */
787 if (alignb * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)
790 /* Skip variables that aren't partition representatives. */
791 if (stack_vars[i].representative != i)
794 /* Skip variables that have already had rtl assigned. See also
795 add_stack_var where we perpetrate this pc_rtx hack. */
796 decl = stack_vars[i].decl;
797 if ((TREE_CODE (decl) == SSA_NAME
798 ? SA.partition_to_pseudo[var_to_partition (SA.map, decl)]
799 : DECL_RTL (decl)) != pc_rtx)
802 large_size += alignb - 1;
803 large_size &= -(HOST_WIDE_INT)alignb;
804 large_size += stack_vars[i].size;
807 /* If there were any, allocate space. */
809 large_base = allocate_dynamic_stack_space (GEN_INT (large_size), 0,
813 for (si = 0; si < n; ++si)
816 unsigned base_align, alignb;
817 HOST_WIDE_INT offset;
819 i = stack_vars_sorted[si];
821 /* Skip variables that aren't partition representatives, for now. */
822 if (stack_vars[i].representative != i)
825 /* Skip variables that have already had rtl assigned. See also
826 add_stack_var where we perpetrate this pc_rtx hack. */
827 decl = stack_vars[i].decl;
828 if ((TREE_CODE (decl) == SSA_NAME
829 ? SA.partition_to_pseudo[var_to_partition (SA.map, decl)]
830 : DECL_RTL (decl)) != pc_rtx)
833 /* Check the predicate to see whether this variable should be
834 allocated in this pass. */
835 if (pred && !pred (decl))
838 alignb = stack_vars[i].alignb;
839 if (alignb * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT)
841 offset = alloc_stack_frame_space (stack_vars[i].size, alignb);
842 base = virtual_stack_vars_rtx;
843 base_align = crtl->max_used_stack_slot_alignment;
847 /* Large alignment is only processed in the last pass. */
850 gcc_assert (large_base != NULL);
852 large_alloc += alignb - 1;
853 large_alloc &= -(HOST_WIDE_INT)alignb;
854 offset = large_alloc;
855 large_alloc += stack_vars[i].size;
858 base_align = large_align;
861 /* Create rtl for each variable based on their location within the
863 for (j = i; j != EOC; j = stack_vars[j].next)
865 gcc_assert (stack_vars[j].offset <= stack_vars[i].size);
866 expand_one_stack_var_at (stack_vars[j].decl,
868 stack_vars[j].offset + offset);
872 gcc_assert (large_alloc == large_size);
875 /* Take into account all sizes of partitions and reset DECL_RTLs. */
877 account_stack_vars (void)
879 size_t si, j, i, n = stack_vars_num;
880 HOST_WIDE_INT size = 0;
882 for (si = 0; si < n; ++si)
884 i = stack_vars_sorted[si];
886 /* Skip variables that aren't partition representatives, for now. */
887 if (stack_vars[i].representative != i)
890 size += stack_vars[i].size;
891 for (j = i; j != EOC; j = stack_vars[j].next)
892 set_rtl (stack_vars[j].decl, NULL);
897 /* A subroutine of expand_one_var. Called to immediately assign rtl
898 to a variable to be allocated in the stack frame. */
901 expand_one_stack_var (tree var)
903 HOST_WIDE_INT size, offset;
906 size = tree_low_cst (DECL_SIZE_UNIT (SSAVAR (var)), 1);
907 byte_align = get_decl_align_unit (SSAVAR (var));
909 /* We handle highly aligned variables in expand_stack_vars. */
910 gcc_assert (byte_align * BITS_PER_UNIT <= MAX_SUPPORTED_STACK_ALIGNMENT);
912 offset = alloc_stack_frame_space (size, byte_align);
914 expand_one_stack_var_at (var, virtual_stack_vars_rtx,
915 crtl->max_used_stack_slot_alignment, offset);
918 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
919 that will reside in a hard register. */
922 expand_one_hard_reg_var (tree var)
924 rest_of_decl_compilation (var, 0, 0);
927 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
928 that will reside in a pseudo register. */
931 expand_one_register_var (tree var)
933 tree decl = SSAVAR (var);
934 tree type = TREE_TYPE (decl);
935 enum machine_mode reg_mode = promote_decl_mode (decl, NULL);
936 rtx x = gen_reg_rtx (reg_mode);
940 /* Note if the object is a user variable. */
941 if (!DECL_ARTIFICIAL (decl))
944 if (POINTER_TYPE_P (type))
945 mark_reg_pointer (x, TYPE_ALIGN (TREE_TYPE (type)));
948 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
949 has some associated error, e.g. its type is error-mark. We just need
950 to pick something that won't crash the rest of the compiler. */
953 expand_one_error_var (tree var)
955 enum machine_mode mode = DECL_MODE (var);
959 x = gen_rtx_MEM (BLKmode, const0_rtx);
960 else if (mode == VOIDmode)
963 x = gen_reg_rtx (mode);
965 SET_DECL_RTL (var, x);
968 /* A subroutine of expand_one_var. VAR is a variable that will be
969 allocated to the local stack frame. Return true if we wish to
970 add VAR to STACK_VARS so that it will be coalesced with other
971 variables. Return false to allocate VAR immediately.
973 This function is used to reduce the number of variables considered
974 for coalescing, which reduces the size of the quadratic problem. */
977 defer_stack_allocation (tree var, bool toplevel)
979 /* If stack protection is enabled, *all* stack variables must be deferred,
980 so that we can re-order the strings to the top of the frame. */
981 if (flag_stack_protect)
984 /* We handle "large" alignment via dynamic allocation. We want to handle
985 this extra complication in only one place, so defer them. */
986 if (DECL_ALIGN (var) > MAX_SUPPORTED_STACK_ALIGNMENT)
989 /* Variables in the outermost scope automatically conflict with
990 every other variable. The only reason to want to defer them
991 at all is that, after sorting, we can more efficiently pack
992 small variables in the stack frame. Continue to defer at -O2. */
993 if (toplevel && optimize < 2)
996 /* Without optimization, *most* variables are allocated from the
997 stack, which makes the quadratic problem large exactly when we
998 want compilation to proceed as quickly as possible. On the
999 other hand, we don't want the function's stack frame size to
1000 get completely out of hand. So we avoid adding scalars and
1001 "small" aggregates to the list at all. */
1002 if (optimize == 0 && tree_low_cst (DECL_SIZE_UNIT (var), 1) < 32)
1008 /* A subroutine of expand_used_vars. Expand one variable according to
1009 its flavor. Variables to be placed on the stack are not actually
1010 expanded yet, merely recorded.
1011 When REALLY_EXPAND is false, only add stack values to be allocated.
1012 Return stack usage this variable is supposed to take.
1015 static HOST_WIDE_INT
1016 expand_one_var (tree var, bool toplevel, bool really_expand)
1018 unsigned int align = BITS_PER_UNIT;
1023 if (TREE_TYPE (var) != error_mark_node && TREE_CODE (var) == VAR_DECL)
1025 /* Because we don't know if VAR will be in register or on stack,
1026 we conservatively assume it will be on stack even if VAR is
1027 eventually put into register after RA pass. For non-automatic
1028 variables, which won't be on stack, we collect alignment of
1029 type and ignore user specified alignment. */
1030 if (TREE_STATIC (var) || DECL_EXTERNAL (var))
1031 align = MINIMUM_ALIGNMENT (TREE_TYPE (var),
1032 TYPE_MODE (TREE_TYPE (var)),
1033 TYPE_ALIGN (TREE_TYPE (var)));
1034 else if (DECL_HAS_VALUE_EXPR_P (var)
1035 || (DECL_RTL_SET_P (var) && MEM_P (DECL_RTL (var))))
1036 /* Don't consider debug only variables with DECL_HAS_VALUE_EXPR_P set
1037 or variables which were assigned a stack slot already by
1038 expand_one_stack_var_at - in the latter case DECL_ALIGN has been
1039 changed from the offset chosen to it. */
1040 align = crtl->stack_alignment_estimated;
1042 align = MINIMUM_ALIGNMENT (var, DECL_MODE (var), DECL_ALIGN (var));
1044 /* If the variable alignment is very large we'll dynamicaly allocate
1045 it, which means that in-frame portion is just a pointer. */
1046 if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
1047 align = POINTER_SIZE;
1050 if (SUPPORTS_STACK_ALIGNMENT
1051 && crtl->stack_alignment_estimated < align)
1053 /* stack_alignment_estimated shouldn't change after stack
1054 realign decision made */
1055 gcc_assert(!crtl->stack_realign_processed);
1056 crtl->stack_alignment_estimated = align;
1059 /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
1060 So here we only make sure stack_alignment_needed >= align. */
1061 if (crtl->stack_alignment_needed < align)
1062 crtl->stack_alignment_needed = align;
1063 if (crtl->max_used_stack_slot_alignment < align)
1064 crtl->max_used_stack_slot_alignment = align;
1066 if (TREE_CODE (origvar) == SSA_NAME)
1068 gcc_assert (TREE_CODE (var) != VAR_DECL
1069 || (!DECL_EXTERNAL (var)
1070 && !DECL_HAS_VALUE_EXPR_P (var)
1071 && !TREE_STATIC (var)
1072 && TREE_TYPE (var) != error_mark_node
1073 && !DECL_HARD_REGISTER (var)
1076 if (TREE_CODE (var) != VAR_DECL && TREE_CODE (origvar) != SSA_NAME)
1078 else if (DECL_EXTERNAL (var))
1080 else if (DECL_HAS_VALUE_EXPR_P (var))
1082 else if (TREE_STATIC (var))
1084 else if (TREE_CODE (origvar) != SSA_NAME && DECL_RTL_SET_P (var))
1086 else if (TREE_TYPE (var) == error_mark_node)
1089 expand_one_error_var (var);
1091 else if (TREE_CODE (var) == VAR_DECL && DECL_HARD_REGISTER (var))
1094 expand_one_hard_reg_var (var);
1096 else if (use_register_for_decl (var))
1099 expand_one_register_var (origvar);
1101 else if (!host_integerp (DECL_SIZE_UNIT (var), 1))
1105 error ("size of variable %q+D is too large", var);
1106 expand_one_error_var (var);
1109 else if (defer_stack_allocation (var, toplevel))
1110 add_stack_var (origvar);
1114 expand_one_stack_var (origvar);
1115 return tree_low_cst (DECL_SIZE_UNIT (var), 1);
1120 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1121 expanding variables. Those variables that can be put into registers
1122 are allocated pseudos; those that can't are put on the stack.
1124 TOPLEVEL is true if this is the outermost BLOCK. */
1127 expand_used_vars_for_block (tree block, bool toplevel)
1129 size_t i, j, old_sv_num, this_sv_num, new_sv_num;
1132 old_sv_num = toplevel ? 0 : stack_vars_num;
1134 /* Expand all variables at this level. */
1135 for (t = BLOCK_VARS (block); t ; t = DECL_CHAIN (t))
1137 expand_one_var (t, toplevel, true);
1139 this_sv_num = stack_vars_num;
1141 /* Expand all variables at containing levels. */
1142 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
1143 expand_used_vars_for_block (t, false);
1145 /* Since we do not track exact variable lifetimes (which is not even
1146 possible for variables whose address escapes), we mirror the block
1147 tree in the interference graph. Here we cause all variables at this
1148 level, and all sublevels, to conflict. */
1149 if (old_sv_num < this_sv_num)
1151 new_sv_num = stack_vars_num;
1153 for (i = old_sv_num; i < new_sv_num; ++i)
1154 for (j = i < this_sv_num ? i : this_sv_num; j-- > old_sv_num ;)
1155 add_stack_var_conflict (i, j);
1159 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1160 and clear TREE_USED on all local variables. */
1163 clear_tree_used (tree block)
1167 for (t = BLOCK_VARS (block); t ; t = DECL_CHAIN (t))
1168 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
1171 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
1172 clear_tree_used (t);
1175 /* Examine TYPE and determine a bit mask of the following features. */
1177 #define SPCT_HAS_LARGE_CHAR_ARRAY 1
1178 #define SPCT_HAS_SMALL_CHAR_ARRAY 2
1179 #define SPCT_HAS_ARRAY 4
1180 #define SPCT_HAS_AGGREGATE 8
1183 stack_protect_classify_type (tree type)
1185 unsigned int ret = 0;
1188 switch (TREE_CODE (type))
1191 t = TYPE_MAIN_VARIANT (TREE_TYPE (type));
1192 if (t == char_type_node
1193 || t == signed_char_type_node
1194 || t == unsigned_char_type_node)
1196 unsigned HOST_WIDE_INT max = PARAM_VALUE (PARAM_SSP_BUFFER_SIZE);
1197 unsigned HOST_WIDE_INT len;
1199 if (!TYPE_SIZE_UNIT (type)
1200 || !host_integerp (TYPE_SIZE_UNIT (type), 1))
1203 len = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
1206 ret = SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_ARRAY;
1208 ret = SPCT_HAS_LARGE_CHAR_ARRAY | SPCT_HAS_ARRAY;
1211 ret = SPCT_HAS_ARRAY;
1215 case QUAL_UNION_TYPE:
1217 ret = SPCT_HAS_AGGREGATE;
1218 for (t = TYPE_FIELDS (type); t ; t = TREE_CHAIN (t))
1219 if (TREE_CODE (t) == FIELD_DECL)
1220 ret |= stack_protect_classify_type (TREE_TYPE (t));
1230 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
1231 part of the local stack frame. Remember if we ever return nonzero for
1232 any variable in this function. The return value is the phase number in
1233 which the variable should be allocated. */
1236 stack_protect_decl_phase (tree decl)
1238 unsigned int bits = stack_protect_classify_type (TREE_TYPE (decl));
1241 if (bits & SPCT_HAS_SMALL_CHAR_ARRAY)
1242 has_short_buffer = true;
1244 if (flag_stack_protect == 2)
1246 if ((bits & (SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_LARGE_CHAR_ARRAY))
1247 && !(bits & SPCT_HAS_AGGREGATE))
1249 else if (bits & SPCT_HAS_ARRAY)
1253 ret = (bits & SPCT_HAS_LARGE_CHAR_ARRAY) != 0;
1256 has_protected_decls = true;
1261 /* Two helper routines that check for phase 1 and phase 2. These are used
1262 as callbacks for expand_stack_vars. */
1265 stack_protect_decl_phase_1 (tree decl)
1267 return stack_protect_decl_phase (decl) == 1;
1271 stack_protect_decl_phase_2 (tree decl)
1273 return stack_protect_decl_phase (decl) == 2;
1276 /* Ensure that variables in different stack protection phases conflict
1277 so that they are not merged and share the same stack slot. */
1280 add_stack_protection_conflicts (void)
1282 size_t i, j, n = stack_vars_num;
1283 unsigned char *phase;
1285 phase = XNEWVEC (unsigned char, n);
1286 for (i = 0; i < n; ++i)
1287 phase[i] = stack_protect_decl_phase (stack_vars[i].decl);
1289 for (i = 0; i < n; ++i)
1291 unsigned char ph_i = phase[i];
1292 for (j = 0; j < i; ++j)
1293 if (ph_i != phase[j])
1294 add_stack_var_conflict (i, j);
1300 /* Create a decl for the guard at the top of the stack frame. */
1303 create_stack_guard (void)
1305 tree guard = build_decl (DECL_SOURCE_LOCATION (current_function_decl),
1306 VAR_DECL, NULL, ptr_type_node);
1307 TREE_THIS_VOLATILE (guard) = 1;
1308 TREE_USED (guard) = 1;
1309 expand_one_stack_var (guard);
1310 crtl->stack_protect_guard = guard;
1313 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1314 expanding variables. Those variables that can be put into registers
1315 are allocated pseudos; those that can't are put on the stack.
1317 TOPLEVEL is true if this is the outermost BLOCK. */
1319 static HOST_WIDE_INT
1320 account_used_vars_for_block (tree block, bool toplevel)
1323 HOST_WIDE_INT size = 0;
1325 /* Expand all variables at this level. */
1326 for (t = BLOCK_VARS (block); t ; t = DECL_CHAIN (t))
1328 size += expand_one_var (t, toplevel, false);
1330 /* Expand all variables at containing levels. */
1331 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
1332 size += account_used_vars_for_block (t, false);
1337 /* Prepare for expanding variables. */
1339 init_vars_expansion (void)
1343 /* Set TREE_USED on all variables in the local_decls. */
1344 FOR_EACH_LOCAL_DECL (cfun, ix, t)
1347 /* Clear TREE_USED on all variables associated with a block scope. */
1348 clear_tree_used (DECL_INITIAL (current_function_decl));
1350 /* Initialize local stack smashing state. */
1351 has_protected_decls = false;
1352 has_short_buffer = false;
1355 /* Free up stack variable graph data. */
1357 fini_vars_expansion (void)
1359 size_t i, n = stack_vars_num;
1360 for (i = 0; i < n; i++)
1361 BITMAP_FREE (stack_vars[i].conflicts);
1362 XDELETEVEC (stack_vars);
1363 XDELETEVEC (stack_vars_sorted);
1365 stack_vars_alloc = stack_vars_num = 0;
1368 /* Make a fair guess for the size of the stack frame of the decl
1369 passed. This doesn't have to be exact, the result is only used
1370 in the inline heuristics. So we don't want to run the full stack
1371 var packing algorithm (which is quadratic in the number of stack
1372 vars). Instead, we calculate the total size of all stack vars.
1373 This turns out to be a pretty fair estimate -- packing of stack
1374 vars doesn't happen very often. */
1377 estimated_stack_frame_size (tree decl)
1379 HOST_WIDE_INT size = 0;
1381 tree var, outer_block = DECL_INITIAL (current_function_decl);
1383 tree old_cur_fun_decl = current_function_decl;
1384 current_function_decl = decl;
1385 push_cfun (DECL_STRUCT_FUNCTION (decl));
1387 init_vars_expansion ();
1389 FOR_EACH_LOCAL_DECL (cfun, ix, var)
1391 if (TREE_USED (var))
1392 size += expand_one_var (var, true, false);
1393 TREE_USED (var) = 1;
1395 size += account_used_vars_for_block (outer_block, true);
1397 if (stack_vars_num > 0)
1399 /* Fake sorting the stack vars for account_stack_vars (). */
1400 stack_vars_sorted = XNEWVEC (size_t, stack_vars_num);
1401 for (i = 0; i < stack_vars_num; ++i)
1402 stack_vars_sorted[i] = i;
1403 size += account_stack_vars ();
1404 fini_vars_expansion ();
1407 current_function_decl = old_cur_fun_decl;
1411 /* Expand all variables used in the function. */
1414 expand_used_vars (void)
1416 tree var, outer_block = DECL_INITIAL (current_function_decl);
1417 VEC(tree,heap) *maybe_local_decls = NULL;
1421 /* Compute the phase of the stack frame for this function. */
1423 int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
1424 int off = STARTING_FRAME_OFFSET % align;
1425 frame_phase = off ? align - off : 0;
1428 init_vars_expansion ();
1430 for (i = 0; i < SA.map->num_partitions; i++)
1432 tree var = partition_to_var (SA.map, i);
1434 gcc_assert (is_gimple_reg (var));
1435 if (TREE_CODE (SSA_NAME_VAR (var)) == VAR_DECL)
1436 expand_one_var (var, true, true);
1439 /* This is a PARM_DECL or RESULT_DECL. For those partitions that
1440 contain the default def (representing the parm or result itself)
1441 we don't do anything here. But those which don't contain the
1442 default def (representing a temporary based on the parm/result)
1443 we need to allocate space just like for normal VAR_DECLs. */
1444 if (!bitmap_bit_p (SA.partition_has_default_def, i))
1446 expand_one_var (var, true, true);
1447 gcc_assert (SA.partition_to_pseudo[i]);
1452 /* At this point all variables on the local_decls with TREE_USED
1453 set are not associated with any block scope. Lay them out. */
1455 len = VEC_length (tree, cfun->local_decls);
1456 FOR_EACH_LOCAL_DECL (cfun, i, var)
1458 bool expand_now = false;
1460 /* Expanded above already. */
1461 if (is_gimple_reg (var))
1463 TREE_USED (var) = 0;
1466 /* We didn't set a block for static or extern because it's hard
1467 to tell the difference between a global variable (re)declared
1468 in a local scope, and one that's really declared there to
1469 begin with. And it doesn't really matter much, since we're
1470 not giving them stack space. Expand them now. */
1471 else if (TREE_STATIC (var) || DECL_EXTERNAL (var))
1474 /* If the variable is not associated with any block, then it
1475 was created by the optimizers, and could be live anywhere
1477 else if (TREE_USED (var))
1480 /* Finally, mark all variables on the list as used. We'll use
1481 this in a moment when we expand those associated with scopes. */
1482 TREE_USED (var) = 1;
1485 expand_one_var (var, true, true);
1488 if (DECL_ARTIFICIAL (var) && !DECL_IGNORED_P (var))
1490 rtx rtl = DECL_RTL_IF_SET (var);
1492 /* Keep artificial non-ignored vars in cfun->local_decls
1493 chain until instantiate_decls. */
1494 if (rtl && (MEM_P (rtl) || GET_CODE (rtl) == CONCAT))
1495 add_local_decl (cfun, var);
1496 else if (rtl == NULL_RTX)
1497 /* If rtl isn't set yet, which can happen e.g. with
1498 -fstack-protector, retry before returning from this
1500 VEC_safe_push (tree, heap, maybe_local_decls, var);
1504 /* We duplicated some of the decls in CFUN->LOCAL_DECLS.
1506 +-----------------+-----------------+
1507 | ...processed... | ...duplicates...|
1508 +-----------------+-----------------+
1510 +-- LEN points here.
1512 We just want the duplicates, as those are the artificial
1513 non-ignored vars that we want to keep until instantiate_decls.
1514 Move them down and truncate the array. */
1515 if (!VEC_empty (tree, cfun->local_decls))
1516 VEC_block_remove (tree, cfun->local_decls, 0, len);
1518 /* At this point, all variables within the block tree with TREE_USED
1519 set are actually used by the optimized function. Lay them out. */
1520 expand_used_vars_for_block (outer_block, true);
1522 if (stack_vars_num > 0)
1524 /* Due to the way alias sets work, no variables with non-conflicting
1525 alias sets may be assigned the same address. Add conflicts to
1527 add_alias_set_conflicts ();
1529 /* If stack protection is enabled, we don't share space between
1530 vulnerable data and non-vulnerable data. */
1531 if (flag_stack_protect)
1532 add_stack_protection_conflicts ();
1534 /* Now that we have collected all stack variables, and have computed a
1535 minimal interference graph, attempt to save some stack space. */
1536 partition_stack_vars ();
1538 dump_stack_var_partition ();
1541 /* There are several conditions under which we should create a
1542 stack guard: protect-all, alloca used, protected decls present. */
1543 if (flag_stack_protect == 2
1544 || (flag_stack_protect
1545 && (cfun->calls_alloca || has_protected_decls)))
1546 create_stack_guard ();
1548 /* Assign rtl to each variable based on these partitions. */
1549 if (stack_vars_num > 0)
1551 /* Reorder decls to be protected by iterating over the variables
1552 array multiple times, and allocating out of each phase in turn. */
1553 /* ??? We could probably integrate this into the qsort we did
1554 earlier, such that we naturally see these variables first,
1555 and thus naturally allocate things in the right order. */
1556 if (has_protected_decls)
1558 /* Phase 1 contains only character arrays. */
1559 expand_stack_vars (stack_protect_decl_phase_1);
1561 /* Phase 2 contains other kinds of arrays. */
1562 if (flag_stack_protect == 2)
1563 expand_stack_vars (stack_protect_decl_phase_2);
1566 expand_stack_vars (NULL);
1568 fini_vars_expansion ();
1571 /* If there were any artificial non-ignored vars without rtl
1572 found earlier, see if deferred stack allocation hasn't assigned
1574 FOR_EACH_VEC_ELT_REVERSE (tree, maybe_local_decls, i, var)
1576 rtx rtl = DECL_RTL_IF_SET (var);
1578 /* Keep artificial non-ignored vars in cfun->local_decls
1579 chain until instantiate_decls. */
1580 if (rtl && (MEM_P (rtl) || GET_CODE (rtl) == CONCAT))
1581 add_local_decl (cfun, var);
1583 VEC_free (tree, heap, maybe_local_decls);
1585 /* If the target requires that FRAME_OFFSET be aligned, do it. */
1586 if (STACK_ALIGNMENT_NEEDED)
1588 HOST_WIDE_INT align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
1589 if (!FRAME_GROWS_DOWNWARD)
1590 frame_offset += align - 1;
1591 frame_offset &= -align;
1596 /* If we need to produce a detailed dump, print the tree representation
1597 for STMT to the dump file. SINCE is the last RTX after which the RTL
1598 generated for STMT should have been appended. */
1601 maybe_dump_rtl_for_gimple_stmt (gimple stmt, rtx since)
1603 if (dump_file && (dump_flags & TDF_DETAILS))
1605 fprintf (dump_file, "\n;; ");
1606 print_gimple_stmt (dump_file, stmt, 0,
1607 TDF_SLIM | (dump_flags & TDF_LINENO));
1608 fprintf (dump_file, "\n");
1610 print_rtl (dump_file, since ? NEXT_INSN (since) : since);
1614 /* Maps the blocks that do not contain tree labels to rtx labels. */
1616 static struct pointer_map_t *lab_rtx_for_bb;
1618 /* Returns the label_rtx expression for a label starting basic block BB. */
1621 label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED)
1623 gimple_stmt_iterator gsi;
1628 if (bb->flags & BB_RTL)
1629 return block_label (bb);
1631 elt = pointer_map_contains (lab_rtx_for_bb, bb);
1635 /* Find the tree label if it is present. */
1637 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1639 lab_stmt = gsi_stmt (gsi);
1640 if (gimple_code (lab_stmt) != GIMPLE_LABEL)
1643 lab = gimple_label_label (lab_stmt);
1644 if (DECL_NONLOCAL (lab))
1647 return label_rtx (lab);
1650 elt = pointer_map_insert (lab_rtx_for_bb, bb);
1651 *elt = gen_label_rtx ();
1656 /* A subroutine of expand_gimple_cond. Given E, a fallthrough edge
1657 of a basic block where we just expanded the conditional at the end,
1658 possibly clean up the CFG and instruction sequence. LAST is the
1659 last instruction before the just emitted jump sequence. */
1662 maybe_cleanup_end_of_block (edge e, rtx last)
1664 /* Special case: when jumpif decides that the condition is
1665 trivial it emits an unconditional jump (and the necessary
1666 barrier). But we still have two edges, the fallthru one is
1667 wrong. purge_dead_edges would clean this up later. Unfortunately
1668 we have to insert insns (and split edges) before
1669 find_many_sub_basic_blocks and hence before purge_dead_edges.
1670 But splitting edges might create new blocks which depend on the
1671 fact that if there are two edges there's no barrier. So the
1672 barrier would get lost and verify_flow_info would ICE. Instead
1673 of auditing all edge splitters to care for the barrier (which
1674 normally isn't there in a cleaned CFG), fix it here. */
1675 if (BARRIER_P (get_last_insn ()))
1679 /* Now, we have a single successor block, if we have insns to
1680 insert on the remaining edge we potentially will insert
1681 it at the end of this block (if the dest block isn't feasible)
1682 in order to avoid splitting the edge. This insertion will take
1683 place in front of the last jump. But we might have emitted
1684 multiple jumps (conditional and one unconditional) to the
1685 same destination. Inserting in front of the last one then
1686 is a problem. See PR 40021. We fix this by deleting all
1687 jumps except the last unconditional one. */
1688 insn = PREV_INSN (get_last_insn ());
1689 /* Make sure we have an unconditional jump. Otherwise we're
1691 gcc_assert (JUMP_P (insn) && !any_condjump_p (insn));
1692 for (insn = PREV_INSN (insn); insn != last;)
1694 insn = PREV_INSN (insn);
1695 if (JUMP_P (NEXT_INSN (insn)))
1696 delete_insn (NEXT_INSN (insn));
1701 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_COND.
1702 Returns a new basic block if we've terminated the current basic
1703 block and created a new one. */
1706 expand_gimple_cond (basic_block bb, gimple stmt)
1708 basic_block new_bb, dest;
1713 enum tree_code code;
1716 code = gimple_cond_code (stmt);
1717 op0 = gimple_cond_lhs (stmt);
1718 op1 = gimple_cond_rhs (stmt);
1719 /* We're sometimes presented with such code:
1723 This would expand to two comparisons which then later might
1724 be cleaned up by combine. But some pattern matchers like if-conversion
1725 work better when there's only one compare, so make up for this
1726 here as special exception if TER would have made the same change. */
1727 if (gimple_cond_single_var_p (stmt)
1729 && TREE_CODE (op0) == SSA_NAME
1730 && bitmap_bit_p (SA.values, SSA_NAME_VERSION (op0)))
1732 gimple second = SSA_NAME_DEF_STMT (op0);
1733 if (gimple_code (second) == GIMPLE_ASSIGN)
1735 enum tree_code code2 = gimple_assign_rhs_code (second);
1736 if (TREE_CODE_CLASS (code2) == tcc_comparison)
1739 op0 = gimple_assign_rhs1 (second);
1740 op1 = gimple_assign_rhs2 (second);
1742 /* If jumps are cheap turn some more codes into
1744 else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4)
1746 if ((code2 == BIT_AND_EXPR
1747 && TYPE_PRECISION (TREE_TYPE (op0)) == 1
1748 && TREE_CODE (gimple_assign_rhs2 (second)) != INTEGER_CST)
1749 || code2 == TRUTH_AND_EXPR)
1751 code = TRUTH_ANDIF_EXPR;
1752 op0 = gimple_assign_rhs1 (second);
1753 op1 = gimple_assign_rhs2 (second);
1755 else if (code2 == BIT_IOR_EXPR || code2 == TRUTH_OR_EXPR)
1757 code = TRUTH_ORIF_EXPR;
1758 op0 = gimple_assign_rhs1 (second);
1759 op1 = gimple_assign_rhs2 (second);
1765 last2 = last = get_last_insn ();
1767 extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
1768 if (gimple_has_location (stmt))
1770 set_curr_insn_source_location (gimple_location (stmt));
1771 set_curr_insn_block (gimple_block (stmt));
1774 /* These flags have no purpose in RTL land. */
1775 true_edge->flags &= ~EDGE_TRUE_VALUE;
1776 false_edge->flags &= ~EDGE_FALSE_VALUE;
1778 /* We can either have a pure conditional jump with one fallthru edge or
1779 two-way jump that needs to be decomposed into two basic blocks. */
1780 if (false_edge->dest == bb->next_bb)
1782 jumpif_1 (code, op0, op1, label_rtx_for_bb (true_edge->dest),
1783 true_edge->probability);
1784 maybe_dump_rtl_for_gimple_stmt (stmt, last);
1785 if (true_edge->goto_locus)
1787 set_curr_insn_source_location (true_edge->goto_locus);
1788 set_curr_insn_block (true_edge->goto_block);
1789 true_edge->goto_locus = curr_insn_locator ();
1791 true_edge->goto_block = NULL;
1792 false_edge->flags |= EDGE_FALLTHRU;
1793 maybe_cleanup_end_of_block (false_edge, last);
1796 if (true_edge->dest == bb->next_bb)
1798 jumpifnot_1 (code, op0, op1, label_rtx_for_bb (false_edge->dest),
1799 false_edge->probability);
1800 maybe_dump_rtl_for_gimple_stmt (stmt, last);
1801 if (false_edge->goto_locus)
1803 set_curr_insn_source_location (false_edge->goto_locus);
1804 set_curr_insn_block (false_edge->goto_block);
1805 false_edge->goto_locus = curr_insn_locator ();
1807 false_edge->goto_block = NULL;
1808 true_edge->flags |= EDGE_FALLTHRU;
1809 maybe_cleanup_end_of_block (true_edge, last);
1813 jumpif_1 (code, op0, op1, label_rtx_for_bb (true_edge->dest),
1814 true_edge->probability);
1815 last = get_last_insn ();
1816 if (false_edge->goto_locus)
1818 set_curr_insn_source_location (false_edge->goto_locus);
1819 set_curr_insn_block (false_edge->goto_block);
1820 false_edge->goto_locus = curr_insn_locator ();
1822 false_edge->goto_block = NULL;
1823 emit_jump (label_rtx_for_bb (false_edge->dest));
1826 if (BARRIER_P (BB_END (bb)))
1827 BB_END (bb) = PREV_INSN (BB_END (bb));
1828 update_bb_for_insn (bb);
1830 new_bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
1831 dest = false_edge->dest;
1832 redirect_edge_succ (false_edge, new_bb);
1833 false_edge->flags |= EDGE_FALLTHRU;
1834 new_bb->count = false_edge->count;
1835 new_bb->frequency = EDGE_FREQUENCY (false_edge);
1836 new_edge = make_edge (new_bb, dest, 0);
1837 new_edge->probability = REG_BR_PROB_BASE;
1838 new_edge->count = new_bb->count;
1839 if (BARRIER_P (BB_END (new_bb)))
1840 BB_END (new_bb) = PREV_INSN (BB_END (new_bb));
1841 update_bb_for_insn (new_bb);
1843 maybe_dump_rtl_for_gimple_stmt (stmt, last2);
1845 if (true_edge->goto_locus)
1847 set_curr_insn_source_location (true_edge->goto_locus);
1848 set_curr_insn_block (true_edge->goto_block);
1849 true_edge->goto_locus = curr_insn_locator ();
1851 true_edge->goto_block = NULL;
1856 /* A subroutine of expand_gimple_stmt_1, expanding one GIMPLE_CALL
1860 expand_call_stmt (gimple stmt)
1863 tree lhs = gimple_call_lhs (stmt);
1868 exp = build_vl_exp (CALL_EXPR, gimple_call_num_args (stmt) + 3);
1870 CALL_EXPR_FN (exp) = gimple_call_fn (stmt);
1871 decl = gimple_call_fndecl (stmt);
1872 builtin_p = decl && DECL_BUILT_IN (decl);
1874 TREE_TYPE (exp) = gimple_call_return_type (stmt);
1875 CALL_EXPR_STATIC_CHAIN (exp) = gimple_call_chain (stmt);
1877 for (i = 0; i < gimple_call_num_args (stmt); i++)
1879 tree arg = gimple_call_arg (stmt, i);
1881 /* TER addresses into arguments of builtin functions so we have a
1882 chance to infer more correct alignment information. See PR39954. */
1884 && TREE_CODE (arg) == SSA_NAME
1885 && (def = get_gimple_for_ssa_name (arg))
1886 && gimple_assign_rhs_code (def) == ADDR_EXPR)
1887 arg = gimple_assign_rhs1 (def);
1888 CALL_EXPR_ARG (exp, i) = arg;
1891 if (gimple_has_side_effects (stmt))
1892 TREE_SIDE_EFFECTS (exp) = 1;
1894 if (gimple_call_nothrow_p (stmt))
1895 TREE_NOTHROW (exp) = 1;
1897 CALL_EXPR_TAILCALL (exp) = gimple_call_tail_p (stmt);
1898 CALL_EXPR_RETURN_SLOT_OPT (exp) = gimple_call_return_slot_opt_p (stmt);
1899 CALL_FROM_THUNK_P (exp) = gimple_call_from_thunk_p (stmt);
1900 CALL_CANNOT_INLINE_P (exp) = gimple_call_cannot_inline_p (stmt);
1901 CALL_EXPR_VA_ARG_PACK (exp) = gimple_call_va_arg_pack_p (stmt);
1902 SET_EXPR_LOCATION (exp, gimple_location (stmt));
1903 TREE_BLOCK (exp) = gimple_block (stmt);
1906 expand_assignment (lhs, exp, false);
1908 expand_expr_real_1 (exp, const0_rtx, VOIDmode, EXPAND_NORMAL, NULL);
1911 /* A subroutine of expand_gimple_stmt, expanding one gimple statement
1912 STMT that doesn't require special handling for outgoing edges. That
1913 is no tailcalls and no GIMPLE_COND. */
1916 expand_gimple_stmt_1 (gimple stmt)
1919 switch (gimple_code (stmt))
1922 op0 = gimple_goto_dest (stmt);
1923 if (TREE_CODE (op0) == LABEL_DECL)
1926 expand_computed_goto (op0);
1929 expand_label (gimple_label_label (stmt));
1932 case GIMPLE_PREDICT:
1938 expand_asm_stmt (stmt);
1941 expand_call_stmt (stmt);
1945 op0 = gimple_return_retval (stmt);
1947 if (op0 && op0 != error_mark_node)
1949 tree result = DECL_RESULT (current_function_decl);
1951 /* If we are not returning the current function's RESULT_DECL,
1952 build an assignment to it. */
1955 /* I believe that a function's RESULT_DECL is unique. */
1956 gcc_assert (TREE_CODE (op0) != RESULT_DECL);
1958 /* ??? We'd like to use simply expand_assignment here,
1959 but this fails if the value is of BLKmode but the return
1960 decl is a register. expand_return has special handling
1961 for this combination, which eventually should move
1962 to common code. See comments there. Until then, let's
1963 build a modify expression :-/ */
1964 op0 = build2 (MODIFY_EXPR, TREE_TYPE (result),
1969 expand_null_return ();
1971 expand_return (op0);
1976 tree lhs = gimple_assign_lhs (stmt);
1978 /* Tree expand used to fiddle with |= and &= of two bitfield
1979 COMPONENT_REFs here. This can't happen with gimple, the LHS
1980 of binary assigns must be a gimple reg. */
1982 if (TREE_CODE (lhs) != SSA_NAME
1983 || get_gimple_rhs_class (gimple_expr_code (stmt))
1984 == GIMPLE_SINGLE_RHS)
1986 tree rhs = gimple_assign_rhs1 (stmt);
1987 gcc_assert (get_gimple_rhs_class (gimple_expr_code (stmt))
1988 == GIMPLE_SINGLE_RHS);
1989 if (gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (rhs))
1990 SET_EXPR_LOCATION (rhs, gimple_location (stmt));
1991 expand_assignment (lhs, rhs,
1992 gimple_assign_nontemporal_move_p (stmt));
1997 bool nontemporal = gimple_assign_nontemporal_move_p (stmt);
1998 struct separate_ops ops;
1999 bool promoted = false;
2001 target = expand_expr (lhs, NULL_RTX, VOIDmode, EXPAND_WRITE);
2002 if (GET_CODE (target) == SUBREG && SUBREG_PROMOTED_VAR_P (target))
2005 ops.code = gimple_assign_rhs_code (stmt);
2006 ops.type = TREE_TYPE (lhs);
2007 switch (get_gimple_rhs_class (gimple_expr_code (stmt)))
2009 case GIMPLE_TERNARY_RHS:
2010 ops.op2 = gimple_assign_rhs3 (stmt);
2012 case GIMPLE_BINARY_RHS:
2013 ops.op1 = gimple_assign_rhs2 (stmt);
2015 case GIMPLE_UNARY_RHS:
2016 ops.op0 = gimple_assign_rhs1 (stmt);
2021 ops.location = gimple_location (stmt);
2023 /* If we want to use a nontemporal store, force the value to
2024 register first. If we store into a promoted register,
2025 don't directly expand to target. */
2026 temp = nontemporal || promoted ? NULL_RTX : target;
2027 temp = expand_expr_real_2 (&ops, temp, GET_MODE (target),
2034 int unsignedp = SUBREG_PROMOTED_UNSIGNED_P (target);
2035 /* If TEMP is a VOIDmode constant, use convert_modes to make
2036 sure that we properly convert it. */
2037 if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode)
2039 temp = convert_modes (GET_MODE (target),
2040 TYPE_MODE (ops.type),
2042 temp = convert_modes (GET_MODE (SUBREG_REG (target)),
2043 GET_MODE (target), temp, unsignedp);
2046 convert_move (SUBREG_REG (target), temp, unsignedp);
2048 else if (nontemporal && emit_storent_insn (target, temp))
2052 temp = force_operand (temp, target);
2054 emit_move_insn (target, temp);
2065 /* Expand one gimple statement STMT and return the last RTL instruction
2066 before any of the newly generated ones.
2068 In addition to generating the necessary RTL instructions this also
2069 sets REG_EH_REGION notes if necessary and sets the current source
2070 location for diagnostics. */
2073 expand_gimple_stmt (gimple stmt)
2077 location_t saved_location = input_location;
2079 last = get_last_insn ();
2081 /* If this is an expression of some kind and it has an associated line
2082 number, then emit the line number before expanding the expression.
2084 We need to save and restore the file and line information so that
2085 errors discovered during expansion are emitted with the right
2086 information. It would be better of the diagnostic routines
2087 used the file/line information embedded in the tree nodes rather
2091 if (gimple_has_location (stmt))
2093 input_location = gimple_location (stmt);
2094 set_curr_insn_source_location (input_location);
2096 /* Record where the insns produced belong. */
2097 set_curr_insn_block (gimple_block (stmt));
2100 expand_gimple_stmt_1 (stmt);
2101 /* Free any temporaries used to evaluate this statement. */
2104 input_location = saved_location;
2106 /* Mark all insns that may trap. */
2107 lp_nr = lookup_stmt_eh_lp (stmt);
2111 for (insn = next_real_insn (last); insn;
2112 insn = next_real_insn (insn))
2114 if (! find_reg_note (insn, REG_EH_REGION, NULL_RTX)
2115 /* If we want exceptions for non-call insns, any
2116 may_trap_p instruction may throw. */
2117 && GET_CODE (PATTERN (insn)) != CLOBBER
2118 && GET_CODE (PATTERN (insn)) != USE
2119 && insn_could_throw_p (insn))
2120 make_reg_eh_region_note (insn, 0, lp_nr);
2127 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_CALL
2128 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
2129 generated a tail call (something that might be denied by the ABI
2130 rules governing the call; see calls.c).
2132 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
2133 can still reach the rest of BB. The case here is __builtin_sqrt,
2134 where the NaN result goes through the external function (with a
2135 tailcall) and the normal result happens via a sqrt instruction. */
2138 expand_gimple_tailcall (basic_block bb, gimple stmt, bool *can_fallthru)
2146 last2 = last = expand_gimple_stmt (stmt);
2148 for (last = NEXT_INSN (last); last; last = NEXT_INSN (last))
2149 if (CALL_P (last) && SIBLING_CALL_P (last))
2152 maybe_dump_rtl_for_gimple_stmt (stmt, last2);
2154 *can_fallthru = true;
2158 /* ??? Wouldn't it be better to just reset any pending stack adjust?
2159 Any instructions emitted here are about to be deleted. */
2160 do_pending_stack_adjust ();
2162 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
2163 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
2164 EH or abnormal edges, we shouldn't have created a tail call in
2165 the first place. So it seems to me we should just be removing
2166 all edges here, or redirecting the existing fallthru edge to
2172 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
2174 if (!(e->flags & (EDGE_ABNORMAL | EDGE_EH)))
2176 if (e->dest != EXIT_BLOCK_PTR)
2178 e->dest->count -= e->count;
2179 e->dest->frequency -= EDGE_FREQUENCY (e);
2180 if (e->dest->count < 0)
2182 if (e->dest->frequency < 0)
2183 e->dest->frequency = 0;
2186 probability += e->probability;
2193 /* This is somewhat ugly: the call_expr expander often emits instructions
2194 after the sibcall (to perform the function return). These confuse the
2195 find_many_sub_basic_blocks code, so we need to get rid of these. */
2196 last = NEXT_INSN (last);
2197 gcc_assert (BARRIER_P (last));
2199 *can_fallthru = false;
2200 while (NEXT_INSN (last))
2202 /* For instance an sqrt builtin expander expands if with
2203 sibcall in the then and label for `else`. */
2204 if (LABEL_P (NEXT_INSN (last)))
2206 *can_fallthru = true;
2209 delete_insn (NEXT_INSN (last));
2212 e = make_edge (bb, EXIT_BLOCK_PTR, EDGE_ABNORMAL | EDGE_SIBCALL);
2213 e->probability += probability;
2216 update_bb_for_insn (bb);
2218 if (NEXT_INSN (last))
2220 bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
2223 if (BARRIER_P (last))
2224 BB_END (bb) = PREV_INSN (last);
2227 maybe_dump_rtl_for_gimple_stmt (stmt, last2);
2232 /* Return the difference between the floor and the truncated result of
2233 a signed division by OP1 with remainder MOD. */
2235 floor_sdiv_adjust (enum machine_mode mode, rtx mod, rtx op1)
2237 /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
2238 return gen_rtx_IF_THEN_ELSE
2239 (mode, gen_rtx_NE (BImode, mod, const0_rtx),
2240 gen_rtx_IF_THEN_ELSE
2241 (mode, gen_rtx_LT (BImode,
2242 gen_rtx_DIV (mode, op1, mod),
2244 constm1_rtx, const0_rtx),
2248 /* Return the difference between the ceil and the truncated result of
2249 a signed division by OP1 with remainder MOD. */
2251 ceil_sdiv_adjust (enum machine_mode mode, rtx mod, rtx op1)
2253 /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
2254 return gen_rtx_IF_THEN_ELSE
2255 (mode, gen_rtx_NE (BImode, mod, const0_rtx),
2256 gen_rtx_IF_THEN_ELSE
2257 (mode, gen_rtx_GT (BImode,
2258 gen_rtx_DIV (mode, op1, mod),
2260 const1_rtx, const0_rtx),
2264 /* Return the difference between the ceil and the truncated result of
2265 an unsigned division by OP1 with remainder MOD. */
2267 ceil_udiv_adjust (enum machine_mode mode, rtx mod, rtx op1 ATTRIBUTE_UNUSED)
2269 /* (mod != 0 ? 1 : 0) */
2270 return gen_rtx_IF_THEN_ELSE
2271 (mode, gen_rtx_NE (BImode, mod, const0_rtx),
2272 const1_rtx, const0_rtx);
2275 /* Return the difference between the rounded and the truncated result
2276 of a signed division by OP1 with remainder MOD. Halfway cases are
2277 rounded away from zero, rather than to the nearest even number. */
2279 round_sdiv_adjust (enum machine_mode mode, rtx mod, rtx op1)
2281 /* (abs (mod) >= abs (op1) - abs (mod)
2282 ? (op1 / mod > 0 ? 1 : -1)
2284 return gen_rtx_IF_THEN_ELSE
2285 (mode, gen_rtx_GE (BImode, gen_rtx_ABS (mode, mod),
2286 gen_rtx_MINUS (mode,
2287 gen_rtx_ABS (mode, op1),
2288 gen_rtx_ABS (mode, mod))),
2289 gen_rtx_IF_THEN_ELSE
2290 (mode, gen_rtx_GT (BImode,
2291 gen_rtx_DIV (mode, op1, mod),
2293 const1_rtx, constm1_rtx),
2297 /* Return the difference between the rounded and the truncated result
2298 of a unsigned division by OP1 with remainder MOD. Halfway cases
2299 are rounded away from zero, rather than to the nearest even
2302 round_udiv_adjust (enum machine_mode mode, rtx mod, rtx op1)
2304 /* (mod >= op1 - mod ? 1 : 0) */
2305 return gen_rtx_IF_THEN_ELSE
2306 (mode, gen_rtx_GE (BImode, mod,
2307 gen_rtx_MINUS (mode, op1, mod)),
2308 const1_rtx, const0_rtx);
2311 /* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
2315 convert_debug_memory_address (enum machine_mode mode, rtx x)
2317 enum machine_mode xmode = GET_MODE (x);
2319 #ifndef POINTERS_EXTEND_UNSIGNED
2320 gcc_assert (mode == Pmode);
2321 gcc_assert (xmode == mode || xmode == VOIDmode);
2323 gcc_assert (mode == Pmode || mode == ptr_mode);
2325 if (GET_MODE (x) == mode || GET_MODE (x) == VOIDmode)
2328 if (GET_MODE_BITSIZE (mode) < GET_MODE_BITSIZE (xmode))
2329 x = simplify_gen_subreg (mode, x, xmode,
2330 subreg_lowpart_offset
2332 else if (POINTERS_EXTEND_UNSIGNED > 0)
2333 x = gen_rtx_ZERO_EXTEND (mode, x);
2334 else if (!POINTERS_EXTEND_UNSIGNED)
2335 x = gen_rtx_SIGN_EXTEND (mode, x);
2338 #endif /* POINTERS_EXTEND_UNSIGNED */
2343 /* Return an RTX equivalent to the value of the tree expression
2347 expand_debug_expr (tree exp)
2349 rtx op0 = NULL_RTX, op1 = NULL_RTX, op2 = NULL_RTX;
2350 enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
2351 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (exp));
2354 switch (TREE_CODE_CLASS (TREE_CODE (exp)))
2356 case tcc_expression:
2357 switch (TREE_CODE (exp))
2361 case WIDEN_MULT_PLUS_EXPR:
2362 case WIDEN_MULT_MINUS_EXPR:
2366 case TRUTH_ANDIF_EXPR:
2367 case TRUTH_ORIF_EXPR:
2368 case TRUTH_AND_EXPR:
2370 case TRUTH_XOR_EXPR:
2373 case TRUTH_NOT_EXPR:
2382 op2 = expand_debug_expr (TREE_OPERAND (exp, 2));
2389 case tcc_comparison:
2390 op1 = expand_debug_expr (TREE_OPERAND (exp, 1));
2397 op0 = expand_debug_expr (TREE_OPERAND (exp, 0));
2407 case tcc_exceptional:
2408 case tcc_declaration:
2414 switch (TREE_CODE (exp))
2417 if (!lookup_constant_def (exp))
2419 if (strlen (TREE_STRING_POINTER (exp)) + 1
2420 != (size_t) TREE_STRING_LENGTH (exp))
2422 op0 = gen_rtx_CONST_STRING (Pmode, TREE_STRING_POINTER (exp));
2423 op0 = gen_rtx_MEM (BLKmode, op0);
2424 set_mem_attributes (op0, exp, 0);
2427 /* Fall through... */
2432 op0 = expand_expr (exp, NULL_RTX, mode, EXPAND_INITIALIZER);
2436 gcc_assert (COMPLEX_MODE_P (mode));
2437 op0 = expand_debug_expr (TREE_REALPART (exp));
2438 op1 = expand_debug_expr (TREE_IMAGPART (exp));
2439 return gen_rtx_CONCAT (mode, op0, op1);
2441 case DEBUG_EXPR_DECL:
2442 op0 = DECL_RTL_IF_SET (exp);
2447 op0 = gen_rtx_DEBUG_EXPR (mode);
2448 DEBUG_EXPR_TREE_DECL (op0) = exp;
2449 SET_DECL_RTL (exp, op0);
2459 op0 = DECL_RTL_IF_SET (exp);
2461 /* This decl was probably optimized away. */
2464 if (TREE_CODE (exp) != VAR_DECL
2465 || DECL_EXTERNAL (exp)
2466 || !TREE_STATIC (exp)
2468 || DECL_HARD_REGISTER (exp)
2469 || mode == VOIDmode)
2472 op0 = make_decl_rtl_for_debug (exp);
2474 || GET_CODE (XEXP (op0, 0)) != SYMBOL_REF
2475 || SYMBOL_REF_DECL (XEXP (op0, 0)) != exp)
2479 op0 = copy_rtx (op0);
2481 if (GET_MODE (op0) == BLKmode
2482 /* If op0 is not BLKmode, but BLKmode is, adjust_mode
2483 below would ICE. While it is likely a FE bug,
2484 try to be robust here. See PR43166. */
2486 || (mode == VOIDmode && GET_MODE (op0) != VOIDmode))
2488 gcc_assert (MEM_P (op0));
2489 op0 = adjust_address_nv (op0, mode, 0);
2500 enum machine_mode inner_mode = GET_MODE (op0);
2502 if (mode == inner_mode)
2505 if (inner_mode == VOIDmode)
2507 if (TREE_CODE (exp) == SSA_NAME)
2508 inner_mode = TYPE_MODE (TREE_TYPE (exp));
2510 inner_mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
2511 if (mode == inner_mode)
2515 if (FLOAT_MODE_P (mode) && FLOAT_MODE_P (inner_mode))
2517 if (GET_MODE_BITSIZE (mode) == GET_MODE_BITSIZE (inner_mode))
2518 op0 = simplify_gen_subreg (mode, op0, inner_mode, 0);
2519 else if (GET_MODE_BITSIZE (mode) < GET_MODE_BITSIZE (inner_mode))
2520 op0 = simplify_gen_unary (FLOAT_TRUNCATE, mode, op0, inner_mode);
2522 op0 = simplify_gen_unary (FLOAT_EXTEND, mode, op0, inner_mode);
2524 else if (FLOAT_MODE_P (mode))
2526 gcc_assert (TREE_CODE (exp) != SSA_NAME);
2527 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))))
2528 op0 = simplify_gen_unary (UNSIGNED_FLOAT, mode, op0, inner_mode);
2530 op0 = simplify_gen_unary (FLOAT, mode, op0, inner_mode);
2532 else if (FLOAT_MODE_P (inner_mode))
2535 op0 = simplify_gen_unary (UNSIGNED_FIX, mode, op0, inner_mode);
2537 op0 = simplify_gen_unary (FIX, mode, op0, inner_mode);
2539 else if (CONSTANT_P (op0)
2540 || GET_MODE_BITSIZE (mode) <= GET_MODE_BITSIZE (inner_mode))
2541 op0 = simplify_gen_subreg (mode, op0, inner_mode,
2542 subreg_lowpart_offset (mode,
2544 else if (TREE_CODE_CLASS (TREE_CODE (exp)) == tcc_unary
2545 ? TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)))
2547 op0 = gen_rtx_ZERO_EXTEND (mode, op0);
2549 op0 = gen_rtx_SIGN_EXTEND (mode, op0);
2556 op0 = expand_debug_expr (TREE_OPERAND (exp, 0));
2560 if (TREE_CODE (exp) == MEM_REF)
2562 op1 = expand_debug_expr (TREE_OPERAND (exp, 1));
2563 if (!op1 || !CONST_INT_P (op1))
2566 op0 = plus_constant (op0, INTVAL (op1));
2569 if (POINTER_TYPE_P (TREE_TYPE (exp)))
2570 as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp)));
2572 as = ADDR_SPACE_GENERIC;
2574 op0 = gen_rtx_MEM (mode, op0);
2576 set_mem_attributes (op0, exp, 0);
2577 set_mem_addr_space (op0, as);
2581 case TARGET_MEM_REF:
2582 if (TREE_CODE (TMR_BASE (exp)) == ADDR_EXPR
2583 && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp), 0)))
2586 op0 = expand_debug_expr
2587 (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp)), exp));
2591 as = TYPE_ADDR_SPACE (TREE_TYPE (exp));
2593 op0 = gen_rtx_MEM (mode, op0);
2595 set_mem_attributes (op0, exp, 0);
2596 set_mem_addr_space (op0, as);
2601 case ARRAY_RANGE_REF:
2606 case VIEW_CONVERT_EXPR:
2608 enum machine_mode mode1;
2609 HOST_WIDE_INT bitsize, bitpos;
2612 tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset,
2613 &mode1, &unsignedp, &volatilep, false);
2619 orig_op0 = op0 = expand_debug_expr (tem);
2626 enum machine_mode addrmode, offmode;
2631 op0 = XEXP (op0, 0);
2632 addrmode = GET_MODE (op0);
2633 if (addrmode == VOIDmode)
2636 op1 = expand_debug_expr (offset);
2640 offmode = GET_MODE (op1);
2641 if (offmode == VOIDmode)
2642 offmode = TYPE_MODE (TREE_TYPE (offset));
2644 if (addrmode != offmode)
2645 op1 = simplify_gen_subreg (addrmode, op1, offmode,
2646 subreg_lowpart_offset (addrmode,
2649 /* Don't use offset_address here, we don't need a
2650 recognizable address, and we don't want to generate
2652 op0 = gen_rtx_MEM (mode, gen_rtx_PLUS (addrmode, op0, op1));
2657 if (mode1 == VOIDmode)
2659 mode1 = smallest_mode_for_size (bitsize, MODE_INT);
2660 if (bitpos >= BITS_PER_UNIT)
2662 op0 = adjust_address_nv (op0, mode1, bitpos / BITS_PER_UNIT);
2663 bitpos %= BITS_PER_UNIT;
2665 else if (bitpos < 0)
2668 = (-bitpos + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
2669 op0 = adjust_address_nv (op0, mode1, units);
2670 bitpos += units * BITS_PER_UNIT;
2672 else if (bitpos == 0 && bitsize == GET_MODE_BITSIZE (mode))
2673 op0 = adjust_address_nv (op0, mode, 0);
2674 else if (GET_MODE (op0) != mode1)
2675 op0 = adjust_address_nv (op0, mode1, 0);
2677 op0 = copy_rtx (op0);
2678 if (op0 == orig_op0)
2679 op0 = shallow_copy_rtx (op0);
2680 set_mem_attributes (op0, exp, 0);
2683 if (bitpos == 0 && mode == GET_MODE (op0))
2689 if (GET_MODE (op0) == BLKmode)
2692 if ((bitpos % BITS_PER_UNIT) == 0
2693 && bitsize == GET_MODE_BITSIZE (mode1))
2695 enum machine_mode opmode = GET_MODE (op0);
2697 if (opmode == VOIDmode)
2700 /* This condition may hold if we're expanding the address
2701 right past the end of an array that turned out not to
2702 be addressable (i.e., the address was only computed in
2703 debug stmts). The gen_subreg below would rightfully
2704 crash, and the address doesn't really exist, so just
2706 if (bitpos >= GET_MODE_BITSIZE (opmode))
2709 if ((bitpos % GET_MODE_BITSIZE (mode)) == 0)
2710 return simplify_gen_subreg (mode, op0, opmode,
2711 bitpos / BITS_PER_UNIT);
2714 return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0))
2715 && TYPE_UNSIGNED (TREE_TYPE (exp))
2717 : ZERO_EXTRACT, mode,
2718 GET_MODE (op0) != VOIDmode
2719 ? GET_MODE (op0) : mode1,
2720 op0, GEN_INT (bitsize), GEN_INT (bitpos));
2724 return gen_rtx_ABS (mode, op0);
2727 return gen_rtx_NEG (mode, op0);
2730 return gen_rtx_NOT (mode, op0);
2734 return gen_rtx_UNSIGNED_FLOAT (mode, op0);
2736 return gen_rtx_FLOAT (mode, op0);
2738 case FIX_TRUNC_EXPR:
2740 return gen_rtx_UNSIGNED_FIX (mode, op0);
2742 return gen_rtx_FIX (mode, op0);
2744 case POINTER_PLUS_EXPR:
2745 /* For the rare target where pointers are not the same size as
2746 size_t, we need to check for mis-matched modes and correct
2749 && GET_MODE (op0) != VOIDmode && GET_MODE (op1) != VOIDmode
2750 && GET_MODE (op0) != GET_MODE (op1))
2752 if (GET_MODE_BITSIZE (GET_MODE (op0)) < GET_MODE_BITSIZE (GET_MODE (op1)))
2753 op1 = gen_rtx_TRUNCATE (GET_MODE (op0), op1);
2755 /* We always sign-extend, regardless of the signedness of
2756 the operand, because the operand is always unsigned
2757 here even if the original C expression is signed. */
2758 op1 = gen_rtx_SIGN_EXTEND (GET_MODE (op0), op1);
2762 return gen_rtx_PLUS (mode, op0, op1);
2765 return gen_rtx_MINUS (mode, op0, op1);
2768 return gen_rtx_MULT (mode, op0, op1);
2771 case TRUNC_DIV_EXPR:
2772 case EXACT_DIV_EXPR:
2774 return gen_rtx_UDIV (mode, op0, op1);
2776 return gen_rtx_DIV (mode, op0, op1);
2778 case TRUNC_MOD_EXPR:
2780 return gen_rtx_UMOD (mode, op0, op1);
2782 return gen_rtx_MOD (mode, op0, op1);
2784 case FLOOR_DIV_EXPR:
2786 return gen_rtx_UDIV (mode, op0, op1);
2789 rtx div = gen_rtx_DIV (mode, op0, op1);
2790 rtx mod = gen_rtx_MOD (mode, op0, op1);
2791 rtx adj = floor_sdiv_adjust (mode, mod, op1);
2792 return gen_rtx_PLUS (mode, div, adj);
2795 case FLOOR_MOD_EXPR:
2797 return gen_rtx_UMOD (mode, op0, op1);
2800 rtx mod = gen_rtx_MOD (mode, op0, op1);
2801 rtx adj = floor_sdiv_adjust (mode, mod, op1);
2802 adj = gen_rtx_NEG (mode, gen_rtx_MULT (mode, adj, op1));
2803 return gen_rtx_PLUS (mode, mod, adj);
2809 rtx div = gen_rtx_UDIV (mode, op0, op1);
2810 rtx mod = gen_rtx_UMOD (mode, op0, op1);
2811 rtx adj = ceil_udiv_adjust (mode, mod, op1);
2812 return gen_rtx_PLUS (mode, div, adj);
2816 rtx div = gen_rtx_DIV (mode, op0, op1);
2817 rtx mod = gen_rtx_MOD (mode, op0, op1);
2818 rtx adj = ceil_sdiv_adjust (mode, mod, op1);
2819 return gen_rtx_PLUS (mode, div, adj);
2825 rtx mod = gen_rtx_UMOD (mode, op0, op1);
2826 rtx adj = ceil_udiv_adjust (mode, mod, op1);
2827 adj = gen_rtx_NEG (mode, gen_rtx_MULT (mode, adj, op1));
2828 return gen_rtx_PLUS (mode, mod, adj);
2832 rtx mod = gen_rtx_MOD (mode, op0, op1);
2833 rtx adj = ceil_sdiv_adjust (mode, mod, op1);
2834 adj = gen_rtx_NEG (mode, gen_rtx_MULT (mode, adj, op1));
2835 return gen_rtx_PLUS (mode, mod, adj);
2838 case ROUND_DIV_EXPR:
2841 rtx div = gen_rtx_UDIV (mode, op0, op1);
2842 rtx mod = gen_rtx_UMOD (mode, op0, op1);
2843 rtx adj = round_udiv_adjust (mode, mod, op1);
2844 return gen_rtx_PLUS (mode, div, adj);
2848 rtx div = gen_rtx_DIV (mode, op0, op1);
2849 rtx mod = gen_rtx_MOD (mode, op0, op1);
2850 rtx adj = round_sdiv_adjust (mode, mod, op1);
2851 return gen_rtx_PLUS (mode, div, adj);
2854 case ROUND_MOD_EXPR:
2857 rtx mod = gen_rtx_UMOD (mode, op0, op1);
2858 rtx adj = round_udiv_adjust (mode, mod, op1);
2859 adj = gen_rtx_NEG (mode, gen_rtx_MULT (mode, adj, op1));
2860 return gen_rtx_PLUS (mode, mod, adj);
2864 rtx mod = gen_rtx_MOD (mode, op0, op1);
2865 rtx adj = round_sdiv_adjust (mode, mod, op1);
2866 adj = gen_rtx_NEG (mode, gen_rtx_MULT (mode, adj, op1));
2867 return gen_rtx_PLUS (mode, mod, adj);
2871 return gen_rtx_ASHIFT (mode, op0, op1);
2875 return gen_rtx_LSHIFTRT (mode, op0, op1);
2877 return gen_rtx_ASHIFTRT (mode, op0, op1);
2880 return gen_rtx_ROTATE (mode, op0, op1);
2883 return gen_rtx_ROTATERT (mode, op0, op1);
2887 return gen_rtx_UMIN (mode, op0, op1);
2889 return gen_rtx_SMIN (mode, op0, op1);
2893 return gen_rtx_UMAX (mode, op0, op1);
2895 return gen_rtx_SMAX (mode, op0, op1);
2898 case TRUTH_AND_EXPR:
2899 return gen_rtx_AND (mode, op0, op1);
2903 return gen_rtx_IOR (mode, op0, op1);
2906 case TRUTH_XOR_EXPR:
2907 return gen_rtx_XOR (mode, op0, op1);
2909 case TRUTH_ANDIF_EXPR:
2910 return gen_rtx_IF_THEN_ELSE (mode, op0, op1, const0_rtx);
2912 case TRUTH_ORIF_EXPR:
2913 return gen_rtx_IF_THEN_ELSE (mode, op0, const_true_rtx, op1);
2915 case TRUTH_NOT_EXPR:
2916 return gen_rtx_EQ (mode, op0, const0_rtx);
2920 return gen_rtx_LTU (mode, op0, op1);
2922 return gen_rtx_LT (mode, op0, op1);
2926 return gen_rtx_LEU (mode, op0, op1);
2928 return gen_rtx_LE (mode, op0, op1);
2932 return gen_rtx_GTU (mode, op0, op1);
2934 return gen_rtx_GT (mode, op0, op1);
2938 return gen_rtx_GEU (mode, op0, op1);
2940 return gen_rtx_GE (mode, op0, op1);
2943 return gen_rtx_EQ (mode, op0, op1);
2946 return gen_rtx_NE (mode, op0, op1);
2948 case UNORDERED_EXPR:
2949 return gen_rtx_UNORDERED (mode, op0, op1);
2952 return gen_rtx_ORDERED (mode, op0, op1);
2955 return gen_rtx_UNLT (mode, op0, op1);
2958 return gen_rtx_UNLE (mode, op0, op1);
2961 return gen_rtx_UNGT (mode, op0, op1);
2964 return gen_rtx_UNGE (mode, op0, op1);
2967 return gen_rtx_UNEQ (mode, op0, op1);
2970 return gen_rtx_LTGT (mode, op0, op1);
2973 return gen_rtx_IF_THEN_ELSE (mode, op0, op1, op2);
2976 gcc_assert (COMPLEX_MODE_P (mode));
2977 if (GET_MODE (op0) == VOIDmode)
2978 op0 = gen_rtx_CONST (GET_MODE_INNER (mode), op0);
2979 if (GET_MODE (op1) == VOIDmode)
2980 op1 = gen_rtx_CONST (GET_MODE_INNER (mode), op1);
2981 return gen_rtx_CONCAT (mode, op0, op1);
2984 if (GET_CODE (op0) == CONCAT)
2985 return gen_rtx_CONCAT (mode, XEXP (op0, 0),
2986 gen_rtx_NEG (GET_MODE_INNER (mode),
2990 enum machine_mode imode = GET_MODE_INNER (mode);
2995 re = adjust_address_nv (op0, imode, 0);
2996 im = adjust_address_nv (op0, imode, GET_MODE_SIZE (imode));
3000 enum machine_mode ifmode = int_mode_for_mode (mode);
3001 enum machine_mode ihmode = int_mode_for_mode (imode);
3003 if (ifmode == BLKmode || ihmode == BLKmode)
3005 halfsize = GEN_INT (GET_MODE_BITSIZE (ihmode));
3008 re = gen_rtx_SUBREG (ifmode, re, 0);
3009 re = gen_rtx_ZERO_EXTRACT (ihmode, re, halfsize, const0_rtx);
3010 if (imode != ihmode)
3011 re = gen_rtx_SUBREG (imode, re, 0);
3012 im = copy_rtx (op0);
3014 im = gen_rtx_SUBREG (ifmode, im, 0);
3015 im = gen_rtx_ZERO_EXTRACT (ihmode, im, halfsize, halfsize);
3016 if (imode != ihmode)
3017 im = gen_rtx_SUBREG (imode, im, 0);
3019 im = gen_rtx_NEG (imode, im);
3020 return gen_rtx_CONCAT (mode, re, im);
3024 op0 = expand_debug_expr (TREE_OPERAND (exp, 0));
3025 if (!op0 || !MEM_P (op0))
3027 if ((TREE_CODE (TREE_OPERAND (exp, 0)) == VAR_DECL
3028 || TREE_CODE (TREE_OPERAND (exp, 0)) == PARM_DECL
3029 || TREE_CODE (TREE_OPERAND (exp, 0)) == RESULT_DECL)
3030 && !TREE_ADDRESSABLE (TREE_OPERAND (exp, 0)))
3031 return gen_rtx_DEBUG_IMPLICIT_PTR (mode, TREE_OPERAND (exp, 0));
3033 if (handled_component_p (TREE_OPERAND (exp, 0)))
3035 HOST_WIDE_INT bitoffset, bitsize, maxsize;
3037 = get_ref_base_and_extent (TREE_OPERAND (exp, 0),
3038 &bitoffset, &bitsize, &maxsize);
3039 if ((TREE_CODE (decl) == VAR_DECL
3040 || TREE_CODE (decl) == PARM_DECL
3041 || TREE_CODE (decl) == RESULT_DECL)
3042 && !TREE_ADDRESSABLE (decl)
3043 && (bitoffset % BITS_PER_UNIT) == 0
3045 && bitsize == maxsize)
3046 return plus_constant (gen_rtx_DEBUG_IMPLICIT_PTR (mode, decl),
3047 bitoffset / BITS_PER_UNIT);
3053 op0 = convert_debug_memory_address (mode, XEXP (op0, 0));
3058 exp = build_constructor_from_list (TREE_TYPE (exp),
3059 TREE_VECTOR_CST_ELTS (exp));
3063 if (TREE_CODE (TREE_TYPE (exp)) == VECTOR_TYPE)
3068 op0 = gen_rtx_CONCATN
3069 (mode, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp))));
3071 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), i, val)
3073 op1 = expand_debug_expr (val);
3076 XVECEXP (op0, 0, i) = op1;
3079 if (i < TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp)))
3081 op1 = expand_debug_expr
3082 (build_zero_cst (TREE_TYPE (TREE_TYPE (exp))));
3087 for (; i < TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp)); i++)
3088 XVECEXP (op0, 0, i) = op1;
3094 goto flag_unsupported;
3097 /* ??? Maybe handle some builtins? */
3102 gimple g = get_gimple_for_ssa_name (exp);
3105 op0 = expand_debug_expr (gimple_assign_rhs_to_tree (g));
3111 int part = var_to_partition (SA.map, exp);
3113 if (part == NO_PARTITION)
3116 gcc_assert (part >= 0 && (unsigned)part < SA.map->num_partitions);
3118 op0 = SA.partition_to_pseudo[part];
3126 /* Vector stuff. For most of the codes we don't have rtl codes. */
3127 case REALIGN_LOAD_EXPR:
3128 case REDUC_MAX_EXPR:
3129 case REDUC_MIN_EXPR:
3130 case REDUC_PLUS_EXPR:
3132 case VEC_EXTRACT_EVEN_EXPR:
3133 case VEC_EXTRACT_ODD_EXPR:
3134 case VEC_INTERLEAVE_HIGH_EXPR:
3135 case VEC_INTERLEAVE_LOW_EXPR:
3136 case VEC_LSHIFT_EXPR:
3137 case VEC_PACK_FIX_TRUNC_EXPR:
3138 case VEC_PACK_SAT_EXPR:
3139 case VEC_PACK_TRUNC_EXPR:
3140 case VEC_RSHIFT_EXPR:
3141 case VEC_UNPACK_FLOAT_HI_EXPR:
3142 case VEC_UNPACK_FLOAT_LO_EXPR:
3143 case VEC_UNPACK_HI_EXPR:
3144 case VEC_UNPACK_LO_EXPR:
3145 case VEC_WIDEN_MULT_HI_EXPR:
3146 case VEC_WIDEN_MULT_LO_EXPR:
3150 case ADDR_SPACE_CONVERT_EXPR:
3151 case FIXED_CONVERT_EXPR:
3153 case WITH_SIZE_EXPR:
3157 if (SCALAR_INT_MODE_P (GET_MODE (op0))
3158 && SCALAR_INT_MODE_P (mode))
3160 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))))
3161 op0 = gen_rtx_ZERO_EXTEND (mode, op0);
3163 op0 = gen_rtx_SIGN_EXTEND (mode, op0);
3164 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 1))))
3165 op1 = gen_rtx_ZERO_EXTEND (mode, op1);
3167 op1 = gen_rtx_SIGN_EXTEND (mode, op1);
3168 op0 = gen_rtx_MULT (mode, op0, op1);
3169 return gen_rtx_PLUS (mode, op0, op2);
3173 case WIDEN_MULT_EXPR:
3174 case WIDEN_MULT_PLUS_EXPR:
3175 case WIDEN_MULT_MINUS_EXPR:
3176 if (SCALAR_INT_MODE_P (GET_MODE (op0))
3177 && SCALAR_INT_MODE_P (mode))
3179 enum machine_mode inner_mode = GET_MODE (op0);
3180 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))))
3181 op0 = simplify_gen_unary (ZERO_EXTEND, mode, op0, inner_mode);
3183 op0 = simplify_gen_unary (SIGN_EXTEND, mode, op0, inner_mode);
3184 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 1))))
3185 op1 = simplify_gen_unary (ZERO_EXTEND, mode, op1, inner_mode);
3187 op1 = simplify_gen_unary (SIGN_EXTEND, mode, op1, inner_mode);
3188 op0 = gen_rtx_MULT (mode, op0, op1);
3189 if (TREE_CODE (exp) == WIDEN_MULT_EXPR)
3191 else if (TREE_CODE (exp) == WIDEN_MULT_PLUS_EXPR)
3192 return gen_rtx_PLUS (mode, op0, op2);
3194 return gen_rtx_MINUS (mode, op2, op0);
3198 case WIDEN_SUM_EXPR:
3199 if (SCALAR_INT_MODE_P (GET_MODE (op0))
3200 && SCALAR_INT_MODE_P (mode))
3202 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))))
3203 op0 = gen_rtx_ZERO_EXTEND (mode, op0);
3205 op0 = gen_rtx_SIGN_EXTEND (mode, op0);
3206 return gen_rtx_PLUS (mode, op0, op1);
3211 return gen_rtx_FMA (mode, op0, op1, op2);
3215 #ifdef ENABLE_CHECKING
3224 /* Expand the _LOCs in debug insns. We run this after expanding all
3225 regular insns, so that any variables referenced in the function
3226 will have their DECL_RTLs set. */
3229 expand_debug_locations (void)
3232 rtx last = get_last_insn ();
3233 int save_strict_alias = flag_strict_aliasing;
3235 /* New alias sets while setting up memory attributes cause
3236 -fcompare-debug failures, even though it doesn't bring about any
3238 flag_strict_aliasing = 0;
3240 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3241 if (DEBUG_INSN_P (insn))
3243 tree value = (tree)INSN_VAR_LOCATION_LOC (insn);
3245 enum machine_mode mode;
3247 if (value == NULL_TREE)
3251 val = expand_debug_expr (value);
3252 gcc_assert (last == get_last_insn ());
3256 val = gen_rtx_UNKNOWN_VAR_LOC ();
3259 mode = GET_MODE (INSN_VAR_LOCATION (insn));
3261 gcc_assert (mode == GET_MODE (val)
3262 || (GET_MODE (val) == VOIDmode
3263 && (CONST_INT_P (val)
3264 || GET_CODE (val) == CONST_FIXED
3265 || GET_CODE (val) == CONST_DOUBLE
3266 || GET_CODE (val) == LABEL_REF)));
3269 INSN_VAR_LOCATION_LOC (insn) = val;
3272 flag_strict_aliasing = save_strict_alias;
3275 /* Expand basic block BB from GIMPLE trees to RTL. */
3278 expand_gimple_basic_block (basic_block bb)
3280 gimple_stmt_iterator gsi;
3289 fprintf (dump_file, "\n;; Generating RTL for gimple basic block %d\n",
3292 /* Note that since we are now transitioning from GIMPLE to RTL, we
3293 cannot use the gsi_*_bb() routines because they expect the basic
3294 block to be in GIMPLE, instead of RTL. Therefore, we need to
3295 access the BB sequence directly. */
3296 stmts = bb_seq (bb);
3297 bb->il.gimple = NULL;
3298 rtl_profile_for_bb (bb);
3299 init_rtl_bb_info (bb);
3300 bb->flags |= BB_RTL;
3302 /* Remove the RETURN_EXPR if we may fall though to the exit
3304 gsi = gsi_last (stmts);
3305 if (!gsi_end_p (gsi)
3306 && gimple_code (gsi_stmt (gsi)) == GIMPLE_RETURN)
3308 gimple ret_stmt = gsi_stmt (gsi);
3310 gcc_assert (single_succ_p (bb));
3311 gcc_assert (single_succ (bb) == EXIT_BLOCK_PTR);
3313 if (bb->next_bb == EXIT_BLOCK_PTR
3314 && !gimple_return_retval (ret_stmt))
3316 gsi_remove (&gsi, false);
3317 single_succ_edge (bb)->flags |= EDGE_FALLTHRU;
3321 gsi = gsi_start (stmts);
3322 if (!gsi_end_p (gsi))
3324 stmt = gsi_stmt (gsi);
3325 if (gimple_code (stmt) != GIMPLE_LABEL)
3329 elt = pointer_map_contains (lab_rtx_for_bb, bb);
3333 last = get_last_insn ();
3337 expand_gimple_stmt (stmt);
3342 emit_label ((rtx) *elt);
3344 /* Java emits line number notes in the top of labels.
3345 ??? Make this go away once line number notes are obsoleted. */
3346 BB_HEAD (bb) = NEXT_INSN (last);
3347 if (NOTE_P (BB_HEAD (bb)))
3348 BB_HEAD (bb) = NEXT_INSN (BB_HEAD (bb));
3349 note = emit_note_after (NOTE_INSN_BASIC_BLOCK, BB_HEAD (bb));
3351 maybe_dump_rtl_for_gimple_stmt (stmt, last);
3354 note = BB_HEAD (bb) = emit_note (NOTE_INSN_BASIC_BLOCK);
3356 NOTE_BASIC_BLOCK (note) = bb;
3358 for (; !gsi_end_p (gsi); gsi_next (&gsi))
3362 stmt = gsi_stmt (gsi);
3364 /* If this statement is a non-debug one, and we generate debug
3365 insns, then this one might be the last real use of a TERed
3366 SSA_NAME, but where there are still some debug uses further
3367 down. Expanding the current SSA name in such further debug
3368 uses by their RHS might lead to wrong debug info, as coalescing
3369 might make the operands of such RHS be placed into the same
3370 pseudo as something else. Like so:
3371 a_1 = a_0 + 1; // Assume a_1 is TERed and a_0 is dead
3375 As a_0 and a_2 don't overlap in lifetime, assume they are coalesced.
3376 If we now would expand a_1 by it's RHS (a_0 + 1) in the debug use,
3377 the write to a_2 would actually have clobbered the place which
3380 So, instead of that, we recognize the situation, and generate
3381 debug temporaries at the last real use of TERed SSA names:
3388 if (MAY_HAVE_DEBUG_INSNS
3390 && !is_gimple_debug (stmt))
3396 location_t sloc = get_curr_insn_source_location ();
3397 tree sblock = get_curr_insn_block ();
3399 /* Look for SSA names that have their last use here (TERed
3400 names always have only one real use). */
3401 FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
3402 if ((def = get_gimple_for_ssa_name (op)))
3404 imm_use_iterator imm_iter;
3405 use_operand_p use_p;
3406 bool have_debug_uses = false;
3408 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, op)
3410 if (gimple_debug_bind_p (USE_STMT (use_p)))
3412 have_debug_uses = true;
3417 if (have_debug_uses)
3419 /* OP is a TERed SSA name, with DEF it's defining
3420 statement, and where OP is used in further debug
3421 instructions. Generate a debug temporary, and
3422 replace all uses of OP in debug insns with that
3425 tree value = gimple_assign_rhs_to_tree (def);
3426 tree vexpr = make_node (DEBUG_EXPR_DECL);
3428 enum machine_mode mode;
3430 set_curr_insn_source_location (gimple_location (def));
3431 set_curr_insn_block (gimple_block (def));
3433 DECL_ARTIFICIAL (vexpr) = 1;
3434 TREE_TYPE (vexpr) = TREE_TYPE (value);
3436 mode = DECL_MODE (value);
3438 mode = TYPE_MODE (TREE_TYPE (value));
3439 DECL_MODE (vexpr) = mode;
3441 val = gen_rtx_VAR_LOCATION
3442 (mode, vexpr, (rtx)value, VAR_INIT_STATUS_INITIALIZED);
3444 val = emit_debug_insn (val);
3446 FOR_EACH_IMM_USE_STMT (debugstmt, imm_iter, op)
3448 if (!gimple_debug_bind_p (debugstmt))
3451 FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter)
3452 SET_USE (use_p, vexpr);
3454 update_stmt (debugstmt);
3458 set_curr_insn_source_location (sloc);
3459 set_curr_insn_block (sblock);
3462 currently_expanding_gimple_stmt = stmt;
3464 /* Expand this statement, then evaluate the resulting RTL and
3465 fixup the CFG accordingly. */
3466 if (gimple_code (stmt) == GIMPLE_COND)
3468 new_bb = expand_gimple_cond (bb, stmt);
3472 else if (gimple_debug_bind_p (stmt))
3474 location_t sloc = get_curr_insn_source_location ();
3475 tree sblock = get_curr_insn_block ();
3476 gimple_stmt_iterator nsi = gsi;
3480 tree var = gimple_debug_bind_get_var (stmt);
3483 enum machine_mode mode;
3485 if (gimple_debug_bind_has_value_p (stmt))
3486 value = gimple_debug_bind_get_value (stmt);
3490 last = get_last_insn ();
3492 set_curr_insn_source_location (gimple_location (stmt));
3493 set_curr_insn_block (gimple_block (stmt));
3496 mode = DECL_MODE (var);
3498 mode = TYPE_MODE (TREE_TYPE (var));
3500 val = gen_rtx_VAR_LOCATION
3501 (mode, var, (rtx)value, VAR_INIT_STATUS_INITIALIZED);
3503 val = emit_debug_insn (val);
3505 if (dump_file && (dump_flags & TDF_DETAILS))
3507 /* We can't dump the insn with a TREE where an RTX
3509 INSN_VAR_LOCATION_LOC (val) = const0_rtx;
3510 maybe_dump_rtl_for_gimple_stmt (stmt, last);
3511 INSN_VAR_LOCATION_LOC (val) = (rtx)value;
3514 /* In order not to generate too many debug temporaries,
3515 we delink all uses of debug statements we already expanded.
3516 Therefore debug statements between definition and real
3517 use of TERed SSA names will continue to use the SSA name,
3518 and not be replaced with debug temps. */
3519 delink_stmt_imm_use (stmt);
3523 if (gsi_end_p (nsi))
3525 stmt = gsi_stmt (nsi);
3526 if (!gimple_debug_bind_p (stmt))
3530 set_curr_insn_source_location (sloc);
3531 set_curr_insn_block (sblock);
3535 if (is_gimple_call (stmt) && gimple_call_tail_p (stmt))
3538 new_bb = expand_gimple_tailcall (bb, stmt, &can_fallthru);
3549 def_operand_p def_p;
3550 def_p = SINGLE_SSA_DEF_OPERAND (stmt, SSA_OP_DEF);
3554 /* Ignore this stmt if it is in the list of
3555 replaceable expressions. */
3557 && bitmap_bit_p (SA.values,
3558 SSA_NAME_VERSION (DEF_FROM_PTR (def_p))))
3561 last = expand_gimple_stmt (stmt);
3562 maybe_dump_rtl_for_gimple_stmt (stmt, last);
3567 currently_expanding_gimple_stmt = NULL;
3569 /* Expand implicit goto and convert goto_locus. */
3570 FOR_EACH_EDGE (e, ei, bb->succs)
3572 if (e->goto_locus && e->goto_block)
3574 set_curr_insn_source_location (e->goto_locus);
3575 set_curr_insn_block (e->goto_block);
3576 e->goto_locus = curr_insn_locator ();
3578 e->goto_block = NULL;
3579 if ((e->flags & EDGE_FALLTHRU) && e->dest != bb->next_bb)
3581 emit_jump (label_rtx_for_bb (e->dest));
3582 e->flags &= ~EDGE_FALLTHRU;
3586 /* Expanded RTL can create a jump in the last instruction of block.
3587 This later might be assumed to be a jump to successor and break edge insertion.
3588 We need to insert dummy move to prevent this. PR41440. */
3589 if (single_succ_p (bb)
3590 && (single_succ_edge (bb)->flags & EDGE_FALLTHRU)
3591 && (last = get_last_insn ())
3594 rtx dummy = gen_reg_rtx (SImode);
3595 emit_insn_after_noloc (gen_move_insn (dummy, dummy), last, NULL);
3598 do_pending_stack_adjust ();
3600 /* Find the block tail. The last insn in the block is the insn
3601 before a barrier and/or table jump insn. */
3602 last = get_last_insn ();
3603 if (BARRIER_P (last))
3604 last = PREV_INSN (last);
3605 if (JUMP_TABLE_DATA_P (last))
3606 last = PREV_INSN (PREV_INSN (last));
3609 update_bb_for_insn (bb);
3615 /* Create a basic block for initialization code. */
3618 construct_init_block (void)
3620 basic_block init_block, first_block;
3624 /* Multiple entry points not supported yet. */
3625 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR->succs) == 1);
3626 init_rtl_bb_info (ENTRY_BLOCK_PTR);
3627 init_rtl_bb_info (EXIT_BLOCK_PTR);
3628 ENTRY_BLOCK_PTR->flags |= BB_RTL;
3629 EXIT_BLOCK_PTR->flags |= BB_RTL;
3631 e = EDGE_SUCC (ENTRY_BLOCK_PTR, 0);
3633 /* When entry edge points to first basic block, we don't need jump,
3634 otherwise we have to jump into proper target. */
3635 if (e && e->dest != ENTRY_BLOCK_PTR->next_bb)
3637 tree label = gimple_block_label (e->dest);
3639 emit_jump (label_rtx (label));
3643 flags = EDGE_FALLTHRU;
3645 init_block = create_basic_block (NEXT_INSN (get_insns ()),
3648 init_block->frequency = ENTRY_BLOCK_PTR->frequency;
3649 init_block->count = ENTRY_BLOCK_PTR->count;
3652 first_block = e->dest;
3653 redirect_edge_succ (e, init_block);
3654 e = make_edge (init_block, first_block, flags);
3657 e = make_edge (init_block, EXIT_BLOCK_PTR, EDGE_FALLTHRU);
3658 e->probability = REG_BR_PROB_BASE;
3659 e->count = ENTRY_BLOCK_PTR->count;
3661 update_bb_for_insn (init_block);
3665 /* For each lexical block, set BLOCK_NUMBER to the depth at which it is
3666 found in the block tree. */
3669 set_block_levels (tree block, int level)
3673 BLOCK_NUMBER (block) = level;
3674 set_block_levels (BLOCK_SUBBLOCKS (block), level + 1);
3675 block = BLOCK_CHAIN (block);
3679 /* Create a block containing landing pads and similar stuff. */
3682 construct_exit_block (void)
3684 rtx head = get_last_insn ();
3686 basic_block exit_block;
3690 rtx orig_end = BB_END (EXIT_BLOCK_PTR->prev_bb);
3692 rtl_profile_for_bb (EXIT_BLOCK_PTR);
3694 /* Make sure the locus is set to the end of the function, so that
3695 epilogue line numbers and warnings are set properly. */
3696 if (cfun->function_end_locus != UNKNOWN_LOCATION)
3697 input_location = cfun->function_end_locus;
3699 /* The following insns belong to the top scope. */
3700 set_curr_insn_block (DECL_INITIAL (current_function_decl));
3702 /* Generate rtl for function exit. */
3703 expand_function_end ();
3705 end = get_last_insn ();
3708 /* While emitting the function end we could move end of the last basic block.
3710 BB_END (EXIT_BLOCK_PTR->prev_bb) = orig_end;
3711 while (NEXT_INSN (head) && NOTE_P (NEXT_INSN (head)))
3712 head = NEXT_INSN (head);
3713 exit_block = create_basic_block (NEXT_INSN (head), end,
3714 EXIT_BLOCK_PTR->prev_bb);
3715 exit_block->frequency = EXIT_BLOCK_PTR->frequency;
3716 exit_block->count = EXIT_BLOCK_PTR->count;
3719 while (ix < EDGE_COUNT (EXIT_BLOCK_PTR->preds))
3721 e = EDGE_PRED (EXIT_BLOCK_PTR, ix);
3722 if (!(e->flags & EDGE_ABNORMAL))
3723 redirect_edge_succ (e, exit_block);
3728 e = make_edge (exit_block, EXIT_BLOCK_PTR, EDGE_FALLTHRU);
3729 e->probability = REG_BR_PROB_BASE;
3730 e->count = EXIT_BLOCK_PTR->count;
3731 FOR_EACH_EDGE (e2, ei, EXIT_BLOCK_PTR->preds)
3734 e->count -= e2->count;
3735 exit_block->count -= e2->count;
3736 exit_block->frequency -= EDGE_FREQUENCY (e2);
3740 if (exit_block->count < 0)
3741 exit_block->count = 0;
3742 if (exit_block->frequency < 0)
3743 exit_block->frequency = 0;
3744 update_bb_for_insn (exit_block);
3747 /* Helper function for discover_nonconstant_array_refs.
3748 Look for ARRAY_REF nodes with non-constant indexes and mark them
3752 discover_nonconstant_array_refs_r (tree * tp, int *walk_subtrees,
3753 void *data ATTRIBUTE_UNUSED)
3757 if (IS_TYPE_OR_DECL_P (t))
3759 else if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
3761 while (((TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
3762 && is_gimple_min_invariant (TREE_OPERAND (t, 1))
3763 && (!TREE_OPERAND (t, 2)
3764 || is_gimple_min_invariant (TREE_OPERAND (t, 2))))
3765 || (TREE_CODE (t) == COMPONENT_REF
3766 && (!TREE_OPERAND (t,2)
3767 || is_gimple_min_invariant (TREE_OPERAND (t, 2))))
3768 || TREE_CODE (t) == BIT_FIELD_REF
3769 || TREE_CODE (t) == REALPART_EXPR
3770 || TREE_CODE (t) == IMAGPART_EXPR
3771 || TREE_CODE (t) == VIEW_CONVERT_EXPR
3772 || CONVERT_EXPR_P (t))
3773 t = TREE_OPERAND (t, 0);
3775 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
3777 t = get_base_address (t);
3779 && DECL_MODE (t) != BLKmode)
3780 TREE_ADDRESSABLE (t) = 1;
3789 /* RTL expansion is not able to compile array references with variable
3790 offsets for arrays stored in single register. Discover such
3791 expressions and mark variables as addressable to avoid this
3795 discover_nonconstant_array_refs (void)
3798 gimple_stmt_iterator gsi;
3801 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
3803 gimple stmt = gsi_stmt (gsi);
3804 if (!is_gimple_debug (stmt))
3805 walk_gimple_op (stmt, discover_nonconstant_array_refs_r, NULL);
3809 /* This function sets crtl->args.internal_arg_pointer to a virtual
3810 register if DRAP is needed. Local register allocator will replace
3811 virtual_incoming_args_rtx with the virtual register. */
3814 expand_stack_alignment (void)
3817 unsigned int preferred_stack_boundary;
3819 if (! SUPPORTS_STACK_ALIGNMENT)
3822 if (cfun->calls_alloca
3823 || cfun->has_nonlocal_label
3824 || crtl->has_nonlocal_goto)
3825 crtl->need_drap = true;
3827 /* Call update_stack_boundary here again to update incoming stack
3828 boundary. It may set incoming stack alignment to a different
3829 value after RTL expansion. TARGET_FUNCTION_OK_FOR_SIBCALL may
3830 use the minimum incoming stack alignment to check if it is OK
3831 to perform sibcall optimization since sibcall optimization will
3832 only align the outgoing stack to incoming stack boundary. */
3833 if (targetm.calls.update_stack_boundary)
3834 targetm.calls.update_stack_boundary ();
3836 /* The incoming stack frame has to be aligned at least at
3837 parm_stack_boundary. */
3838 gcc_assert (crtl->parm_stack_boundary <= INCOMING_STACK_BOUNDARY);
3840 /* Update crtl->stack_alignment_estimated and use it later to align
3841 stack. We check PREFERRED_STACK_BOUNDARY if there may be non-call
3842 exceptions since callgraph doesn't collect incoming stack alignment
3844 if (cfun->can_throw_non_call_exceptions
3845 && PREFERRED_STACK_BOUNDARY > crtl->preferred_stack_boundary)
3846 preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
3848 preferred_stack_boundary = crtl->preferred_stack_boundary;
3849 if (preferred_stack_boundary > crtl->stack_alignment_estimated)
3850 crtl->stack_alignment_estimated = preferred_stack_boundary;
3851 if (preferred_stack_boundary > crtl->stack_alignment_needed)
3852 crtl->stack_alignment_needed = preferred_stack_boundary;
3854 gcc_assert (crtl->stack_alignment_needed
3855 <= crtl->stack_alignment_estimated);
3857 crtl->stack_realign_needed
3858 = INCOMING_STACK_BOUNDARY < crtl->stack_alignment_estimated;
3859 crtl->stack_realign_tried = crtl->stack_realign_needed;
3861 crtl->stack_realign_processed = true;
3863 /* Target has to redefine TARGET_GET_DRAP_RTX to support stack
3865 gcc_assert (targetm.calls.get_drap_rtx != NULL);
3866 drap_rtx = targetm.calls.get_drap_rtx ();
3868 /* stack_realign_drap and drap_rtx must match. */
3869 gcc_assert ((stack_realign_drap != 0) == (drap_rtx != NULL));
3871 /* Do nothing if NULL is returned, which means DRAP is not needed. */
3872 if (NULL != drap_rtx)
3874 crtl->args.internal_arg_pointer = drap_rtx;
3876 /* Call fixup_tail_calls to clean up REG_EQUIV note if DRAP is
3878 fixup_tail_calls ();
3882 /* Translate the intermediate representation contained in the CFG
3883 from GIMPLE trees to RTL.
3885 We do conversion per basic block and preserve/update the tree CFG.
3886 This implies we have to do some magic as the CFG can simultaneously
3887 consist of basic blocks containing RTL and GIMPLE trees. This can
3888 confuse the CFG hooks, so be careful to not manipulate CFG during
3892 gimple_expand_cfg (void)
3894 basic_block bb, init_block;
3901 timevar_push (TV_OUT_OF_SSA);
3902 rewrite_out_of_ssa (&SA);
3903 timevar_pop (TV_OUT_OF_SSA);
3904 SA.partition_to_pseudo = (rtx *)xcalloc (SA.map->num_partitions,
3907 /* Some backends want to know that we are expanding to RTL. */
3908 currently_expanding_to_rtl = 1;
3910 rtl_profile_for_bb (ENTRY_BLOCK_PTR);
3912 insn_locators_alloc ();
3913 if (!DECL_IS_BUILTIN (current_function_decl))
3915 /* Eventually, all FEs should explicitly set function_start_locus. */
3916 if (cfun->function_start_locus == UNKNOWN_LOCATION)
3917 set_curr_insn_source_location
3918 (DECL_SOURCE_LOCATION (current_function_decl));
3920 set_curr_insn_source_location (cfun->function_start_locus);
3922 set_curr_insn_block (DECL_INITIAL (current_function_decl));
3923 prologue_locator = curr_insn_locator ();
3925 #ifdef INSN_SCHEDULING
3926 init_sched_attrs ();
3929 /* Make sure first insn is a note even if we don't want linenums.
3930 This makes sure the first insn will never be deleted.
3931 Also, final expects a note to appear there. */
3932 emit_note (NOTE_INSN_DELETED);
3934 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
3935 discover_nonconstant_array_refs ();
3937 targetm.expand_to_rtl_hook ();
3938 crtl->stack_alignment_needed = STACK_BOUNDARY;
3939 crtl->max_used_stack_slot_alignment = STACK_BOUNDARY;
3940 crtl->stack_alignment_estimated = 0;
3941 crtl->preferred_stack_boundary = STACK_BOUNDARY;
3942 cfun->cfg->max_jumptable_ents = 0;
3944 /* Expand the variables recorded during gimple lowering. */
3945 timevar_push (TV_VAR_EXPAND);
3948 expand_used_vars ();
3950 var_seq = get_insns ();
3952 timevar_pop (TV_VAR_EXPAND);
3954 /* Honor stack protection warnings. */
3955 if (warn_stack_protect)
3957 if (cfun->calls_alloca)
3958 warning (OPT_Wstack_protector,
3959 "stack protector not protecting local variables: "
3960 "variable length buffer");
3961 if (has_short_buffer && !crtl->stack_protect_guard)
3962 warning (OPT_Wstack_protector,
3963 "stack protector not protecting function: "
3964 "all local arrays are less than %d bytes long",
3965 (int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE));
3968 /* Set up parameters and prepare for return, for the function. */
3969 expand_function_start (current_function_decl);
3971 /* If we emitted any instructions for setting up the variables,
3972 emit them before the FUNCTION_START note. */
3975 emit_insn_before (var_seq, parm_birth_insn);
3977 /* In expand_function_end we'll insert the alloca save/restore
3978 before parm_birth_insn. We've just insertted an alloca call.
3979 Adjust the pointer to match. */
3980 parm_birth_insn = var_seq;
3983 /* Now that we also have the parameter RTXs, copy them over to our
3985 for (i = 0; i < SA.map->num_partitions; i++)
3987 tree var = SSA_NAME_VAR (partition_to_var (SA.map, i));
3989 if (TREE_CODE (var) != VAR_DECL
3990 && !SA.partition_to_pseudo[i])
3991 SA.partition_to_pseudo[i] = DECL_RTL_IF_SET (var);
3992 gcc_assert (SA.partition_to_pseudo[i]);
3994 /* If this decl was marked as living in multiple places, reset
3995 this now to NULL. */
3996 if (DECL_RTL_IF_SET (var) == pc_rtx)
3997 SET_DECL_RTL (var, NULL);
3999 /* Some RTL parts really want to look at DECL_RTL(x) when x
4000 was a decl marked in REG_ATTR or MEM_ATTR. We could use
4001 SET_DECL_RTL here making this available, but that would mean
4002 to select one of the potentially many RTLs for one DECL. Instead
4003 of doing that we simply reset the MEM_EXPR of the RTL in question,
4004 then nobody can get at it and hence nobody can call DECL_RTL on it. */
4005 if (!DECL_RTL_SET_P (var))
4007 if (MEM_P (SA.partition_to_pseudo[i]))
4008 set_mem_expr (SA.partition_to_pseudo[i], NULL);
4012 /* If this function is `main', emit a call to `__main'
4013 to run global initializers, etc. */
4014 if (DECL_NAME (current_function_decl)
4015 && MAIN_NAME_P (DECL_NAME (current_function_decl))
4016 && DECL_FILE_SCOPE_P (current_function_decl))
4017 expand_main_function ();
4019 /* Initialize the stack_protect_guard field. This must happen after the
4020 call to __main (if any) so that the external decl is initialized. */
4021 if (crtl->stack_protect_guard)
4022 stack_protect_prologue ();
4024 expand_phi_nodes (&SA);
4026 /* Register rtl specific functions for cfg. */
4027 rtl_register_cfg_hooks ();
4029 init_block = construct_init_block ();
4031 /* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
4032 remaining edges later. */
4033 FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
4034 e->flags &= ~EDGE_EXECUTABLE;
4036 lab_rtx_for_bb = pointer_map_create ();
4037 FOR_BB_BETWEEN (bb, init_block->next_bb, EXIT_BLOCK_PTR, next_bb)
4038 bb = expand_gimple_basic_block (bb);
4040 if (MAY_HAVE_DEBUG_INSNS)
4041 expand_debug_locations ();
4043 execute_free_datastructures ();
4044 timevar_push (TV_OUT_OF_SSA);
4045 finish_out_of_ssa (&SA);
4046 timevar_pop (TV_OUT_OF_SSA);
4048 timevar_push (TV_POST_EXPAND);
4049 /* We are no longer in SSA form. */
4050 cfun->gimple_df->in_ssa_p = false;
4052 /* Expansion is used by optimization passes too, set maybe_hot_insn_p
4053 conservatively to true until they are all profile aware. */
4054 pointer_map_destroy (lab_rtx_for_bb);
4057 construct_exit_block ();
4058 set_curr_insn_block (DECL_INITIAL (current_function_decl));
4059 insn_locators_finalize ();
4061 /* Zap the tree EH table. */
4062 set_eh_throw_stmt_table (cfun, NULL);
4064 rebuild_jump_labels (get_insns ());
4066 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
4070 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
4073 commit_one_edge_insertion (e);
4079 /* We're done expanding trees to RTL. */
4080 currently_expanding_to_rtl = 0;
4082 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR->next_bb, EXIT_BLOCK_PTR, next_bb)
4086 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
4088 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
4089 e->flags &= ~EDGE_EXECUTABLE;
4091 /* At the moment not all abnormal edges match the RTL
4092 representation. It is safe to remove them here as
4093 find_many_sub_basic_blocks will rediscover them.
4094 In the future we should get this fixed properly. */
4095 if ((e->flags & EDGE_ABNORMAL)
4096 && !(e->flags & EDGE_SIBCALL))
4103 blocks = sbitmap_alloc (last_basic_block);
4104 sbitmap_ones (blocks);
4105 find_many_sub_basic_blocks (blocks);
4106 sbitmap_free (blocks);
4107 purge_all_dead_edges ();
4111 expand_stack_alignment ();
4113 #ifdef ENABLE_CHECKING
4114 verify_flow_info ();
4117 /* There's no need to defer outputting this function any more; we
4118 know we want to output it. */
4119 DECL_DEFER_OUTPUT (current_function_decl) = 0;
4121 /* Now that we're done expanding trees to RTL, we shouldn't have any
4122 more CONCATs anywhere. */
4123 generating_concat_p = 0;
4128 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
4129 /* And the pass manager will dump RTL for us. */
4132 /* If we're emitting a nested function, make sure its parent gets
4133 emitted as well. Doing otherwise confuses debug info. */
4136 for (parent = DECL_CONTEXT (current_function_decl);
4137 parent != NULL_TREE;
4138 parent = get_containing_scope (parent))
4139 if (TREE_CODE (parent) == FUNCTION_DECL)
4140 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent)) = 1;
4143 /* We are now committed to emitting code for this function. Do any
4144 preparation, such as emitting abstract debug info for the inline
4145 before it gets mangled by optimization. */
4146 if (cgraph_function_possibly_inlined_p (current_function_decl))
4147 (*debug_hooks->outlining_inline_function) (current_function_decl);
4149 TREE_ASM_WRITTEN (current_function_decl) = 1;
4151 /* After expanding, the return labels are no longer needed. */
4152 return_label = NULL;
4153 naked_return_label = NULL;
4154 /* Tag the blocks with a depth number so that change_scope can find
4155 the common parent easily. */
4156 set_block_levels (DECL_INITIAL (cfun->decl), 0);
4157 default_rtl_profile ();
4158 timevar_pop (TV_POST_EXPAND);
4162 struct rtl_opt_pass pass_expand =
4166 "expand", /* name */
4168 gimple_expand_cfg, /* execute */
4171 0, /* static_pass_number */
4172 TV_EXPAND, /* tv_id */
4173 PROP_ssa | PROP_gimple_leh | PROP_cfg
4174 | PROP_gimple_lcx, /* properties_required */
4175 PROP_rtl, /* properties_provided */
4176 PROP_ssa | PROP_trees, /* properties_destroyed */
4177 TODO_verify_ssa | TODO_verify_flow
4178 | TODO_verify_stmts, /* todo_flags_start */
4180 | TODO_ggc_collect /* todo_flags_finish */