1 /* A pass for lowering trees to RTL.
2 Copyright (C) 2004-2013 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
27 #include "basic-block.h"
30 #include "langhooks.h"
31 #include "tree-flow.h"
32 #include "tree-pass.h"
35 #include "diagnostic.h"
36 #include "gimple-pretty-print.h"
40 #include "tree-inline.h"
41 #include "value-prof.h"
43 #include "ssaexpand.h"
47 #include "regs.h" /* For reg_renumber. */
48 #include "insn-attr.h" /* For INSN_SCHEDULING. */
51 /* This variable holds information helping the rewriting of SSA trees
55 /* This variable holds the currently expanded gimple statement for purposes
56 of comminucating the profile info to the builtin expanders. */
57 gimple currently_expanding_gimple_stmt
;
59 static rtx
expand_debug_expr (tree
);
61 /* Return an expression tree corresponding to the RHS of GIMPLE
65 gimple_assign_rhs_to_tree (gimple stmt
)
68 enum gimple_rhs_class grhs_class
;
70 grhs_class
= get_gimple_rhs_class (gimple_expr_code (stmt
));
72 if (grhs_class
== GIMPLE_TERNARY_RHS
)
73 t
= build3 (gimple_assign_rhs_code (stmt
),
74 TREE_TYPE (gimple_assign_lhs (stmt
)),
75 gimple_assign_rhs1 (stmt
),
76 gimple_assign_rhs2 (stmt
),
77 gimple_assign_rhs3 (stmt
));
78 else if (grhs_class
== GIMPLE_BINARY_RHS
)
79 t
= build2 (gimple_assign_rhs_code (stmt
),
80 TREE_TYPE (gimple_assign_lhs (stmt
)),
81 gimple_assign_rhs1 (stmt
),
82 gimple_assign_rhs2 (stmt
));
83 else if (grhs_class
== GIMPLE_UNARY_RHS
)
84 t
= build1 (gimple_assign_rhs_code (stmt
),
85 TREE_TYPE (gimple_assign_lhs (stmt
)),
86 gimple_assign_rhs1 (stmt
));
87 else if (grhs_class
== GIMPLE_SINGLE_RHS
)
89 t
= gimple_assign_rhs1 (stmt
);
90 /* Avoid modifying this tree in place below. */
91 if ((gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (t
)
92 && gimple_location (stmt
) != EXPR_LOCATION (t
))
93 || (gimple_block (stmt
)
94 && currently_expanding_to_rtl
101 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (t
))
102 SET_EXPR_LOCATION (t
, gimple_location (stmt
));
108 #ifndef STACK_ALIGNMENT_NEEDED
109 #define STACK_ALIGNMENT_NEEDED 1
112 #define SSAVAR(x) (TREE_CODE (x) == SSA_NAME ? SSA_NAME_VAR (x) : x)
114 /* Associate declaration T with storage space X. If T is no
115 SSA name this is exactly SET_DECL_RTL, otherwise make the
116 partition of T associated with X. */
118 set_rtl (tree t
, rtx x
)
120 if (TREE_CODE (t
) == SSA_NAME
)
122 SA
.partition_to_pseudo
[var_to_partition (SA
.map
, t
)] = x
;
124 set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (t
), x
);
125 /* For the benefit of debug information at -O0 (where vartracking
126 doesn't run) record the place also in the base DECL if it's
127 a normal variable (not a parameter). */
128 if (x
&& x
!= pc_rtx
&& TREE_CODE (SSA_NAME_VAR (t
)) == VAR_DECL
)
130 tree var
= SSA_NAME_VAR (t
);
131 /* If we don't yet have something recorded, just record it now. */
132 if (!DECL_RTL_SET_P (var
))
133 SET_DECL_RTL (var
, x
);
134 /* If we have it set already to "multiple places" don't
136 else if (DECL_RTL (var
) == pc_rtx
)
138 /* If we have something recorded and it's not the same place
139 as we want to record now, we have multiple partitions for the
140 same base variable, with different places. We can't just
141 randomly chose one, hence we have to say that we don't know.
142 This only happens with optimization, and there var-tracking
143 will figure out the right thing. */
144 else if (DECL_RTL (var
) != x
)
145 SET_DECL_RTL (var
, pc_rtx
);
152 /* This structure holds data relevant to one variable that will be
153 placed in a stack slot. */
159 /* Initially, the size of the variable. Later, the size of the partition,
160 if this variable becomes it's partition's representative. */
163 /* The *byte* alignment required for this variable. Or as, with the
164 size, the alignment for this partition. */
167 /* The partition representative. */
168 size_t representative
;
170 /* The next stack variable in the partition, or EOC. */
173 /* The numbers of conflicting stack variables. */
177 #define EOC ((size_t)-1)
179 /* We have an array of such objects while deciding allocation. */
180 static struct stack_var
*stack_vars
;
181 static size_t stack_vars_alloc
;
182 static size_t stack_vars_num
;
183 static struct pointer_map_t
*decl_to_stack_part
;
185 /* Conflict bitmaps go on this obstack. This allows us to destroy
186 all of them in one big sweep. */
187 static bitmap_obstack stack_var_bitmap_obstack
;
189 /* An array of indices such that stack_vars[stack_vars_sorted[i]].size
190 is non-decreasing. */
191 static size_t *stack_vars_sorted
;
193 /* The phase of the stack frame. This is the known misalignment of
194 virtual_stack_vars_rtx from PREFERRED_STACK_BOUNDARY. That is,
195 (frame_offset+frame_phase) % PREFERRED_STACK_BOUNDARY == 0. */
196 static int frame_phase
;
198 /* Used during expand_used_vars to remember if we saw any decls for
199 which we'd like to enable stack smashing protection. */
200 static bool has_protected_decls
;
202 /* Used during expand_used_vars. Remember if we say a character buffer
203 smaller than our cutoff threshold. Used for -Wstack-protector. */
204 static bool has_short_buffer
;
206 /* Compute the byte alignment to use for DECL. Ignore alignment
207 we can't do with expected alignment of the stack boundary. */
210 align_local_variable (tree decl
)
212 unsigned int align
= LOCAL_DECL_ALIGNMENT (decl
);
213 DECL_ALIGN (decl
) = align
;
214 return align
/ BITS_PER_UNIT
;
217 /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
218 Return the frame offset. */
221 alloc_stack_frame_space (HOST_WIDE_INT size
, unsigned HOST_WIDE_INT align
)
223 HOST_WIDE_INT offset
, new_frame_offset
;
225 new_frame_offset
= frame_offset
;
226 if (FRAME_GROWS_DOWNWARD
)
228 new_frame_offset
-= size
+ frame_phase
;
229 new_frame_offset
&= -align
;
230 new_frame_offset
+= frame_phase
;
231 offset
= new_frame_offset
;
235 new_frame_offset
-= frame_phase
;
236 new_frame_offset
+= align
- 1;
237 new_frame_offset
&= -align
;
238 new_frame_offset
+= frame_phase
;
239 offset
= new_frame_offset
;
240 new_frame_offset
+= size
;
242 frame_offset
= new_frame_offset
;
244 if (frame_offset_overflow (frame_offset
, cfun
->decl
))
245 frame_offset
= offset
= 0;
250 /* Accumulate DECL into STACK_VARS. */
253 add_stack_var (tree decl
)
257 if (stack_vars_num
>= stack_vars_alloc
)
259 if (stack_vars_alloc
)
260 stack_vars_alloc
= stack_vars_alloc
* 3 / 2;
262 stack_vars_alloc
= 32;
264 = XRESIZEVEC (struct stack_var
, stack_vars
, stack_vars_alloc
);
266 if (!decl_to_stack_part
)
267 decl_to_stack_part
= pointer_map_create ();
269 v
= &stack_vars
[stack_vars_num
];
270 * (size_t *)pointer_map_insert (decl_to_stack_part
, decl
) = stack_vars_num
;
273 v
->size
= tree_low_cst (DECL_SIZE_UNIT (SSAVAR (decl
)), 1);
274 /* Ensure that all variables have size, so that &a != &b for any two
275 variables that are simultaneously live. */
278 v
->alignb
= align_local_variable (SSAVAR (decl
));
279 /* An alignment of zero can mightily confuse us later. */
280 gcc_assert (v
->alignb
!= 0);
282 /* All variables are initially in their own partition. */
283 v
->representative
= stack_vars_num
;
286 /* All variables initially conflict with no other. */
289 /* Ensure that this decl doesn't get put onto the list twice. */
290 set_rtl (decl
, pc_rtx
);
295 /* Make the decls associated with luid's X and Y conflict. */
298 add_stack_var_conflict (size_t x
, size_t y
)
300 struct stack_var
*a
= &stack_vars
[x
];
301 struct stack_var
*b
= &stack_vars
[y
];
303 a
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
305 b
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
306 bitmap_set_bit (a
->conflicts
, y
);
307 bitmap_set_bit (b
->conflicts
, x
);
310 /* Check whether the decls associated with luid's X and Y conflict. */
313 stack_var_conflict_p (size_t x
, size_t y
)
315 struct stack_var
*a
= &stack_vars
[x
];
316 struct stack_var
*b
= &stack_vars
[y
];
319 /* Partitions containing an SSA name result from gimple registers
320 with things like unsupported modes. They are top-level and
321 hence conflict with everything else. */
322 if (TREE_CODE (a
->decl
) == SSA_NAME
|| TREE_CODE (b
->decl
) == SSA_NAME
)
325 if (!a
->conflicts
|| !b
->conflicts
)
327 return bitmap_bit_p (a
->conflicts
, y
);
330 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
331 enter its partition number into bitmap DATA. */
334 visit_op (gimple stmt ATTRIBUTE_UNUSED
, tree op
, void *data
)
336 bitmap active
= (bitmap
)data
;
337 op
= get_base_address (op
);
340 && DECL_RTL_IF_SET (op
) == pc_rtx
)
342 size_t *v
= (size_t *) pointer_map_contains (decl_to_stack_part
, op
);
344 bitmap_set_bit (active
, *v
);
349 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
350 record conflicts between it and all currently active other partitions
354 visit_conflict (gimple stmt ATTRIBUTE_UNUSED
, tree op
, void *data
)
356 bitmap active
= (bitmap
)data
;
357 op
= get_base_address (op
);
360 && DECL_RTL_IF_SET (op
) == pc_rtx
)
363 (size_t *) pointer_map_contains (decl_to_stack_part
, op
);
364 if (v
&& bitmap_set_bit (active
, *v
))
369 gcc_assert (num
< stack_vars_num
);
370 EXECUTE_IF_SET_IN_BITMAP (active
, 0, i
, bi
)
371 add_stack_var_conflict (num
, i
);
377 /* Helper routine for add_scope_conflicts, calculating the active partitions
378 at the end of BB, leaving the result in WORK. We're called to generate
379 conflicts when FOR_CONFLICT is true, otherwise we're just tracking
383 add_scope_conflicts_1 (basic_block bb
, bitmap work
, bool for_conflict
)
387 gimple_stmt_iterator gsi
;
388 bool (*visit
)(gimple
, tree
, void *);
391 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
392 bitmap_ior_into (work
, (bitmap
)e
->src
->aux
);
396 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
398 gimple stmt
= gsi_stmt (gsi
);
399 walk_stmt_load_store_addr_ops (stmt
, work
, NULL
, NULL
, visit
);
401 for (gsi
= gsi_after_labels (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
403 gimple stmt
= gsi_stmt (gsi
);
405 if (gimple_clobber_p (stmt
))
407 tree lhs
= gimple_assign_lhs (stmt
);
409 /* Nested function lowering might introduce LHSs
410 that are COMPONENT_REFs. */
411 if (TREE_CODE (lhs
) != VAR_DECL
)
413 if (DECL_RTL_IF_SET (lhs
) == pc_rtx
415 pointer_map_contains (decl_to_stack_part
, lhs
)))
416 bitmap_clear_bit (work
, *v
);
418 else if (!is_gimple_debug (stmt
))
421 && visit
== visit_op
)
423 /* If this is the first real instruction in this BB we need
424 to add conflicts for everything live at this point now.
425 Unlike classical liveness for named objects we can't
426 rely on seeing a def/use of the names we're interested in.
427 There might merely be indirect loads/stores. We'd not add any
428 conflicts for such partitions. */
431 EXECUTE_IF_SET_IN_BITMAP (work
, 0, i
, bi
)
433 struct stack_var
*a
= &stack_vars
[i
];
435 a
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
436 bitmap_ior_into (a
->conflicts
, work
);
438 visit
= visit_conflict
;
440 walk_stmt_load_store_addr_ops (stmt
, work
, visit
, visit
, visit
);
445 /* Generate stack partition conflicts between all partitions that are
446 simultaneously live. */
449 add_scope_conflicts (void)
453 bitmap work
= BITMAP_ALLOC (NULL
);
457 /* We approximate the live range of a stack variable by taking the first
458 mention of its name as starting point(s), and by the end-of-scope
459 death clobber added by gimplify as ending point(s) of the range.
460 This overapproximates in the case we for instance moved an address-taken
461 operation upward, without also moving a dereference to it upwards.
462 But it's conservatively correct as a variable never can hold values
463 before its name is mentioned at least once.
465 We then do a mostly classical bitmap liveness algorithm. */
468 bb
->aux
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
470 rpo
= XNEWVEC (int, last_basic_block
);
471 n_bbs
= pre_and_rev_post_order_compute (NULL
, rpo
, false);
478 for (i
= 0; i
< n_bbs
; i
++)
481 bb
= BASIC_BLOCK (rpo
[i
]);
482 active
= (bitmap
)bb
->aux
;
483 add_scope_conflicts_1 (bb
, work
, false);
484 if (bitmap_ior_into (active
, work
))
490 add_scope_conflicts_1 (bb
, work
, true);
495 BITMAP_FREE (bb
->aux
);
498 /* A subroutine of partition_stack_vars. A comparison function for qsort,
499 sorting an array of indices by the properties of the object. */
502 stack_var_cmp (const void *a
, const void *b
)
504 size_t ia
= *(const size_t *)a
;
505 size_t ib
= *(const size_t *)b
;
506 unsigned int aligna
= stack_vars
[ia
].alignb
;
507 unsigned int alignb
= stack_vars
[ib
].alignb
;
508 HOST_WIDE_INT sizea
= stack_vars
[ia
].size
;
509 HOST_WIDE_INT sizeb
= stack_vars
[ib
].size
;
510 tree decla
= stack_vars
[ia
].decl
;
511 tree declb
= stack_vars
[ib
].decl
;
513 unsigned int uida
, uidb
;
515 /* Primary compare on "large" alignment. Large comes first. */
516 largea
= (aligna
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
517 largeb
= (alignb
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
518 if (largea
!= largeb
)
519 return (int)largeb
- (int)largea
;
521 /* Secondary compare on size, decreasing */
527 /* Tertiary compare on true alignment, decreasing. */
533 /* Final compare on ID for sort stability, increasing.
534 Two SSA names are compared by their version, SSA names come before
535 non-SSA names, and two normal decls are compared by their DECL_UID. */
536 if (TREE_CODE (decla
) == SSA_NAME
)
538 if (TREE_CODE (declb
) == SSA_NAME
)
539 uida
= SSA_NAME_VERSION (decla
), uidb
= SSA_NAME_VERSION (declb
);
543 else if (TREE_CODE (declb
) == SSA_NAME
)
546 uida
= DECL_UID (decla
), uidb
= DECL_UID (declb
);
555 /* If the points-to solution *PI points to variables that are in a partition
556 together with other variables add all partition members to the pointed-to
560 add_partitioned_vars_to_ptset (struct pt_solution
*pt
,
561 struct pointer_map_t
*decls_to_partitions
,
562 struct pointer_set_t
*visited
, bitmap temp
)
570 /* The pointed-to vars bitmap is shared, it is enough to
572 || pointer_set_insert(visited
, pt
->vars
))
577 /* By using a temporary bitmap to store all members of the partitions
578 we have to add we make sure to visit each of the partitions only
580 EXECUTE_IF_SET_IN_BITMAP (pt
->vars
, 0, i
, bi
)
582 || !bitmap_bit_p (temp
, i
))
583 && (part
= (bitmap
*) pointer_map_contains (decls_to_partitions
,
584 (void *)(size_t) i
)))
585 bitmap_ior_into (temp
, *part
);
586 if (!bitmap_empty_p (temp
))
587 bitmap_ior_into (pt
->vars
, temp
);
590 /* Update points-to sets based on partition info, so we can use them on RTL.
591 The bitmaps representing stack partitions will be saved until expand,
592 where partitioned decls used as bases in memory expressions will be
596 update_alias_info_with_stack_vars (void)
598 struct pointer_map_t
*decls_to_partitions
= NULL
;
600 tree var
= NULL_TREE
;
602 for (i
= 0; i
< stack_vars_num
; i
++)
606 struct ptr_info_def
*pi
;
608 /* Not interested in partitions with single variable. */
609 if (stack_vars
[i
].representative
!= i
610 || stack_vars
[i
].next
== EOC
)
613 if (!decls_to_partitions
)
615 decls_to_partitions
= pointer_map_create ();
616 cfun
->gimple_df
->decls_to_pointers
= pointer_map_create ();
619 /* Create an SSA_NAME that points to the partition for use
620 as base during alias-oracle queries on RTL for bases that
621 have been partitioned. */
622 if (var
== NULL_TREE
)
623 var
= create_tmp_var (ptr_type_node
, NULL
);
624 name
= make_ssa_name (var
, NULL
);
626 /* Create bitmaps representing partitions. They will be used for
627 points-to sets later, so use GGC alloc. */
628 part
= BITMAP_GGC_ALLOC ();
629 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
631 tree decl
= stack_vars
[j
].decl
;
632 unsigned int uid
= DECL_PT_UID (decl
);
633 bitmap_set_bit (part
, uid
);
634 *((bitmap
*) pointer_map_insert (decls_to_partitions
,
635 (void *)(size_t) uid
)) = part
;
636 *((tree
*) pointer_map_insert (cfun
->gimple_df
->decls_to_pointers
,
638 if (TREE_ADDRESSABLE (decl
))
639 TREE_ADDRESSABLE (name
) = 1;
642 /* Make the SSA name point to all partition members. */
643 pi
= get_ptr_info (name
);
644 pt_solution_set (&pi
->pt
, part
, false);
647 /* Make all points-to sets that contain one member of a partition
648 contain all members of the partition. */
649 if (decls_to_partitions
)
652 struct pointer_set_t
*visited
= pointer_set_create ();
653 bitmap temp
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
655 for (i
= 1; i
< num_ssa_names
; i
++)
657 tree name
= ssa_name (i
);
658 struct ptr_info_def
*pi
;
661 && POINTER_TYPE_P (TREE_TYPE (name
))
662 && ((pi
= SSA_NAME_PTR_INFO (name
)) != NULL
))
663 add_partitioned_vars_to_ptset (&pi
->pt
, decls_to_partitions
,
667 add_partitioned_vars_to_ptset (&cfun
->gimple_df
->escaped
,
668 decls_to_partitions
, visited
, temp
);
670 pointer_set_destroy (visited
);
671 pointer_map_destroy (decls_to_partitions
);
676 /* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
677 partitioning algorithm. Partitions A and B are known to be non-conflicting.
678 Merge them into a single partition A. */
681 union_stack_vars (size_t a
, size_t b
)
683 struct stack_var
*vb
= &stack_vars
[b
];
687 gcc_assert (stack_vars
[b
].next
== EOC
);
688 /* Add B to A's partition. */
689 stack_vars
[b
].next
= stack_vars
[a
].next
;
690 stack_vars
[b
].representative
= a
;
691 stack_vars
[a
].next
= b
;
693 /* Update the required alignment of partition A to account for B. */
694 if (stack_vars
[a
].alignb
< stack_vars
[b
].alignb
)
695 stack_vars
[a
].alignb
= stack_vars
[b
].alignb
;
697 /* Update the interference graph and merge the conflicts. */
700 EXECUTE_IF_SET_IN_BITMAP (vb
->conflicts
, 0, u
, bi
)
701 add_stack_var_conflict (a
, stack_vars
[u
].representative
);
702 BITMAP_FREE (vb
->conflicts
);
706 /* A subroutine of expand_used_vars. Binpack the variables into
707 partitions constrained by the interference graph. The overall
708 algorithm used is as follows:
710 Sort the objects by size in descending order.
715 Look for the largest non-conflicting object B with size <= S.
722 partition_stack_vars (void)
724 size_t si
, sj
, n
= stack_vars_num
;
726 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
727 for (si
= 0; si
< n
; ++si
)
728 stack_vars_sorted
[si
] = si
;
733 qsort (stack_vars_sorted
, n
, sizeof (size_t), stack_var_cmp
);
735 for (si
= 0; si
< n
; ++si
)
737 size_t i
= stack_vars_sorted
[si
];
738 unsigned int ialign
= stack_vars
[i
].alignb
;
739 HOST_WIDE_INT isize
= stack_vars
[i
].size
;
741 /* Ignore objects that aren't partition representatives. If we
742 see a var that is not a partition representative, it must
743 have been merged earlier. */
744 if (stack_vars
[i
].representative
!= i
)
747 for (sj
= si
+ 1; sj
< n
; ++sj
)
749 size_t j
= stack_vars_sorted
[sj
];
750 unsigned int jalign
= stack_vars
[j
].alignb
;
751 HOST_WIDE_INT jsize
= stack_vars
[j
].size
;
753 /* Ignore objects that aren't partition representatives. */
754 if (stack_vars
[j
].representative
!= j
)
757 /* Do not mix objects of "small" (supported) alignment
758 and "large" (unsupported) alignment. */
759 if ((ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
760 != (jalign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
))
763 /* For Address Sanitizer do not mix objects with different
764 sizes, as the shorter vars wouldn't be adequately protected.
765 Don't do that for "large" (unsupported) alignment objects,
766 those aren't protected anyway. */
767 if (flag_asan
&& isize
!= jsize
768 && ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
771 /* Ignore conflicting objects. */
772 if (stack_var_conflict_p (i
, j
))
775 /* UNION the objects, placing J at OFFSET. */
776 union_stack_vars (i
, j
);
780 update_alias_info_with_stack_vars ();
783 /* A debugging aid for expand_used_vars. Dump the generated partitions. */
786 dump_stack_var_partition (void)
788 size_t si
, i
, j
, n
= stack_vars_num
;
790 for (si
= 0; si
< n
; ++si
)
792 i
= stack_vars_sorted
[si
];
794 /* Skip variables that aren't partition representatives, for now. */
795 if (stack_vars
[i
].representative
!= i
)
798 fprintf (dump_file
, "Partition %lu: size " HOST_WIDE_INT_PRINT_DEC
799 " align %u\n", (unsigned long) i
, stack_vars
[i
].size
,
800 stack_vars
[i
].alignb
);
802 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
804 fputc ('\t', dump_file
);
805 print_generic_expr (dump_file
, stack_vars
[j
].decl
, dump_flags
);
807 fputc ('\n', dump_file
);
811 /* Assign rtl to DECL at BASE + OFFSET. */
814 expand_one_stack_var_at (tree decl
, rtx base
, unsigned base_align
,
815 HOST_WIDE_INT offset
)
820 /* If this fails, we've overflowed the stack frame. Error nicely? */
821 gcc_assert (offset
== trunc_int_for_mode (offset
, Pmode
));
823 x
= plus_constant (Pmode
, base
, offset
);
824 x
= gen_rtx_MEM (DECL_MODE (SSAVAR (decl
)), x
);
826 if (TREE_CODE (decl
) != SSA_NAME
)
828 /* Set alignment we actually gave this decl if it isn't an SSA name.
829 If it is we generate stack slots only accidentally so it isn't as
830 important, we'll simply use the alignment that is already set. */
831 if (base
== virtual_stack_vars_rtx
)
832 offset
-= frame_phase
;
833 align
= offset
& -offset
;
834 align
*= BITS_PER_UNIT
;
835 if (align
== 0 || align
> base_align
)
838 /* One would think that we could assert that we're not decreasing
839 alignment here, but (at least) the i386 port does exactly this
840 via the MINIMUM_ALIGNMENT hook. */
842 DECL_ALIGN (decl
) = align
;
843 DECL_USER_ALIGN (decl
) = 0;
846 set_mem_attributes (x
, SSAVAR (decl
), true);
850 struct stack_vars_data
852 /* Vector of offset pairs, always end of some padding followed
853 by start of the padding that needs Address Sanitizer protection.
854 The vector is in reversed, highest offset pairs come first. */
855 vec
<HOST_WIDE_INT
> asan_vec
;
857 /* Vector of partition representative decls in between the paddings. */
858 vec
<tree
> asan_decl_vec
;
861 /* A subroutine of expand_used_vars. Give each partition representative
862 a unique location within the stack frame. Update each partition member
863 with that location. */
866 expand_stack_vars (bool (*pred
) (size_t), struct stack_vars_data
*data
)
868 size_t si
, i
, j
, n
= stack_vars_num
;
869 HOST_WIDE_INT large_size
= 0, large_alloc
= 0;
870 rtx large_base
= NULL
;
871 unsigned large_align
= 0;
874 /* Determine if there are any variables requiring "large" alignment.
875 Since these are dynamically allocated, we only process these if
876 no predicate involved. */
877 large_align
= stack_vars
[stack_vars_sorted
[0]].alignb
* BITS_PER_UNIT
;
878 if (pred
== NULL
&& large_align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
880 /* Find the total size of these variables. */
881 for (si
= 0; si
< n
; ++si
)
885 i
= stack_vars_sorted
[si
];
886 alignb
= stack_vars
[i
].alignb
;
888 /* Stop when we get to the first decl with "small" alignment. */
889 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
892 /* Skip variables that aren't partition representatives. */
893 if (stack_vars
[i
].representative
!= i
)
896 /* Skip variables that have already had rtl assigned. See also
897 add_stack_var where we perpetrate this pc_rtx hack. */
898 decl
= stack_vars
[i
].decl
;
899 if ((TREE_CODE (decl
) == SSA_NAME
900 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)]
901 : DECL_RTL (decl
)) != pc_rtx
)
904 large_size
+= alignb
- 1;
905 large_size
&= -(HOST_WIDE_INT
)alignb
;
906 large_size
+= stack_vars
[i
].size
;
909 /* If there were any, allocate space. */
911 large_base
= allocate_dynamic_stack_space (GEN_INT (large_size
), 0,
915 for (si
= 0; si
< n
; ++si
)
918 unsigned base_align
, alignb
;
919 HOST_WIDE_INT offset
;
921 i
= stack_vars_sorted
[si
];
923 /* Skip variables that aren't partition representatives, for now. */
924 if (stack_vars
[i
].representative
!= i
)
927 /* Skip variables that have already had rtl assigned. See also
928 add_stack_var where we perpetrate this pc_rtx hack. */
929 decl
= stack_vars
[i
].decl
;
930 if ((TREE_CODE (decl
) == SSA_NAME
931 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)]
932 : DECL_RTL (decl
)) != pc_rtx
)
935 /* Check the predicate to see whether this variable should be
936 allocated in this pass. */
937 if (pred
&& !pred (i
))
940 alignb
= stack_vars
[i
].alignb
;
941 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
943 if (flag_asan
&& pred
)
945 HOST_WIDE_INT prev_offset
= frame_offset
;
946 tree repr_decl
= NULL_TREE
;
949 = alloc_stack_frame_space (stack_vars
[i
].size
950 + ASAN_RED_ZONE_SIZE
,
951 MAX (alignb
, ASAN_RED_ZONE_SIZE
));
952 data
->asan_vec
.safe_push (prev_offset
);
953 data
->asan_vec
.safe_push (offset
+ stack_vars
[i
].size
);
954 /* Find best representative of the partition.
955 Prefer those with DECL_NAME, even better
956 satisfying asan_protect_stack_decl predicate. */
957 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
958 if (asan_protect_stack_decl (stack_vars
[j
].decl
)
959 && DECL_NAME (stack_vars
[j
].decl
))
961 repr_decl
= stack_vars
[j
].decl
;
964 else if (repr_decl
== NULL_TREE
965 && DECL_P (stack_vars
[j
].decl
)
966 && DECL_NAME (stack_vars
[j
].decl
))
967 repr_decl
= stack_vars
[j
].decl
;
968 if (repr_decl
== NULL_TREE
)
969 repr_decl
= stack_vars
[i
].decl
;
970 data
->asan_decl_vec
.safe_push (repr_decl
);
973 offset
= alloc_stack_frame_space (stack_vars
[i
].size
, alignb
);
974 base
= virtual_stack_vars_rtx
;
975 base_align
= crtl
->max_used_stack_slot_alignment
;
979 /* Large alignment is only processed in the last pass. */
982 gcc_assert (large_base
!= NULL
);
984 large_alloc
+= alignb
- 1;
985 large_alloc
&= -(HOST_WIDE_INT
)alignb
;
986 offset
= large_alloc
;
987 large_alloc
+= stack_vars
[i
].size
;
990 base_align
= large_align
;
993 /* Create rtl for each variable based on their location within the
995 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
997 expand_one_stack_var_at (stack_vars
[j
].decl
,
1003 gcc_assert (large_alloc
== large_size
);
1006 /* Take into account all sizes of partitions and reset DECL_RTLs. */
1007 static HOST_WIDE_INT
1008 account_stack_vars (void)
1010 size_t si
, j
, i
, n
= stack_vars_num
;
1011 HOST_WIDE_INT size
= 0;
1013 for (si
= 0; si
< n
; ++si
)
1015 i
= stack_vars_sorted
[si
];
1017 /* Skip variables that aren't partition representatives, for now. */
1018 if (stack_vars
[i
].representative
!= i
)
1021 size
+= stack_vars
[i
].size
;
1022 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1023 set_rtl (stack_vars
[j
].decl
, NULL
);
1028 /* A subroutine of expand_one_var. Called to immediately assign rtl
1029 to a variable to be allocated in the stack frame. */
1032 expand_one_stack_var (tree var
)
1034 HOST_WIDE_INT size
, offset
;
1035 unsigned byte_align
;
1037 size
= tree_low_cst (DECL_SIZE_UNIT (SSAVAR (var
)), 1);
1038 byte_align
= align_local_variable (SSAVAR (var
));
1040 /* We handle highly aligned variables in expand_stack_vars. */
1041 gcc_assert (byte_align
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
);
1043 offset
= alloc_stack_frame_space (size
, byte_align
);
1045 expand_one_stack_var_at (var
, virtual_stack_vars_rtx
,
1046 crtl
->max_used_stack_slot_alignment
, offset
);
1049 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1050 that will reside in a hard register. */
1053 expand_one_hard_reg_var (tree var
)
1055 rest_of_decl_compilation (var
, 0, 0);
1058 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1059 that will reside in a pseudo register. */
1062 expand_one_register_var (tree var
)
1064 tree decl
= SSAVAR (var
);
1065 tree type
= TREE_TYPE (decl
);
1066 enum machine_mode reg_mode
= promote_decl_mode (decl
, NULL
);
1067 rtx x
= gen_reg_rtx (reg_mode
);
1071 /* Note if the object is a user variable. */
1072 if (!DECL_ARTIFICIAL (decl
))
1075 if (POINTER_TYPE_P (type
))
1076 mark_reg_pointer (x
, get_pointer_alignment (var
));
1079 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
1080 has some associated error, e.g. its type is error-mark. We just need
1081 to pick something that won't crash the rest of the compiler. */
1084 expand_one_error_var (tree var
)
1086 enum machine_mode mode
= DECL_MODE (var
);
1089 if (mode
== BLKmode
)
1090 x
= gen_rtx_MEM (BLKmode
, const0_rtx
);
1091 else if (mode
== VOIDmode
)
1094 x
= gen_reg_rtx (mode
);
1096 SET_DECL_RTL (var
, x
);
1099 /* A subroutine of expand_one_var. VAR is a variable that will be
1100 allocated to the local stack frame. Return true if we wish to
1101 add VAR to STACK_VARS so that it will be coalesced with other
1102 variables. Return false to allocate VAR immediately.
1104 This function is used to reduce the number of variables considered
1105 for coalescing, which reduces the size of the quadratic problem. */
1108 defer_stack_allocation (tree var
, bool toplevel
)
1110 /* If stack protection is enabled, *all* stack variables must be deferred,
1111 so that we can re-order the strings to the top of the frame.
1112 Similarly for Address Sanitizer. */
1113 if (flag_stack_protect
|| flag_asan
)
1116 /* We handle "large" alignment via dynamic allocation. We want to handle
1117 this extra complication in only one place, so defer them. */
1118 if (DECL_ALIGN (var
) > MAX_SUPPORTED_STACK_ALIGNMENT
)
1121 /* Variables in the outermost scope automatically conflict with
1122 every other variable. The only reason to want to defer them
1123 at all is that, after sorting, we can more efficiently pack
1124 small variables in the stack frame. Continue to defer at -O2. */
1125 if (toplevel
&& optimize
< 2)
1128 /* Without optimization, *most* variables are allocated from the
1129 stack, which makes the quadratic problem large exactly when we
1130 want compilation to proceed as quickly as possible. On the
1131 other hand, we don't want the function's stack frame size to
1132 get completely out of hand. So we avoid adding scalars and
1133 "small" aggregates to the list at all. */
1134 if (optimize
== 0 && tree_low_cst (DECL_SIZE_UNIT (var
), 1) < 32)
1140 /* A subroutine of expand_used_vars. Expand one variable according to
1141 its flavor. Variables to be placed on the stack are not actually
1142 expanded yet, merely recorded.
1143 When REALLY_EXPAND is false, only add stack values to be allocated.
1144 Return stack usage this variable is supposed to take.
1147 static HOST_WIDE_INT
1148 expand_one_var (tree var
, bool toplevel
, bool really_expand
)
1150 unsigned int align
= BITS_PER_UNIT
;
1155 if (TREE_TYPE (var
) != error_mark_node
&& TREE_CODE (var
) == VAR_DECL
)
1157 /* Because we don't know if VAR will be in register or on stack,
1158 we conservatively assume it will be on stack even if VAR is
1159 eventually put into register after RA pass. For non-automatic
1160 variables, which won't be on stack, we collect alignment of
1161 type and ignore user specified alignment. */
1162 if (TREE_STATIC (var
) || DECL_EXTERNAL (var
))
1163 align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1164 TYPE_MODE (TREE_TYPE (var
)),
1165 TYPE_ALIGN (TREE_TYPE (var
)));
1166 else if (DECL_HAS_VALUE_EXPR_P (var
)
1167 || (DECL_RTL_SET_P (var
) && MEM_P (DECL_RTL (var
))))
1168 /* Don't consider debug only variables with DECL_HAS_VALUE_EXPR_P set
1169 or variables which were assigned a stack slot already by
1170 expand_one_stack_var_at - in the latter case DECL_ALIGN has been
1171 changed from the offset chosen to it. */
1172 align
= crtl
->stack_alignment_estimated
;
1174 align
= MINIMUM_ALIGNMENT (var
, DECL_MODE (var
), DECL_ALIGN (var
));
1176 /* If the variable alignment is very large we'll dynamicaly allocate
1177 it, which means that in-frame portion is just a pointer. */
1178 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1179 align
= POINTER_SIZE
;
1182 if (SUPPORTS_STACK_ALIGNMENT
1183 && crtl
->stack_alignment_estimated
< align
)
1185 /* stack_alignment_estimated shouldn't change after stack
1186 realign decision made */
1187 gcc_assert(!crtl
->stack_realign_processed
);
1188 crtl
->stack_alignment_estimated
= align
;
1191 /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
1192 So here we only make sure stack_alignment_needed >= align. */
1193 if (crtl
->stack_alignment_needed
< align
)
1194 crtl
->stack_alignment_needed
= align
;
1195 if (crtl
->max_used_stack_slot_alignment
< align
)
1196 crtl
->max_used_stack_slot_alignment
= align
;
1198 if (TREE_CODE (origvar
) == SSA_NAME
)
1200 gcc_assert (TREE_CODE (var
) != VAR_DECL
1201 || (!DECL_EXTERNAL (var
)
1202 && !DECL_HAS_VALUE_EXPR_P (var
)
1203 && !TREE_STATIC (var
)
1204 && TREE_TYPE (var
) != error_mark_node
1205 && !DECL_HARD_REGISTER (var
)
1208 if (TREE_CODE (var
) != VAR_DECL
&& TREE_CODE (origvar
) != SSA_NAME
)
1210 else if (DECL_EXTERNAL (var
))
1212 else if (DECL_HAS_VALUE_EXPR_P (var
))
1214 else if (TREE_STATIC (var
))
1216 else if (TREE_CODE (origvar
) != SSA_NAME
&& DECL_RTL_SET_P (var
))
1218 else if (TREE_TYPE (var
) == error_mark_node
)
1221 expand_one_error_var (var
);
1223 else if (TREE_CODE (var
) == VAR_DECL
&& DECL_HARD_REGISTER (var
))
1226 expand_one_hard_reg_var (var
);
1228 else if (use_register_for_decl (var
))
1231 expand_one_register_var (origvar
);
1233 else if (! valid_constant_size_p (DECL_SIZE_UNIT (var
)))
1235 /* Reject variables which cover more than half of the address-space. */
1238 error ("size of variable %q+D is too large", var
);
1239 expand_one_error_var (var
);
1242 else if (defer_stack_allocation (var
, toplevel
))
1243 add_stack_var (origvar
);
1247 expand_one_stack_var (origvar
);
1248 return tree_low_cst (DECL_SIZE_UNIT (var
), 1);
1253 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1254 expanding variables. Those variables that can be put into registers
1255 are allocated pseudos; those that can't are put on the stack.
1257 TOPLEVEL is true if this is the outermost BLOCK. */
1260 expand_used_vars_for_block (tree block
, bool toplevel
)
1264 /* Expand all variables at this level. */
1265 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1267 && ((TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != RESULT_DECL
)
1268 || !DECL_NONSHAREABLE (t
)))
1269 expand_one_var (t
, toplevel
, true);
1271 /* Expand all variables at containing levels. */
1272 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1273 expand_used_vars_for_block (t
, false);
1276 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1277 and clear TREE_USED on all local variables. */
1280 clear_tree_used (tree block
)
1284 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1285 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
1286 if ((TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != RESULT_DECL
)
1287 || !DECL_NONSHAREABLE (t
))
1290 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1291 clear_tree_used (t
);
1294 /* Examine TYPE and determine a bit mask of the following features. */
1296 #define SPCT_HAS_LARGE_CHAR_ARRAY 1
1297 #define SPCT_HAS_SMALL_CHAR_ARRAY 2
1298 #define SPCT_HAS_ARRAY 4
1299 #define SPCT_HAS_AGGREGATE 8
1302 stack_protect_classify_type (tree type
)
1304 unsigned int ret
= 0;
1307 switch (TREE_CODE (type
))
1310 t
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1311 if (t
== char_type_node
1312 || t
== signed_char_type_node
1313 || t
== unsigned_char_type_node
)
1315 unsigned HOST_WIDE_INT max
= PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
);
1316 unsigned HOST_WIDE_INT len
;
1318 if (!TYPE_SIZE_UNIT (type
)
1319 || !host_integerp (TYPE_SIZE_UNIT (type
), 1))
1322 len
= tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
1325 ret
= SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1327 ret
= SPCT_HAS_LARGE_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1330 ret
= SPCT_HAS_ARRAY
;
1334 case QUAL_UNION_TYPE
:
1336 ret
= SPCT_HAS_AGGREGATE
;
1337 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
1338 if (TREE_CODE (t
) == FIELD_DECL
)
1339 ret
|= stack_protect_classify_type (TREE_TYPE (t
));
1349 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
1350 part of the local stack frame. Remember if we ever return nonzero for
1351 any variable in this function. The return value is the phase number in
1352 which the variable should be allocated. */
1355 stack_protect_decl_phase (tree decl
)
1357 unsigned int bits
= stack_protect_classify_type (TREE_TYPE (decl
));
1360 if (bits
& SPCT_HAS_SMALL_CHAR_ARRAY
)
1361 has_short_buffer
= true;
1363 if (flag_stack_protect
== 2)
1365 if ((bits
& (SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_LARGE_CHAR_ARRAY
))
1366 && !(bits
& SPCT_HAS_AGGREGATE
))
1368 else if (bits
& SPCT_HAS_ARRAY
)
1372 ret
= (bits
& SPCT_HAS_LARGE_CHAR_ARRAY
) != 0;
1375 has_protected_decls
= true;
1380 /* Two helper routines that check for phase 1 and phase 2. These are used
1381 as callbacks for expand_stack_vars. */
1384 stack_protect_decl_phase_1 (size_t i
)
1386 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 1;
1390 stack_protect_decl_phase_2 (size_t i
)
1392 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 2;
1395 /* And helper function that checks for asan phase (with stack protector
1396 it is phase 3). This is used as callback for expand_stack_vars.
1397 Returns true if any of the vars in the partition need to be protected. */
1400 asan_decl_phase_3 (size_t i
)
1404 if (asan_protect_stack_decl (stack_vars
[i
].decl
))
1406 i
= stack_vars
[i
].next
;
1411 /* Ensure that variables in different stack protection phases conflict
1412 so that they are not merged and share the same stack slot. */
1415 add_stack_protection_conflicts (void)
1417 size_t i
, j
, n
= stack_vars_num
;
1418 unsigned char *phase
;
1420 phase
= XNEWVEC (unsigned char, n
);
1421 for (i
= 0; i
< n
; ++i
)
1422 phase
[i
] = stack_protect_decl_phase (stack_vars
[i
].decl
);
1424 for (i
= 0; i
< n
; ++i
)
1426 unsigned char ph_i
= phase
[i
];
1427 for (j
= i
+ 1; j
< n
; ++j
)
1428 if (ph_i
!= phase
[j
])
1429 add_stack_var_conflict (i
, j
);
1435 /* Create a decl for the guard at the top of the stack frame. */
1438 create_stack_guard (void)
1440 tree guard
= build_decl (DECL_SOURCE_LOCATION (current_function_decl
),
1441 VAR_DECL
, NULL
, ptr_type_node
);
1442 TREE_THIS_VOLATILE (guard
) = 1;
1443 TREE_USED (guard
) = 1;
1444 expand_one_stack_var (guard
);
1445 crtl
->stack_protect_guard
= guard
;
1448 /* Prepare for expanding variables. */
1450 init_vars_expansion (void)
1452 /* Conflict bitmaps, and a few related temporary bitmaps, go here. */
1453 bitmap_obstack_initialize (&stack_var_bitmap_obstack
);
1455 /* A map from decl to stack partition. */
1456 decl_to_stack_part
= pointer_map_create ();
1458 /* Initialize local stack smashing state. */
1459 has_protected_decls
= false;
1460 has_short_buffer
= false;
1463 /* Free up stack variable graph data. */
1465 fini_vars_expansion (void)
1467 bitmap_obstack_release (&stack_var_bitmap_obstack
);
1469 XDELETEVEC (stack_vars
);
1470 if (stack_vars_sorted
)
1471 XDELETEVEC (stack_vars_sorted
);
1473 stack_vars_sorted
= NULL
;
1474 stack_vars_alloc
= stack_vars_num
= 0;
1475 pointer_map_destroy (decl_to_stack_part
);
1476 decl_to_stack_part
= NULL
;
1479 /* Make a fair guess for the size of the stack frame of the function
1480 in NODE. This doesn't have to be exact, the result is only used in
1481 the inline heuristics. So we don't want to run the full stack var
1482 packing algorithm (which is quadratic in the number of stack vars).
1483 Instead, we calculate the total size of all stack vars. This turns
1484 out to be a pretty fair estimate -- packing of stack vars doesn't
1485 happen very often. */
1488 estimated_stack_frame_size (struct cgraph_node
*node
)
1490 HOST_WIDE_INT size
= 0;
1493 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->symbol
.decl
);
1497 init_vars_expansion ();
1499 FOR_EACH_LOCAL_DECL (fn
, i
, var
)
1500 if (auto_var_in_fn_p (var
, fn
->decl
))
1501 size
+= expand_one_var (var
, true, false);
1503 if (stack_vars_num
> 0)
1505 /* Fake sorting the stack vars for account_stack_vars (). */
1506 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
1507 for (i
= 0; i
< stack_vars_num
; ++i
)
1508 stack_vars_sorted
[i
] = i
;
1509 size
+= account_stack_vars ();
1512 fini_vars_expansion ();
1517 /* Expand all variables used in the function. */
1520 expand_used_vars (void)
1522 tree var
, outer_block
= DECL_INITIAL (current_function_decl
);
1523 vec
<tree
> maybe_local_decls
= vNULL
;
1524 rtx var_end_seq
= NULL_RTX
;
1525 struct pointer_map_t
*ssa_name_decls
;
1529 /* Compute the phase of the stack frame for this function. */
1531 int align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
1532 int off
= STARTING_FRAME_OFFSET
% align
;
1533 frame_phase
= off
? align
- off
: 0;
1536 /* Set TREE_USED on all variables in the local_decls. */
1537 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
1538 TREE_USED (var
) = 1;
1539 /* Clear TREE_USED on all variables associated with a block scope. */
1540 clear_tree_used (DECL_INITIAL (current_function_decl
));
1542 init_vars_expansion ();
1544 ssa_name_decls
= pointer_map_create ();
1545 for (i
= 0; i
< SA
.map
->num_partitions
; i
++)
1547 tree var
= partition_to_var (SA
.map
, i
);
1549 gcc_assert (!virtual_operand_p (var
));
1551 /* Assign decls to each SSA name partition, share decls for partitions
1552 we could have coalesced (those with the same type). */
1553 if (SSA_NAME_VAR (var
) == NULL_TREE
)
1555 void **slot
= pointer_map_insert (ssa_name_decls
, TREE_TYPE (var
));
1557 *slot
= (void *) create_tmp_reg (TREE_TYPE (var
), NULL
);
1558 replace_ssa_name_symbol (var
, (tree
) *slot
);
1561 if (TREE_CODE (SSA_NAME_VAR (var
)) == VAR_DECL
)
1562 expand_one_var (var
, true, true);
1565 /* This is a PARM_DECL or RESULT_DECL. For those partitions that
1566 contain the default def (representing the parm or result itself)
1567 we don't do anything here. But those which don't contain the
1568 default def (representing a temporary based on the parm/result)
1569 we need to allocate space just like for normal VAR_DECLs. */
1570 if (!bitmap_bit_p (SA
.partition_has_default_def
, i
))
1572 expand_one_var (var
, true, true);
1573 gcc_assert (SA
.partition_to_pseudo
[i
]);
1577 pointer_map_destroy (ssa_name_decls
);
1579 /* At this point all variables on the local_decls with TREE_USED
1580 set are not associated with any block scope. Lay them out. */
1582 len
= vec_safe_length (cfun
->local_decls
);
1583 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
1585 bool expand_now
= false;
1587 /* Expanded above already. */
1588 if (is_gimple_reg (var
))
1590 TREE_USED (var
) = 0;
1593 /* We didn't set a block for static or extern because it's hard
1594 to tell the difference between a global variable (re)declared
1595 in a local scope, and one that's really declared there to
1596 begin with. And it doesn't really matter much, since we're
1597 not giving them stack space. Expand them now. */
1598 else if (TREE_STATIC (var
) || DECL_EXTERNAL (var
))
1601 /* If the variable is not associated with any block, then it
1602 was created by the optimizers, and could be live anywhere
1604 else if (TREE_USED (var
))
1607 /* Finally, mark all variables on the list as used. We'll use
1608 this in a moment when we expand those associated with scopes. */
1609 TREE_USED (var
) = 1;
1612 expand_one_var (var
, true, true);
1615 if (DECL_ARTIFICIAL (var
) && !DECL_IGNORED_P (var
))
1617 rtx rtl
= DECL_RTL_IF_SET (var
);
1619 /* Keep artificial non-ignored vars in cfun->local_decls
1620 chain until instantiate_decls. */
1621 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
1622 add_local_decl (cfun
, var
);
1623 else if (rtl
== NULL_RTX
)
1624 /* If rtl isn't set yet, which can happen e.g. with
1625 -fstack-protector, retry before returning from this
1627 maybe_local_decls
.safe_push (var
);
1631 /* We duplicated some of the decls in CFUN->LOCAL_DECLS.
1633 +-----------------+-----------------+
1634 | ...processed... | ...duplicates...|
1635 +-----------------+-----------------+
1637 +-- LEN points here.
1639 We just want the duplicates, as those are the artificial
1640 non-ignored vars that we want to keep until instantiate_decls.
1641 Move them down and truncate the array. */
1642 if (!vec_safe_is_empty (cfun
->local_decls
))
1643 cfun
->local_decls
->block_remove (0, len
);
1645 /* At this point, all variables within the block tree with TREE_USED
1646 set are actually used by the optimized function. Lay them out. */
1647 expand_used_vars_for_block (outer_block
, true);
1649 if (stack_vars_num
> 0)
1651 add_scope_conflicts ();
1653 /* If stack protection is enabled, we don't share space between
1654 vulnerable data and non-vulnerable data. */
1655 if (flag_stack_protect
)
1656 add_stack_protection_conflicts ();
1658 /* Now that we have collected all stack variables, and have computed a
1659 minimal interference graph, attempt to save some stack space. */
1660 partition_stack_vars ();
1662 dump_stack_var_partition ();
1665 /* There are several conditions under which we should create a
1666 stack guard: protect-all, alloca used, protected decls present. */
1667 if (flag_stack_protect
== 2
1668 || (flag_stack_protect
1669 && (cfun
->calls_alloca
|| has_protected_decls
)))
1670 create_stack_guard ();
1672 /* Assign rtl to each variable based on these partitions. */
1673 if (stack_vars_num
> 0)
1675 struct stack_vars_data data
;
1677 data
.asan_vec
= vNULL
;
1678 data
.asan_decl_vec
= vNULL
;
1680 /* Reorder decls to be protected by iterating over the variables
1681 array multiple times, and allocating out of each phase in turn. */
1682 /* ??? We could probably integrate this into the qsort we did
1683 earlier, such that we naturally see these variables first,
1684 and thus naturally allocate things in the right order. */
1685 if (has_protected_decls
)
1687 /* Phase 1 contains only character arrays. */
1688 expand_stack_vars (stack_protect_decl_phase_1
, &data
);
1690 /* Phase 2 contains other kinds of arrays. */
1691 if (flag_stack_protect
== 2)
1692 expand_stack_vars (stack_protect_decl_phase_2
, &data
);
1696 /* Phase 3, any partitions that need asan protection
1697 in addition to phase 1 and 2. */
1698 expand_stack_vars (asan_decl_phase_3
, &data
);
1700 if (!data
.asan_vec
.is_empty ())
1702 HOST_WIDE_INT prev_offset
= frame_offset
;
1703 HOST_WIDE_INT offset
1704 = alloc_stack_frame_space (ASAN_RED_ZONE_SIZE
,
1705 ASAN_RED_ZONE_SIZE
);
1706 data
.asan_vec
.safe_push (prev_offset
);
1707 data
.asan_vec
.safe_push (offset
);
1710 = asan_emit_stack_protection (virtual_stack_vars_rtx
,
1711 data
.asan_vec
.address (),
1712 data
.asan_decl_vec
. address(),
1713 data
.asan_vec
.length ());
1716 expand_stack_vars (NULL
, &data
);
1718 data
.asan_vec
.release ();
1719 data
.asan_decl_vec
.release ();
1722 fini_vars_expansion ();
1724 /* If there were any artificial non-ignored vars without rtl
1725 found earlier, see if deferred stack allocation hasn't assigned
1727 FOR_EACH_VEC_ELT_REVERSE (maybe_local_decls
, i
, var
)
1729 rtx rtl
= DECL_RTL_IF_SET (var
);
1731 /* Keep artificial non-ignored vars in cfun->local_decls
1732 chain until instantiate_decls. */
1733 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
1734 add_local_decl (cfun
, var
);
1736 maybe_local_decls
.release ();
1738 /* If the target requires that FRAME_OFFSET be aligned, do it. */
1739 if (STACK_ALIGNMENT_NEEDED
)
1741 HOST_WIDE_INT align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
1742 if (!FRAME_GROWS_DOWNWARD
)
1743 frame_offset
+= align
- 1;
1744 frame_offset
&= -align
;
1751 /* If we need to produce a detailed dump, print the tree representation
1752 for STMT to the dump file. SINCE is the last RTX after which the RTL
1753 generated for STMT should have been appended. */
1756 maybe_dump_rtl_for_gimple_stmt (gimple stmt
, rtx since
)
1758 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1760 fprintf (dump_file
, "\n;; ");
1761 print_gimple_stmt (dump_file
, stmt
, 0,
1762 TDF_SLIM
| (dump_flags
& TDF_LINENO
));
1763 fprintf (dump_file
, "\n");
1765 print_rtl (dump_file
, since
? NEXT_INSN (since
) : since
);
1769 /* Maps the blocks that do not contain tree labels to rtx labels. */
1771 static struct pointer_map_t
*lab_rtx_for_bb
;
1773 /* Returns the label_rtx expression for a label starting basic block BB. */
1776 label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED
)
1778 gimple_stmt_iterator gsi
;
1783 if (bb
->flags
& BB_RTL
)
1784 return block_label (bb
);
1786 elt
= pointer_map_contains (lab_rtx_for_bb
, bb
);
1790 /* Find the tree label if it is present. */
1792 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1794 lab_stmt
= gsi_stmt (gsi
);
1795 if (gimple_code (lab_stmt
) != GIMPLE_LABEL
)
1798 lab
= gimple_label_label (lab_stmt
);
1799 if (DECL_NONLOCAL (lab
))
1802 return label_rtx (lab
);
1805 elt
= pointer_map_insert (lab_rtx_for_bb
, bb
);
1806 *elt
= gen_label_rtx ();
1811 /* A subroutine of expand_gimple_cond. Given E, a fallthrough edge
1812 of a basic block where we just expanded the conditional at the end,
1813 possibly clean up the CFG and instruction sequence. LAST is the
1814 last instruction before the just emitted jump sequence. */
1817 maybe_cleanup_end_of_block (edge e
, rtx last
)
1819 /* Special case: when jumpif decides that the condition is
1820 trivial it emits an unconditional jump (and the necessary
1821 barrier). But we still have two edges, the fallthru one is
1822 wrong. purge_dead_edges would clean this up later. Unfortunately
1823 we have to insert insns (and split edges) before
1824 find_many_sub_basic_blocks and hence before purge_dead_edges.
1825 But splitting edges might create new blocks which depend on the
1826 fact that if there are two edges there's no barrier. So the
1827 barrier would get lost and verify_flow_info would ICE. Instead
1828 of auditing all edge splitters to care for the barrier (which
1829 normally isn't there in a cleaned CFG), fix it here. */
1830 if (BARRIER_P (get_last_insn ()))
1834 /* Now, we have a single successor block, if we have insns to
1835 insert on the remaining edge we potentially will insert
1836 it at the end of this block (if the dest block isn't feasible)
1837 in order to avoid splitting the edge. This insertion will take
1838 place in front of the last jump. But we might have emitted
1839 multiple jumps (conditional and one unconditional) to the
1840 same destination. Inserting in front of the last one then
1841 is a problem. See PR 40021. We fix this by deleting all
1842 jumps except the last unconditional one. */
1843 insn
= PREV_INSN (get_last_insn ());
1844 /* Make sure we have an unconditional jump. Otherwise we're
1846 gcc_assert (JUMP_P (insn
) && !any_condjump_p (insn
));
1847 for (insn
= PREV_INSN (insn
); insn
!= last
;)
1849 insn
= PREV_INSN (insn
);
1850 if (JUMP_P (NEXT_INSN (insn
)))
1852 if (!any_condjump_p (NEXT_INSN (insn
)))
1854 gcc_assert (BARRIER_P (NEXT_INSN (NEXT_INSN (insn
))));
1855 delete_insn (NEXT_INSN (NEXT_INSN (insn
)));
1857 delete_insn (NEXT_INSN (insn
));
1863 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_COND.
1864 Returns a new basic block if we've terminated the current basic
1865 block and created a new one. */
1868 expand_gimple_cond (basic_block bb
, gimple stmt
)
1870 basic_block new_bb
, dest
;
1875 enum tree_code code
;
1878 code
= gimple_cond_code (stmt
);
1879 op0
= gimple_cond_lhs (stmt
);
1880 op1
= gimple_cond_rhs (stmt
);
1881 /* We're sometimes presented with such code:
1885 This would expand to two comparisons which then later might
1886 be cleaned up by combine. But some pattern matchers like if-conversion
1887 work better when there's only one compare, so make up for this
1888 here as special exception if TER would have made the same change. */
1890 && TREE_CODE (op0
) == SSA_NAME
1891 && TREE_CODE (TREE_TYPE (op0
)) == BOOLEAN_TYPE
1892 && TREE_CODE (op1
) == INTEGER_CST
1893 && ((gimple_cond_code (stmt
) == NE_EXPR
1894 && integer_zerop (op1
))
1895 || (gimple_cond_code (stmt
) == EQ_EXPR
1896 && integer_onep (op1
)))
1897 && bitmap_bit_p (SA
.values
, SSA_NAME_VERSION (op0
)))
1899 gimple second
= SSA_NAME_DEF_STMT (op0
);
1900 if (gimple_code (second
) == GIMPLE_ASSIGN
)
1902 enum tree_code code2
= gimple_assign_rhs_code (second
);
1903 if (TREE_CODE_CLASS (code2
) == tcc_comparison
)
1906 op0
= gimple_assign_rhs1 (second
);
1907 op1
= gimple_assign_rhs2 (second
);
1909 /* If jumps are cheap turn some more codes into
1911 else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4)
1913 if ((code2
== BIT_AND_EXPR
1914 && TYPE_PRECISION (TREE_TYPE (op0
)) == 1
1915 && TREE_CODE (gimple_assign_rhs2 (second
)) != INTEGER_CST
)
1916 || code2
== TRUTH_AND_EXPR
)
1918 code
= TRUTH_ANDIF_EXPR
;
1919 op0
= gimple_assign_rhs1 (second
);
1920 op1
= gimple_assign_rhs2 (second
);
1922 else if (code2
== BIT_IOR_EXPR
|| code2
== TRUTH_OR_EXPR
)
1924 code
= TRUTH_ORIF_EXPR
;
1925 op0
= gimple_assign_rhs1 (second
);
1926 op1
= gimple_assign_rhs2 (second
);
1932 last2
= last
= get_last_insn ();
1934 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
1935 set_curr_insn_location (gimple_location (stmt
));
1937 /* These flags have no purpose in RTL land. */
1938 true_edge
->flags
&= ~EDGE_TRUE_VALUE
;
1939 false_edge
->flags
&= ~EDGE_FALSE_VALUE
;
1941 /* We can either have a pure conditional jump with one fallthru edge or
1942 two-way jump that needs to be decomposed into two basic blocks. */
1943 if (false_edge
->dest
== bb
->next_bb
)
1945 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
1946 true_edge
->probability
);
1947 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
1948 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
1949 set_curr_insn_location (true_edge
->goto_locus
);
1950 false_edge
->flags
|= EDGE_FALLTHRU
;
1951 maybe_cleanup_end_of_block (false_edge
, last
);
1954 if (true_edge
->dest
== bb
->next_bb
)
1956 jumpifnot_1 (code
, op0
, op1
, label_rtx_for_bb (false_edge
->dest
),
1957 false_edge
->probability
);
1958 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
1959 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
1960 set_curr_insn_location (false_edge
->goto_locus
);
1961 true_edge
->flags
|= EDGE_FALLTHRU
;
1962 maybe_cleanup_end_of_block (true_edge
, last
);
1966 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
1967 true_edge
->probability
);
1968 last
= get_last_insn ();
1969 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
1970 set_curr_insn_location (false_edge
->goto_locus
);
1971 emit_jump (label_rtx_for_bb (false_edge
->dest
));
1974 if (BARRIER_P (BB_END (bb
)))
1975 BB_END (bb
) = PREV_INSN (BB_END (bb
));
1976 update_bb_for_insn (bb
);
1978 new_bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
1979 dest
= false_edge
->dest
;
1980 redirect_edge_succ (false_edge
, new_bb
);
1981 false_edge
->flags
|= EDGE_FALLTHRU
;
1982 new_bb
->count
= false_edge
->count
;
1983 new_bb
->frequency
= EDGE_FREQUENCY (false_edge
);
1984 if (current_loops
&& bb
->loop_father
)
1985 add_bb_to_loop (new_bb
, bb
->loop_father
);
1986 new_edge
= make_edge (new_bb
, dest
, 0);
1987 new_edge
->probability
= REG_BR_PROB_BASE
;
1988 new_edge
->count
= new_bb
->count
;
1989 if (BARRIER_P (BB_END (new_bb
)))
1990 BB_END (new_bb
) = PREV_INSN (BB_END (new_bb
));
1991 update_bb_for_insn (new_bb
);
1993 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
1995 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
1997 set_curr_insn_location (true_edge
->goto_locus
);
1998 true_edge
->goto_locus
= curr_insn_location ();
2004 /* Mark all calls that can have a transaction restart. */
2007 mark_transaction_restart_calls (gimple stmt
)
2009 struct tm_restart_node dummy
;
2012 if (!cfun
->gimple_df
->tm_restart
)
2016 slot
= htab_find_slot (cfun
->gimple_df
->tm_restart
, &dummy
, NO_INSERT
);
2019 struct tm_restart_node
*n
= (struct tm_restart_node
*) *slot
;
2020 tree list
= n
->label_or_list
;
2023 for (insn
= next_real_insn (get_last_insn ());
2025 insn
= next_real_insn (insn
))
2028 if (TREE_CODE (list
) == LABEL_DECL
)
2029 add_reg_note (insn
, REG_TM
, label_rtx (list
));
2031 for (; list
; list
= TREE_CHAIN (list
))
2032 add_reg_note (insn
, REG_TM
, label_rtx (TREE_VALUE (list
)));
2036 /* A subroutine of expand_gimple_stmt_1, expanding one GIMPLE_CALL
2040 expand_call_stmt (gimple stmt
)
2042 tree exp
, decl
, lhs
;
2046 if (gimple_call_internal_p (stmt
))
2048 expand_internal_call (stmt
);
2052 exp
= build_vl_exp (CALL_EXPR
, gimple_call_num_args (stmt
) + 3);
2054 CALL_EXPR_FN (exp
) = gimple_call_fn (stmt
);
2055 decl
= gimple_call_fndecl (stmt
);
2056 builtin_p
= decl
&& DECL_BUILT_IN (decl
);
2058 /* If this is not a builtin function, the function type through which the
2059 call is made may be different from the type of the function. */
2062 = fold_convert (build_pointer_type (gimple_call_fntype (stmt
)),
2063 CALL_EXPR_FN (exp
));
2065 TREE_TYPE (exp
) = gimple_call_return_type (stmt
);
2066 CALL_EXPR_STATIC_CHAIN (exp
) = gimple_call_chain (stmt
);
2068 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2070 tree arg
= gimple_call_arg (stmt
, i
);
2072 /* TER addresses into arguments of builtin functions so we have a
2073 chance to infer more correct alignment information. See PR39954. */
2075 && TREE_CODE (arg
) == SSA_NAME
2076 && (def
= get_gimple_for_ssa_name (arg
))
2077 && gimple_assign_rhs_code (def
) == ADDR_EXPR
)
2078 arg
= gimple_assign_rhs1 (def
);
2079 CALL_EXPR_ARG (exp
, i
) = arg
;
2082 if (gimple_has_side_effects (stmt
))
2083 TREE_SIDE_EFFECTS (exp
) = 1;
2085 if (gimple_call_nothrow_p (stmt
))
2086 TREE_NOTHROW (exp
) = 1;
2088 CALL_EXPR_TAILCALL (exp
) = gimple_call_tail_p (stmt
);
2089 CALL_EXPR_RETURN_SLOT_OPT (exp
) = gimple_call_return_slot_opt_p (stmt
);
2091 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
2092 && (DECL_FUNCTION_CODE (decl
) == BUILT_IN_ALLOCA
2093 || DECL_FUNCTION_CODE (decl
) == BUILT_IN_ALLOCA_WITH_ALIGN
))
2094 CALL_ALLOCA_FOR_VAR_P (exp
) = gimple_call_alloca_for_var_p (stmt
);
2096 CALL_FROM_THUNK_P (exp
) = gimple_call_from_thunk_p (stmt
);
2097 CALL_EXPR_VA_ARG_PACK (exp
) = gimple_call_va_arg_pack_p (stmt
);
2098 SET_EXPR_LOCATION (exp
, gimple_location (stmt
));
2100 /* Ensure RTL is created for debug args. */
2101 if (decl
&& DECL_HAS_DEBUG_ARGS_P (decl
))
2103 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (decl
);
2108 for (ix
= 1; (*debug_args
)->iterate (ix
, &dtemp
); ix
+= 2)
2110 gcc_assert (TREE_CODE (dtemp
) == DEBUG_EXPR_DECL
);
2111 expand_debug_expr (dtemp
);
2115 lhs
= gimple_call_lhs (stmt
);
2117 expand_assignment (lhs
, exp
, false);
2119 expand_expr_real_1 (exp
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
, NULL
);
2121 mark_transaction_restart_calls (stmt
);
2124 /* A subroutine of expand_gimple_stmt, expanding one gimple statement
2125 STMT that doesn't require special handling for outgoing edges. That
2126 is no tailcalls and no GIMPLE_COND. */
2129 expand_gimple_stmt_1 (gimple stmt
)
2133 set_curr_insn_location (gimple_location (stmt
));
2135 switch (gimple_code (stmt
))
2138 op0
= gimple_goto_dest (stmt
);
2139 if (TREE_CODE (op0
) == LABEL_DECL
)
2142 expand_computed_goto (op0
);
2145 expand_label (gimple_label_label (stmt
));
2148 case GIMPLE_PREDICT
:
2154 expand_asm_stmt (stmt
);
2157 expand_call_stmt (stmt
);
2161 op0
= gimple_return_retval (stmt
);
2163 if (op0
&& op0
!= error_mark_node
)
2165 tree result
= DECL_RESULT (current_function_decl
);
2167 /* If we are not returning the current function's RESULT_DECL,
2168 build an assignment to it. */
2171 /* I believe that a function's RESULT_DECL is unique. */
2172 gcc_assert (TREE_CODE (op0
) != RESULT_DECL
);
2174 /* ??? We'd like to use simply expand_assignment here,
2175 but this fails if the value is of BLKmode but the return
2176 decl is a register. expand_return has special handling
2177 for this combination, which eventually should move
2178 to common code. See comments there. Until then, let's
2179 build a modify expression :-/ */
2180 op0
= build2 (MODIFY_EXPR
, TREE_TYPE (result
),
2185 expand_null_return ();
2187 expand_return (op0
);
2192 tree lhs
= gimple_assign_lhs (stmt
);
2194 /* Tree expand used to fiddle with |= and &= of two bitfield
2195 COMPONENT_REFs here. This can't happen with gimple, the LHS
2196 of binary assigns must be a gimple reg. */
2198 if (TREE_CODE (lhs
) != SSA_NAME
2199 || get_gimple_rhs_class (gimple_expr_code (stmt
))
2200 == GIMPLE_SINGLE_RHS
)
2202 tree rhs
= gimple_assign_rhs1 (stmt
);
2203 gcc_assert (get_gimple_rhs_class (gimple_expr_code (stmt
))
2204 == GIMPLE_SINGLE_RHS
);
2205 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (rhs
))
2206 SET_EXPR_LOCATION (rhs
, gimple_location (stmt
));
2207 if (TREE_CLOBBER_P (rhs
))
2208 /* This is a clobber to mark the going out of scope for
2212 expand_assignment (lhs
, rhs
,
2213 gimple_assign_nontemporal_move_p (stmt
));
2218 bool nontemporal
= gimple_assign_nontemporal_move_p (stmt
);
2219 struct separate_ops ops
;
2220 bool promoted
= false;
2222 target
= expand_expr (lhs
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
2223 if (GET_CODE (target
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (target
))
2226 ops
.code
= gimple_assign_rhs_code (stmt
);
2227 ops
.type
= TREE_TYPE (lhs
);
2228 switch (get_gimple_rhs_class (gimple_expr_code (stmt
)))
2230 case GIMPLE_TERNARY_RHS
:
2231 ops
.op2
= gimple_assign_rhs3 (stmt
);
2233 case GIMPLE_BINARY_RHS
:
2234 ops
.op1
= gimple_assign_rhs2 (stmt
);
2236 case GIMPLE_UNARY_RHS
:
2237 ops
.op0
= gimple_assign_rhs1 (stmt
);
2242 ops
.location
= gimple_location (stmt
);
2244 /* If we want to use a nontemporal store, force the value to
2245 register first. If we store into a promoted register,
2246 don't directly expand to target. */
2247 temp
= nontemporal
|| promoted
? NULL_RTX
: target
;
2248 temp
= expand_expr_real_2 (&ops
, temp
, GET_MODE (target
),
2255 int unsignedp
= SUBREG_PROMOTED_UNSIGNED_P (target
);
2256 /* If TEMP is a VOIDmode constant, use convert_modes to make
2257 sure that we properly convert it. */
2258 if (CONSTANT_P (temp
) && GET_MODE (temp
) == VOIDmode
)
2260 temp
= convert_modes (GET_MODE (target
),
2261 TYPE_MODE (ops
.type
),
2263 temp
= convert_modes (GET_MODE (SUBREG_REG (target
)),
2264 GET_MODE (target
), temp
, unsignedp
);
2267 convert_move (SUBREG_REG (target
), temp
, unsignedp
);
2269 else if (nontemporal
&& emit_storent_insn (target
, temp
))
2273 temp
= force_operand (temp
, target
);
2275 emit_move_insn (target
, temp
);
2286 /* Expand one gimple statement STMT and return the last RTL instruction
2287 before any of the newly generated ones.
2289 In addition to generating the necessary RTL instructions this also
2290 sets REG_EH_REGION notes if necessary and sets the current source
2291 location for diagnostics. */
2294 expand_gimple_stmt (gimple stmt
)
2296 location_t saved_location
= input_location
;
2297 rtx last
= get_last_insn ();
2302 /* We need to save and restore the current source location so that errors
2303 discovered during expansion are emitted with the right location. But
2304 it would be better if the diagnostic routines used the source location
2305 embedded in the tree nodes rather than globals. */
2306 if (gimple_has_location (stmt
))
2307 input_location
= gimple_location (stmt
);
2309 expand_gimple_stmt_1 (stmt
);
2311 /* Free any temporaries used to evaluate this statement. */
2314 input_location
= saved_location
;
2316 /* Mark all insns that may trap. */
2317 lp_nr
= lookup_stmt_eh_lp (stmt
);
2321 for (insn
= next_real_insn (last
); insn
;
2322 insn
= next_real_insn (insn
))
2324 if (! find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
2325 /* If we want exceptions for non-call insns, any
2326 may_trap_p instruction may throw. */
2327 && GET_CODE (PATTERN (insn
)) != CLOBBER
2328 && GET_CODE (PATTERN (insn
)) != USE
2329 && insn_could_throw_p (insn
))
2330 make_reg_eh_region_note (insn
, 0, lp_nr
);
2337 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_CALL
2338 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
2339 generated a tail call (something that might be denied by the ABI
2340 rules governing the call; see calls.c).
2342 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
2343 can still reach the rest of BB. The case here is __builtin_sqrt,
2344 where the NaN result goes through the external function (with a
2345 tailcall) and the normal result happens via a sqrt instruction. */
2348 expand_gimple_tailcall (basic_block bb
, gimple stmt
, bool *can_fallthru
)
2356 last2
= last
= expand_gimple_stmt (stmt
);
2358 for (last
= NEXT_INSN (last
); last
; last
= NEXT_INSN (last
))
2359 if (CALL_P (last
) && SIBLING_CALL_P (last
))
2362 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
2364 *can_fallthru
= true;
2368 /* ??? Wouldn't it be better to just reset any pending stack adjust?
2369 Any instructions emitted here are about to be deleted. */
2370 do_pending_stack_adjust ();
2372 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
2373 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
2374 EH or abnormal edges, we shouldn't have created a tail call in
2375 the first place. So it seems to me we should just be removing
2376 all edges here, or redirecting the existing fallthru edge to
2382 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
2384 if (!(e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
)))
2386 if (e
->dest
!= EXIT_BLOCK_PTR
)
2388 e
->dest
->count
-= e
->count
;
2389 e
->dest
->frequency
-= EDGE_FREQUENCY (e
);
2390 if (e
->dest
->count
< 0)
2392 if (e
->dest
->frequency
< 0)
2393 e
->dest
->frequency
= 0;
2396 probability
+= e
->probability
;
2403 /* This is somewhat ugly: the call_expr expander often emits instructions
2404 after the sibcall (to perform the function return). These confuse the
2405 find_many_sub_basic_blocks code, so we need to get rid of these. */
2406 last
= NEXT_INSN (last
);
2407 gcc_assert (BARRIER_P (last
));
2409 *can_fallthru
= false;
2410 while (NEXT_INSN (last
))
2412 /* For instance an sqrt builtin expander expands if with
2413 sibcall in the then and label for `else`. */
2414 if (LABEL_P (NEXT_INSN (last
)))
2416 *can_fallthru
= true;
2419 delete_insn (NEXT_INSN (last
));
2422 e
= make_edge (bb
, EXIT_BLOCK_PTR
, EDGE_ABNORMAL
| EDGE_SIBCALL
);
2423 e
->probability
+= probability
;
2426 update_bb_for_insn (bb
);
2428 if (NEXT_INSN (last
))
2430 bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
2433 if (BARRIER_P (last
))
2434 BB_END (bb
) = PREV_INSN (last
);
2437 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
2442 /* Return the difference between the floor and the truncated result of
2443 a signed division by OP1 with remainder MOD. */
2445 floor_sdiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1
)
2447 /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
2448 return gen_rtx_IF_THEN_ELSE
2449 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
2450 gen_rtx_IF_THEN_ELSE
2451 (mode
, gen_rtx_LT (BImode
,
2452 gen_rtx_DIV (mode
, op1
, mod
),
2454 constm1_rtx
, const0_rtx
),
2458 /* Return the difference between the ceil and the truncated result of
2459 a signed division by OP1 with remainder MOD. */
2461 ceil_sdiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1
)
2463 /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
2464 return gen_rtx_IF_THEN_ELSE
2465 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
2466 gen_rtx_IF_THEN_ELSE
2467 (mode
, gen_rtx_GT (BImode
,
2468 gen_rtx_DIV (mode
, op1
, mod
),
2470 const1_rtx
, const0_rtx
),
2474 /* Return the difference between the ceil and the truncated result of
2475 an unsigned division by OP1 with remainder MOD. */
2477 ceil_udiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1 ATTRIBUTE_UNUSED
)
2479 /* (mod != 0 ? 1 : 0) */
2480 return gen_rtx_IF_THEN_ELSE
2481 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
2482 const1_rtx
, const0_rtx
);
2485 /* Return the difference between the rounded and the truncated result
2486 of a signed division by OP1 with remainder MOD. Halfway cases are
2487 rounded away from zero, rather than to the nearest even number. */
2489 round_sdiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1
)
2491 /* (abs (mod) >= abs (op1) - abs (mod)
2492 ? (op1 / mod > 0 ? 1 : -1)
2494 return gen_rtx_IF_THEN_ELSE
2495 (mode
, gen_rtx_GE (BImode
, gen_rtx_ABS (mode
, mod
),
2496 gen_rtx_MINUS (mode
,
2497 gen_rtx_ABS (mode
, op1
),
2498 gen_rtx_ABS (mode
, mod
))),
2499 gen_rtx_IF_THEN_ELSE
2500 (mode
, gen_rtx_GT (BImode
,
2501 gen_rtx_DIV (mode
, op1
, mod
),
2503 const1_rtx
, constm1_rtx
),
2507 /* Return the difference between the rounded and the truncated result
2508 of a unsigned division by OP1 with remainder MOD. Halfway cases
2509 are rounded away from zero, rather than to the nearest even
2512 round_udiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1
)
2514 /* (mod >= op1 - mod ? 1 : 0) */
2515 return gen_rtx_IF_THEN_ELSE
2516 (mode
, gen_rtx_GE (BImode
, mod
,
2517 gen_rtx_MINUS (mode
, op1
, mod
)),
2518 const1_rtx
, const0_rtx
);
2521 /* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
2525 convert_debug_memory_address (enum machine_mode mode
, rtx x
,
2528 enum machine_mode xmode
= GET_MODE (x
);
2530 #ifndef POINTERS_EXTEND_UNSIGNED
2531 gcc_assert (mode
== Pmode
2532 || mode
== targetm
.addr_space
.address_mode (as
));
2533 gcc_assert (xmode
== mode
|| xmode
== VOIDmode
);
2537 gcc_assert (targetm
.addr_space
.valid_pointer_mode (mode
, as
));
2539 if (GET_MODE (x
) == mode
|| GET_MODE (x
) == VOIDmode
)
2542 if (GET_MODE_PRECISION (mode
) < GET_MODE_PRECISION (xmode
))
2543 x
= simplify_gen_subreg (mode
, x
, xmode
,
2544 subreg_lowpart_offset
2546 else if (POINTERS_EXTEND_UNSIGNED
> 0)
2547 x
= gen_rtx_ZERO_EXTEND (mode
, x
);
2548 else if (!POINTERS_EXTEND_UNSIGNED
)
2549 x
= gen_rtx_SIGN_EXTEND (mode
, x
);
2552 switch (GET_CODE (x
))
2555 if ((SUBREG_PROMOTED_VAR_P (x
)
2556 || (REG_P (SUBREG_REG (x
)) && REG_POINTER (SUBREG_REG (x
)))
2557 || (GET_CODE (SUBREG_REG (x
)) == PLUS
2558 && REG_P (XEXP (SUBREG_REG (x
), 0))
2559 && REG_POINTER (XEXP (SUBREG_REG (x
), 0))
2560 && CONST_INT_P (XEXP (SUBREG_REG (x
), 1))))
2561 && GET_MODE (SUBREG_REG (x
)) == mode
)
2562 return SUBREG_REG (x
);
2565 temp
= gen_rtx_LABEL_REF (mode
, XEXP (x
, 0));
2566 LABEL_REF_NONLOCAL_P (temp
) = LABEL_REF_NONLOCAL_P (x
);
2569 temp
= shallow_copy_rtx (x
);
2570 PUT_MODE (temp
, mode
);
2573 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
2575 temp
= gen_rtx_CONST (mode
, temp
);
2579 if (CONST_INT_P (XEXP (x
, 1)))
2581 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
2583 return gen_rtx_fmt_ee (GET_CODE (x
), mode
, temp
, XEXP (x
, 1));
2589 /* Don't know how to express ptr_extend as operation in debug info. */
2592 #endif /* POINTERS_EXTEND_UNSIGNED */
2597 /* Return an RTX equivalent to the value of the parameter DECL. */
2600 expand_debug_parm_decl (tree decl
)
2602 rtx incoming
= DECL_INCOMING_RTL (decl
);
2605 && GET_MODE (incoming
) != BLKmode
2606 && ((REG_P (incoming
) && HARD_REGISTER_P (incoming
))
2607 || (MEM_P (incoming
)
2608 && REG_P (XEXP (incoming
, 0))
2609 && HARD_REGISTER_P (XEXP (incoming
, 0)))))
2611 rtx rtl
= gen_rtx_ENTRY_VALUE (GET_MODE (incoming
));
2613 #ifdef HAVE_window_save
2614 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
2615 If the target machine has an explicit window save instruction, the
2616 actual entry value is the corresponding OUTGOING_REGNO instead. */
2617 if (REG_P (incoming
)
2618 && OUTGOING_REGNO (REGNO (incoming
)) != REGNO (incoming
))
2620 = gen_rtx_REG_offset (incoming
, GET_MODE (incoming
),
2621 OUTGOING_REGNO (REGNO (incoming
)), 0);
2622 else if (MEM_P (incoming
))
2624 rtx reg
= XEXP (incoming
, 0);
2625 if (OUTGOING_REGNO (REGNO (reg
)) != REGNO (reg
))
2627 reg
= gen_raw_REG (GET_MODE (reg
), OUTGOING_REGNO (REGNO (reg
)));
2628 incoming
= replace_equiv_address_nv (incoming
, reg
);
2631 incoming
= copy_rtx (incoming
);
2635 ENTRY_VALUE_EXP (rtl
) = incoming
;
2640 && GET_MODE (incoming
) != BLKmode
2641 && !TREE_ADDRESSABLE (decl
)
2643 && (XEXP (incoming
, 0) == virtual_incoming_args_rtx
2644 || (GET_CODE (XEXP (incoming
, 0)) == PLUS
2645 && XEXP (XEXP (incoming
, 0), 0) == virtual_incoming_args_rtx
2646 && CONST_INT_P (XEXP (XEXP (incoming
, 0), 1)))))
2647 return copy_rtx (incoming
);
2652 /* Return an RTX equivalent to the value of the tree expression EXP. */
2655 expand_debug_expr (tree exp
)
2657 rtx op0
= NULL_RTX
, op1
= NULL_RTX
, op2
= NULL_RTX
;
2658 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
2659 enum machine_mode inner_mode
= VOIDmode
;
2660 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (exp
));
2663 switch (TREE_CODE_CLASS (TREE_CODE (exp
)))
2665 case tcc_expression
:
2666 switch (TREE_CODE (exp
))
2670 case WIDEN_MULT_PLUS_EXPR
:
2671 case WIDEN_MULT_MINUS_EXPR
:
2675 case TRUTH_ANDIF_EXPR
:
2676 case TRUTH_ORIF_EXPR
:
2677 case TRUTH_AND_EXPR
:
2679 case TRUTH_XOR_EXPR
:
2682 case TRUTH_NOT_EXPR
:
2691 op2
= expand_debug_expr (TREE_OPERAND (exp
, 2));
2698 case tcc_comparison
:
2699 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
2706 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
2707 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
2717 case tcc_exceptional
:
2718 case tcc_declaration
:
2724 switch (TREE_CODE (exp
))
2727 if (!lookup_constant_def (exp
))
2729 if (strlen (TREE_STRING_POINTER (exp
)) + 1
2730 != (size_t) TREE_STRING_LENGTH (exp
))
2732 op0
= gen_rtx_CONST_STRING (Pmode
, TREE_STRING_POINTER (exp
));
2733 op0
= gen_rtx_MEM (BLKmode
, op0
);
2734 set_mem_attributes (op0
, exp
, 0);
2737 /* Fall through... */
2742 op0
= expand_expr (exp
, NULL_RTX
, mode
, EXPAND_INITIALIZER
);
2746 gcc_assert (COMPLEX_MODE_P (mode
));
2747 op0
= expand_debug_expr (TREE_REALPART (exp
));
2748 op1
= expand_debug_expr (TREE_IMAGPART (exp
));
2749 return gen_rtx_CONCAT (mode
, op0
, op1
);
2751 case DEBUG_EXPR_DECL
:
2752 op0
= DECL_RTL_IF_SET (exp
);
2757 op0
= gen_rtx_DEBUG_EXPR (mode
);
2758 DEBUG_EXPR_TREE_DECL (op0
) = exp
;
2759 SET_DECL_RTL (exp
, op0
);
2769 op0
= DECL_RTL_IF_SET (exp
);
2771 /* This decl was probably optimized away. */
2774 if (TREE_CODE (exp
) != VAR_DECL
2775 || DECL_EXTERNAL (exp
)
2776 || !TREE_STATIC (exp
)
2778 || DECL_HARD_REGISTER (exp
)
2779 || DECL_IN_CONSTANT_POOL (exp
)
2780 || mode
== VOIDmode
)
2783 op0
= make_decl_rtl_for_debug (exp
);
2785 || GET_CODE (XEXP (op0
, 0)) != SYMBOL_REF
2786 || SYMBOL_REF_DECL (XEXP (op0
, 0)) != exp
)
2790 op0
= copy_rtx (op0
);
2792 if (GET_MODE (op0
) == BLKmode
2793 /* If op0 is not BLKmode, but BLKmode is, adjust_mode
2794 below would ICE. While it is likely a FE bug,
2795 try to be robust here. See PR43166. */
2797 || (mode
== VOIDmode
&& GET_MODE (op0
) != VOIDmode
))
2799 gcc_assert (MEM_P (op0
));
2800 op0
= adjust_address_nv (op0
, mode
, 0);
2811 inner_mode
= GET_MODE (op0
);
2813 if (mode
== inner_mode
)
2816 if (inner_mode
== VOIDmode
)
2818 if (TREE_CODE (exp
) == SSA_NAME
)
2819 inner_mode
= TYPE_MODE (TREE_TYPE (exp
));
2821 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
2822 if (mode
== inner_mode
)
2826 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
2828 if (GET_MODE_BITSIZE (mode
) == GET_MODE_BITSIZE (inner_mode
))
2829 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
2830 else if (GET_MODE_BITSIZE (mode
) < GET_MODE_BITSIZE (inner_mode
))
2831 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
2833 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
2835 else if (FLOAT_MODE_P (mode
))
2837 gcc_assert (TREE_CODE (exp
) != SSA_NAME
);
2838 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
2839 op0
= simplify_gen_unary (UNSIGNED_FLOAT
, mode
, op0
, inner_mode
);
2841 op0
= simplify_gen_unary (FLOAT
, mode
, op0
, inner_mode
);
2843 else if (FLOAT_MODE_P (inner_mode
))
2846 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
2848 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
2850 else if (CONSTANT_P (op0
)
2851 || GET_MODE_PRECISION (mode
) <= GET_MODE_PRECISION (inner_mode
))
2852 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
,
2853 subreg_lowpart_offset (mode
,
2855 else if (TREE_CODE_CLASS (TREE_CODE (exp
)) == tcc_unary
2856 ? TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)))
2858 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
2860 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
2866 if (!is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
2868 tree newexp
= fold_binary (MEM_REF
, TREE_TYPE (exp
),
2869 TREE_OPERAND (exp
, 0),
2870 TREE_OPERAND (exp
, 1));
2872 return expand_debug_expr (newexp
);
2876 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
2877 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
2881 if (TREE_CODE (exp
) == MEM_REF
)
2883 if (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
2884 || (GET_CODE (op0
) == PLUS
2885 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
))
2886 /* (mem (debug_implicit_ptr)) might confuse aliasing.
2887 Instead just use get_inner_reference. */
2890 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
2891 if (!op1
|| !CONST_INT_P (op1
))
2894 op0
= plus_constant (inner_mode
, op0
, INTVAL (op1
));
2897 if (POINTER_TYPE_P (TREE_TYPE (exp
)))
2898 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)));
2900 as
= ADDR_SPACE_GENERIC
;
2902 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
2904 if (op0
== NULL_RTX
)
2907 op0
= gen_rtx_MEM (mode
, op0
);
2908 set_mem_attributes (op0
, exp
, 0);
2909 if (TREE_CODE (exp
) == MEM_REF
2910 && !is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
2911 set_mem_expr (op0
, NULL_TREE
);
2912 set_mem_addr_space (op0
, as
);
2916 case TARGET_MEM_REF
:
2917 if (TREE_CODE (TMR_BASE (exp
)) == ADDR_EXPR
2918 && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp
), 0)))
2921 op0
= expand_debug_expr
2922 (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp
)), exp
));
2926 if (POINTER_TYPE_P (TREE_TYPE (exp
)))
2927 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)));
2929 as
= ADDR_SPACE_GENERIC
;
2931 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
2933 if (op0
== NULL_RTX
)
2936 op0
= gen_rtx_MEM (mode
, op0
);
2938 set_mem_attributes (op0
, exp
, 0);
2939 set_mem_addr_space (op0
, as
);
2945 case ARRAY_RANGE_REF
:
2950 case VIEW_CONVERT_EXPR
:
2952 enum machine_mode mode1
;
2953 HOST_WIDE_INT bitsize
, bitpos
;
2956 tree tem
= get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
,
2957 &mode1
, &unsignedp
, &volatilep
, false);
2963 orig_op0
= op0
= expand_debug_expr (tem
);
2970 enum machine_mode addrmode
, offmode
;
2975 op0
= XEXP (op0
, 0);
2976 addrmode
= GET_MODE (op0
);
2977 if (addrmode
== VOIDmode
)
2980 op1
= expand_debug_expr (offset
);
2984 offmode
= GET_MODE (op1
);
2985 if (offmode
== VOIDmode
)
2986 offmode
= TYPE_MODE (TREE_TYPE (offset
));
2988 if (addrmode
!= offmode
)
2989 op1
= simplify_gen_subreg (addrmode
, op1
, offmode
,
2990 subreg_lowpart_offset (addrmode
,
2993 /* Don't use offset_address here, we don't need a
2994 recognizable address, and we don't want to generate
2996 op0
= gen_rtx_MEM (mode
, simplify_gen_binary (PLUS
, addrmode
,
3002 if (mode1
== VOIDmode
)
3004 mode1
= smallest_mode_for_size (bitsize
, MODE_INT
);
3005 if (bitpos
>= BITS_PER_UNIT
)
3007 op0
= adjust_address_nv (op0
, mode1
, bitpos
/ BITS_PER_UNIT
);
3008 bitpos
%= BITS_PER_UNIT
;
3010 else if (bitpos
< 0)
3013 = (-bitpos
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
3014 op0
= adjust_address_nv (op0
, mode1
, units
);
3015 bitpos
+= units
* BITS_PER_UNIT
;
3017 else if (bitpos
== 0 && bitsize
== GET_MODE_BITSIZE (mode
))
3018 op0
= adjust_address_nv (op0
, mode
, 0);
3019 else if (GET_MODE (op0
) != mode1
)
3020 op0
= adjust_address_nv (op0
, mode1
, 0);
3022 op0
= copy_rtx (op0
);
3023 if (op0
== orig_op0
)
3024 op0
= shallow_copy_rtx (op0
);
3025 set_mem_attributes (op0
, exp
, 0);
3028 if (bitpos
== 0 && mode
== GET_MODE (op0
))
3034 if (GET_MODE (op0
) == BLKmode
)
3037 if ((bitpos
% BITS_PER_UNIT
) == 0
3038 && bitsize
== GET_MODE_BITSIZE (mode1
))
3040 enum machine_mode opmode
= GET_MODE (op0
);
3042 if (opmode
== VOIDmode
)
3043 opmode
= TYPE_MODE (TREE_TYPE (tem
));
3045 /* This condition may hold if we're expanding the address
3046 right past the end of an array that turned out not to
3047 be addressable (i.e., the address was only computed in
3048 debug stmts). The gen_subreg below would rightfully
3049 crash, and the address doesn't really exist, so just
3051 if (bitpos
>= GET_MODE_BITSIZE (opmode
))
3054 if ((bitpos
% GET_MODE_BITSIZE (mode
)) == 0)
3055 return simplify_gen_subreg (mode
, op0
, opmode
,
3056 bitpos
/ BITS_PER_UNIT
);
3059 return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0
))
3060 && TYPE_UNSIGNED (TREE_TYPE (exp
))
3062 : ZERO_EXTRACT
, mode
,
3063 GET_MODE (op0
) != VOIDmode
3065 : TYPE_MODE (TREE_TYPE (tem
)),
3066 op0
, GEN_INT (bitsize
), GEN_INT (bitpos
));
3070 return simplify_gen_unary (ABS
, mode
, op0
, mode
);
3073 return simplify_gen_unary (NEG
, mode
, op0
, mode
);
3076 return simplify_gen_unary (NOT
, mode
, op0
, mode
);
3079 return simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
3081 ? UNSIGNED_FLOAT
: FLOAT
, mode
, op0
,
3084 case FIX_TRUNC_EXPR
:
3085 return simplify_gen_unary (unsignedp
? UNSIGNED_FIX
: FIX
, mode
, op0
,
3088 case POINTER_PLUS_EXPR
:
3089 /* For the rare target where pointers are not the same size as
3090 size_t, we need to check for mis-matched modes and correct
3093 && GET_MODE (op0
) != VOIDmode
&& GET_MODE (op1
) != VOIDmode
3094 && GET_MODE (op0
) != GET_MODE (op1
))
3096 if (GET_MODE_BITSIZE (GET_MODE (op0
)) < GET_MODE_BITSIZE (GET_MODE (op1
)))
3097 op1
= simplify_gen_unary (TRUNCATE
, GET_MODE (op0
), op1
,
3100 /* We always sign-extend, regardless of the signedness of
3101 the operand, because the operand is always unsigned
3102 here even if the original C expression is signed. */
3103 op1
= simplify_gen_unary (SIGN_EXTEND
, GET_MODE (op0
), op1
,
3108 return simplify_gen_binary (PLUS
, mode
, op0
, op1
);
3111 return simplify_gen_binary (MINUS
, mode
, op0
, op1
);
3114 return simplify_gen_binary (MULT
, mode
, op0
, op1
);
3117 case TRUNC_DIV_EXPR
:
3118 case EXACT_DIV_EXPR
:
3120 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
3122 return simplify_gen_binary (DIV
, mode
, op0
, op1
);
3124 case TRUNC_MOD_EXPR
:
3125 return simplify_gen_binary (unsignedp
? UMOD
: MOD
, mode
, op0
, op1
);
3127 case FLOOR_DIV_EXPR
:
3129 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
3132 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
3133 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
3134 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
3135 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
3138 case FLOOR_MOD_EXPR
:
3140 return simplify_gen_binary (UMOD
, mode
, op0
, op1
);
3143 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
3144 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
3145 adj
= simplify_gen_unary (NEG
, mode
,
3146 simplify_gen_binary (MULT
, mode
, adj
, op1
),
3148 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
3154 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
3155 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
3156 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
3157 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
3161 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
3162 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
3163 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
3164 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
3170 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
3171 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
3172 adj
= simplify_gen_unary (NEG
, mode
,
3173 simplify_gen_binary (MULT
, mode
, adj
, op1
),
3175 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
3179 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
3180 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
3181 adj
= simplify_gen_unary (NEG
, mode
,
3182 simplify_gen_binary (MULT
, mode
, adj
, op1
),
3184 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
3187 case ROUND_DIV_EXPR
:
3190 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
3191 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
3192 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
3193 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
3197 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
3198 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
3199 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
3200 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
3203 case ROUND_MOD_EXPR
:
3206 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
3207 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
3208 adj
= simplify_gen_unary (NEG
, mode
,
3209 simplify_gen_binary (MULT
, mode
, adj
, op1
),
3211 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
3215 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
3216 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
3217 adj
= simplify_gen_unary (NEG
, mode
,
3218 simplify_gen_binary (MULT
, mode
, adj
, op1
),
3220 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
3224 return simplify_gen_binary (ASHIFT
, mode
, op0
, op1
);
3228 return simplify_gen_binary (LSHIFTRT
, mode
, op0
, op1
);
3230 return simplify_gen_binary (ASHIFTRT
, mode
, op0
, op1
);
3233 return simplify_gen_binary (ROTATE
, mode
, op0
, op1
);
3236 return simplify_gen_binary (ROTATERT
, mode
, op0
, op1
);
3239 return simplify_gen_binary (unsignedp
? UMIN
: SMIN
, mode
, op0
, op1
);
3242 return simplify_gen_binary (unsignedp
? UMAX
: SMAX
, mode
, op0
, op1
);
3245 case TRUTH_AND_EXPR
:
3246 return simplify_gen_binary (AND
, mode
, op0
, op1
);
3250 return simplify_gen_binary (IOR
, mode
, op0
, op1
);
3253 case TRUTH_XOR_EXPR
:
3254 return simplify_gen_binary (XOR
, mode
, op0
, op1
);
3256 case TRUTH_ANDIF_EXPR
:
3257 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, const0_rtx
);
3259 case TRUTH_ORIF_EXPR
:
3260 return gen_rtx_IF_THEN_ELSE (mode
, op0
, const_true_rtx
, op1
);
3262 case TRUTH_NOT_EXPR
:
3263 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, const0_rtx
);
3266 return simplify_gen_relational (unsignedp
? LTU
: LT
, mode
, inner_mode
,
3270 return simplify_gen_relational (unsignedp
? LEU
: LE
, mode
, inner_mode
,
3274 return simplify_gen_relational (unsignedp
? GTU
: GT
, mode
, inner_mode
,
3278 return simplify_gen_relational (unsignedp
? GEU
: GE
, mode
, inner_mode
,
3282 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, op1
);
3285 return simplify_gen_relational (NE
, mode
, inner_mode
, op0
, op1
);
3287 case UNORDERED_EXPR
:
3288 return simplify_gen_relational (UNORDERED
, mode
, inner_mode
, op0
, op1
);
3291 return simplify_gen_relational (ORDERED
, mode
, inner_mode
, op0
, op1
);
3294 return simplify_gen_relational (UNLT
, mode
, inner_mode
, op0
, op1
);
3297 return simplify_gen_relational (UNLE
, mode
, inner_mode
, op0
, op1
);
3300 return simplify_gen_relational (UNGT
, mode
, inner_mode
, op0
, op1
);
3303 return simplify_gen_relational (UNGE
, mode
, inner_mode
, op0
, op1
);
3306 return simplify_gen_relational (UNEQ
, mode
, inner_mode
, op0
, op1
);
3309 return simplify_gen_relational (LTGT
, mode
, inner_mode
, op0
, op1
);
3312 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, op2
);
3315 gcc_assert (COMPLEX_MODE_P (mode
));
3316 if (GET_MODE (op0
) == VOIDmode
)
3317 op0
= gen_rtx_CONST (GET_MODE_INNER (mode
), op0
);
3318 if (GET_MODE (op1
) == VOIDmode
)
3319 op1
= gen_rtx_CONST (GET_MODE_INNER (mode
), op1
);
3320 return gen_rtx_CONCAT (mode
, op0
, op1
);
3323 if (GET_CODE (op0
) == CONCAT
)
3324 return gen_rtx_CONCAT (mode
, XEXP (op0
, 0),
3325 simplify_gen_unary (NEG
, GET_MODE_INNER (mode
),
3327 GET_MODE_INNER (mode
)));
3330 enum machine_mode imode
= GET_MODE_INNER (mode
);
3335 re
= adjust_address_nv (op0
, imode
, 0);
3336 im
= adjust_address_nv (op0
, imode
, GET_MODE_SIZE (imode
));
3340 enum machine_mode ifmode
= int_mode_for_mode (mode
);
3341 enum machine_mode ihmode
= int_mode_for_mode (imode
);
3343 if (ifmode
== BLKmode
|| ihmode
== BLKmode
)
3345 halfsize
= GEN_INT (GET_MODE_BITSIZE (ihmode
));
3348 re
= gen_rtx_SUBREG (ifmode
, re
, 0);
3349 re
= gen_rtx_ZERO_EXTRACT (ihmode
, re
, halfsize
, const0_rtx
);
3350 if (imode
!= ihmode
)
3351 re
= gen_rtx_SUBREG (imode
, re
, 0);
3352 im
= copy_rtx (op0
);
3354 im
= gen_rtx_SUBREG (ifmode
, im
, 0);
3355 im
= gen_rtx_ZERO_EXTRACT (ihmode
, im
, halfsize
, halfsize
);
3356 if (imode
!= ihmode
)
3357 im
= gen_rtx_SUBREG (imode
, im
, 0);
3359 im
= gen_rtx_NEG (imode
, im
);
3360 return gen_rtx_CONCAT (mode
, re
, im
);
3364 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
3365 if (!op0
|| !MEM_P (op0
))
3367 if ((TREE_CODE (TREE_OPERAND (exp
, 0)) == VAR_DECL
3368 || TREE_CODE (TREE_OPERAND (exp
, 0)) == PARM_DECL
3369 || TREE_CODE (TREE_OPERAND (exp
, 0)) == RESULT_DECL
)
3370 && (!TREE_ADDRESSABLE (TREE_OPERAND (exp
, 0))
3371 || target_for_debug_bind (TREE_OPERAND (exp
, 0))))
3372 return gen_rtx_DEBUG_IMPLICIT_PTR (mode
, TREE_OPERAND (exp
, 0));
3374 if (handled_component_p (TREE_OPERAND (exp
, 0)))
3376 HOST_WIDE_INT bitoffset
, bitsize
, maxsize
;
3378 = get_ref_base_and_extent (TREE_OPERAND (exp
, 0),
3379 &bitoffset
, &bitsize
, &maxsize
);
3380 if ((TREE_CODE (decl
) == VAR_DECL
3381 || TREE_CODE (decl
) == PARM_DECL
3382 || TREE_CODE (decl
) == RESULT_DECL
)
3383 && (!TREE_ADDRESSABLE (decl
)
3384 || target_for_debug_bind (decl
))
3385 && (bitoffset
% BITS_PER_UNIT
) == 0
3387 && bitsize
== maxsize
)
3389 rtx base
= gen_rtx_DEBUG_IMPLICIT_PTR (mode
, decl
);
3390 return plus_constant (mode
, base
, bitoffset
/ BITS_PER_UNIT
);
3394 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == MEM_REF
3395 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
3398 op0
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
3401 && (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
3402 || (GET_CODE (op0
) == PLUS
3403 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
3404 && CONST_INT_P (XEXP (op0
, 1)))))
3406 op1
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
3408 if (!op1
|| !CONST_INT_P (op1
))
3411 return plus_constant (mode
, op0
, INTVAL (op1
));
3418 as
= TYPE_ADDR_SPACE (TREE_TYPE (exp
));
3419 op0
= convert_debug_memory_address (mode
, XEXP (op0
, 0), as
);
3427 op0
= gen_rtx_CONCATN
3428 (mode
, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
))));
3430 for (i
= 0; i
< VECTOR_CST_NELTS (exp
); ++i
)
3432 op1
= expand_debug_expr (VECTOR_CST_ELT (exp
, i
));
3435 XVECEXP (op0
, 0, i
) = op1
;
3442 if (TREE_CLOBBER_P (exp
))
3444 else if (TREE_CODE (TREE_TYPE (exp
)) == VECTOR_TYPE
)
3449 op0
= gen_rtx_CONCATN
3450 (mode
, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
))));
3452 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), i
, val
)
3454 op1
= expand_debug_expr (val
);
3457 XVECEXP (op0
, 0, i
) = op1
;
3460 if (i
< TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)))
3462 op1
= expand_debug_expr
3463 (build_zero_cst (TREE_TYPE (TREE_TYPE (exp
))));
3468 for (; i
< TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)); i
++)
3469 XVECEXP (op0
, 0, i
) = op1
;
3475 goto flag_unsupported
;
3478 /* ??? Maybe handle some builtins? */
3483 gimple g
= get_gimple_for_ssa_name (exp
);
3486 op0
= expand_debug_expr (gimple_assign_rhs_to_tree (g
));
3492 int part
= var_to_partition (SA
.map
, exp
);
3494 if (part
== NO_PARTITION
)
3496 /* If this is a reference to an incoming value of parameter
3497 that is never used in the code or where the incoming
3498 value is never used in the code, use PARM_DECL's
3500 if (SSA_NAME_IS_DEFAULT_DEF (exp
)
3501 && TREE_CODE (SSA_NAME_VAR (exp
)) == PARM_DECL
)
3503 op0
= expand_debug_parm_decl (SSA_NAME_VAR (exp
));
3506 op0
= expand_debug_expr (SSA_NAME_VAR (exp
));
3513 gcc_assert (part
>= 0 && (unsigned)part
< SA
.map
->num_partitions
);
3515 op0
= copy_rtx (SA
.partition_to_pseudo
[part
]);
3523 /* Vector stuff. For most of the codes we don't have rtl codes. */
3524 case REALIGN_LOAD_EXPR
:
3525 case REDUC_MAX_EXPR
:
3526 case REDUC_MIN_EXPR
:
3527 case REDUC_PLUS_EXPR
:
3529 case VEC_LSHIFT_EXPR
:
3530 case VEC_PACK_FIX_TRUNC_EXPR
:
3531 case VEC_PACK_SAT_EXPR
:
3532 case VEC_PACK_TRUNC_EXPR
:
3533 case VEC_RSHIFT_EXPR
:
3534 case VEC_UNPACK_FLOAT_HI_EXPR
:
3535 case VEC_UNPACK_FLOAT_LO_EXPR
:
3536 case VEC_UNPACK_HI_EXPR
:
3537 case VEC_UNPACK_LO_EXPR
:
3538 case VEC_WIDEN_MULT_HI_EXPR
:
3539 case VEC_WIDEN_MULT_LO_EXPR
:
3540 case VEC_WIDEN_MULT_EVEN_EXPR
:
3541 case VEC_WIDEN_MULT_ODD_EXPR
:
3542 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3543 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3548 case ADDR_SPACE_CONVERT_EXPR
:
3549 case FIXED_CONVERT_EXPR
:
3551 case WITH_SIZE_EXPR
:
3555 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
3556 && SCALAR_INT_MODE_P (mode
))
3559 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
3561 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
3564 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
3566 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op1
,
3568 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
3569 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
3573 case WIDEN_MULT_EXPR
:
3574 case WIDEN_MULT_PLUS_EXPR
:
3575 case WIDEN_MULT_MINUS_EXPR
:
3576 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
3577 && SCALAR_INT_MODE_P (mode
))
3579 inner_mode
= GET_MODE (op0
);
3580 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
3581 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
3583 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
3584 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 1))))
3585 op1
= simplify_gen_unary (ZERO_EXTEND
, mode
, op1
, inner_mode
);
3587 op1
= simplify_gen_unary (SIGN_EXTEND
, mode
, op1
, inner_mode
);
3588 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
3589 if (TREE_CODE (exp
) == WIDEN_MULT_EXPR
)
3591 else if (TREE_CODE (exp
) == WIDEN_MULT_PLUS_EXPR
)
3592 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
3594 return simplify_gen_binary (MINUS
, mode
, op2
, op0
);
3598 case MULT_HIGHPART_EXPR
:
3599 /* ??? Similar to the above. */
3602 case WIDEN_SUM_EXPR
:
3603 case WIDEN_LSHIFT_EXPR
:
3604 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
3605 && SCALAR_INT_MODE_P (mode
))
3608 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
3610 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
3612 return simplify_gen_binary (TREE_CODE (exp
) == WIDEN_LSHIFT_EXPR
3613 ? ASHIFT
: PLUS
, mode
, op0
, op1
);
3618 return simplify_gen_ternary (FMA
, mode
, inner_mode
, op0
, op1
, op2
);
3622 #ifdef ENABLE_CHECKING
3631 /* Return an RTX equivalent to the source bind value of the tree expression
3635 expand_debug_source_expr (tree exp
)
3638 enum machine_mode mode
= VOIDmode
, inner_mode
;
3640 switch (TREE_CODE (exp
))
3644 mode
= DECL_MODE (exp
);
3645 op0
= expand_debug_parm_decl (exp
);
3648 /* See if this isn't an argument that has been completely
3650 if (!DECL_RTL_SET_P (exp
)
3651 && !DECL_INCOMING_RTL (exp
)
3652 && DECL_ABSTRACT_ORIGIN (current_function_decl
))
3654 tree aexp
= DECL_ORIGIN (exp
);
3655 if (DECL_CONTEXT (aexp
)
3656 == DECL_ABSTRACT_ORIGIN (current_function_decl
))
3658 vec
<tree
, va_gc
> **debug_args
;
3661 debug_args
= decl_debug_args_lookup (current_function_decl
);
3662 if (debug_args
!= NULL
)
3664 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, &ddecl
);
3667 return gen_rtx_DEBUG_PARAMETER_REF (mode
, aexp
);
3677 if (op0
== NULL_RTX
)
3680 inner_mode
= GET_MODE (op0
);
3681 if (mode
== inner_mode
)
3684 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
3686 if (GET_MODE_BITSIZE (mode
) == GET_MODE_BITSIZE (inner_mode
))
3687 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
3688 else if (GET_MODE_BITSIZE (mode
) < GET_MODE_BITSIZE (inner_mode
))
3689 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
3691 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
3693 else if (FLOAT_MODE_P (mode
))
3695 else if (FLOAT_MODE_P (inner_mode
))
3697 if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
3698 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
3700 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
3702 else if (CONSTANT_P (op0
)
3703 || GET_MODE_BITSIZE (mode
) <= GET_MODE_BITSIZE (inner_mode
))
3704 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
,
3705 subreg_lowpart_offset (mode
, inner_mode
));
3706 else if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
3707 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
3709 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
3714 /* Ensure INSN_VAR_LOCATION_LOC (insn) doesn't have unbound complexity.
3715 Allow 4 levels of rtl nesting for most rtl codes, and if we see anything
3716 deeper than that, create DEBUG_EXPRs and emit DEBUG_INSNs before INSN. */
3719 avoid_complex_debug_insns (rtx insn
, rtx
*exp_p
, int depth
)
3723 if (exp
== NULL_RTX
)
3726 if ((OBJECT_P (exp
) && !MEM_P (exp
)) || GET_CODE (exp
) == CLOBBER
)
3731 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
3732 rtx dval
= make_debug_expr_from_rtl (exp
);
3734 /* Emit a debug bind insn before INSN. */
3735 rtx bind
= gen_rtx_VAR_LOCATION (GET_MODE (exp
),
3736 DEBUG_EXPR_TREE_DECL (dval
), exp
,
3737 VAR_INIT_STATUS_INITIALIZED
);
3739 emit_debug_insn_before (bind
, insn
);
3744 const char *format_ptr
= GET_RTX_FORMAT (GET_CODE (exp
));
3746 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
3747 switch (*format_ptr
++)
3750 avoid_complex_debug_insns (insn
, &XEXP (exp
, i
), depth
+ 1);
3755 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
3756 avoid_complex_debug_insns (insn
, &XVECEXP (exp
, i
, j
), depth
+ 1);
3764 /* Expand the _LOCs in debug insns. We run this after expanding all
3765 regular insns, so that any variables referenced in the function
3766 will have their DECL_RTLs set. */
3769 expand_debug_locations (void)
3772 rtx last
= get_last_insn ();
3773 int save_strict_alias
= flag_strict_aliasing
;
3775 /* New alias sets while setting up memory attributes cause
3776 -fcompare-debug failures, even though it doesn't bring about any
3778 flag_strict_aliasing
= 0;
3780 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
3781 if (DEBUG_INSN_P (insn
))
3783 tree value
= (tree
)INSN_VAR_LOCATION_LOC (insn
);
3784 rtx val
, prev_insn
, insn2
;
3785 enum machine_mode mode
;
3787 if (value
== NULL_TREE
)
3791 if (INSN_VAR_LOCATION_STATUS (insn
)
3792 == VAR_INIT_STATUS_UNINITIALIZED
)
3793 val
= expand_debug_source_expr (value
);
3795 val
= expand_debug_expr (value
);
3796 gcc_assert (last
== get_last_insn ());
3800 val
= gen_rtx_UNKNOWN_VAR_LOC ();
3803 mode
= GET_MODE (INSN_VAR_LOCATION (insn
));
3805 gcc_assert (mode
== GET_MODE (val
)
3806 || (GET_MODE (val
) == VOIDmode
3807 && (CONST_SCALAR_INT_P (val
)
3808 || GET_CODE (val
) == CONST_FIXED
3809 || GET_CODE (val
) == LABEL_REF
)));
3812 INSN_VAR_LOCATION_LOC (insn
) = val
;
3813 prev_insn
= PREV_INSN (insn
);
3814 for (insn2
= insn
; insn2
!= prev_insn
; insn2
= PREV_INSN (insn2
))
3815 avoid_complex_debug_insns (insn2
, &INSN_VAR_LOCATION_LOC (insn2
), 0);
3818 flag_strict_aliasing
= save_strict_alias
;
3821 /* Expand basic block BB from GIMPLE trees to RTL. */
3824 expand_gimple_basic_block (basic_block bb
, bool disable_tail_calls
)
3826 gimple_stmt_iterator gsi
;
3835 fprintf (dump_file
, "\n;; Generating RTL for gimple basic block %d\n",
3838 /* Note that since we are now transitioning from GIMPLE to RTL, we
3839 cannot use the gsi_*_bb() routines because they expect the basic
3840 block to be in GIMPLE, instead of RTL. Therefore, we need to
3841 access the BB sequence directly. */
3842 stmts
= bb_seq (bb
);
3843 bb
->il
.gimple
.seq
= NULL
;
3844 bb
->il
.gimple
.phi_nodes
= NULL
;
3845 rtl_profile_for_bb (bb
);
3846 init_rtl_bb_info (bb
);
3847 bb
->flags
|= BB_RTL
;
3849 /* Remove the RETURN_EXPR if we may fall though to the exit
3851 gsi
= gsi_last (stmts
);
3852 if (!gsi_end_p (gsi
)
3853 && gimple_code (gsi_stmt (gsi
)) == GIMPLE_RETURN
)
3855 gimple ret_stmt
= gsi_stmt (gsi
);
3857 gcc_assert (single_succ_p (bb
));
3858 gcc_assert (single_succ (bb
) == EXIT_BLOCK_PTR
);
3860 if (bb
->next_bb
== EXIT_BLOCK_PTR
3861 && !gimple_return_retval (ret_stmt
))
3863 gsi_remove (&gsi
, false);
3864 single_succ_edge (bb
)->flags
|= EDGE_FALLTHRU
;
3868 gsi
= gsi_start (stmts
);
3869 if (!gsi_end_p (gsi
))
3871 stmt
= gsi_stmt (gsi
);
3872 if (gimple_code (stmt
) != GIMPLE_LABEL
)
3876 elt
= pointer_map_contains (lab_rtx_for_bb
, bb
);
3880 last
= get_last_insn ();
3884 expand_gimple_stmt (stmt
);
3889 emit_label ((rtx
) *elt
);
3891 /* Java emits line number notes in the top of labels.
3892 ??? Make this go away once line number notes are obsoleted. */
3893 BB_HEAD (bb
) = NEXT_INSN (last
);
3894 if (NOTE_P (BB_HEAD (bb
)))
3895 BB_HEAD (bb
) = NEXT_INSN (BB_HEAD (bb
));
3896 note
= emit_note_after (NOTE_INSN_BASIC_BLOCK
, BB_HEAD (bb
));
3898 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
3901 note
= BB_HEAD (bb
) = emit_note (NOTE_INSN_BASIC_BLOCK
);
3903 NOTE_BASIC_BLOCK (note
) = bb
;
3905 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
3909 stmt
= gsi_stmt (gsi
);
3911 /* If this statement is a non-debug one, and we generate debug
3912 insns, then this one might be the last real use of a TERed
3913 SSA_NAME, but where there are still some debug uses further
3914 down. Expanding the current SSA name in such further debug
3915 uses by their RHS might lead to wrong debug info, as coalescing
3916 might make the operands of such RHS be placed into the same
3917 pseudo as something else. Like so:
3918 a_1 = a_0 + 1; // Assume a_1 is TERed and a_0 is dead
3922 As a_0 and a_2 don't overlap in lifetime, assume they are coalesced.
3923 If we now would expand a_1 by it's RHS (a_0 + 1) in the debug use,
3924 the write to a_2 would actually have clobbered the place which
3927 So, instead of that, we recognize the situation, and generate
3928 debug temporaries at the last real use of TERed SSA names:
3935 if (MAY_HAVE_DEBUG_INSNS
3937 && !is_gimple_debug (stmt
))
3943 location_t sloc
= curr_insn_location ();
3945 /* Look for SSA names that have their last use here (TERed
3946 names always have only one real use). */
3947 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
)
3948 if ((def
= get_gimple_for_ssa_name (op
)))
3950 imm_use_iterator imm_iter
;
3951 use_operand_p use_p
;
3952 bool have_debug_uses
= false;
3954 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, op
)
3956 if (gimple_debug_bind_p (USE_STMT (use_p
)))
3958 have_debug_uses
= true;
3963 if (have_debug_uses
)
3965 /* OP is a TERed SSA name, with DEF it's defining
3966 statement, and where OP is used in further debug
3967 instructions. Generate a debug temporary, and
3968 replace all uses of OP in debug insns with that
3971 tree value
= gimple_assign_rhs_to_tree (def
);
3972 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
3974 enum machine_mode mode
;
3976 set_curr_insn_location (gimple_location (def
));
3978 DECL_ARTIFICIAL (vexpr
) = 1;
3979 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
3981 mode
= DECL_MODE (value
);
3983 mode
= TYPE_MODE (TREE_TYPE (value
));
3984 DECL_MODE (vexpr
) = mode
;
3986 val
= gen_rtx_VAR_LOCATION
3987 (mode
, vexpr
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
3989 emit_debug_insn (val
);
3991 FOR_EACH_IMM_USE_STMT (debugstmt
, imm_iter
, op
)
3993 if (!gimple_debug_bind_p (debugstmt
))
3996 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
3997 SET_USE (use_p
, vexpr
);
3999 update_stmt (debugstmt
);
4003 set_curr_insn_location (sloc
);
4006 currently_expanding_gimple_stmt
= stmt
;
4008 /* Expand this statement, then evaluate the resulting RTL and
4009 fixup the CFG accordingly. */
4010 if (gimple_code (stmt
) == GIMPLE_COND
)
4012 new_bb
= expand_gimple_cond (bb
, stmt
);
4016 else if (gimple_debug_bind_p (stmt
))
4018 location_t sloc
= curr_insn_location ();
4019 gimple_stmt_iterator nsi
= gsi
;
4023 tree var
= gimple_debug_bind_get_var (stmt
);
4026 enum machine_mode mode
;
4028 if (TREE_CODE (var
) != DEBUG_EXPR_DECL
4029 && TREE_CODE (var
) != LABEL_DECL
4030 && !target_for_debug_bind (var
))
4031 goto delink_debug_stmt
;
4033 if (gimple_debug_bind_has_value_p (stmt
))
4034 value
= gimple_debug_bind_get_value (stmt
);
4038 last
= get_last_insn ();
4040 set_curr_insn_location (gimple_location (stmt
));
4043 mode
= DECL_MODE (var
);
4045 mode
= TYPE_MODE (TREE_TYPE (var
));
4047 val
= gen_rtx_VAR_LOCATION
4048 (mode
, var
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
4050 emit_debug_insn (val
);
4052 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4054 /* We can't dump the insn with a TREE where an RTX
4056 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
4057 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
4058 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
4062 /* In order not to generate too many debug temporaries,
4063 we delink all uses of debug statements we already expanded.
4064 Therefore debug statements between definition and real
4065 use of TERed SSA names will continue to use the SSA name,
4066 and not be replaced with debug temps. */
4067 delink_stmt_imm_use (stmt
);
4071 if (gsi_end_p (nsi
))
4073 stmt
= gsi_stmt (nsi
);
4074 if (!gimple_debug_bind_p (stmt
))
4078 set_curr_insn_location (sloc
);
4080 else if (gimple_debug_source_bind_p (stmt
))
4082 location_t sloc
= curr_insn_location ();
4083 tree var
= gimple_debug_source_bind_get_var (stmt
);
4084 tree value
= gimple_debug_source_bind_get_value (stmt
);
4086 enum machine_mode mode
;
4088 last
= get_last_insn ();
4090 set_curr_insn_location (gimple_location (stmt
));
4092 mode
= DECL_MODE (var
);
4094 val
= gen_rtx_VAR_LOCATION (mode
, var
, (rtx
)value
,
4095 VAR_INIT_STATUS_UNINITIALIZED
);
4097 emit_debug_insn (val
);
4099 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4101 /* We can't dump the insn with a TREE where an RTX
4103 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
4104 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
4105 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
4108 set_curr_insn_location (sloc
);
4112 if (is_gimple_call (stmt
)
4113 && gimple_call_tail_p (stmt
)
4114 && disable_tail_calls
)
4115 gimple_call_set_tail (stmt
, false);
4117 if (is_gimple_call (stmt
) && gimple_call_tail_p (stmt
))
4120 new_bb
= expand_gimple_tailcall (bb
, stmt
, &can_fallthru
);
4131 def_operand_p def_p
;
4132 def_p
= SINGLE_SSA_DEF_OPERAND (stmt
, SSA_OP_DEF
);
4136 /* Ignore this stmt if it is in the list of
4137 replaceable expressions. */
4139 && bitmap_bit_p (SA
.values
,
4140 SSA_NAME_VERSION (DEF_FROM_PTR (def_p
))))
4143 last
= expand_gimple_stmt (stmt
);
4144 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
4149 currently_expanding_gimple_stmt
= NULL
;
4151 /* Expand implicit goto and convert goto_locus. */
4152 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
4154 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
4155 set_curr_insn_location (e
->goto_locus
);
4156 if ((e
->flags
& EDGE_FALLTHRU
) && e
->dest
!= bb
->next_bb
)
4158 emit_jump (label_rtx_for_bb (e
->dest
));
4159 e
->flags
&= ~EDGE_FALLTHRU
;
4163 /* Expanded RTL can create a jump in the last instruction of block.
4164 This later might be assumed to be a jump to successor and break edge insertion.
4165 We need to insert dummy move to prevent this. PR41440. */
4166 if (single_succ_p (bb
)
4167 && (single_succ_edge (bb
)->flags
& EDGE_FALLTHRU
)
4168 && (last
= get_last_insn ())
4171 rtx dummy
= gen_reg_rtx (SImode
);
4172 emit_insn_after_noloc (gen_move_insn (dummy
, dummy
), last
, NULL
);
4175 do_pending_stack_adjust ();
4177 /* Find the block tail. The last insn in the block is the insn
4178 before a barrier and/or table jump insn. */
4179 last
= get_last_insn ();
4180 if (BARRIER_P (last
))
4181 last
= PREV_INSN (last
);
4182 if (JUMP_TABLE_DATA_P (last
))
4183 last
= PREV_INSN (PREV_INSN (last
));
4186 update_bb_for_insn (bb
);
4192 /* Create a basic block for initialization code. */
4195 construct_init_block (void)
4197 basic_block init_block
, first_block
;
4201 /* Multiple entry points not supported yet. */
4202 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR
->succs
) == 1);
4203 init_rtl_bb_info (ENTRY_BLOCK_PTR
);
4204 init_rtl_bb_info (EXIT_BLOCK_PTR
);
4205 ENTRY_BLOCK_PTR
->flags
|= BB_RTL
;
4206 EXIT_BLOCK_PTR
->flags
|= BB_RTL
;
4208 e
= EDGE_SUCC (ENTRY_BLOCK_PTR
, 0);
4210 /* When entry edge points to first basic block, we don't need jump,
4211 otherwise we have to jump into proper target. */
4212 if (e
&& e
->dest
!= ENTRY_BLOCK_PTR
->next_bb
)
4214 tree label
= gimple_block_label (e
->dest
);
4216 emit_jump (label_rtx (label
));
4220 flags
= EDGE_FALLTHRU
;
4222 init_block
= create_basic_block (NEXT_INSN (get_insns ()),
4225 init_block
->frequency
= ENTRY_BLOCK_PTR
->frequency
;
4226 init_block
->count
= ENTRY_BLOCK_PTR
->count
;
4227 if (current_loops
&& ENTRY_BLOCK_PTR
->loop_father
)
4228 add_bb_to_loop (init_block
, ENTRY_BLOCK_PTR
->loop_father
);
4231 first_block
= e
->dest
;
4232 redirect_edge_succ (e
, init_block
);
4233 e
= make_edge (init_block
, first_block
, flags
);
4236 e
= make_edge (init_block
, EXIT_BLOCK_PTR
, EDGE_FALLTHRU
);
4237 e
->probability
= REG_BR_PROB_BASE
;
4238 e
->count
= ENTRY_BLOCK_PTR
->count
;
4240 update_bb_for_insn (init_block
);
4244 /* For each lexical block, set BLOCK_NUMBER to the depth at which it is
4245 found in the block tree. */
4248 set_block_levels (tree block
, int level
)
4252 BLOCK_NUMBER (block
) = level
;
4253 set_block_levels (BLOCK_SUBBLOCKS (block
), level
+ 1);
4254 block
= BLOCK_CHAIN (block
);
4258 /* Create a block containing landing pads and similar stuff. */
4261 construct_exit_block (void)
4263 rtx head
= get_last_insn ();
4265 basic_block exit_block
;
4269 rtx orig_end
= BB_END (EXIT_BLOCK_PTR
->prev_bb
);
4271 rtl_profile_for_bb (EXIT_BLOCK_PTR
);
4273 /* Make sure the locus is set to the end of the function, so that
4274 epilogue line numbers and warnings are set properly. */
4275 if (LOCATION_LOCUS (cfun
->function_end_locus
) != UNKNOWN_LOCATION
)
4276 input_location
= cfun
->function_end_locus
;
4278 /* Generate rtl for function exit. */
4279 expand_function_end ();
4281 end
= get_last_insn ();
4284 /* While emitting the function end we could move end of the last basic block.
4286 BB_END (EXIT_BLOCK_PTR
->prev_bb
) = orig_end
;
4287 while (NEXT_INSN (head
) && NOTE_P (NEXT_INSN (head
)))
4288 head
= NEXT_INSN (head
);
4289 exit_block
= create_basic_block (NEXT_INSN (head
), end
,
4290 EXIT_BLOCK_PTR
->prev_bb
);
4291 exit_block
->frequency
= EXIT_BLOCK_PTR
->frequency
;
4292 exit_block
->count
= EXIT_BLOCK_PTR
->count
;
4293 if (current_loops
&& EXIT_BLOCK_PTR
->loop_father
)
4294 add_bb_to_loop (exit_block
, EXIT_BLOCK_PTR
->loop_father
);
4297 while (ix
< EDGE_COUNT (EXIT_BLOCK_PTR
->preds
))
4299 e
= EDGE_PRED (EXIT_BLOCK_PTR
, ix
);
4300 if (!(e
->flags
& EDGE_ABNORMAL
))
4301 redirect_edge_succ (e
, exit_block
);
4306 e
= make_edge (exit_block
, EXIT_BLOCK_PTR
, EDGE_FALLTHRU
);
4307 e
->probability
= REG_BR_PROB_BASE
;
4308 e
->count
= EXIT_BLOCK_PTR
->count
;
4309 FOR_EACH_EDGE (e2
, ei
, EXIT_BLOCK_PTR
->preds
)
4312 e
->count
-= e2
->count
;
4313 exit_block
->count
-= e2
->count
;
4314 exit_block
->frequency
-= EDGE_FREQUENCY (e2
);
4318 if (exit_block
->count
< 0)
4319 exit_block
->count
= 0;
4320 if (exit_block
->frequency
< 0)
4321 exit_block
->frequency
= 0;
4322 update_bb_for_insn (exit_block
);
4325 /* Helper function for discover_nonconstant_array_refs.
4326 Look for ARRAY_REF nodes with non-constant indexes and mark them
4330 discover_nonconstant_array_refs_r (tree
* tp
, int *walk_subtrees
,
4331 void *data ATTRIBUTE_UNUSED
)
4335 if (IS_TYPE_OR_DECL_P (t
))
4337 else if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
4339 while (((TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
4340 && is_gimple_min_invariant (TREE_OPERAND (t
, 1))
4341 && (!TREE_OPERAND (t
, 2)
4342 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
4343 || (TREE_CODE (t
) == COMPONENT_REF
4344 && (!TREE_OPERAND (t
,2)
4345 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
4346 || TREE_CODE (t
) == BIT_FIELD_REF
4347 || TREE_CODE (t
) == REALPART_EXPR
4348 || TREE_CODE (t
) == IMAGPART_EXPR
4349 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
4350 || CONVERT_EXPR_P (t
))
4351 t
= TREE_OPERAND (t
, 0);
4353 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
4355 t
= get_base_address (t
);
4357 && DECL_MODE (t
) != BLKmode
)
4358 TREE_ADDRESSABLE (t
) = 1;
4367 /* RTL expansion is not able to compile array references with variable
4368 offsets for arrays stored in single register. Discover such
4369 expressions and mark variables as addressable to avoid this
4373 discover_nonconstant_array_refs (void)
4376 gimple_stmt_iterator gsi
;
4379 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4381 gimple stmt
= gsi_stmt (gsi
);
4382 if (!is_gimple_debug (stmt
))
4383 walk_gimple_op (stmt
, discover_nonconstant_array_refs_r
, NULL
);
4387 /* This function sets crtl->args.internal_arg_pointer to a virtual
4388 register if DRAP is needed. Local register allocator will replace
4389 virtual_incoming_args_rtx with the virtual register. */
4392 expand_stack_alignment (void)
4395 unsigned int preferred_stack_boundary
;
4397 if (! SUPPORTS_STACK_ALIGNMENT
)
4400 if (cfun
->calls_alloca
4401 || cfun
->has_nonlocal_label
4402 || crtl
->has_nonlocal_goto
)
4403 crtl
->need_drap
= true;
4405 /* Call update_stack_boundary here again to update incoming stack
4406 boundary. It may set incoming stack alignment to a different
4407 value after RTL expansion. TARGET_FUNCTION_OK_FOR_SIBCALL may
4408 use the minimum incoming stack alignment to check if it is OK
4409 to perform sibcall optimization since sibcall optimization will
4410 only align the outgoing stack to incoming stack boundary. */
4411 if (targetm
.calls
.update_stack_boundary
)
4412 targetm
.calls
.update_stack_boundary ();
4414 /* The incoming stack frame has to be aligned at least at
4415 parm_stack_boundary. */
4416 gcc_assert (crtl
->parm_stack_boundary
<= INCOMING_STACK_BOUNDARY
);
4418 /* Update crtl->stack_alignment_estimated and use it later to align
4419 stack. We check PREFERRED_STACK_BOUNDARY if there may be non-call
4420 exceptions since callgraph doesn't collect incoming stack alignment
4422 if (cfun
->can_throw_non_call_exceptions
4423 && PREFERRED_STACK_BOUNDARY
> crtl
->preferred_stack_boundary
)
4424 preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
4426 preferred_stack_boundary
= crtl
->preferred_stack_boundary
;
4427 if (preferred_stack_boundary
> crtl
->stack_alignment_estimated
)
4428 crtl
->stack_alignment_estimated
= preferred_stack_boundary
;
4429 if (preferred_stack_boundary
> crtl
->stack_alignment_needed
)
4430 crtl
->stack_alignment_needed
= preferred_stack_boundary
;
4432 gcc_assert (crtl
->stack_alignment_needed
4433 <= crtl
->stack_alignment_estimated
);
4435 crtl
->stack_realign_needed
4436 = INCOMING_STACK_BOUNDARY
< crtl
->stack_alignment_estimated
;
4437 crtl
->stack_realign_tried
= crtl
->stack_realign_needed
;
4439 crtl
->stack_realign_processed
= true;
4441 /* Target has to redefine TARGET_GET_DRAP_RTX to support stack
4443 gcc_assert (targetm
.calls
.get_drap_rtx
!= NULL
);
4444 drap_rtx
= targetm
.calls
.get_drap_rtx ();
4446 /* stack_realign_drap and drap_rtx must match. */
4447 gcc_assert ((stack_realign_drap
!= 0) == (drap_rtx
!= NULL
));
4449 /* Do nothing if NULL is returned, which means DRAP is not needed. */
4450 if (NULL
!= drap_rtx
)
4452 crtl
->args
.internal_arg_pointer
= drap_rtx
;
4454 /* Call fixup_tail_calls to clean up REG_EQUIV note if DRAP is
4456 fixup_tail_calls ();
4460 /* Translate the intermediate representation contained in the CFG
4461 from GIMPLE trees to RTL.
4463 We do conversion per basic block and preserve/update the tree CFG.
4464 This implies we have to do some magic as the CFG can simultaneously
4465 consist of basic blocks containing RTL and GIMPLE trees. This can
4466 confuse the CFG hooks, so be careful to not manipulate CFG during
4470 gimple_expand_cfg (void)
4472 basic_block bb
, init_block
;
4476 rtx var_seq
, var_ret_seq
;
4479 timevar_push (TV_OUT_OF_SSA
);
4480 rewrite_out_of_ssa (&SA
);
4481 timevar_pop (TV_OUT_OF_SSA
);
4482 SA
.partition_to_pseudo
= XCNEWVEC (rtx
, SA
.map
->num_partitions
);
4484 /* Make sure all values used by the optimization passes have sane
4488 /* Some backends want to know that we are expanding to RTL. */
4489 currently_expanding_to_rtl
= 1;
4490 /* Dominators are not kept up-to-date as we may create new basic-blocks. */
4491 free_dominance_info (CDI_DOMINATORS
);
4493 rtl_profile_for_bb (ENTRY_BLOCK_PTR
);
4495 insn_locations_init ();
4496 if (!DECL_IS_BUILTIN (current_function_decl
))
4498 /* Eventually, all FEs should explicitly set function_start_locus. */
4499 if (LOCATION_LOCUS (cfun
->function_start_locus
) == UNKNOWN_LOCATION
)
4500 set_curr_insn_location
4501 (DECL_SOURCE_LOCATION (current_function_decl
));
4503 set_curr_insn_location (cfun
->function_start_locus
);
4506 set_curr_insn_location (UNKNOWN_LOCATION
);
4507 prologue_location
= curr_insn_location ();
4509 #ifdef INSN_SCHEDULING
4510 init_sched_attrs ();
4513 /* Make sure first insn is a note even if we don't want linenums.
4514 This makes sure the first insn will never be deleted.
4515 Also, final expects a note to appear there. */
4516 emit_note (NOTE_INSN_DELETED
);
4518 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
4519 discover_nonconstant_array_refs ();
4521 targetm
.expand_to_rtl_hook ();
4522 crtl
->stack_alignment_needed
= STACK_BOUNDARY
;
4523 crtl
->max_used_stack_slot_alignment
= STACK_BOUNDARY
;
4524 crtl
->stack_alignment_estimated
= 0;
4525 crtl
->preferred_stack_boundary
= STACK_BOUNDARY
;
4526 cfun
->cfg
->max_jumptable_ents
= 0;
4528 /* Resovle the function section. Some targets, like ARM EABI rely on knowledge
4529 of the function section at exapnsion time to predict distance of calls. */
4530 resolve_unique_section (current_function_decl
, 0, flag_function_sections
);
4532 /* Expand the variables recorded during gimple lowering. */
4533 timevar_push (TV_VAR_EXPAND
);
4536 var_ret_seq
= expand_used_vars ();
4538 var_seq
= get_insns ();
4540 timevar_pop (TV_VAR_EXPAND
);
4542 /* Honor stack protection warnings. */
4543 if (warn_stack_protect
)
4545 if (cfun
->calls_alloca
)
4546 warning (OPT_Wstack_protector
,
4547 "stack protector not protecting local variables: "
4548 "variable length buffer");
4549 if (has_short_buffer
&& !crtl
->stack_protect_guard
)
4550 warning (OPT_Wstack_protector
,
4551 "stack protector not protecting function: "
4552 "all local arrays are less than %d bytes long",
4553 (int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
));
4556 /* Set up parameters and prepare for return, for the function. */
4557 expand_function_start (current_function_decl
);
4559 /* If we emitted any instructions for setting up the variables,
4560 emit them before the FUNCTION_START note. */
4563 emit_insn_before (var_seq
, parm_birth_insn
);
4565 /* In expand_function_end we'll insert the alloca save/restore
4566 before parm_birth_insn. We've just insertted an alloca call.
4567 Adjust the pointer to match. */
4568 parm_birth_insn
= var_seq
;
4571 /* Now that we also have the parameter RTXs, copy them over to our
4573 for (i
= 0; i
< SA
.map
->num_partitions
; i
++)
4575 tree var
= SSA_NAME_VAR (partition_to_var (SA
.map
, i
));
4577 if (TREE_CODE (var
) != VAR_DECL
4578 && !SA
.partition_to_pseudo
[i
])
4579 SA
.partition_to_pseudo
[i
] = DECL_RTL_IF_SET (var
);
4580 gcc_assert (SA
.partition_to_pseudo
[i
]);
4582 /* If this decl was marked as living in multiple places, reset
4583 this now to NULL. */
4584 if (DECL_RTL_IF_SET (var
) == pc_rtx
)
4585 SET_DECL_RTL (var
, NULL
);
4587 /* Some RTL parts really want to look at DECL_RTL(x) when x
4588 was a decl marked in REG_ATTR or MEM_ATTR. We could use
4589 SET_DECL_RTL here making this available, but that would mean
4590 to select one of the potentially many RTLs for one DECL. Instead
4591 of doing that we simply reset the MEM_EXPR of the RTL in question,
4592 then nobody can get at it and hence nobody can call DECL_RTL on it. */
4593 if (!DECL_RTL_SET_P (var
))
4595 if (MEM_P (SA
.partition_to_pseudo
[i
]))
4596 set_mem_expr (SA
.partition_to_pseudo
[i
], NULL
);
4600 /* If we have a class containing differently aligned pointers
4601 we need to merge those into the corresponding RTL pointer
4603 for (i
= 1; i
< num_ssa_names
; i
++)
4605 tree name
= ssa_name (i
);
4610 /* We might have generated new SSA names in
4611 update_alias_info_with_stack_vars. They will have a NULL
4612 defining statements, and won't be part of the partitioning,
4614 || !SSA_NAME_DEF_STMT (name
))
4616 part
= var_to_partition (SA
.map
, name
);
4617 if (part
== NO_PARTITION
)
4620 /* Adjust all partition members to get the underlying decl of
4621 the representative which we might have created in expand_one_var. */
4622 if (SSA_NAME_VAR (name
) == NULL_TREE
)
4624 tree leader
= partition_to_var (SA
.map
, part
);
4625 gcc_assert (SSA_NAME_VAR (leader
) != NULL_TREE
);
4626 replace_ssa_name_symbol (name
, SSA_NAME_VAR (leader
));
4628 if (!POINTER_TYPE_P (TREE_TYPE (name
)))
4631 r
= SA
.partition_to_pseudo
[part
];
4633 mark_reg_pointer (r
, get_pointer_alignment (name
));
4636 /* If this function is `main', emit a call to `__main'
4637 to run global initializers, etc. */
4638 if (DECL_NAME (current_function_decl
)
4639 && MAIN_NAME_P (DECL_NAME (current_function_decl
))
4640 && DECL_FILE_SCOPE_P (current_function_decl
))
4641 expand_main_function ();
4643 /* Initialize the stack_protect_guard field. This must happen after the
4644 call to __main (if any) so that the external decl is initialized. */
4645 if (crtl
->stack_protect_guard
)
4646 stack_protect_prologue ();
4648 expand_phi_nodes (&SA
);
4650 /* Register rtl specific functions for cfg. */
4651 rtl_register_cfg_hooks ();
4653 init_block
= construct_init_block ();
4655 /* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
4656 remaining edges later. */
4657 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR
->succs
)
4658 e
->flags
&= ~EDGE_EXECUTABLE
;
4660 lab_rtx_for_bb
= pointer_map_create ();
4661 FOR_BB_BETWEEN (bb
, init_block
->next_bb
, EXIT_BLOCK_PTR
, next_bb
)
4662 bb
= expand_gimple_basic_block (bb
, var_ret_seq
!= NULL_RTX
);
4664 if (MAY_HAVE_DEBUG_INSNS
)
4665 expand_debug_locations ();
4667 /* Free stuff we no longer need after GIMPLE optimizations. */
4668 free_dominance_info (CDI_DOMINATORS
);
4669 free_dominance_info (CDI_POST_DOMINATORS
);
4670 delete_tree_cfg_annotations ();
4672 timevar_push (TV_OUT_OF_SSA
);
4673 finish_out_of_ssa (&SA
);
4674 timevar_pop (TV_OUT_OF_SSA
);
4676 timevar_push (TV_POST_EXPAND
);
4677 /* We are no longer in SSA form. */
4678 cfun
->gimple_df
->in_ssa_p
= false;
4680 loops_state_clear (LOOP_CLOSED_SSA
);
4682 /* Expansion is used by optimization passes too, set maybe_hot_insn_p
4683 conservatively to true until they are all profile aware. */
4684 pointer_map_destroy (lab_rtx_for_bb
);
4687 construct_exit_block ();
4688 insn_locations_finalize ();
4692 rtx after
= return_label
;
4693 rtx next
= NEXT_INSN (after
);
4694 if (next
&& NOTE_INSN_BASIC_BLOCK_P (next
))
4696 emit_insn_after (var_ret_seq
, after
);
4699 /* Zap the tree EH table. */
4700 set_eh_throw_stmt_table (cfun
, NULL
);
4702 /* We need JUMP_LABEL be set in order to redirect jumps, and hence
4703 split edges which edge insertions might do. */
4704 rebuild_jump_labels (get_insns ());
4706 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR
, EXIT_BLOCK_PTR
, next_bb
)
4710 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
4714 rebuild_jump_labels_chain (e
->insns
.r
);
4715 /* Avoid putting insns before parm_birth_insn. */
4716 if (e
->src
== ENTRY_BLOCK_PTR
4717 && single_succ_p (ENTRY_BLOCK_PTR
)
4720 rtx insns
= e
->insns
.r
;
4721 e
->insns
.r
= NULL_RTX
;
4722 emit_insn_after_noloc (insns
, parm_birth_insn
, e
->dest
);
4725 commit_one_edge_insertion (e
);
4732 /* We're done expanding trees to RTL. */
4733 currently_expanding_to_rtl
= 0;
4735 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR
->next_bb
, EXIT_BLOCK_PTR
, next_bb
)
4739 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
4741 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
4742 e
->flags
&= ~EDGE_EXECUTABLE
;
4744 /* At the moment not all abnormal edges match the RTL
4745 representation. It is safe to remove them here as
4746 find_many_sub_basic_blocks will rediscover them.
4747 In the future we should get this fixed properly. */
4748 if ((e
->flags
& EDGE_ABNORMAL
)
4749 && !(e
->flags
& EDGE_SIBCALL
))
4756 blocks
= sbitmap_alloc (last_basic_block
);
4757 bitmap_ones (blocks
);
4758 find_many_sub_basic_blocks (blocks
);
4759 sbitmap_free (blocks
);
4760 purge_all_dead_edges ();
4762 expand_stack_alignment ();
4764 /* Fixup REG_EQUIV notes in the prologue if there are tailcalls in this
4766 if (crtl
->tail_call_emit
)
4767 fixup_tail_calls ();
4769 /* After initial rtl generation, call back to finish generating
4770 exception support code. We need to do this before cleaning up
4771 the CFG as the code does not expect dead landing pads. */
4772 if (cfun
->eh
->region_tree
!= NULL
)
4773 finish_eh_generation ();
4775 /* Remove unreachable blocks, otherwise we cannot compute dominators
4776 which are needed for loop state verification. As a side-effect
4777 this also compacts blocks.
4778 ??? We cannot remove trivially dead insns here as for example
4779 the DRAP reg on i?86 is not magically live at this point.
4780 gcc.c-torture/execute/ipa-sra-2.c execution, -Os -m32 fails otherwise. */
4781 cleanup_cfg (CLEANUP_NO_INSN_DEL
);
4783 #ifdef ENABLE_CHECKING
4784 verify_flow_info ();
4787 /* Initialize pseudos allocated for hard registers. */
4788 emit_initial_value_sets ();
4790 /* And finally unshare all RTL. */
4793 /* There's no need to defer outputting this function any more; we
4794 know we want to output it. */
4795 DECL_DEFER_OUTPUT (current_function_decl
) = 0;
4797 /* Now that we're done expanding trees to RTL, we shouldn't have any
4798 more CONCATs anywhere. */
4799 generating_concat_p
= 0;
4804 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
4805 /* And the pass manager will dump RTL for us. */
4808 /* If we're emitting a nested function, make sure its parent gets
4809 emitted as well. Doing otherwise confuses debug info. */
4812 for (parent
= DECL_CONTEXT (current_function_decl
);
4813 parent
!= NULL_TREE
;
4814 parent
= get_containing_scope (parent
))
4815 if (TREE_CODE (parent
) == FUNCTION_DECL
)
4816 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent
)) = 1;
4819 /* We are now committed to emitting code for this function. Do any
4820 preparation, such as emitting abstract debug info for the inline
4821 before it gets mangled by optimization. */
4822 if (cgraph_function_possibly_inlined_p (current_function_decl
))
4823 (*debug_hooks
->outlining_inline_function
) (current_function_decl
);
4825 TREE_ASM_WRITTEN (current_function_decl
) = 1;
4827 /* After expanding, the return labels are no longer needed. */
4828 return_label
= NULL
;
4829 naked_return_label
= NULL
;
4831 /* After expanding, the tm_restart map is no longer needed. */
4832 if (cfun
->gimple_df
->tm_restart
)
4834 htab_delete (cfun
->gimple_df
->tm_restart
);
4835 cfun
->gimple_df
->tm_restart
= NULL
;
4838 /* Tag the blocks with a depth number so that change_scope can find
4839 the common parent easily. */
4840 set_block_levels (DECL_INITIAL (cfun
->decl
), 0);
4841 default_rtl_profile ();
4843 timevar_pop (TV_POST_EXPAND
);
4848 struct rtl_opt_pass pass_expand
=
4852 "expand", /* name */
4853 OPTGROUP_NONE
, /* optinfo_flags */
4855 gimple_expand_cfg
, /* execute */
4858 0, /* static_pass_number */
4859 TV_EXPAND
, /* tv_id */
4860 PROP_ssa
| PROP_gimple_leh
| PROP_cfg
4862 | PROP_gimple_lvec
, /* properties_required */
4863 PROP_rtl
, /* properties_provided */
4864 PROP_ssa
| PROP_trees
, /* properties_destroyed */
4865 TODO_verify_ssa
| TODO_verify_flow
4866 | TODO_verify_stmts
, /* todo_flags_start */
4867 TODO_ggc_collect
/* todo_flags_finish */