1 /* A pass for lowering trees to RTL.
2 Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
28 #include "basic-block.h"
31 #include "langhooks.h"
32 #include "tree-flow.h"
34 #include "tree-dump.h"
35 #include "tree-pass.h"
38 #include "diagnostic.h"
39 #include "tree-pretty-print.h"
40 #include "gimple-pretty-print.h"
44 #include "tree-inline.h"
45 #include "value-prof.h"
47 #include "ssaexpand.h"
50 #include "insn-attr.h" /* For INSN_SCHEDULING. */
52 /* This variable holds information helping the rewriting of SSA trees
56 /* This variable holds the currently expanded gimple statement for purposes
57 of comminucating the profile info to the builtin expanders. */
58 gimple currently_expanding_gimple_stmt
;
60 /* 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 /* Compute the byte alignment to use for DECL. Ignore alignment
209 we can't do with expected alignment of the stack boundary. */
212 align_local_variable (tree decl
)
214 unsigned int align
= LOCAL_DECL_ALIGNMENT (decl
);
215 DECL_ALIGN (decl
) = align
;
216 return align
/ BITS_PER_UNIT
;
219 /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
220 Return the frame offset. */
223 alloc_stack_frame_space (HOST_WIDE_INT size
, unsigned HOST_WIDE_INT align
)
225 HOST_WIDE_INT offset
, new_frame_offset
;
227 new_frame_offset
= frame_offset
;
228 if (FRAME_GROWS_DOWNWARD
)
230 new_frame_offset
-= size
+ frame_phase
;
231 new_frame_offset
&= -align
;
232 new_frame_offset
+= frame_phase
;
233 offset
= new_frame_offset
;
237 new_frame_offset
-= frame_phase
;
238 new_frame_offset
+= align
- 1;
239 new_frame_offset
&= -align
;
240 new_frame_offset
+= frame_phase
;
241 offset
= new_frame_offset
;
242 new_frame_offset
+= size
;
244 frame_offset
= new_frame_offset
;
246 if (frame_offset_overflow (frame_offset
, cfun
->decl
))
247 frame_offset
= offset
= 0;
252 /* Accumulate DECL into STACK_VARS. */
255 add_stack_var (tree decl
)
259 if (stack_vars_num
>= stack_vars_alloc
)
261 if (stack_vars_alloc
)
262 stack_vars_alloc
= stack_vars_alloc
* 3 / 2;
264 stack_vars_alloc
= 32;
266 = XRESIZEVEC (struct stack_var
, stack_vars
, stack_vars_alloc
);
268 v
= &stack_vars
[stack_vars_num
];
272 v
->size
= tree_low_cst (DECL_SIZE_UNIT (SSAVAR (decl
)), 1);
273 /* Ensure that all variables have size, so that &a != &b for any two
274 variables that are simultaneously live. */
277 v
->alignb
= align_local_variable (SSAVAR (decl
));
279 /* All variables are initially in their own partition. */
280 v
->representative
= stack_vars_num
;
283 /* All variables initially conflict with no other. */
286 /* Ensure that this decl doesn't get put onto the list twice. */
287 set_rtl (decl
, pc_rtx
);
292 /* Make the decls associated with luid's X and Y conflict. */
295 add_stack_var_conflict (size_t x
, size_t y
)
297 struct stack_var
*a
= &stack_vars
[x
];
298 struct stack_var
*b
= &stack_vars
[y
];
300 a
->conflicts
= BITMAP_ALLOC (NULL
);
302 b
->conflicts
= BITMAP_ALLOC (NULL
);
303 bitmap_set_bit (a
->conflicts
, y
);
304 bitmap_set_bit (b
->conflicts
, x
);
307 /* Check whether the decls associated with luid's X and Y conflict. */
310 stack_var_conflict_p (size_t x
, size_t y
)
312 struct stack_var
*a
= &stack_vars
[x
];
313 struct stack_var
*b
= &stack_vars
[y
];
314 if (!a
->conflicts
|| !b
->conflicts
)
316 return bitmap_bit_p (a
->conflicts
, y
);
319 /* Returns true if TYPE is or contains a union type. */
322 aggregate_contains_union_type (tree type
)
326 if (TREE_CODE (type
) == UNION_TYPE
327 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
329 if (TREE_CODE (type
) == ARRAY_TYPE
)
330 return aggregate_contains_union_type (TREE_TYPE (type
));
331 if (TREE_CODE (type
) != RECORD_TYPE
)
334 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
335 if (TREE_CODE (field
) == FIELD_DECL
)
336 if (aggregate_contains_union_type (TREE_TYPE (field
)))
342 /* A subroutine of expand_used_vars. If two variables X and Y have alias
343 sets that do not conflict, then do add a conflict for these variables
344 in the interference graph. We also need to make sure to add conflicts
345 for union containing structures. Else RTL alias analysis comes along
346 and due to type based aliasing rules decides that for two overlapping
347 union temporaries { short s; int i; } accesses to the same mem through
348 different types may not alias and happily reorders stores across
349 life-time boundaries of the temporaries (See PR25654).
350 We also have to mind MEM_IN_STRUCT_P and MEM_SCALAR_P. */
353 add_alias_set_conflicts (void)
355 size_t i
, j
, n
= stack_vars_num
;
357 for (i
= 0; i
< n
; ++i
)
359 tree type_i
= TREE_TYPE (stack_vars
[i
].decl
);
360 bool aggr_i
= AGGREGATE_TYPE_P (type_i
);
363 contains_union
= aggregate_contains_union_type (type_i
);
364 for (j
= 0; j
< i
; ++j
)
366 tree type_j
= TREE_TYPE (stack_vars
[j
].decl
);
367 bool aggr_j
= AGGREGATE_TYPE_P (type_j
);
369 /* Either the objects conflict by means of type based
370 aliasing rules, or we need to add a conflict. */
371 || !objects_must_conflict_p (type_i
, type_j
)
372 /* In case the types do not conflict ensure that access
373 to elements will conflict. In case of unions we have
374 to be careful as type based aliasing rules may say
375 access to the same memory does not conflict. So play
376 safe and add a conflict in this case. */
378 add_stack_var_conflict (i
, j
);
383 /* A subroutine of partition_stack_vars. A comparison function for qsort,
384 sorting an array of indices by the properties of the object. */
387 stack_var_cmp (const void *a
, const void *b
)
389 size_t ia
= *(const size_t *)a
;
390 size_t ib
= *(const size_t *)b
;
391 unsigned int aligna
= stack_vars
[ia
].alignb
;
392 unsigned int alignb
= stack_vars
[ib
].alignb
;
393 HOST_WIDE_INT sizea
= stack_vars
[ia
].size
;
394 HOST_WIDE_INT sizeb
= stack_vars
[ib
].size
;
395 tree decla
= stack_vars
[ia
].decl
;
396 tree declb
= stack_vars
[ib
].decl
;
398 unsigned int uida
, uidb
;
400 /* Primary compare on "large" alignment. Large comes first. */
401 largea
= (aligna
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
402 largeb
= (alignb
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
403 if (largea
!= largeb
)
404 return (int)largeb
- (int)largea
;
406 /* Secondary compare on size, decreasing */
412 /* Tertiary compare on true alignment, decreasing. */
418 /* Final compare on ID for sort stability, increasing.
419 Two SSA names are compared by their version, SSA names come before
420 non-SSA names, and two normal decls are compared by their DECL_UID. */
421 if (TREE_CODE (decla
) == SSA_NAME
)
423 if (TREE_CODE (declb
) == SSA_NAME
)
424 uida
= SSA_NAME_VERSION (decla
), uidb
= SSA_NAME_VERSION (declb
);
428 else if (TREE_CODE (declb
) == SSA_NAME
)
431 uida
= DECL_UID (decla
), uidb
= DECL_UID (declb
);
440 /* If the points-to solution *PI points to variables that are in a partition
441 together with other variables add all partition members to the pointed-to
445 add_partitioned_vars_to_ptset (struct pt_solution
*pt
,
446 struct pointer_map_t
*decls_to_partitions
,
447 struct pointer_set_t
*visited
, bitmap temp
)
455 /* The pointed-to vars bitmap is shared, it is enough to
457 || pointer_set_insert(visited
, pt
->vars
))
462 /* By using a temporary bitmap to store all members of the partitions
463 we have to add we make sure to visit each of the partitions only
465 EXECUTE_IF_SET_IN_BITMAP (pt
->vars
, 0, i
, bi
)
467 || !bitmap_bit_p (temp
, i
))
468 && (part
= (bitmap
*) pointer_map_contains (decls_to_partitions
,
469 (void *)(size_t) i
)))
470 bitmap_ior_into (temp
, *part
);
471 if (!bitmap_empty_p (temp
))
472 bitmap_ior_into (pt
->vars
, temp
);
475 /* Update points-to sets based on partition info, so we can use them on RTL.
476 The bitmaps representing stack partitions will be saved until expand,
477 where partitioned decls used as bases in memory expressions will be
481 update_alias_info_with_stack_vars (void)
483 struct pointer_map_t
*decls_to_partitions
= NULL
;
485 tree var
= NULL_TREE
;
487 for (i
= 0; i
< stack_vars_num
; i
++)
491 struct ptr_info_def
*pi
;
493 /* Not interested in partitions with single variable. */
494 if (stack_vars
[i
].representative
!= i
495 || stack_vars
[i
].next
== EOC
)
498 if (!decls_to_partitions
)
500 decls_to_partitions
= pointer_map_create ();
501 cfun
->gimple_df
->decls_to_pointers
= pointer_map_create ();
504 /* Create an SSA_NAME that points to the partition for use
505 as base during alias-oracle queries on RTL for bases that
506 have been partitioned. */
507 if (var
== NULL_TREE
)
508 var
= create_tmp_var (ptr_type_node
, NULL
);
509 name
= make_ssa_name (var
, NULL
);
511 /* Create bitmaps representing partitions. They will be used for
512 points-to sets later, so use GGC alloc. */
513 part
= BITMAP_GGC_ALLOC ();
514 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
516 tree decl
= stack_vars
[j
].decl
;
517 unsigned int uid
= DECL_PT_UID (decl
);
518 /* We should never end up partitioning SSA names (though they
519 may end up on the stack). Neither should we allocate stack
520 space to something that is unused and thus unreferenced, except
521 for -O0 where we are preserving even unreferenced variables. */
522 gcc_assert (DECL_P (decl
)
524 || referenced_var_lookup (cfun
, DECL_UID (decl
))));
525 bitmap_set_bit (part
, uid
);
526 *((bitmap
*) pointer_map_insert (decls_to_partitions
,
527 (void *)(size_t) uid
)) = part
;
528 *((tree
*) pointer_map_insert (cfun
->gimple_df
->decls_to_pointers
,
532 /* Make the SSA name point to all partition members. */
533 pi
= get_ptr_info (name
);
534 pt_solution_set (&pi
->pt
, part
, false, false);
537 /* Make all points-to sets that contain one member of a partition
538 contain all members of the partition. */
539 if (decls_to_partitions
)
542 struct pointer_set_t
*visited
= pointer_set_create ();
543 bitmap temp
= BITMAP_ALLOC (NULL
);
545 for (i
= 1; i
< num_ssa_names
; i
++)
547 tree name
= ssa_name (i
);
548 struct ptr_info_def
*pi
;
551 && POINTER_TYPE_P (TREE_TYPE (name
))
552 && ((pi
= SSA_NAME_PTR_INFO (name
)) != NULL
))
553 add_partitioned_vars_to_ptset (&pi
->pt
, decls_to_partitions
,
557 add_partitioned_vars_to_ptset (&cfun
->gimple_df
->escaped
,
558 decls_to_partitions
, visited
, temp
);
560 pointer_set_destroy (visited
);
561 pointer_map_destroy (decls_to_partitions
);
566 /* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
567 partitioning algorithm. Partitions A and B are known to be non-conflicting.
568 Merge them into a single partition A.
570 At the same time, add OFFSET to all variables in partition B. At the end
571 of the partitioning process we've have a nice block easy to lay out within
575 union_stack_vars (size_t a
, size_t b
, HOST_WIDE_INT offset
)
578 struct stack_var
*vb
= &stack_vars
[b
];
582 /* Update each element of partition B with the given offset,
583 and merge them into partition A. */
584 for (last
= i
= b
; i
!= EOC
; last
= i
, i
= stack_vars
[i
].next
)
586 stack_vars
[i
].offset
+= offset
;
587 stack_vars
[i
].representative
= a
;
589 stack_vars
[last
].next
= stack_vars
[a
].next
;
590 stack_vars
[a
].next
= b
;
592 /* Update the required alignment of partition A to account for B. */
593 if (stack_vars
[a
].alignb
< stack_vars
[b
].alignb
)
594 stack_vars
[a
].alignb
= stack_vars
[b
].alignb
;
596 /* Update the interference graph and merge the conflicts. */
599 EXECUTE_IF_SET_IN_BITMAP (vb
->conflicts
, 0, u
, bi
)
600 add_stack_var_conflict (a
, stack_vars
[u
].representative
);
601 BITMAP_FREE (vb
->conflicts
);
605 /* A subroutine of expand_used_vars. Binpack the variables into
606 partitions constrained by the interference graph. The overall
607 algorithm used is as follows:
609 Sort the objects by size.
614 Look for the largest non-conflicting object B with size <= S.
624 partition_stack_vars (void)
626 size_t si
, sj
, n
= stack_vars_num
;
628 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
629 for (si
= 0; si
< n
; ++si
)
630 stack_vars_sorted
[si
] = si
;
635 qsort (stack_vars_sorted
, n
, sizeof (size_t), stack_var_cmp
);
637 for (si
= 0; si
< n
; ++si
)
639 size_t i
= stack_vars_sorted
[si
];
640 HOST_WIDE_INT isize
= stack_vars
[i
].size
;
641 unsigned int ialign
= stack_vars
[i
].alignb
;
642 HOST_WIDE_INT offset
= 0;
644 for (sj
= si
; sj
-- > 0; )
646 size_t j
= stack_vars_sorted
[sj
];
647 HOST_WIDE_INT jsize
= stack_vars
[j
].size
;
648 unsigned int jalign
= stack_vars
[j
].alignb
;
650 /* Ignore objects that aren't partition representatives. */
651 if (stack_vars
[j
].representative
!= j
)
654 /* Ignore objects too large for the remaining space. */
658 /* Ignore conflicting objects. */
659 if (stack_var_conflict_p (i
, j
))
662 /* Do not mix objects of "small" (supported) alignment
663 and "large" (unsupported) alignment. */
664 if ((ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
665 != (jalign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
))
668 /* Refine the remaining space check to include alignment. */
669 if (offset
& (jalign
- 1))
671 HOST_WIDE_INT toff
= offset
;
673 toff
&= -(HOST_WIDE_INT
)jalign
;
674 if (isize
- (toff
- offset
) < jsize
)
677 isize
-= toff
- offset
;
681 /* UNION the objects, placing J at OFFSET. */
682 union_stack_vars (i
, j
, offset
);
690 update_alias_info_with_stack_vars ();
693 /* A debugging aid for expand_used_vars. Dump the generated partitions. */
696 dump_stack_var_partition (void)
698 size_t si
, i
, j
, n
= stack_vars_num
;
700 for (si
= 0; si
< n
; ++si
)
702 i
= stack_vars_sorted
[si
];
704 /* Skip variables that aren't partition representatives, for now. */
705 if (stack_vars
[i
].representative
!= i
)
708 fprintf (dump_file
, "Partition %lu: size " HOST_WIDE_INT_PRINT_DEC
709 " align %u\n", (unsigned long) i
, stack_vars
[i
].size
,
710 stack_vars
[i
].alignb
);
712 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
714 fputc ('\t', dump_file
);
715 print_generic_expr (dump_file
, stack_vars
[j
].decl
, dump_flags
);
716 fprintf (dump_file
, ", offset " HOST_WIDE_INT_PRINT_DEC
"\n",
717 stack_vars
[j
].offset
);
722 /* Assign rtl to DECL at BASE + OFFSET. */
725 expand_one_stack_var_at (tree decl
, rtx base
, unsigned base_align
,
726 HOST_WIDE_INT offset
)
731 /* If this fails, we've overflowed the stack frame. Error nicely? */
732 gcc_assert (offset
== trunc_int_for_mode (offset
, Pmode
));
734 x
= plus_constant (base
, offset
);
735 x
= gen_rtx_MEM (DECL_MODE (SSAVAR (decl
)), x
);
737 if (TREE_CODE (decl
) != SSA_NAME
)
739 /* Set alignment we actually gave this decl if it isn't an SSA name.
740 If it is we generate stack slots only accidentally so it isn't as
741 important, we'll simply use the alignment that is already set. */
742 if (base
== virtual_stack_vars_rtx
)
743 offset
-= frame_phase
;
744 align
= offset
& -offset
;
745 align
*= BITS_PER_UNIT
;
746 if (align
== 0 || align
> base_align
)
749 /* One would think that we could assert that we're not decreasing
750 alignment here, but (at least) the i386 port does exactly this
751 via the MINIMUM_ALIGNMENT hook. */
753 DECL_ALIGN (decl
) = align
;
754 DECL_USER_ALIGN (decl
) = 0;
757 set_mem_attributes (x
, SSAVAR (decl
), true);
761 /* A subroutine of expand_used_vars. Give each partition representative
762 a unique location within the stack frame. Update each partition member
763 with that location. */
766 expand_stack_vars (bool (*pred
) (tree
))
768 size_t si
, i
, j
, n
= stack_vars_num
;
769 HOST_WIDE_INT large_size
= 0, large_alloc
= 0;
770 rtx large_base
= NULL
;
771 unsigned large_align
= 0;
774 /* Determine if there are any variables requiring "large" alignment.
775 Since these are dynamically allocated, we only process these if
776 no predicate involved. */
777 large_align
= stack_vars
[stack_vars_sorted
[0]].alignb
* BITS_PER_UNIT
;
778 if (pred
== NULL
&& large_align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
780 /* Find the total size of these variables. */
781 for (si
= 0; si
< n
; ++si
)
785 i
= stack_vars_sorted
[si
];
786 alignb
= stack_vars
[i
].alignb
;
788 /* Stop when we get to the first decl with "small" alignment. */
789 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
792 /* Skip variables that aren't partition representatives. */
793 if (stack_vars
[i
].representative
!= i
)
796 /* Skip variables that have already had rtl assigned. See also
797 add_stack_var where we perpetrate this pc_rtx hack. */
798 decl
= stack_vars
[i
].decl
;
799 if ((TREE_CODE (decl
) == SSA_NAME
800 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)]
801 : DECL_RTL (decl
)) != pc_rtx
)
804 large_size
+= alignb
- 1;
805 large_size
&= -(HOST_WIDE_INT
)alignb
;
806 large_size
+= stack_vars
[i
].size
;
809 /* If there were any, allocate space. */
811 large_base
= allocate_dynamic_stack_space (GEN_INT (large_size
), 0,
815 for (si
= 0; si
< n
; ++si
)
818 unsigned base_align
, alignb
;
819 HOST_WIDE_INT offset
;
821 i
= stack_vars_sorted
[si
];
823 /* Skip variables that aren't partition representatives, for now. */
824 if (stack_vars
[i
].representative
!= i
)
827 /* Skip variables that have already had rtl assigned. See also
828 add_stack_var where we perpetrate this pc_rtx hack. */
829 decl
= stack_vars
[i
].decl
;
830 if ((TREE_CODE (decl
) == SSA_NAME
831 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)]
832 : DECL_RTL (decl
)) != pc_rtx
)
835 /* Check the predicate to see whether this variable should be
836 allocated in this pass. */
837 if (pred
&& !pred (decl
))
840 alignb
= stack_vars
[i
].alignb
;
841 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
843 offset
= alloc_stack_frame_space (stack_vars
[i
].size
, alignb
);
844 base
= virtual_stack_vars_rtx
;
845 base_align
= crtl
->max_used_stack_slot_alignment
;
849 /* Large alignment is only processed in the last pass. */
852 gcc_assert (large_base
!= NULL
);
854 large_alloc
+= alignb
- 1;
855 large_alloc
&= -(HOST_WIDE_INT
)alignb
;
856 offset
= large_alloc
;
857 large_alloc
+= stack_vars
[i
].size
;
860 base_align
= large_align
;
863 /* Create rtl for each variable based on their location within the
865 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
867 gcc_assert (stack_vars
[j
].offset
<= stack_vars
[i
].size
);
868 expand_one_stack_var_at (stack_vars
[j
].decl
,
870 stack_vars
[j
].offset
+ offset
);
874 gcc_assert (large_alloc
== large_size
);
877 /* Take into account all sizes of partitions and reset DECL_RTLs. */
879 account_stack_vars (void)
881 size_t si
, j
, i
, n
= stack_vars_num
;
882 HOST_WIDE_INT size
= 0;
884 for (si
= 0; si
< n
; ++si
)
886 i
= stack_vars_sorted
[si
];
888 /* Skip variables that aren't partition representatives, for now. */
889 if (stack_vars
[i
].representative
!= i
)
892 size
+= stack_vars
[i
].size
;
893 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
894 set_rtl (stack_vars
[j
].decl
, NULL
);
899 /* A subroutine of expand_one_var. Called to immediately assign rtl
900 to a variable to be allocated in the stack frame. */
903 expand_one_stack_var (tree var
)
905 HOST_WIDE_INT size
, offset
;
908 size
= tree_low_cst (DECL_SIZE_UNIT (SSAVAR (var
)), 1);
909 byte_align
= align_local_variable (SSAVAR (var
));
911 /* We handle highly aligned variables in expand_stack_vars. */
912 gcc_assert (byte_align
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
);
914 offset
= alloc_stack_frame_space (size
, byte_align
);
916 expand_one_stack_var_at (var
, virtual_stack_vars_rtx
,
917 crtl
->max_used_stack_slot_alignment
, offset
);
920 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
921 that will reside in a hard register. */
924 expand_one_hard_reg_var (tree var
)
926 rest_of_decl_compilation (var
, 0, 0);
929 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
930 that will reside in a pseudo register. */
933 expand_one_register_var (tree var
)
935 tree decl
= SSAVAR (var
);
936 tree type
= TREE_TYPE (decl
);
937 enum machine_mode reg_mode
= promote_decl_mode (decl
, NULL
);
938 rtx x
= gen_reg_rtx (reg_mode
);
942 /* Note if the object is a user variable. */
943 if (!DECL_ARTIFICIAL (decl
))
946 if (POINTER_TYPE_P (type
))
947 mark_reg_pointer (x
, TYPE_ALIGN (TREE_TYPE (type
)));
950 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
951 has some associated error, e.g. its type is error-mark. We just need
952 to pick something that won't crash the rest of the compiler. */
955 expand_one_error_var (tree var
)
957 enum machine_mode mode
= DECL_MODE (var
);
961 x
= gen_rtx_MEM (BLKmode
, const0_rtx
);
962 else if (mode
== VOIDmode
)
965 x
= gen_reg_rtx (mode
);
967 SET_DECL_RTL (var
, x
);
970 /* A subroutine of expand_one_var. VAR is a variable that will be
971 allocated to the local stack frame. Return true if we wish to
972 add VAR to STACK_VARS so that it will be coalesced with other
973 variables. Return false to allocate VAR immediately.
975 This function is used to reduce the number of variables considered
976 for coalescing, which reduces the size of the quadratic problem. */
979 defer_stack_allocation (tree var
, bool toplevel
)
981 /* If stack protection is enabled, *all* stack variables must be deferred,
982 so that we can re-order the strings to the top of the frame. */
983 if (flag_stack_protect
)
986 /* We handle "large" alignment via dynamic allocation. We want to handle
987 this extra complication in only one place, so defer them. */
988 if (DECL_ALIGN (var
) > MAX_SUPPORTED_STACK_ALIGNMENT
)
991 /* Variables in the outermost scope automatically conflict with
992 every other variable. The only reason to want to defer them
993 at all is that, after sorting, we can more efficiently pack
994 small variables in the stack frame. Continue to defer at -O2. */
995 if (toplevel
&& optimize
< 2)
998 /* Without optimization, *most* variables are allocated from the
999 stack, which makes the quadratic problem large exactly when we
1000 want compilation to proceed as quickly as possible. On the
1001 other hand, we don't want the function's stack frame size to
1002 get completely out of hand. So we avoid adding scalars and
1003 "small" aggregates to the list at all. */
1004 if (optimize
== 0 && tree_low_cst (DECL_SIZE_UNIT (var
), 1) < 32)
1010 /* A subroutine of expand_used_vars. Expand one variable according to
1011 its flavor. Variables to be placed on the stack are not actually
1012 expanded yet, merely recorded.
1013 When REALLY_EXPAND is false, only add stack values to be allocated.
1014 Return stack usage this variable is supposed to take.
1017 static HOST_WIDE_INT
1018 expand_one_var (tree var
, bool toplevel
, bool really_expand
)
1020 unsigned int align
= BITS_PER_UNIT
;
1025 if (TREE_TYPE (var
) != error_mark_node
&& TREE_CODE (var
) == VAR_DECL
)
1027 /* Because we don't know if VAR will be in register or on stack,
1028 we conservatively assume it will be on stack even if VAR is
1029 eventually put into register after RA pass. For non-automatic
1030 variables, which won't be on stack, we collect alignment of
1031 type and ignore user specified alignment. */
1032 if (TREE_STATIC (var
) || DECL_EXTERNAL (var
))
1033 align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1034 TYPE_MODE (TREE_TYPE (var
)),
1035 TYPE_ALIGN (TREE_TYPE (var
)));
1036 else if (DECL_HAS_VALUE_EXPR_P (var
)
1037 || (DECL_RTL_SET_P (var
) && MEM_P (DECL_RTL (var
))))
1038 /* Don't consider debug only variables with DECL_HAS_VALUE_EXPR_P set
1039 or variables which were assigned a stack slot already by
1040 expand_one_stack_var_at - in the latter case DECL_ALIGN has been
1041 changed from the offset chosen to it. */
1042 align
= crtl
->stack_alignment_estimated
;
1044 align
= MINIMUM_ALIGNMENT (var
, DECL_MODE (var
), DECL_ALIGN (var
));
1046 /* If the variable alignment is very large we'll dynamicaly allocate
1047 it, which means that in-frame portion is just a pointer. */
1048 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1049 align
= POINTER_SIZE
;
1052 if (SUPPORTS_STACK_ALIGNMENT
1053 && crtl
->stack_alignment_estimated
< align
)
1055 /* stack_alignment_estimated shouldn't change after stack
1056 realign decision made */
1057 gcc_assert(!crtl
->stack_realign_processed
);
1058 crtl
->stack_alignment_estimated
= align
;
1061 /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
1062 So here we only make sure stack_alignment_needed >= align. */
1063 if (crtl
->stack_alignment_needed
< align
)
1064 crtl
->stack_alignment_needed
= align
;
1065 if (crtl
->max_used_stack_slot_alignment
< align
)
1066 crtl
->max_used_stack_slot_alignment
= align
;
1068 if (TREE_CODE (origvar
) == SSA_NAME
)
1070 gcc_assert (TREE_CODE (var
) != VAR_DECL
1071 || (!DECL_EXTERNAL (var
)
1072 && !DECL_HAS_VALUE_EXPR_P (var
)
1073 && !TREE_STATIC (var
)
1074 && TREE_TYPE (var
) != error_mark_node
1075 && !DECL_HARD_REGISTER (var
)
1078 if (TREE_CODE (var
) != VAR_DECL
&& TREE_CODE (origvar
) != SSA_NAME
)
1080 else if (DECL_EXTERNAL (var
))
1082 else if (DECL_HAS_VALUE_EXPR_P (var
))
1084 else if (TREE_STATIC (var
))
1086 else if (TREE_CODE (origvar
) != SSA_NAME
&& DECL_RTL_SET_P (var
))
1088 else if (TREE_TYPE (var
) == error_mark_node
)
1091 expand_one_error_var (var
);
1093 else if (TREE_CODE (var
) == VAR_DECL
&& DECL_HARD_REGISTER (var
))
1096 expand_one_hard_reg_var (var
);
1098 else if (use_register_for_decl (var
))
1101 expand_one_register_var (origvar
);
1103 else if (!host_integerp (DECL_SIZE_UNIT (var
), 1))
1107 error ("size of variable %q+D is too large", var
);
1108 expand_one_error_var (var
);
1111 else if (defer_stack_allocation (var
, toplevel
))
1112 add_stack_var (origvar
);
1116 expand_one_stack_var (origvar
);
1117 return tree_low_cst (DECL_SIZE_UNIT (var
), 1);
1122 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1123 expanding variables. Those variables that can be put into registers
1124 are allocated pseudos; those that can't are put on the stack.
1126 TOPLEVEL is true if this is the outermost BLOCK. */
1129 expand_used_vars_for_block (tree block
, bool toplevel
)
1131 size_t i
, j
, old_sv_num
, this_sv_num
, new_sv_num
;
1134 old_sv_num
= toplevel
? 0 : stack_vars_num
;
1136 /* Expand all variables at this level. */
1137 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1139 expand_one_var (t
, toplevel
, true);
1141 this_sv_num
= stack_vars_num
;
1143 /* Expand all variables at containing levels. */
1144 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1145 expand_used_vars_for_block (t
, false);
1147 /* Since we do not track exact variable lifetimes (which is not even
1148 possible for variables whose address escapes), we mirror the block
1149 tree in the interference graph. Here we cause all variables at this
1150 level, and all sublevels, to conflict. */
1151 if (old_sv_num
< this_sv_num
)
1153 new_sv_num
= stack_vars_num
;
1155 for (i
= old_sv_num
; i
< new_sv_num
; ++i
)
1156 for (j
= i
< this_sv_num
? i
: this_sv_num
; j
-- > old_sv_num
;)
1157 add_stack_var_conflict (i
, j
);
1161 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1162 and clear TREE_USED on all local variables. */
1165 clear_tree_used (tree block
)
1169 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1170 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
1173 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1174 clear_tree_used (t
);
1177 /* Examine TYPE and determine a bit mask of the following features. */
1179 #define SPCT_HAS_LARGE_CHAR_ARRAY 1
1180 #define SPCT_HAS_SMALL_CHAR_ARRAY 2
1181 #define SPCT_HAS_ARRAY 4
1182 #define SPCT_HAS_AGGREGATE 8
1185 stack_protect_classify_type (tree type
)
1187 unsigned int ret
= 0;
1190 switch (TREE_CODE (type
))
1193 t
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1194 if (t
== char_type_node
1195 || t
== signed_char_type_node
1196 || t
== unsigned_char_type_node
)
1198 unsigned HOST_WIDE_INT max
= PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
);
1199 unsigned HOST_WIDE_INT len
;
1201 if (!TYPE_SIZE_UNIT (type
)
1202 || !host_integerp (TYPE_SIZE_UNIT (type
), 1))
1205 len
= tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
1208 ret
= SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1210 ret
= SPCT_HAS_LARGE_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1213 ret
= SPCT_HAS_ARRAY
;
1217 case QUAL_UNION_TYPE
:
1219 ret
= SPCT_HAS_AGGREGATE
;
1220 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
1221 if (TREE_CODE (t
) == FIELD_DECL
)
1222 ret
|= stack_protect_classify_type (TREE_TYPE (t
));
1232 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
1233 part of the local stack frame. Remember if we ever return nonzero for
1234 any variable in this function. The return value is the phase number in
1235 which the variable should be allocated. */
1238 stack_protect_decl_phase (tree decl
)
1240 unsigned int bits
= stack_protect_classify_type (TREE_TYPE (decl
));
1243 if (bits
& SPCT_HAS_SMALL_CHAR_ARRAY
)
1244 has_short_buffer
= true;
1246 if (flag_stack_protect
== 2)
1248 if ((bits
& (SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_LARGE_CHAR_ARRAY
))
1249 && !(bits
& SPCT_HAS_AGGREGATE
))
1251 else if (bits
& SPCT_HAS_ARRAY
)
1255 ret
= (bits
& SPCT_HAS_LARGE_CHAR_ARRAY
) != 0;
1258 has_protected_decls
= true;
1263 /* Two helper routines that check for phase 1 and phase 2. These are used
1264 as callbacks for expand_stack_vars. */
1267 stack_protect_decl_phase_1 (tree decl
)
1269 return stack_protect_decl_phase (decl
) == 1;
1273 stack_protect_decl_phase_2 (tree decl
)
1275 return stack_protect_decl_phase (decl
) == 2;
1278 /* Ensure that variables in different stack protection phases conflict
1279 so that they are not merged and share the same stack slot. */
1282 add_stack_protection_conflicts (void)
1284 size_t i
, j
, n
= stack_vars_num
;
1285 unsigned char *phase
;
1287 phase
= XNEWVEC (unsigned char, n
);
1288 for (i
= 0; i
< n
; ++i
)
1289 phase
[i
] = stack_protect_decl_phase (stack_vars
[i
].decl
);
1291 for (i
= 0; i
< n
; ++i
)
1293 unsigned char ph_i
= phase
[i
];
1294 for (j
= 0; j
< i
; ++j
)
1295 if (ph_i
!= phase
[j
])
1296 add_stack_var_conflict (i
, j
);
1302 /* Create a decl for the guard at the top of the stack frame. */
1305 create_stack_guard (void)
1307 tree guard
= build_decl (DECL_SOURCE_LOCATION (current_function_decl
),
1308 VAR_DECL
, NULL
, ptr_type_node
);
1309 TREE_THIS_VOLATILE (guard
) = 1;
1310 TREE_USED (guard
) = 1;
1311 expand_one_stack_var (guard
);
1312 crtl
->stack_protect_guard
= guard
;
1315 /* Prepare for expanding variables. */
1317 init_vars_expansion (void)
1321 /* Set TREE_USED on all variables in the local_decls. */
1322 FOR_EACH_LOCAL_DECL (cfun
, ix
, t
)
1325 /* Clear TREE_USED on all variables associated with a block scope. */
1326 clear_tree_used (DECL_INITIAL (current_function_decl
));
1328 /* Initialize local stack smashing state. */
1329 has_protected_decls
= false;
1330 has_short_buffer
= false;
1333 /* Free up stack variable graph data. */
1335 fini_vars_expansion (void)
1337 size_t i
, n
= stack_vars_num
;
1338 for (i
= 0; i
< n
; i
++)
1339 BITMAP_FREE (stack_vars
[i
].conflicts
);
1340 XDELETEVEC (stack_vars
);
1341 XDELETEVEC (stack_vars_sorted
);
1343 stack_vars_alloc
= stack_vars_num
= 0;
1346 /* Make a fair guess for the size of the stack frame of the function
1347 in NODE. This doesn't have to be exact, the result is only used in
1348 the inline heuristics. So we don't want to run the full stack var
1349 packing algorithm (which is quadratic in the number of stack vars).
1350 Instead, we calculate the total size of all stack vars. This turns
1351 out to be a pretty fair estimate -- packing of stack vars doesn't
1352 happen very often. */
1355 estimated_stack_frame_size (struct cgraph_node
*node
)
1357 HOST_WIDE_INT size
= 0;
1360 tree old_cur_fun_decl
= current_function_decl
;
1361 referenced_var_iterator rvi
;
1362 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
1364 current_function_decl
= node
->decl
;
1367 gcc_checking_assert (gimple_referenced_vars (fn
));
1368 FOR_EACH_REFERENCED_VAR (fn
, var
, rvi
)
1369 size
+= expand_one_var (var
, true, false);
1371 if (stack_vars_num
> 0)
1373 /* Fake sorting the stack vars for account_stack_vars (). */
1374 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
1375 for (i
= 0; i
< stack_vars_num
; ++i
)
1376 stack_vars_sorted
[i
] = i
;
1377 size
+= account_stack_vars ();
1378 fini_vars_expansion ();
1381 current_function_decl
= old_cur_fun_decl
;
1385 /* Expand all variables used in the function. */
1388 expand_used_vars (void)
1390 tree var
, outer_block
= DECL_INITIAL (current_function_decl
);
1391 VEC(tree
,heap
) *maybe_local_decls
= NULL
;
1395 /* Compute the phase of the stack frame for this function. */
1397 int align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
1398 int off
= STARTING_FRAME_OFFSET
% align
;
1399 frame_phase
= off
? align
- off
: 0;
1402 init_vars_expansion ();
1404 for (i
= 0; i
< SA
.map
->num_partitions
; i
++)
1406 tree var
= partition_to_var (SA
.map
, i
);
1408 gcc_assert (is_gimple_reg (var
));
1409 if (TREE_CODE (SSA_NAME_VAR (var
)) == VAR_DECL
)
1410 expand_one_var (var
, true, true);
1413 /* This is a PARM_DECL or RESULT_DECL. For those partitions that
1414 contain the default def (representing the parm or result itself)
1415 we don't do anything here. But those which don't contain the
1416 default def (representing a temporary based on the parm/result)
1417 we need to allocate space just like for normal VAR_DECLs. */
1418 if (!bitmap_bit_p (SA
.partition_has_default_def
, i
))
1420 expand_one_var (var
, true, true);
1421 gcc_assert (SA
.partition_to_pseudo
[i
]);
1426 /* At this point all variables on the local_decls with TREE_USED
1427 set are not associated with any block scope. Lay them out. */
1429 len
= VEC_length (tree
, cfun
->local_decls
);
1430 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
1432 bool expand_now
= false;
1434 /* Expanded above already. */
1435 if (is_gimple_reg (var
))
1437 TREE_USED (var
) = 0;
1440 /* We didn't set a block for static or extern because it's hard
1441 to tell the difference between a global variable (re)declared
1442 in a local scope, and one that's really declared there to
1443 begin with. And it doesn't really matter much, since we're
1444 not giving them stack space. Expand them now. */
1445 else if (TREE_STATIC (var
) || DECL_EXTERNAL (var
))
1448 /* If the variable is not associated with any block, then it
1449 was created by the optimizers, and could be live anywhere
1451 else if (TREE_USED (var
))
1454 /* Finally, mark all variables on the list as used. We'll use
1455 this in a moment when we expand those associated with scopes. */
1456 TREE_USED (var
) = 1;
1459 expand_one_var (var
, true, true);
1462 if (DECL_ARTIFICIAL (var
) && !DECL_IGNORED_P (var
))
1464 rtx rtl
= DECL_RTL_IF_SET (var
);
1466 /* Keep artificial non-ignored vars in cfun->local_decls
1467 chain until instantiate_decls. */
1468 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
1469 add_local_decl (cfun
, var
);
1470 else if (rtl
== NULL_RTX
)
1471 /* If rtl isn't set yet, which can happen e.g. with
1472 -fstack-protector, retry before returning from this
1474 VEC_safe_push (tree
, heap
, maybe_local_decls
, var
);
1478 /* We duplicated some of the decls in CFUN->LOCAL_DECLS.
1480 +-----------------+-----------------+
1481 | ...processed... | ...duplicates...|
1482 +-----------------+-----------------+
1484 +-- LEN points here.
1486 We just want the duplicates, as those are the artificial
1487 non-ignored vars that we want to keep until instantiate_decls.
1488 Move them down and truncate the array. */
1489 if (!VEC_empty (tree
, cfun
->local_decls
))
1490 VEC_block_remove (tree
, cfun
->local_decls
, 0, len
);
1492 /* At this point, all variables within the block tree with TREE_USED
1493 set are actually used by the optimized function. Lay them out. */
1494 expand_used_vars_for_block (outer_block
, true);
1496 if (stack_vars_num
> 0)
1498 /* Due to the way alias sets work, no variables with non-conflicting
1499 alias sets may be assigned the same address. Add conflicts to
1501 add_alias_set_conflicts ();
1503 /* If stack protection is enabled, we don't share space between
1504 vulnerable data and non-vulnerable data. */
1505 if (flag_stack_protect
)
1506 add_stack_protection_conflicts ();
1508 /* Now that we have collected all stack variables, and have computed a
1509 minimal interference graph, attempt to save some stack space. */
1510 partition_stack_vars ();
1512 dump_stack_var_partition ();
1515 /* There are several conditions under which we should create a
1516 stack guard: protect-all, alloca used, protected decls present. */
1517 if (flag_stack_protect
== 2
1518 || (flag_stack_protect
1519 && (cfun
->calls_alloca
|| has_protected_decls
)))
1520 create_stack_guard ();
1522 /* Assign rtl to each variable based on these partitions. */
1523 if (stack_vars_num
> 0)
1525 /* Reorder decls to be protected by iterating over the variables
1526 array multiple times, and allocating out of each phase in turn. */
1527 /* ??? We could probably integrate this into the qsort we did
1528 earlier, such that we naturally see these variables first,
1529 and thus naturally allocate things in the right order. */
1530 if (has_protected_decls
)
1532 /* Phase 1 contains only character arrays. */
1533 expand_stack_vars (stack_protect_decl_phase_1
);
1535 /* Phase 2 contains other kinds of arrays. */
1536 if (flag_stack_protect
== 2)
1537 expand_stack_vars (stack_protect_decl_phase_2
);
1540 expand_stack_vars (NULL
);
1542 fini_vars_expansion ();
1545 /* If there were any artificial non-ignored vars without rtl
1546 found earlier, see if deferred stack allocation hasn't assigned
1548 FOR_EACH_VEC_ELT_REVERSE (tree
, maybe_local_decls
, i
, var
)
1550 rtx rtl
= DECL_RTL_IF_SET (var
);
1552 /* Keep artificial non-ignored vars in cfun->local_decls
1553 chain until instantiate_decls. */
1554 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
1555 add_local_decl (cfun
, var
);
1557 VEC_free (tree
, heap
, maybe_local_decls
);
1559 /* If the target requires that FRAME_OFFSET be aligned, do it. */
1560 if (STACK_ALIGNMENT_NEEDED
)
1562 HOST_WIDE_INT align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
1563 if (!FRAME_GROWS_DOWNWARD
)
1564 frame_offset
+= align
- 1;
1565 frame_offset
&= -align
;
1570 /* If we need to produce a detailed dump, print the tree representation
1571 for STMT to the dump file. SINCE is the last RTX after which the RTL
1572 generated for STMT should have been appended. */
1575 maybe_dump_rtl_for_gimple_stmt (gimple stmt
, rtx since
)
1577 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1579 fprintf (dump_file
, "\n;; ");
1580 print_gimple_stmt (dump_file
, stmt
, 0,
1581 TDF_SLIM
| (dump_flags
& TDF_LINENO
));
1582 fprintf (dump_file
, "\n");
1584 print_rtl (dump_file
, since
? NEXT_INSN (since
) : since
);
1588 /* Maps the blocks that do not contain tree labels to rtx labels. */
1590 static struct pointer_map_t
*lab_rtx_for_bb
;
1592 /* Returns the label_rtx expression for a label starting basic block BB. */
1595 label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED
)
1597 gimple_stmt_iterator gsi
;
1602 if (bb
->flags
& BB_RTL
)
1603 return block_label (bb
);
1605 elt
= pointer_map_contains (lab_rtx_for_bb
, bb
);
1609 /* Find the tree label if it is present. */
1611 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1613 lab_stmt
= gsi_stmt (gsi
);
1614 if (gimple_code (lab_stmt
) != GIMPLE_LABEL
)
1617 lab
= gimple_label_label (lab_stmt
);
1618 if (DECL_NONLOCAL (lab
))
1621 return label_rtx (lab
);
1624 elt
= pointer_map_insert (lab_rtx_for_bb
, bb
);
1625 *elt
= gen_label_rtx ();
1630 /* A subroutine of expand_gimple_cond. Given E, a fallthrough edge
1631 of a basic block where we just expanded the conditional at the end,
1632 possibly clean up the CFG and instruction sequence. LAST is the
1633 last instruction before the just emitted jump sequence. */
1636 maybe_cleanup_end_of_block (edge e
, rtx last
)
1638 /* Special case: when jumpif decides that the condition is
1639 trivial it emits an unconditional jump (and the necessary
1640 barrier). But we still have two edges, the fallthru one is
1641 wrong. purge_dead_edges would clean this up later. Unfortunately
1642 we have to insert insns (and split edges) before
1643 find_many_sub_basic_blocks and hence before purge_dead_edges.
1644 But splitting edges might create new blocks which depend on the
1645 fact that if there are two edges there's no barrier. So the
1646 barrier would get lost and verify_flow_info would ICE. Instead
1647 of auditing all edge splitters to care for the barrier (which
1648 normally isn't there in a cleaned CFG), fix it here. */
1649 if (BARRIER_P (get_last_insn ()))
1653 /* Now, we have a single successor block, if we have insns to
1654 insert on the remaining edge we potentially will insert
1655 it at the end of this block (if the dest block isn't feasible)
1656 in order to avoid splitting the edge. This insertion will take
1657 place in front of the last jump. But we might have emitted
1658 multiple jumps (conditional and one unconditional) to the
1659 same destination. Inserting in front of the last one then
1660 is a problem. See PR 40021. We fix this by deleting all
1661 jumps except the last unconditional one. */
1662 insn
= PREV_INSN (get_last_insn ());
1663 /* Make sure we have an unconditional jump. Otherwise we're
1665 gcc_assert (JUMP_P (insn
) && !any_condjump_p (insn
));
1666 for (insn
= PREV_INSN (insn
); insn
!= last
;)
1668 insn
= PREV_INSN (insn
);
1669 if (JUMP_P (NEXT_INSN (insn
)))
1671 if (!any_condjump_p (NEXT_INSN (insn
)))
1673 gcc_assert (BARRIER_P (NEXT_INSN (NEXT_INSN (insn
))));
1674 delete_insn (NEXT_INSN (NEXT_INSN (insn
)));
1676 delete_insn (NEXT_INSN (insn
));
1682 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_COND.
1683 Returns a new basic block if we've terminated the current basic
1684 block and created a new one. */
1687 expand_gimple_cond (basic_block bb
, gimple stmt
)
1689 basic_block new_bb
, dest
;
1694 enum tree_code code
;
1697 code
= gimple_cond_code (stmt
);
1698 op0
= gimple_cond_lhs (stmt
);
1699 op1
= gimple_cond_rhs (stmt
);
1700 /* We're sometimes presented with such code:
1704 This would expand to two comparisons which then later might
1705 be cleaned up by combine. But some pattern matchers like if-conversion
1706 work better when there's only one compare, so make up for this
1707 here as special exception if TER would have made the same change. */
1708 if (gimple_cond_single_var_p (stmt
)
1710 && TREE_CODE (op0
) == SSA_NAME
1711 && bitmap_bit_p (SA
.values
, SSA_NAME_VERSION (op0
)))
1713 gimple second
= SSA_NAME_DEF_STMT (op0
);
1714 if (gimple_code (second
) == GIMPLE_ASSIGN
)
1716 enum tree_code code2
= gimple_assign_rhs_code (second
);
1717 if (TREE_CODE_CLASS (code2
) == tcc_comparison
)
1720 op0
= gimple_assign_rhs1 (second
);
1721 op1
= gimple_assign_rhs2 (second
);
1723 /* If jumps are cheap turn some more codes into
1725 else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4)
1727 if ((code2
== BIT_AND_EXPR
1728 && TYPE_PRECISION (TREE_TYPE (op0
)) == 1
1729 && TREE_CODE (gimple_assign_rhs2 (second
)) != INTEGER_CST
)
1730 || code2
== TRUTH_AND_EXPR
)
1732 code
= TRUTH_ANDIF_EXPR
;
1733 op0
= gimple_assign_rhs1 (second
);
1734 op1
= gimple_assign_rhs2 (second
);
1736 else if (code2
== BIT_IOR_EXPR
|| code2
== TRUTH_OR_EXPR
)
1738 code
= TRUTH_ORIF_EXPR
;
1739 op0
= gimple_assign_rhs1 (second
);
1740 op1
= gimple_assign_rhs2 (second
);
1746 last2
= last
= get_last_insn ();
1748 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
1749 set_curr_insn_source_location (gimple_location (stmt
));
1750 set_curr_insn_block (gimple_block (stmt
));
1752 /* These flags have no purpose in RTL land. */
1753 true_edge
->flags
&= ~EDGE_TRUE_VALUE
;
1754 false_edge
->flags
&= ~EDGE_FALSE_VALUE
;
1756 /* We can either have a pure conditional jump with one fallthru edge or
1757 two-way jump that needs to be decomposed into two basic blocks. */
1758 if (false_edge
->dest
== bb
->next_bb
)
1760 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
1761 true_edge
->probability
);
1762 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
1763 if (true_edge
->goto_locus
)
1765 set_curr_insn_source_location (true_edge
->goto_locus
);
1766 set_curr_insn_block (true_edge
->goto_block
);
1767 true_edge
->goto_locus
= curr_insn_locator ();
1769 true_edge
->goto_block
= NULL
;
1770 false_edge
->flags
|= EDGE_FALLTHRU
;
1771 maybe_cleanup_end_of_block (false_edge
, last
);
1774 if (true_edge
->dest
== bb
->next_bb
)
1776 jumpifnot_1 (code
, op0
, op1
, label_rtx_for_bb (false_edge
->dest
),
1777 false_edge
->probability
);
1778 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
1779 if (false_edge
->goto_locus
)
1781 set_curr_insn_source_location (false_edge
->goto_locus
);
1782 set_curr_insn_block (false_edge
->goto_block
);
1783 false_edge
->goto_locus
= curr_insn_locator ();
1785 false_edge
->goto_block
= NULL
;
1786 true_edge
->flags
|= EDGE_FALLTHRU
;
1787 maybe_cleanup_end_of_block (true_edge
, last
);
1791 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
1792 true_edge
->probability
);
1793 last
= get_last_insn ();
1794 if (false_edge
->goto_locus
)
1796 set_curr_insn_source_location (false_edge
->goto_locus
);
1797 set_curr_insn_block (false_edge
->goto_block
);
1798 false_edge
->goto_locus
= curr_insn_locator ();
1800 false_edge
->goto_block
= NULL
;
1801 emit_jump (label_rtx_for_bb (false_edge
->dest
));
1804 if (BARRIER_P (BB_END (bb
)))
1805 BB_END (bb
) = PREV_INSN (BB_END (bb
));
1806 update_bb_for_insn (bb
);
1808 new_bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
1809 dest
= false_edge
->dest
;
1810 redirect_edge_succ (false_edge
, new_bb
);
1811 false_edge
->flags
|= EDGE_FALLTHRU
;
1812 new_bb
->count
= false_edge
->count
;
1813 new_bb
->frequency
= EDGE_FREQUENCY (false_edge
);
1814 new_edge
= make_edge (new_bb
, dest
, 0);
1815 new_edge
->probability
= REG_BR_PROB_BASE
;
1816 new_edge
->count
= new_bb
->count
;
1817 if (BARRIER_P (BB_END (new_bb
)))
1818 BB_END (new_bb
) = PREV_INSN (BB_END (new_bb
));
1819 update_bb_for_insn (new_bb
);
1821 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
1823 if (true_edge
->goto_locus
)
1825 set_curr_insn_source_location (true_edge
->goto_locus
);
1826 set_curr_insn_block (true_edge
->goto_block
);
1827 true_edge
->goto_locus
= curr_insn_locator ();
1829 true_edge
->goto_block
= NULL
;
1834 /* A subroutine of expand_gimple_stmt_1, expanding one GIMPLE_CALL
1838 expand_call_stmt (gimple stmt
)
1840 tree exp
, decl
, lhs
= gimple_call_lhs (stmt
);
1844 exp
= build_vl_exp (CALL_EXPR
, gimple_call_num_args (stmt
) + 3);
1846 CALL_EXPR_FN (exp
) = gimple_call_fn (stmt
);
1847 decl
= gimple_call_fndecl (stmt
);
1848 builtin_p
= decl
&& DECL_BUILT_IN (decl
);
1850 /* If this is not a builtin function, the function type through which the
1851 call is made may be different from the type of the function. */
1854 = fold_convert (build_pointer_type (gimple_call_fntype (stmt
)),
1855 CALL_EXPR_FN (exp
));
1857 TREE_TYPE (exp
) = gimple_call_return_type (stmt
);
1858 CALL_EXPR_STATIC_CHAIN (exp
) = gimple_call_chain (stmt
);
1860 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
1862 tree arg
= gimple_call_arg (stmt
, i
);
1864 /* TER addresses into arguments of builtin functions so we have a
1865 chance to infer more correct alignment information. See PR39954. */
1867 && TREE_CODE (arg
) == SSA_NAME
1868 && (def
= get_gimple_for_ssa_name (arg
))
1869 && gimple_assign_rhs_code (def
) == ADDR_EXPR
)
1870 arg
= gimple_assign_rhs1 (def
);
1871 CALL_EXPR_ARG (exp
, i
) = arg
;
1874 if (gimple_has_side_effects (stmt
))
1875 TREE_SIDE_EFFECTS (exp
) = 1;
1877 if (gimple_call_nothrow_p (stmt
))
1878 TREE_NOTHROW (exp
) = 1;
1880 CALL_EXPR_TAILCALL (exp
) = gimple_call_tail_p (stmt
);
1881 CALL_EXPR_RETURN_SLOT_OPT (exp
) = gimple_call_return_slot_opt_p (stmt
);
1883 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
1884 && DECL_FUNCTION_CODE (decl
) == BUILT_IN_ALLOCA
)
1885 CALL_ALLOCA_FOR_VAR_P (exp
) = gimple_call_alloca_for_var_p (stmt
);
1887 CALL_FROM_THUNK_P (exp
) = gimple_call_from_thunk_p (stmt
);
1888 CALL_CANNOT_INLINE_P (exp
) = gimple_call_cannot_inline_p (stmt
);
1889 CALL_EXPR_VA_ARG_PACK (exp
) = gimple_call_va_arg_pack_p (stmt
);
1890 SET_EXPR_LOCATION (exp
, gimple_location (stmt
));
1891 TREE_BLOCK (exp
) = gimple_block (stmt
);
1894 expand_assignment (lhs
, exp
, false);
1896 expand_expr_real_1 (exp
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
, NULL
);
1899 /* A subroutine of expand_gimple_stmt, expanding one gimple statement
1900 STMT that doesn't require special handling for outgoing edges. That
1901 is no tailcalls and no GIMPLE_COND. */
1904 expand_gimple_stmt_1 (gimple stmt
)
1908 set_curr_insn_source_location (gimple_location (stmt
));
1909 set_curr_insn_block (gimple_block (stmt
));
1911 switch (gimple_code (stmt
))
1914 op0
= gimple_goto_dest (stmt
);
1915 if (TREE_CODE (op0
) == LABEL_DECL
)
1918 expand_computed_goto (op0
);
1921 expand_label (gimple_label_label (stmt
));
1924 case GIMPLE_PREDICT
:
1930 expand_asm_stmt (stmt
);
1933 expand_call_stmt (stmt
);
1937 op0
= gimple_return_retval (stmt
);
1939 if (op0
&& op0
!= error_mark_node
)
1941 tree result
= DECL_RESULT (current_function_decl
);
1943 /* If we are not returning the current function's RESULT_DECL,
1944 build an assignment to it. */
1947 /* I believe that a function's RESULT_DECL is unique. */
1948 gcc_assert (TREE_CODE (op0
) != RESULT_DECL
);
1950 /* ??? We'd like to use simply expand_assignment here,
1951 but this fails if the value is of BLKmode but the return
1952 decl is a register. expand_return has special handling
1953 for this combination, which eventually should move
1954 to common code. See comments there. Until then, let's
1955 build a modify expression :-/ */
1956 op0
= build2 (MODIFY_EXPR
, TREE_TYPE (result
),
1961 expand_null_return ();
1963 expand_return (op0
);
1968 tree lhs
= gimple_assign_lhs (stmt
);
1970 /* Tree expand used to fiddle with |= and &= of two bitfield
1971 COMPONENT_REFs here. This can't happen with gimple, the LHS
1972 of binary assigns must be a gimple reg. */
1974 if (TREE_CODE (lhs
) != SSA_NAME
1975 || get_gimple_rhs_class (gimple_expr_code (stmt
))
1976 == GIMPLE_SINGLE_RHS
)
1978 tree rhs
= gimple_assign_rhs1 (stmt
);
1979 gcc_assert (get_gimple_rhs_class (gimple_expr_code (stmt
))
1980 == GIMPLE_SINGLE_RHS
);
1981 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (rhs
))
1982 SET_EXPR_LOCATION (rhs
, gimple_location (stmt
));
1983 expand_assignment (lhs
, rhs
,
1984 gimple_assign_nontemporal_move_p (stmt
));
1989 bool nontemporal
= gimple_assign_nontemporal_move_p (stmt
);
1990 struct separate_ops ops
;
1991 bool promoted
= false;
1993 target
= expand_expr (lhs
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
1994 if (GET_CODE (target
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (target
))
1997 ops
.code
= gimple_assign_rhs_code (stmt
);
1998 ops
.type
= TREE_TYPE (lhs
);
1999 switch (get_gimple_rhs_class (gimple_expr_code (stmt
)))
2001 case GIMPLE_TERNARY_RHS
:
2002 ops
.op2
= gimple_assign_rhs3 (stmt
);
2004 case GIMPLE_BINARY_RHS
:
2005 ops
.op1
= gimple_assign_rhs2 (stmt
);
2007 case GIMPLE_UNARY_RHS
:
2008 ops
.op0
= gimple_assign_rhs1 (stmt
);
2013 ops
.location
= gimple_location (stmt
);
2015 /* If we want to use a nontemporal store, force the value to
2016 register first. If we store into a promoted register,
2017 don't directly expand to target. */
2018 temp
= nontemporal
|| promoted
? NULL_RTX
: target
;
2019 temp
= expand_expr_real_2 (&ops
, temp
, GET_MODE (target
),
2026 int unsignedp
= SUBREG_PROMOTED_UNSIGNED_P (target
);
2027 /* If TEMP is a VOIDmode constant, use convert_modes to make
2028 sure that we properly convert it. */
2029 if (CONSTANT_P (temp
) && GET_MODE (temp
) == VOIDmode
)
2031 temp
= convert_modes (GET_MODE (target
),
2032 TYPE_MODE (ops
.type
),
2034 temp
= convert_modes (GET_MODE (SUBREG_REG (target
)),
2035 GET_MODE (target
), temp
, unsignedp
);
2038 convert_move (SUBREG_REG (target
), temp
, unsignedp
);
2040 else if (nontemporal
&& emit_storent_insn (target
, temp
))
2044 temp
= force_operand (temp
, target
);
2046 emit_move_insn (target
, temp
);
2057 /* Expand one gimple statement STMT and return the last RTL instruction
2058 before any of the newly generated ones.
2060 In addition to generating the necessary RTL instructions this also
2061 sets REG_EH_REGION notes if necessary and sets the current source
2062 location for diagnostics. */
2065 expand_gimple_stmt (gimple stmt
)
2067 location_t saved_location
= input_location
;
2068 rtx last
= get_last_insn ();
2073 /* We need to save and restore the current source location so that errors
2074 discovered during expansion are emitted with the right location. But
2075 it would be better if the diagnostic routines used the source location
2076 embedded in the tree nodes rather than globals. */
2077 if (gimple_has_location (stmt
))
2078 input_location
= gimple_location (stmt
);
2080 expand_gimple_stmt_1 (stmt
);
2082 /* Free any temporaries used to evaluate this statement. */
2085 input_location
= saved_location
;
2087 /* Mark all insns that may trap. */
2088 lp_nr
= lookup_stmt_eh_lp (stmt
);
2092 for (insn
= next_real_insn (last
); insn
;
2093 insn
= next_real_insn (insn
))
2095 if (! find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
2096 /* If we want exceptions for non-call insns, any
2097 may_trap_p instruction may throw. */
2098 && GET_CODE (PATTERN (insn
)) != CLOBBER
2099 && GET_CODE (PATTERN (insn
)) != USE
2100 && insn_could_throw_p (insn
))
2101 make_reg_eh_region_note (insn
, 0, lp_nr
);
2108 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_CALL
2109 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
2110 generated a tail call (something that might be denied by the ABI
2111 rules governing the call; see calls.c).
2113 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
2114 can still reach the rest of BB. The case here is __builtin_sqrt,
2115 where the NaN result goes through the external function (with a
2116 tailcall) and the normal result happens via a sqrt instruction. */
2119 expand_gimple_tailcall (basic_block bb
, gimple stmt
, bool *can_fallthru
)
2127 last2
= last
= expand_gimple_stmt (stmt
);
2129 for (last
= NEXT_INSN (last
); last
; last
= NEXT_INSN (last
))
2130 if (CALL_P (last
) && SIBLING_CALL_P (last
))
2133 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
2135 *can_fallthru
= true;
2139 /* ??? Wouldn't it be better to just reset any pending stack adjust?
2140 Any instructions emitted here are about to be deleted. */
2141 do_pending_stack_adjust ();
2143 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
2144 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
2145 EH or abnormal edges, we shouldn't have created a tail call in
2146 the first place. So it seems to me we should just be removing
2147 all edges here, or redirecting the existing fallthru edge to
2153 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
2155 if (!(e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
)))
2157 if (e
->dest
!= EXIT_BLOCK_PTR
)
2159 e
->dest
->count
-= e
->count
;
2160 e
->dest
->frequency
-= EDGE_FREQUENCY (e
);
2161 if (e
->dest
->count
< 0)
2163 if (e
->dest
->frequency
< 0)
2164 e
->dest
->frequency
= 0;
2167 probability
+= e
->probability
;
2174 /* This is somewhat ugly: the call_expr expander often emits instructions
2175 after the sibcall (to perform the function return). These confuse the
2176 find_many_sub_basic_blocks code, so we need to get rid of these. */
2177 last
= NEXT_INSN (last
);
2178 gcc_assert (BARRIER_P (last
));
2180 *can_fallthru
= false;
2181 while (NEXT_INSN (last
))
2183 /* For instance an sqrt builtin expander expands if with
2184 sibcall in the then and label for `else`. */
2185 if (LABEL_P (NEXT_INSN (last
)))
2187 *can_fallthru
= true;
2190 delete_insn (NEXT_INSN (last
));
2193 e
= make_edge (bb
, EXIT_BLOCK_PTR
, EDGE_ABNORMAL
| EDGE_SIBCALL
);
2194 e
->probability
+= probability
;
2197 update_bb_for_insn (bb
);
2199 if (NEXT_INSN (last
))
2201 bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
2204 if (BARRIER_P (last
))
2205 BB_END (bb
) = PREV_INSN (last
);
2208 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
2213 /* Return the difference between the floor and the truncated result of
2214 a signed division by OP1 with remainder MOD. */
2216 floor_sdiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1
)
2218 /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
2219 return gen_rtx_IF_THEN_ELSE
2220 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
2221 gen_rtx_IF_THEN_ELSE
2222 (mode
, gen_rtx_LT (BImode
,
2223 gen_rtx_DIV (mode
, op1
, mod
),
2225 constm1_rtx
, const0_rtx
),
2229 /* Return the difference between the ceil and the truncated result of
2230 a signed division by OP1 with remainder MOD. */
2232 ceil_sdiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1
)
2234 /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
2235 return gen_rtx_IF_THEN_ELSE
2236 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
2237 gen_rtx_IF_THEN_ELSE
2238 (mode
, gen_rtx_GT (BImode
,
2239 gen_rtx_DIV (mode
, op1
, mod
),
2241 const1_rtx
, const0_rtx
),
2245 /* Return the difference between the ceil and the truncated result of
2246 an unsigned division by OP1 with remainder MOD. */
2248 ceil_udiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1 ATTRIBUTE_UNUSED
)
2250 /* (mod != 0 ? 1 : 0) */
2251 return gen_rtx_IF_THEN_ELSE
2252 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
2253 const1_rtx
, const0_rtx
);
2256 /* Return the difference between the rounded and the truncated result
2257 of a signed division by OP1 with remainder MOD. Halfway cases are
2258 rounded away from zero, rather than to the nearest even number. */
2260 round_sdiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1
)
2262 /* (abs (mod) >= abs (op1) - abs (mod)
2263 ? (op1 / mod > 0 ? 1 : -1)
2265 return gen_rtx_IF_THEN_ELSE
2266 (mode
, gen_rtx_GE (BImode
, gen_rtx_ABS (mode
, mod
),
2267 gen_rtx_MINUS (mode
,
2268 gen_rtx_ABS (mode
, op1
),
2269 gen_rtx_ABS (mode
, mod
))),
2270 gen_rtx_IF_THEN_ELSE
2271 (mode
, gen_rtx_GT (BImode
,
2272 gen_rtx_DIV (mode
, op1
, mod
),
2274 const1_rtx
, constm1_rtx
),
2278 /* Return the difference between the rounded and the truncated result
2279 of a unsigned division by OP1 with remainder MOD. Halfway cases
2280 are rounded away from zero, rather than to the nearest even
2283 round_udiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1
)
2285 /* (mod >= op1 - mod ? 1 : 0) */
2286 return gen_rtx_IF_THEN_ELSE
2287 (mode
, gen_rtx_GE (BImode
, mod
,
2288 gen_rtx_MINUS (mode
, op1
, mod
)),
2289 const1_rtx
, const0_rtx
);
2292 /* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
2296 convert_debug_memory_address (enum machine_mode mode
, rtx x
,
2299 enum machine_mode xmode
= GET_MODE (x
);
2301 #ifndef POINTERS_EXTEND_UNSIGNED
2302 gcc_assert (mode
== Pmode
2303 || mode
== targetm
.addr_space
.address_mode (as
));
2304 gcc_assert (xmode
== mode
|| xmode
== VOIDmode
);
2307 enum machine_mode address_mode
= targetm
.addr_space
.address_mode (as
);
2308 enum machine_mode pointer_mode
= targetm
.addr_space
.pointer_mode (as
);
2310 gcc_assert (mode
== address_mode
|| mode
== pointer_mode
);
2312 if (GET_MODE (x
) == mode
|| GET_MODE (x
) == VOIDmode
)
2315 if (GET_MODE_BITSIZE (mode
) < GET_MODE_BITSIZE (xmode
))
2316 x
= simplify_gen_subreg (mode
, x
, xmode
,
2317 subreg_lowpart_offset
2319 else if (POINTERS_EXTEND_UNSIGNED
> 0)
2320 x
= gen_rtx_ZERO_EXTEND (mode
, x
);
2321 else if (!POINTERS_EXTEND_UNSIGNED
)
2322 x
= gen_rtx_SIGN_EXTEND (mode
, x
);
2325 switch (GET_CODE (x
))
2328 if ((SUBREG_PROMOTED_VAR_P (x
)
2329 || (REG_P (SUBREG_REG (x
)) && REG_POINTER (SUBREG_REG (x
)))
2330 || (GET_CODE (SUBREG_REG (x
)) == PLUS
2331 && REG_P (XEXP (SUBREG_REG (x
), 0))
2332 && REG_POINTER (XEXP (SUBREG_REG (x
), 0))
2333 && CONST_INT_P (XEXP (SUBREG_REG (x
), 1))))
2334 && GET_MODE (SUBREG_REG (x
)) == mode
)
2335 return SUBREG_REG (x
);
2338 temp
= gen_rtx_LABEL_REF (mode
, XEXP (x
, 0));
2339 LABEL_REF_NONLOCAL_P (temp
) = LABEL_REF_NONLOCAL_P (x
);
2342 temp
= shallow_copy_rtx (x
);
2343 PUT_MODE (temp
, mode
);
2346 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
2348 temp
= gen_rtx_CONST (mode
, temp
);
2352 if (CONST_INT_P (XEXP (x
, 1)))
2354 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
2356 return gen_rtx_fmt_ee (GET_CODE (x
), mode
, temp
, XEXP (x
, 1));
2362 /* Don't know how to express ptr_extend as operation in debug info. */
2365 #endif /* POINTERS_EXTEND_UNSIGNED */
2370 /* Return an RTX equivalent to the value of the tree expression
2374 expand_debug_expr (tree exp
)
2376 rtx op0
= NULL_RTX
, op1
= NULL_RTX
, op2
= NULL_RTX
;
2377 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
2378 enum machine_mode inner_mode
= VOIDmode
;
2379 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (exp
));
2382 switch (TREE_CODE_CLASS (TREE_CODE (exp
)))
2384 case tcc_expression
:
2385 switch (TREE_CODE (exp
))
2389 case WIDEN_MULT_PLUS_EXPR
:
2390 case WIDEN_MULT_MINUS_EXPR
:
2394 case TRUTH_ANDIF_EXPR
:
2395 case TRUTH_ORIF_EXPR
:
2396 case TRUTH_AND_EXPR
:
2398 case TRUTH_XOR_EXPR
:
2401 case TRUTH_NOT_EXPR
:
2410 op2
= expand_debug_expr (TREE_OPERAND (exp
, 2));
2417 case tcc_comparison
:
2418 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
2425 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
2426 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
2436 case tcc_exceptional
:
2437 case tcc_declaration
:
2443 switch (TREE_CODE (exp
))
2446 if (!lookup_constant_def (exp
))
2448 if (strlen (TREE_STRING_POINTER (exp
)) + 1
2449 != (size_t) TREE_STRING_LENGTH (exp
))
2451 op0
= gen_rtx_CONST_STRING (Pmode
, TREE_STRING_POINTER (exp
));
2452 op0
= gen_rtx_MEM (BLKmode
, op0
);
2453 set_mem_attributes (op0
, exp
, 0);
2456 /* Fall through... */
2461 op0
= expand_expr (exp
, NULL_RTX
, mode
, EXPAND_INITIALIZER
);
2465 gcc_assert (COMPLEX_MODE_P (mode
));
2466 op0
= expand_debug_expr (TREE_REALPART (exp
));
2467 op1
= expand_debug_expr (TREE_IMAGPART (exp
));
2468 return gen_rtx_CONCAT (mode
, op0
, op1
);
2470 case DEBUG_EXPR_DECL
:
2471 op0
= DECL_RTL_IF_SET (exp
);
2476 op0
= gen_rtx_DEBUG_EXPR (mode
);
2477 DEBUG_EXPR_TREE_DECL (op0
) = exp
;
2478 SET_DECL_RTL (exp
, op0
);
2488 op0
= DECL_RTL_IF_SET (exp
);
2490 /* This decl was probably optimized away. */
2493 if (TREE_CODE (exp
) != VAR_DECL
2494 || DECL_EXTERNAL (exp
)
2495 || !TREE_STATIC (exp
)
2497 || DECL_HARD_REGISTER (exp
)
2498 || DECL_IN_CONSTANT_POOL (exp
)
2499 || mode
== VOIDmode
)
2502 op0
= make_decl_rtl_for_debug (exp
);
2504 || GET_CODE (XEXP (op0
, 0)) != SYMBOL_REF
2505 || SYMBOL_REF_DECL (XEXP (op0
, 0)) != exp
)
2509 op0
= copy_rtx (op0
);
2511 if (GET_MODE (op0
) == BLKmode
2512 /* If op0 is not BLKmode, but BLKmode is, adjust_mode
2513 below would ICE. While it is likely a FE bug,
2514 try to be robust here. See PR43166. */
2516 || (mode
== VOIDmode
&& GET_MODE (op0
) != VOIDmode
))
2518 gcc_assert (MEM_P (op0
));
2519 op0
= adjust_address_nv (op0
, mode
, 0);
2530 inner_mode
= GET_MODE (op0
);
2532 if (mode
== inner_mode
)
2535 if (inner_mode
== VOIDmode
)
2537 if (TREE_CODE (exp
) == SSA_NAME
)
2538 inner_mode
= TYPE_MODE (TREE_TYPE (exp
));
2540 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
2541 if (mode
== inner_mode
)
2545 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
2547 if (GET_MODE_BITSIZE (mode
) == GET_MODE_BITSIZE (inner_mode
))
2548 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
2549 else if (GET_MODE_BITSIZE (mode
) < GET_MODE_BITSIZE (inner_mode
))
2550 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
2552 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
2554 else if (FLOAT_MODE_P (mode
))
2556 gcc_assert (TREE_CODE (exp
) != SSA_NAME
);
2557 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
2558 op0
= simplify_gen_unary (UNSIGNED_FLOAT
, mode
, op0
, inner_mode
);
2560 op0
= simplify_gen_unary (FLOAT
, mode
, op0
, inner_mode
);
2562 else if (FLOAT_MODE_P (inner_mode
))
2565 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
2567 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
2569 else if (CONSTANT_P (op0
)
2570 || GET_MODE_BITSIZE (mode
) <= GET_MODE_BITSIZE (inner_mode
))
2571 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
,
2572 subreg_lowpart_offset (mode
,
2574 else if (TREE_CODE_CLASS (TREE_CODE (exp
)) == tcc_unary
2575 ? TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)))
2577 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
2579 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
2585 if (!is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
2587 tree newexp
= fold_binary (MEM_REF
, TREE_TYPE (exp
),
2588 TREE_OPERAND (exp
, 0),
2589 TREE_OPERAND (exp
, 1));
2591 return expand_debug_expr (newexp
);
2595 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
2599 if (TREE_CODE (exp
) == MEM_REF
)
2601 if (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
2602 || (GET_CODE (op0
) == PLUS
2603 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
))
2604 /* (mem (debug_implicit_ptr)) might confuse aliasing.
2605 Instead just use get_inner_reference. */
2608 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
2609 if (!op1
|| !CONST_INT_P (op1
))
2612 op0
= plus_constant (op0
, INTVAL (op1
));
2615 if (POINTER_TYPE_P (TREE_TYPE (exp
)))
2616 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)));
2618 as
= ADDR_SPACE_GENERIC
;
2620 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
2622 if (op0
== NULL_RTX
)
2625 op0
= gen_rtx_MEM (mode
, op0
);
2626 set_mem_attributes (op0
, exp
, 0);
2627 if (TREE_CODE (exp
) == MEM_REF
2628 && !is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
2629 set_mem_expr (op0
, NULL_TREE
);
2630 set_mem_addr_space (op0
, as
);
2634 case TARGET_MEM_REF
:
2635 if (TREE_CODE (TMR_BASE (exp
)) == ADDR_EXPR
2636 && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp
), 0)))
2639 op0
= expand_debug_expr
2640 (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp
)), exp
));
2644 if (POINTER_TYPE_P (TREE_TYPE (exp
)))
2645 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)));
2647 as
= ADDR_SPACE_GENERIC
;
2649 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
2651 if (op0
== NULL_RTX
)
2654 op0
= gen_rtx_MEM (mode
, op0
);
2656 set_mem_attributes (op0
, exp
, 0);
2657 set_mem_addr_space (op0
, as
);
2663 case ARRAY_RANGE_REF
:
2668 case VIEW_CONVERT_EXPR
:
2670 enum machine_mode mode1
;
2671 HOST_WIDE_INT bitsize
, bitpos
;
2674 tree tem
= get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
,
2675 &mode1
, &unsignedp
, &volatilep
, false);
2681 orig_op0
= op0
= expand_debug_expr (tem
);
2688 enum machine_mode addrmode
, offmode
;
2693 op0
= XEXP (op0
, 0);
2694 addrmode
= GET_MODE (op0
);
2695 if (addrmode
== VOIDmode
)
2698 op1
= expand_debug_expr (offset
);
2702 offmode
= GET_MODE (op1
);
2703 if (offmode
== VOIDmode
)
2704 offmode
= TYPE_MODE (TREE_TYPE (offset
));
2706 if (addrmode
!= offmode
)
2707 op1
= simplify_gen_subreg (addrmode
, op1
, offmode
,
2708 subreg_lowpart_offset (addrmode
,
2711 /* Don't use offset_address here, we don't need a
2712 recognizable address, and we don't want to generate
2714 op0
= gen_rtx_MEM (mode
, simplify_gen_binary (PLUS
, addrmode
,
2720 if (mode1
== VOIDmode
)
2722 mode1
= smallest_mode_for_size (bitsize
, MODE_INT
);
2723 if (bitpos
>= BITS_PER_UNIT
)
2725 op0
= adjust_address_nv (op0
, mode1
, bitpos
/ BITS_PER_UNIT
);
2726 bitpos
%= BITS_PER_UNIT
;
2728 else if (bitpos
< 0)
2731 = (-bitpos
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
2732 op0
= adjust_address_nv (op0
, mode1
, units
);
2733 bitpos
+= units
* BITS_PER_UNIT
;
2735 else if (bitpos
== 0 && bitsize
== GET_MODE_BITSIZE (mode
))
2736 op0
= adjust_address_nv (op0
, mode
, 0);
2737 else if (GET_MODE (op0
) != mode1
)
2738 op0
= adjust_address_nv (op0
, mode1
, 0);
2740 op0
= copy_rtx (op0
);
2741 if (op0
== orig_op0
)
2742 op0
= shallow_copy_rtx (op0
);
2743 set_mem_attributes (op0
, exp
, 0);
2746 if (bitpos
== 0 && mode
== GET_MODE (op0
))
2752 if (GET_MODE (op0
) == BLKmode
)
2755 if ((bitpos
% BITS_PER_UNIT
) == 0
2756 && bitsize
== GET_MODE_BITSIZE (mode1
))
2758 enum machine_mode opmode
= GET_MODE (op0
);
2760 if (opmode
== VOIDmode
)
2761 opmode
= TYPE_MODE (TREE_TYPE (tem
));
2763 /* This condition may hold if we're expanding the address
2764 right past the end of an array that turned out not to
2765 be addressable (i.e., the address was only computed in
2766 debug stmts). The gen_subreg below would rightfully
2767 crash, and the address doesn't really exist, so just
2769 if (bitpos
>= GET_MODE_BITSIZE (opmode
))
2772 if ((bitpos
% GET_MODE_BITSIZE (mode
)) == 0)
2773 return simplify_gen_subreg (mode
, op0
, opmode
,
2774 bitpos
/ BITS_PER_UNIT
);
2777 return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0
))
2778 && TYPE_UNSIGNED (TREE_TYPE (exp
))
2780 : ZERO_EXTRACT
, mode
,
2781 GET_MODE (op0
) != VOIDmode
2783 : TYPE_MODE (TREE_TYPE (tem
)),
2784 op0
, GEN_INT (bitsize
), GEN_INT (bitpos
));
2788 return simplify_gen_unary (ABS
, mode
, op0
, mode
);
2791 return simplify_gen_unary (NEG
, mode
, op0
, mode
);
2794 return simplify_gen_unary (NOT
, mode
, op0
, mode
);
2797 return simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
2799 ? UNSIGNED_FLOAT
: FLOAT
, mode
, op0
,
2802 case FIX_TRUNC_EXPR
:
2803 return simplify_gen_unary (unsignedp
? UNSIGNED_FIX
: FIX
, mode
, op0
,
2806 case POINTER_PLUS_EXPR
:
2807 /* For the rare target where pointers are not the same size as
2808 size_t, we need to check for mis-matched modes and correct
2811 && GET_MODE (op0
) != VOIDmode
&& GET_MODE (op1
) != VOIDmode
2812 && GET_MODE (op0
) != GET_MODE (op1
))
2814 if (GET_MODE_BITSIZE (GET_MODE (op0
)) < GET_MODE_BITSIZE (GET_MODE (op1
)))
2815 op1
= simplify_gen_unary (TRUNCATE
, GET_MODE (op0
), op1
,
2818 /* We always sign-extend, regardless of the signedness of
2819 the operand, because the operand is always unsigned
2820 here even if the original C expression is signed. */
2821 op1
= simplify_gen_unary (SIGN_EXTEND
, GET_MODE (op0
), op1
,
2826 return simplify_gen_binary (PLUS
, mode
, op0
, op1
);
2829 return simplify_gen_binary (MINUS
, mode
, op0
, op1
);
2832 return simplify_gen_binary (MULT
, mode
, op0
, op1
);
2835 case TRUNC_DIV_EXPR
:
2836 case EXACT_DIV_EXPR
:
2838 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
2840 return simplify_gen_binary (DIV
, mode
, op0
, op1
);
2842 case TRUNC_MOD_EXPR
:
2843 return simplify_gen_binary (unsignedp
? UMOD
: MOD
, mode
, op0
, op1
);
2845 case FLOOR_DIV_EXPR
:
2847 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
2850 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
2851 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
2852 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
2853 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
2856 case FLOOR_MOD_EXPR
:
2858 return simplify_gen_binary (UMOD
, mode
, op0
, op1
);
2861 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
2862 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
2863 adj
= simplify_gen_unary (NEG
, mode
,
2864 simplify_gen_binary (MULT
, mode
, adj
, op1
),
2866 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
2872 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
2873 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
2874 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
2875 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
2879 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
2880 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
2881 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
2882 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
2888 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
2889 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
2890 adj
= simplify_gen_unary (NEG
, mode
,
2891 simplify_gen_binary (MULT
, mode
, adj
, op1
),
2893 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
2897 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
2898 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
2899 adj
= simplify_gen_unary (NEG
, mode
,
2900 simplify_gen_binary (MULT
, mode
, adj
, op1
),
2902 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
2905 case ROUND_DIV_EXPR
:
2908 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
2909 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
2910 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
2911 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
2915 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
2916 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
2917 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
2918 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
2921 case ROUND_MOD_EXPR
:
2924 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
2925 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
2926 adj
= simplify_gen_unary (NEG
, mode
,
2927 simplify_gen_binary (MULT
, mode
, adj
, op1
),
2929 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
2933 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
2934 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
2935 adj
= simplify_gen_unary (NEG
, mode
,
2936 simplify_gen_binary (MULT
, mode
, adj
, op1
),
2938 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
2942 return simplify_gen_binary (ASHIFT
, mode
, op0
, op1
);
2946 return simplify_gen_binary (LSHIFTRT
, mode
, op0
, op1
);
2948 return simplify_gen_binary (ASHIFTRT
, mode
, op0
, op1
);
2951 return simplify_gen_binary (ROTATE
, mode
, op0
, op1
);
2954 return simplify_gen_binary (ROTATERT
, mode
, op0
, op1
);
2957 return simplify_gen_binary (unsignedp
? UMIN
: SMIN
, mode
, op0
, op1
);
2960 return simplify_gen_binary (unsignedp
? UMAX
: SMAX
, mode
, op0
, op1
);
2963 case TRUTH_AND_EXPR
:
2964 return simplify_gen_binary (AND
, mode
, op0
, op1
);
2968 return simplify_gen_binary (IOR
, mode
, op0
, op1
);
2971 case TRUTH_XOR_EXPR
:
2972 return simplify_gen_binary (XOR
, mode
, op0
, op1
);
2974 case TRUTH_ANDIF_EXPR
:
2975 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, const0_rtx
);
2977 case TRUTH_ORIF_EXPR
:
2978 return gen_rtx_IF_THEN_ELSE (mode
, op0
, const_true_rtx
, op1
);
2980 case TRUTH_NOT_EXPR
:
2981 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, const0_rtx
);
2984 return simplify_gen_relational (unsignedp
? LTU
: LT
, mode
, inner_mode
,
2988 return simplify_gen_relational (unsignedp
? LEU
: LE
, mode
, inner_mode
,
2992 return simplify_gen_relational (unsignedp
? GTU
: GT
, mode
, inner_mode
,
2996 return simplify_gen_relational (unsignedp
? GEU
: GE
, mode
, inner_mode
,
3000 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, op1
);
3003 return simplify_gen_relational (NE
, mode
, inner_mode
, op0
, op1
);
3005 case UNORDERED_EXPR
:
3006 return simplify_gen_relational (UNORDERED
, mode
, inner_mode
, op0
, op1
);
3009 return simplify_gen_relational (ORDERED
, mode
, inner_mode
, op0
, op1
);
3012 return simplify_gen_relational (UNLT
, mode
, inner_mode
, op0
, op1
);
3015 return simplify_gen_relational (UNLE
, mode
, inner_mode
, op0
, op1
);
3018 return simplify_gen_relational (UNGT
, mode
, inner_mode
, op0
, op1
);
3021 return simplify_gen_relational (UNGE
, mode
, inner_mode
, op0
, op1
);
3024 return simplify_gen_relational (UNEQ
, mode
, inner_mode
, op0
, op1
);
3027 return simplify_gen_relational (LTGT
, mode
, inner_mode
, op0
, op1
);
3030 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, op2
);
3033 gcc_assert (COMPLEX_MODE_P (mode
));
3034 if (GET_MODE (op0
) == VOIDmode
)
3035 op0
= gen_rtx_CONST (GET_MODE_INNER (mode
), op0
);
3036 if (GET_MODE (op1
) == VOIDmode
)
3037 op1
= gen_rtx_CONST (GET_MODE_INNER (mode
), op1
);
3038 return gen_rtx_CONCAT (mode
, op0
, op1
);
3041 if (GET_CODE (op0
) == CONCAT
)
3042 return gen_rtx_CONCAT (mode
, XEXP (op0
, 0),
3043 simplify_gen_unary (NEG
, GET_MODE_INNER (mode
),
3045 GET_MODE_INNER (mode
)));
3048 enum machine_mode imode
= GET_MODE_INNER (mode
);
3053 re
= adjust_address_nv (op0
, imode
, 0);
3054 im
= adjust_address_nv (op0
, imode
, GET_MODE_SIZE (imode
));
3058 enum machine_mode ifmode
= int_mode_for_mode (mode
);
3059 enum machine_mode ihmode
= int_mode_for_mode (imode
);
3061 if (ifmode
== BLKmode
|| ihmode
== BLKmode
)
3063 halfsize
= GEN_INT (GET_MODE_BITSIZE (ihmode
));
3066 re
= gen_rtx_SUBREG (ifmode
, re
, 0);
3067 re
= gen_rtx_ZERO_EXTRACT (ihmode
, re
, halfsize
, const0_rtx
);
3068 if (imode
!= ihmode
)
3069 re
= gen_rtx_SUBREG (imode
, re
, 0);
3070 im
= copy_rtx (op0
);
3072 im
= gen_rtx_SUBREG (ifmode
, im
, 0);
3073 im
= gen_rtx_ZERO_EXTRACT (ihmode
, im
, halfsize
, halfsize
);
3074 if (imode
!= ihmode
)
3075 im
= gen_rtx_SUBREG (imode
, im
, 0);
3077 im
= gen_rtx_NEG (imode
, im
);
3078 return gen_rtx_CONCAT (mode
, re
, im
);
3082 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
3083 if (!op0
|| !MEM_P (op0
))
3085 if ((TREE_CODE (TREE_OPERAND (exp
, 0)) == VAR_DECL
3086 || TREE_CODE (TREE_OPERAND (exp
, 0)) == PARM_DECL
3087 || TREE_CODE (TREE_OPERAND (exp
, 0)) == RESULT_DECL
)
3088 && !TREE_ADDRESSABLE (TREE_OPERAND (exp
, 0)))
3089 return gen_rtx_DEBUG_IMPLICIT_PTR (mode
, TREE_OPERAND (exp
, 0));
3091 if (handled_component_p (TREE_OPERAND (exp
, 0)))
3093 HOST_WIDE_INT bitoffset
, bitsize
, maxsize
;
3095 = get_ref_base_and_extent (TREE_OPERAND (exp
, 0),
3096 &bitoffset
, &bitsize
, &maxsize
);
3097 if ((TREE_CODE (decl
) == VAR_DECL
3098 || TREE_CODE (decl
) == PARM_DECL
3099 || TREE_CODE (decl
) == RESULT_DECL
)
3100 && !TREE_ADDRESSABLE (decl
)
3101 && (bitoffset
% BITS_PER_UNIT
) == 0
3103 && bitsize
== maxsize
)
3104 return plus_constant (gen_rtx_DEBUG_IMPLICIT_PTR (mode
, decl
),
3105 bitoffset
/ BITS_PER_UNIT
);
3111 as
= TYPE_ADDR_SPACE (TREE_TYPE (exp
));
3112 op0
= convert_debug_memory_address (mode
, XEXP (op0
, 0), as
);
3117 exp
= build_constructor_from_list (TREE_TYPE (exp
),
3118 TREE_VECTOR_CST_ELTS (exp
));
3122 if (TREE_CODE (TREE_TYPE (exp
)) == VECTOR_TYPE
)
3127 op0
= gen_rtx_CONCATN
3128 (mode
, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
))));
3130 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), i
, val
)
3132 op1
= expand_debug_expr (val
);
3135 XVECEXP (op0
, 0, i
) = op1
;
3138 if (i
< TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)))
3140 op1
= expand_debug_expr
3141 (build_zero_cst (TREE_TYPE (TREE_TYPE (exp
))));
3146 for (; i
< TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)); i
++)
3147 XVECEXP (op0
, 0, i
) = op1
;
3153 goto flag_unsupported
;
3156 /* ??? Maybe handle some builtins? */
3161 gimple g
= get_gimple_for_ssa_name (exp
);
3164 op0
= expand_debug_expr (gimple_assign_rhs_to_tree (g
));
3170 int part
= var_to_partition (SA
.map
, exp
);
3172 if (part
== NO_PARTITION
)
3174 /* If this is a reference to an incoming value of parameter
3175 that is never used in the code or where the incoming
3176 value is never used in the code, use PARM_DECL's
3178 if (SSA_NAME_IS_DEFAULT_DEF (exp
)
3179 && TREE_CODE (SSA_NAME_VAR (exp
)) == PARM_DECL
)
3181 rtx incoming
= DECL_INCOMING_RTL (SSA_NAME_VAR (exp
));
3183 && GET_MODE (incoming
) != BLKmode
3184 && ((REG_P (incoming
) && HARD_REGISTER_P (incoming
))
3185 || (MEM_P (incoming
)
3186 && REG_P (XEXP (incoming
, 0))
3187 && HARD_REGISTER_P (XEXP (incoming
, 0)))))
3189 op0
= gen_rtx_ENTRY_VALUE (GET_MODE (incoming
));
3190 ENTRY_VALUE_EXP (op0
) = incoming
;
3193 op0
= expand_debug_expr (SSA_NAME_VAR (exp
));
3201 gcc_assert (part
>= 0 && (unsigned)part
< SA
.map
->num_partitions
);
3203 op0
= copy_rtx (SA
.partition_to_pseudo
[part
]);
3211 /* Vector stuff. For most of the codes we don't have rtl codes. */
3212 case REALIGN_LOAD_EXPR
:
3213 case REDUC_MAX_EXPR
:
3214 case REDUC_MIN_EXPR
:
3215 case REDUC_PLUS_EXPR
:
3217 case VEC_EXTRACT_EVEN_EXPR
:
3218 case VEC_EXTRACT_ODD_EXPR
:
3219 case VEC_INTERLEAVE_HIGH_EXPR
:
3220 case VEC_INTERLEAVE_LOW_EXPR
:
3221 case VEC_LSHIFT_EXPR
:
3222 case VEC_PACK_FIX_TRUNC_EXPR
:
3223 case VEC_PACK_SAT_EXPR
:
3224 case VEC_PACK_TRUNC_EXPR
:
3225 case VEC_RSHIFT_EXPR
:
3226 case VEC_UNPACK_FLOAT_HI_EXPR
:
3227 case VEC_UNPACK_FLOAT_LO_EXPR
:
3228 case VEC_UNPACK_HI_EXPR
:
3229 case VEC_UNPACK_LO_EXPR
:
3230 case VEC_WIDEN_MULT_HI_EXPR
:
3231 case VEC_WIDEN_MULT_LO_EXPR
:
3235 case ADDR_SPACE_CONVERT_EXPR
:
3236 case FIXED_CONVERT_EXPR
:
3238 case WITH_SIZE_EXPR
:
3242 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
3243 && SCALAR_INT_MODE_P (mode
))
3246 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
3248 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
3251 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
3253 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op1
,
3255 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
3256 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
3260 case WIDEN_MULT_EXPR
:
3261 case WIDEN_MULT_PLUS_EXPR
:
3262 case WIDEN_MULT_MINUS_EXPR
:
3263 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
3264 && SCALAR_INT_MODE_P (mode
))
3266 inner_mode
= GET_MODE (op0
);
3267 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
3268 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
3270 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
3271 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 1))))
3272 op1
= simplify_gen_unary (ZERO_EXTEND
, mode
, op1
, inner_mode
);
3274 op1
= simplify_gen_unary (SIGN_EXTEND
, mode
, op1
, inner_mode
);
3275 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
3276 if (TREE_CODE (exp
) == WIDEN_MULT_EXPR
)
3278 else if (TREE_CODE (exp
) == WIDEN_MULT_PLUS_EXPR
)
3279 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
3281 return simplify_gen_binary (MINUS
, mode
, op2
, op0
);
3285 case WIDEN_SUM_EXPR
:
3286 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
3287 && SCALAR_INT_MODE_P (mode
))
3290 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
3292 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
3294 return simplify_gen_binary (PLUS
, mode
, op0
, op1
);
3299 return simplify_gen_ternary (FMA
, mode
, inner_mode
, op0
, op1
, op2
);
3303 #ifdef ENABLE_CHECKING
3312 /* Expand the _LOCs in debug insns. We run this after expanding all
3313 regular insns, so that any variables referenced in the function
3314 will have their DECL_RTLs set. */
3317 expand_debug_locations (void)
3320 rtx last
= get_last_insn ();
3321 int save_strict_alias
= flag_strict_aliasing
;
3323 /* New alias sets while setting up memory attributes cause
3324 -fcompare-debug failures, even though it doesn't bring about any
3326 flag_strict_aliasing
= 0;
3328 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
3329 if (DEBUG_INSN_P (insn
))
3331 tree value
= (tree
)INSN_VAR_LOCATION_LOC (insn
);
3333 enum machine_mode mode
;
3335 if (value
== NULL_TREE
)
3339 val
= expand_debug_expr (value
);
3340 gcc_assert (last
== get_last_insn ());
3344 val
= gen_rtx_UNKNOWN_VAR_LOC ();
3347 mode
= GET_MODE (INSN_VAR_LOCATION (insn
));
3349 gcc_assert (mode
== GET_MODE (val
)
3350 || (GET_MODE (val
) == VOIDmode
3351 && (CONST_INT_P (val
)
3352 || GET_CODE (val
) == CONST_FIXED
3353 || GET_CODE (val
) == CONST_DOUBLE
3354 || GET_CODE (val
) == LABEL_REF
)));
3357 INSN_VAR_LOCATION_LOC (insn
) = val
;
3360 flag_strict_aliasing
= save_strict_alias
;
3363 /* Expand basic block BB from GIMPLE trees to RTL. */
3366 expand_gimple_basic_block (basic_block bb
)
3368 gimple_stmt_iterator gsi
;
3377 fprintf (dump_file
, "\n;; Generating RTL for gimple basic block %d\n",
3380 /* Note that since we are now transitioning from GIMPLE to RTL, we
3381 cannot use the gsi_*_bb() routines because they expect the basic
3382 block to be in GIMPLE, instead of RTL. Therefore, we need to
3383 access the BB sequence directly. */
3384 stmts
= bb_seq (bb
);
3385 bb
->il
.gimple
= NULL
;
3386 rtl_profile_for_bb (bb
);
3387 init_rtl_bb_info (bb
);
3388 bb
->flags
|= BB_RTL
;
3390 /* Remove the RETURN_EXPR if we may fall though to the exit
3392 gsi
= gsi_last (stmts
);
3393 if (!gsi_end_p (gsi
)
3394 && gimple_code (gsi_stmt (gsi
)) == GIMPLE_RETURN
)
3396 gimple ret_stmt
= gsi_stmt (gsi
);
3398 gcc_assert (single_succ_p (bb
));
3399 gcc_assert (single_succ (bb
) == EXIT_BLOCK_PTR
);
3401 if (bb
->next_bb
== EXIT_BLOCK_PTR
3402 && !gimple_return_retval (ret_stmt
))
3404 gsi_remove (&gsi
, false);
3405 single_succ_edge (bb
)->flags
|= EDGE_FALLTHRU
;
3409 gsi
= gsi_start (stmts
);
3410 if (!gsi_end_p (gsi
))
3412 stmt
= gsi_stmt (gsi
);
3413 if (gimple_code (stmt
) != GIMPLE_LABEL
)
3417 elt
= pointer_map_contains (lab_rtx_for_bb
, bb
);
3421 last
= get_last_insn ();
3425 expand_gimple_stmt (stmt
);
3430 emit_label ((rtx
) *elt
);
3432 /* Java emits line number notes in the top of labels.
3433 ??? Make this go away once line number notes are obsoleted. */
3434 BB_HEAD (bb
) = NEXT_INSN (last
);
3435 if (NOTE_P (BB_HEAD (bb
)))
3436 BB_HEAD (bb
) = NEXT_INSN (BB_HEAD (bb
));
3437 note
= emit_note_after (NOTE_INSN_BASIC_BLOCK
, BB_HEAD (bb
));
3439 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
3442 note
= BB_HEAD (bb
) = emit_note (NOTE_INSN_BASIC_BLOCK
);
3444 NOTE_BASIC_BLOCK (note
) = bb
;
3446 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
3450 stmt
= gsi_stmt (gsi
);
3452 /* If this statement is a non-debug one, and we generate debug
3453 insns, then this one might be the last real use of a TERed
3454 SSA_NAME, but where there are still some debug uses further
3455 down. Expanding the current SSA name in such further debug
3456 uses by their RHS might lead to wrong debug info, as coalescing
3457 might make the operands of such RHS be placed into the same
3458 pseudo as something else. Like so:
3459 a_1 = a_0 + 1; // Assume a_1 is TERed and a_0 is dead
3463 As a_0 and a_2 don't overlap in lifetime, assume they are coalesced.
3464 If we now would expand a_1 by it's RHS (a_0 + 1) in the debug use,
3465 the write to a_2 would actually have clobbered the place which
3468 So, instead of that, we recognize the situation, and generate
3469 debug temporaries at the last real use of TERed SSA names:
3476 if (MAY_HAVE_DEBUG_INSNS
3478 && !is_gimple_debug (stmt
))
3484 location_t sloc
= get_curr_insn_source_location ();
3485 tree sblock
= get_curr_insn_block ();
3487 /* Look for SSA names that have their last use here (TERed
3488 names always have only one real use). */
3489 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
)
3490 if ((def
= get_gimple_for_ssa_name (op
)))
3492 imm_use_iterator imm_iter
;
3493 use_operand_p use_p
;
3494 bool have_debug_uses
= false;
3496 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, op
)
3498 if (gimple_debug_bind_p (USE_STMT (use_p
)))
3500 have_debug_uses
= true;
3505 if (have_debug_uses
)
3507 /* OP is a TERed SSA name, with DEF it's defining
3508 statement, and where OP is used in further debug
3509 instructions. Generate a debug temporary, and
3510 replace all uses of OP in debug insns with that
3513 tree value
= gimple_assign_rhs_to_tree (def
);
3514 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
3516 enum machine_mode mode
;
3518 set_curr_insn_source_location (gimple_location (def
));
3519 set_curr_insn_block (gimple_block (def
));
3521 DECL_ARTIFICIAL (vexpr
) = 1;
3522 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
3524 mode
= DECL_MODE (value
);
3526 mode
= TYPE_MODE (TREE_TYPE (value
));
3527 DECL_MODE (vexpr
) = mode
;
3529 val
= gen_rtx_VAR_LOCATION
3530 (mode
, vexpr
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
3532 emit_debug_insn (val
);
3534 FOR_EACH_IMM_USE_STMT (debugstmt
, imm_iter
, op
)
3536 if (!gimple_debug_bind_p (debugstmt
))
3539 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
3540 SET_USE (use_p
, vexpr
);
3542 update_stmt (debugstmt
);
3546 set_curr_insn_source_location (sloc
);
3547 set_curr_insn_block (sblock
);
3550 currently_expanding_gimple_stmt
= stmt
;
3552 /* Expand this statement, then evaluate the resulting RTL and
3553 fixup the CFG accordingly. */
3554 if (gimple_code (stmt
) == GIMPLE_COND
)
3556 new_bb
= expand_gimple_cond (bb
, stmt
);
3560 else if (gimple_debug_bind_p (stmt
))
3562 location_t sloc
= get_curr_insn_source_location ();
3563 tree sblock
= get_curr_insn_block ();
3564 gimple_stmt_iterator nsi
= gsi
;
3568 tree var
= gimple_debug_bind_get_var (stmt
);
3571 enum machine_mode mode
;
3573 if (gimple_debug_bind_has_value_p (stmt
))
3574 value
= gimple_debug_bind_get_value (stmt
);
3578 last
= get_last_insn ();
3580 set_curr_insn_source_location (gimple_location (stmt
));
3581 set_curr_insn_block (gimple_block (stmt
));
3584 mode
= DECL_MODE (var
);
3586 mode
= TYPE_MODE (TREE_TYPE (var
));
3588 val
= gen_rtx_VAR_LOCATION
3589 (mode
, var
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
3591 emit_debug_insn (val
);
3593 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3595 /* We can't dump the insn with a TREE where an RTX
3597 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
3598 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
3599 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
3602 /* In order not to generate too many debug temporaries,
3603 we delink all uses of debug statements we already expanded.
3604 Therefore debug statements between definition and real
3605 use of TERed SSA names will continue to use the SSA name,
3606 and not be replaced with debug temps. */
3607 delink_stmt_imm_use (stmt
);
3611 if (gsi_end_p (nsi
))
3613 stmt
= gsi_stmt (nsi
);
3614 if (!gimple_debug_bind_p (stmt
))
3618 set_curr_insn_source_location (sloc
);
3619 set_curr_insn_block (sblock
);
3623 if (is_gimple_call (stmt
) && gimple_call_tail_p (stmt
))
3626 new_bb
= expand_gimple_tailcall (bb
, stmt
, &can_fallthru
);
3637 def_operand_p def_p
;
3638 def_p
= SINGLE_SSA_DEF_OPERAND (stmt
, SSA_OP_DEF
);
3642 /* Ignore this stmt if it is in the list of
3643 replaceable expressions. */
3645 && bitmap_bit_p (SA
.values
,
3646 SSA_NAME_VERSION (DEF_FROM_PTR (def_p
))))
3649 last
= expand_gimple_stmt (stmt
);
3650 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
3655 currently_expanding_gimple_stmt
= NULL
;
3657 /* Expand implicit goto and convert goto_locus. */
3658 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
3660 if (e
->goto_locus
&& e
->goto_block
)
3662 set_curr_insn_source_location (e
->goto_locus
);
3663 set_curr_insn_block (e
->goto_block
);
3664 e
->goto_locus
= curr_insn_locator ();
3666 e
->goto_block
= NULL
;
3667 if ((e
->flags
& EDGE_FALLTHRU
) && e
->dest
!= bb
->next_bb
)
3669 emit_jump (label_rtx_for_bb (e
->dest
));
3670 e
->flags
&= ~EDGE_FALLTHRU
;
3674 /* Expanded RTL can create a jump in the last instruction of block.
3675 This later might be assumed to be a jump to successor and break edge insertion.
3676 We need to insert dummy move to prevent this. PR41440. */
3677 if (single_succ_p (bb
)
3678 && (single_succ_edge (bb
)->flags
& EDGE_FALLTHRU
)
3679 && (last
= get_last_insn ())
3682 rtx dummy
= gen_reg_rtx (SImode
);
3683 emit_insn_after_noloc (gen_move_insn (dummy
, dummy
), last
, NULL
);
3686 do_pending_stack_adjust ();
3688 /* Find the block tail. The last insn in the block is the insn
3689 before a barrier and/or table jump insn. */
3690 last
= get_last_insn ();
3691 if (BARRIER_P (last
))
3692 last
= PREV_INSN (last
);
3693 if (JUMP_TABLE_DATA_P (last
))
3694 last
= PREV_INSN (PREV_INSN (last
));
3697 update_bb_for_insn (bb
);
3703 /* Create a basic block for initialization code. */
3706 construct_init_block (void)
3708 basic_block init_block
, first_block
;
3712 /* Multiple entry points not supported yet. */
3713 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR
->succs
) == 1);
3714 init_rtl_bb_info (ENTRY_BLOCK_PTR
);
3715 init_rtl_bb_info (EXIT_BLOCK_PTR
);
3716 ENTRY_BLOCK_PTR
->flags
|= BB_RTL
;
3717 EXIT_BLOCK_PTR
->flags
|= BB_RTL
;
3719 e
= EDGE_SUCC (ENTRY_BLOCK_PTR
, 0);
3721 /* When entry edge points to first basic block, we don't need jump,
3722 otherwise we have to jump into proper target. */
3723 if (e
&& e
->dest
!= ENTRY_BLOCK_PTR
->next_bb
)
3725 tree label
= gimple_block_label (e
->dest
);
3727 emit_jump (label_rtx (label
));
3731 flags
= EDGE_FALLTHRU
;
3733 init_block
= create_basic_block (NEXT_INSN (get_insns ()),
3736 init_block
->frequency
= ENTRY_BLOCK_PTR
->frequency
;
3737 init_block
->count
= ENTRY_BLOCK_PTR
->count
;
3740 first_block
= e
->dest
;
3741 redirect_edge_succ (e
, init_block
);
3742 e
= make_edge (init_block
, first_block
, flags
);
3745 e
= make_edge (init_block
, EXIT_BLOCK_PTR
, EDGE_FALLTHRU
);
3746 e
->probability
= REG_BR_PROB_BASE
;
3747 e
->count
= ENTRY_BLOCK_PTR
->count
;
3749 update_bb_for_insn (init_block
);
3753 /* For each lexical block, set BLOCK_NUMBER to the depth at which it is
3754 found in the block tree. */
3757 set_block_levels (tree block
, int level
)
3761 BLOCK_NUMBER (block
) = level
;
3762 set_block_levels (BLOCK_SUBBLOCKS (block
), level
+ 1);
3763 block
= BLOCK_CHAIN (block
);
3767 /* Create a block containing landing pads and similar stuff. */
3770 construct_exit_block (void)
3772 rtx head
= get_last_insn ();
3774 basic_block exit_block
;
3778 rtx orig_end
= BB_END (EXIT_BLOCK_PTR
->prev_bb
);
3780 rtl_profile_for_bb (EXIT_BLOCK_PTR
);
3782 /* Make sure the locus is set to the end of the function, so that
3783 epilogue line numbers and warnings are set properly. */
3784 if (cfun
->function_end_locus
!= UNKNOWN_LOCATION
)
3785 input_location
= cfun
->function_end_locus
;
3787 /* The following insns belong to the top scope. */
3788 set_curr_insn_block (DECL_INITIAL (current_function_decl
));
3790 /* Generate rtl for function exit. */
3791 expand_function_end ();
3793 end
= get_last_insn ();
3796 /* While emitting the function end we could move end of the last basic block.
3798 BB_END (EXIT_BLOCK_PTR
->prev_bb
) = orig_end
;
3799 while (NEXT_INSN (head
) && NOTE_P (NEXT_INSN (head
)))
3800 head
= NEXT_INSN (head
);
3801 exit_block
= create_basic_block (NEXT_INSN (head
), end
,
3802 EXIT_BLOCK_PTR
->prev_bb
);
3803 exit_block
->frequency
= EXIT_BLOCK_PTR
->frequency
;
3804 exit_block
->count
= EXIT_BLOCK_PTR
->count
;
3807 while (ix
< EDGE_COUNT (EXIT_BLOCK_PTR
->preds
))
3809 e
= EDGE_PRED (EXIT_BLOCK_PTR
, ix
);
3810 if (!(e
->flags
& EDGE_ABNORMAL
))
3811 redirect_edge_succ (e
, exit_block
);
3816 e
= make_edge (exit_block
, EXIT_BLOCK_PTR
, EDGE_FALLTHRU
);
3817 e
->probability
= REG_BR_PROB_BASE
;
3818 e
->count
= EXIT_BLOCK_PTR
->count
;
3819 FOR_EACH_EDGE (e2
, ei
, EXIT_BLOCK_PTR
->preds
)
3822 e
->count
-= e2
->count
;
3823 exit_block
->count
-= e2
->count
;
3824 exit_block
->frequency
-= EDGE_FREQUENCY (e2
);
3828 if (exit_block
->count
< 0)
3829 exit_block
->count
= 0;
3830 if (exit_block
->frequency
< 0)
3831 exit_block
->frequency
= 0;
3832 update_bb_for_insn (exit_block
);
3835 /* Helper function for discover_nonconstant_array_refs.
3836 Look for ARRAY_REF nodes with non-constant indexes and mark them
3840 discover_nonconstant_array_refs_r (tree
* tp
, int *walk_subtrees
,
3841 void *data ATTRIBUTE_UNUSED
)
3845 if (IS_TYPE_OR_DECL_P (t
))
3847 else if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
3849 while (((TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
3850 && is_gimple_min_invariant (TREE_OPERAND (t
, 1))
3851 && (!TREE_OPERAND (t
, 2)
3852 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
3853 || (TREE_CODE (t
) == COMPONENT_REF
3854 && (!TREE_OPERAND (t
,2)
3855 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
3856 || TREE_CODE (t
) == BIT_FIELD_REF
3857 || TREE_CODE (t
) == REALPART_EXPR
3858 || TREE_CODE (t
) == IMAGPART_EXPR
3859 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
3860 || CONVERT_EXPR_P (t
))
3861 t
= TREE_OPERAND (t
, 0);
3863 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
3865 t
= get_base_address (t
);
3867 && DECL_MODE (t
) != BLKmode
)
3868 TREE_ADDRESSABLE (t
) = 1;
3877 /* RTL expansion is not able to compile array references with variable
3878 offsets for arrays stored in single register. Discover such
3879 expressions and mark variables as addressable to avoid this
3883 discover_nonconstant_array_refs (void)
3886 gimple_stmt_iterator gsi
;
3889 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3891 gimple stmt
= gsi_stmt (gsi
);
3892 if (!is_gimple_debug (stmt
))
3893 walk_gimple_op (stmt
, discover_nonconstant_array_refs_r
, NULL
);
3897 /* This function sets crtl->args.internal_arg_pointer to a virtual
3898 register if DRAP is needed. Local register allocator will replace
3899 virtual_incoming_args_rtx with the virtual register. */
3902 expand_stack_alignment (void)
3905 unsigned int preferred_stack_boundary
;
3907 if (! SUPPORTS_STACK_ALIGNMENT
)
3910 if (cfun
->calls_alloca
3911 || cfun
->has_nonlocal_label
3912 || crtl
->has_nonlocal_goto
)
3913 crtl
->need_drap
= true;
3915 /* Call update_stack_boundary here again to update incoming stack
3916 boundary. It may set incoming stack alignment to a different
3917 value after RTL expansion. TARGET_FUNCTION_OK_FOR_SIBCALL may
3918 use the minimum incoming stack alignment to check if it is OK
3919 to perform sibcall optimization since sibcall optimization will
3920 only align the outgoing stack to incoming stack boundary. */
3921 if (targetm
.calls
.update_stack_boundary
)
3922 targetm
.calls
.update_stack_boundary ();
3924 /* The incoming stack frame has to be aligned at least at
3925 parm_stack_boundary. */
3926 gcc_assert (crtl
->parm_stack_boundary
<= INCOMING_STACK_BOUNDARY
);
3928 /* Update crtl->stack_alignment_estimated and use it later to align
3929 stack. We check PREFERRED_STACK_BOUNDARY if there may be non-call
3930 exceptions since callgraph doesn't collect incoming stack alignment
3932 if (cfun
->can_throw_non_call_exceptions
3933 && PREFERRED_STACK_BOUNDARY
> crtl
->preferred_stack_boundary
)
3934 preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
3936 preferred_stack_boundary
= crtl
->preferred_stack_boundary
;
3937 if (preferred_stack_boundary
> crtl
->stack_alignment_estimated
)
3938 crtl
->stack_alignment_estimated
= preferred_stack_boundary
;
3939 if (preferred_stack_boundary
> crtl
->stack_alignment_needed
)
3940 crtl
->stack_alignment_needed
= preferred_stack_boundary
;
3942 gcc_assert (crtl
->stack_alignment_needed
3943 <= crtl
->stack_alignment_estimated
);
3945 crtl
->stack_realign_needed
3946 = INCOMING_STACK_BOUNDARY
< crtl
->stack_alignment_estimated
;
3947 crtl
->stack_realign_tried
= crtl
->stack_realign_needed
;
3949 crtl
->stack_realign_processed
= true;
3951 /* Target has to redefine TARGET_GET_DRAP_RTX to support stack
3953 gcc_assert (targetm
.calls
.get_drap_rtx
!= NULL
);
3954 drap_rtx
= targetm
.calls
.get_drap_rtx ();
3956 /* stack_realign_drap and drap_rtx must match. */
3957 gcc_assert ((stack_realign_drap
!= 0) == (drap_rtx
!= NULL
));
3959 /* Do nothing if NULL is returned, which means DRAP is not needed. */
3960 if (NULL
!= drap_rtx
)
3962 crtl
->args
.internal_arg_pointer
= drap_rtx
;
3964 /* Call fixup_tail_calls to clean up REG_EQUIV note if DRAP is
3966 fixup_tail_calls ();
3970 /* Translate the intermediate representation contained in the CFG
3971 from GIMPLE trees to RTL.
3973 We do conversion per basic block and preserve/update the tree CFG.
3974 This implies we have to do some magic as the CFG can simultaneously
3975 consist of basic blocks containing RTL and GIMPLE trees. This can
3976 confuse the CFG hooks, so be careful to not manipulate CFG during
3980 gimple_expand_cfg (void)
3982 basic_block bb
, init_block
;
3989 timevar_push (TV_OUT_OF_SSA
);
3990 rewrite_out_of_ssa (&SA
);
3991 timevar_pop (TV_OUT_OF_SSA
);
3992 SA
.partition_to_pseudo
= (rtx
*)xcalloc (SA
.map
->num_partitions
,
3995 /* Some backends want to know that we are expanding to RTL. */
3996 currently_expanding_to_rtl
= 1;
3998 rtl_profile_for_bb (ENTRY_BLOCK_PTR
);
4000 insn_locators_alloc ();
4001 if (!DECL_IS_BUILTIN (current_function_decl
))
4003 /* Eventually, all FEs should explicitly set function_start_locus. */
4004 if (cfun
->function_start_locus
== UNKNOWN_LOCATION
)
4005 set_curr_insn_source_location
4006 (DECL_SOURCE_LOCATION (current_function_decl
));
4008 set_curr_insn_source_location (cfun
->function_start_locus
);
4011 set_curr_insn_source_location (UNKNOWN_LOCATION
);
4012 set_curr_insn_block (DECL_INITIAL (current_function_decl
));
4013 prologue_locator
= curr_insn_locator ();
4015 #ifdef INSN_SCHEDULING
4016 init_sched_attrs ();
4019 /* Make sure first insn is a note even if we don't want linenums.
4020 This makes sure the first insn will never be deleted.
4021 Also, final expects a note to appear there. */
4022 emit_note (NOTE_INSN_DELETED
);
4024 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
4025 discover_nonconstant_array_refs ();
4027 targetm
.expand_to_rtl_hook ();
4028 crtl
->stack_alignment_needed
= STACK_BOUNDARY
;
4029 crtl
->max_used_stack_slot_alignment
= STACK_BOUNDARY
;
4030 crtl
->stack_alignment_estimated
= 0;
4031 crtl
->preferred_stack_boundary
= STACK_BOUNDARY
;
4032 cfun
->cfg
->max_jumptable_ents
= 0;
4034 /* Resovle the function section. Some targets, like ARM EABI rely on knowledge
4035 of the function section at exapnsion time to predict distance of calls. */
4036 resolve_unique_section (current_function_decl
, 0, flag_function_sections
);
4038 /* Expand the variables recorded during gimple lowering. */
4039 timevar_push (TV_VAR_EXPAND
);
4042 expand_used_vars ();
4044 var_seq
= get_insns ();
4046 timevar_pop (TV_VAR_EXPAND
);
4048 /* Honor stack protection warnings. */
4049 if (warn_stack_protect
)
4051 if (cfun
->calls_alloca
)
4052 warning (OPT_Wstack_protector
,
4053 "stack protector not protecting local variables: "
4054 "variable length buffer");
4055 if (has_short_buffer
&& !crtl
->stack_protect_guard
)
4056 warning (OPT_Wstack_protector
,
4057 "stack protector not protecting function: "
4058 "all local arrays are less than %d bytes long",
4059 (int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
));
4062 /* Set up parameters and prepare for return, for the function. */
4063 expand_function_start (current_function_decl
);
4065 /* If we emitted any instructions for setting up the variables,
4066 emit them before the FUNCTION_START note. */
4069 emit_insn_before (var_seq
, parm_birth_insn
);
4071 /* In expand_function_end we'll insert the alloca save/restore
4072 before parm_birth_insn. We've just insertted an alloca call.
4073 Adjust the pointer to match. */
4074 parm_birth_insn
= var_seq
;
4077 /* Now that we also have the parameter RTXs, copy them over to our
4079 for (i
= 0; i
< SA
.map
->num_partitions
; i
++)
4081 tree var
= SSA_NAME_VAR (partition_to_var (SA
.map
, i
));
4083 if (TREE_CODE (var
) != VAR_DECL
4084 && !SA
.partition_to_pseudo
[i
])
4085 SA
.partition_to_pseudo
[i
] = DECL_RTL_IF_SET (var
);
4086 gcc_assert (SA
.partition_to_pseudo
[i
]);
4088 /* If this decl was marked as living in multiple places, reset
4089 this now to NULL. */
4090 if (DECL_RTL_IF_SET (var
) == pc_rtx
)
4091 SET_DECL_RTL (var
, NULL
);
4093 /* Some RTL parts really want to look at DECL_RTL(x) when x
4094 was a decl marked in REG_ATTR or MEM_ATTR. We could use
4095 SET_DECL_RTL here making this available, but that would mean
4096 to select one of the potentially many RTLs for one DECL. Instead
4097 of doing that we simply reset the MEM_EXPR of the RTL in question,
4098 then nobody can get at it and hence nobody can call DECL_RTL on it. */
4099 if (!DECL_RTL_SET_P (var
))
4101 if (MEM_P (SA
.partition_to_pseudo
[i
]))
4102 set_mem_expr (SA
.partition_to_pseudo
[i
], NULL
);
4106 /* If this function is `main', emit a call to `__main'
4107 to run global initializers, etc. */
4108 if (DECL_NAME (current_function_decl
)
4109 && MAIN_NAME_P (DECL_NAME (current_function_decl
))
4110 && DECL_FILE_SCOPE_P (current_function_decl
))
4111 expand_main_function ();
4113 /* Initialize the stack_protect_guard field. This must happen after the
4114 call to __main (if any) so that the external decl is initialized. */
4115 if (crtl
->stack_protect_guard
)
4116 stack_protect_prologue ();
4118 expand_phi_nodes (&SA
);
4120 /* Register rtl specific functions for cfg. */
4121 rtl_register_cfg_hooks ();
4123 init_block
= construct_init_block ();
4125 /* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
4126 remaining edges later. */
4127 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR
->succs
)
4128 e
->flags
&= ~EDGE_EXECUTABLE
;
4130 lab_rtx_for_bb
= pointer_map_create ();
4131 FOR_BB_BETWEEN (bb
, init_block
->next_bb
, EXIT_BLOCK_PTR
, next_bb
)
4132 bb
= expand_gimple_basic_block (bb
);
4134 if (MAY_HAVE_DEBUG_INSNS
)
4135 expand_debug_locations ();
4137 execute_free_datastructures ();
4138 timevar_push (TV_OUT_OF_SSA
);
4139 finish_out_of_ssa (&SA
);
4140 timevar_pop (TV_OUT_OF_SSA
);
4142 timevar_push (TV_POST_EXPAND
);
4143 /* We are no longer in SSA form. */
4144 cfun
->gimple_df
->in_ssa_p
= false;
4146 /* Expansion is used by optimization passes too, set maybe_hot_insn_p
4147 conservatively to true until they are all profile aware. */
4148 pointer_map_destroy (lab_rtx_for_bb
);
4151 construct_exit_block ();
4152 set_curr_insn_block (DECL_INITIAL (current_function_decl
));
4153 insn_locators_finalize ();
4155 /* Zap the tree EH table. */
4156 set_eh_throw_stmt_table (cfun
, NULL
);
4158 /* We need JUMP_LABEL be set in order to redirect jumps, and hence
4159 split edges which edge insertions might do. */
4160 rebuild_jump_labels (get_insns ());
4162 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR
, EXIT_BLOCK_PTR
, next_bb
)
4166 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
4170 rebuild_jump_labels_chain (e
->insns
.r
);
4171 /* Avoid putting insns before parm_birth_insn. */
4172 if (e
->src
== ENTRY_BLOCK_PTR
4173 && single_succ_p (ENTRY_BLOCK_PTR
)
4176 rtx insns
= e
->insns
.r
;
4177 e
->insns
.r
= NULL_RTX
;
4178 emit_insn_after_noloc (insns
, parm_birth_insn
, e
->dest
);
4181 commit_one_edge_insertion (e
);
4188 /* We're done expanding trees to RTL. */
4189 currently_expanding_to_rtl
= 0;
4191 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR
->next_bb
, EXIT_BLOCK_PTR
, next_bb
)
4195 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
4197 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
4198 e
->flags
&= ~EDGE_EXECUTABLE
;
4200 /* At the moment not all abnormal edges match the RTL
4201 representation. It is safe to remove them here as
4202 find_many_sub_basic_blocks will rediscover them.
4203 In the future we should get this fixed properly. */
4204 if ((e
->flags
& EDGE_ABNORMAL
)
4205 && !(e
->flags
& EDGE_SIBCALL
))
4212 blocks
= sbitmap_alloc (last_basic_block
);
4213 sbitmap_ones (blocks
);
4214 find_many_sub_basic_blocks (blocks
);
4215 sbitmap_free (blocks
);
4216 purge_all_dead_edges ();
4220 expand_stack_alignment ();
4222 #ifdef ENABLE_CHECKING
4223 verify_flow_info ();
4226 /* There's no need to defer outputting this function any more; we
4227 know we want to output it. */
4228 DECL_DEFER_OUTPUT (current_function_decl
) = 0;
4230 /* Now that we're done expanding trees to RTL, we shouldn't have any
4231 more CONCATs anywhere. */
4232 generating_concat_p
= 0;
4237 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
4238 /* And the pass manager will dump RTL for us. */
4241 /* If we're emitting a nested function, make sure its parent gets
4242 emitted as well. Doing otherwise confuses debug info. */
4245 for (parent
= DECL_CONTEXT (current_function_decl
);
4246 parent
!= NULL_TREE
;
4247 parent
= get_containing_scope (parent
))
4248 if (TREE_CODE (parent
) == FUNCTION_DECL
)
4249 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent
)) = 1;
4252 /* We are now committed to emitting code for this function. Do any
4253 preparation, such as emitting abstract debug info for the inline
4254 before it gets mangled by optimization. */
4255 if (cgraph_function_possibly_inlined_p (current_function_decl
))
4256 (*debug_hooks
->outlining_inline_function
) (current_function_decl
);
4258 TREE_ASM_WRITTEN (current_function_decl
) = 1;
4260 /* After expanding, the return labels are no longer needed. */
4261 return_label
= NULL
;
4262 naked_return_label
= NULL
;
4263 /* Tag the blocks with a depth number so that change_scope can find
4264 the common parent easily. */
4265 set_block_levels (DECL_INITIAL (cfun
->decl
), 0);
4266 default_rtl_profile ();
4267 timevar_pop (TV_POST_EXPAND
);
4271 struct rtl_opt_pass pass_expand
=
4275 "expand", /* name */
4277 gimple_expand_cfg
, /* execute */
4280 0, /* static_pass_number */
4281 TV_EXPAND
, /* tv_id */
4282 PROP_ssa
| PROP_gimple_leh
| PROP_cfg
4283 | PROP_gimple_lcx
, /* properties_required */
4284 PROP_rtl
, /* properties_provided */
4285 PROP_ssa
| PROP_trees
, /* properties_destroyed */
4286 TODO_verify_ssa
| TODO_verify_flow
4287 | TODO_verify_stmts
, /* todo_flags_start */
4289 | TODO_ggc_collect
/* todo_flags_finish */