1 /* A pass for lowering trees to RTL.
2 Copyright (C) 2004-2014 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"
25 #include "hard-reg-set.h"
27 #include "stringpool.h"
29 #include "stor-layout.h"
31 #include "print-tree.h"
33 #include "basic-block.h"
36 #include "langhooks.h"
38 #include "pointer-set.h"
39 #include "tree-ssa-alias.h"
40 #include "internal-fn.h"
42 #include "gimple-expr.h"
45 #include "gimple-iterator.h"
46 #include "gimple-walk.h"
47 #include "gimple-ssa.h"
50 #include "tree-phinodes.h"
51 #include "ssa-iterators.h"
52 #include "tree-ssanames.h"
55 #include "tree-pass.h"
58 #include "diagnostic.h"
59 #include "gimple-pretty-print.h"
63 #include "tree-inline.h"
64 #include "value-prof.h"
66 #include "tree-ssa-live.h"
67 #include "tree-outof-ssa.h"
70 #include "regs.h" /* For reg_renumber. */
71 #include "insn-attr.h" /* For INSN_SCHEDULING. */
73 #include "tree-ssa-address.h"
77 /* Some systems use __main in a way incompatible with its use in gcc, in these
78 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
79 give the same symbol without quotes for an alternative entry point. You
80 must define both, or neither. */
82 #define NAME__MAIN "__main"
85 /* This variable holds information helping the rewriting of SSA trees
89 /* This variable holds the currently expanded gimple statement for purposes
90 of comminucating the profile info to the builtin expanders. */
91 gimple currently_expanding_gimple_stmt
;
93 static rtx
expand_debug_expr (tree
);
95 /* Return an expression tree corresponding to the RHS of GIMPLE
99 gimple_assign_rhs_to_tree (gimple stmt
)
102 enum gimple_rhs_class grhs_class
;
104 grhs_class
= get_gimple_rhs_class (gimple_expr_code (stmt
));
106 if (grhs_class
== GIMPLE_TERNARY_RHS
)
107 t
= build3 (gimple_assign_rhs_code (stmt
),
108 TREE_TYPE (gimple_assign_lhs (stmt
)),
109 gimple_assign_rhs1 (stmt
),
110 gimple_assign_rhs2 (stmt
),
111 gimple_assign_rhs3 (stmt
));
112 else if (grhs_class
== GIMPLE_BINARY_RHS
)
113 t
= build2 (gimple_assign_rhs_code (stmt
),
114 TREE_TYPE (gimple_assign_lhs (stmt
)),
115 gimple_assign_rhs1 (stmt
),
116 gimple_assign_rhs2 (stmt
));
117 else if (grhs_class
== GIMPLE_UNARY_RHS
)
118 t
= build1 (gimple_assign_rhs_code (stmt
),
119 TREE_TYPE (gimple_assign_lhs (stmt
)),
120 gimple_assign_rhs1 (stmt
));
121 else if (grhs_class
== GIMPLE_SINGLE_RHS
)
123 t
= gimple_assign_rhs1 (stmt
);
124 /* Avoid modifying this tree in place below. */
125 if ((gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (t
)
126 && gimple_location (stmt
) != EXPR_LOCATION (t
))
127 || (gimple_block (stmt
)
128 && currently_expanding_to_rtl
135 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (t
))
136 SET_EXPR_LOCATION (t
, gimple_location (stmt
));
142 #ifndef STACK_ALIGNMENT_NEEDED
143 #define STACK_ALIGNMENT_NEEDED 1
146 #define SSAVAR(x) (TREE_CODE (x) == SSA_NAME ? SSA_NAME_VAR (x) : x)
148 /* Associate declaration T with storage space X. If T is no
149 SSA name this is exactly SET_DECL_RTL, otherwise make the
150 partition of T associated with X. */
152 set_rtl (tree t
, rtx x
)
154 if (TREE_CODE (t
) == SSA_NAME
)
156 SA
.partition_to_pseudo
[var_to_partition (SA
.map
, t
)] = x
;
158 set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (t
), x
);
159 /* For the benefit of debug information at -O0 (where vartracking
160 doesn't run) record the place also in the base DECL if it's
161 a normal variable (not a parameter). */
162 if (x
&& x
!= pc_rtx
&& TREE_CODE (SSA_NAME_VAR (t
)) == VAR_DECL
)
164 tree var
= SSA_NAME_VAR (t
);
165 /* If we don't yet have something recorded, just record it now. */
166 if (!DECL_RTL_SET_P (var
))
167 SET_DECL_RTL (var
, x
);
168 /* If we have it set already to "multiple places" don't
170 else if (DECL_RTL (var
) == pc_rtx
)
172 /* If we have something recorded and it's not the same place
173 as we want to record now, we have multiple partitions for the
174 same base variable, with different places. We can't just
175 randomly chose one, hence we have to say that we don't know.
176 This only happens with optimization, and there var-tracking
177 will figure out the right thing. */
178 else if (DECL_RTL (var
) != x
)
179 SET_DECL_RTL (var
, pc_rtx
);
186 /* This structure holds data relevant to one variable that will be
187 placed in a stack slot. */
193 /* Initially, the size of the variable. Later, the size of the partition,
194 if this variable becomes it's partition's representative. */
197 /* The *byte* alignment required for this variable. Or as, with the
198 size, the alignment for this partition. */
201 /* The partition representative. */
202 size_t representative
;
204 /* The next stack variable in the partition, or EOC. */
207 /* The numbers of conflicting stack variables. */
211 #define EOC ((size_t)-1)
213 /* We have an array of such objects while deciding allocation. */
214 static struct stack_var
*stack_vars
;
215 static size_t stack_vars_alloc
;
216 static size_t stack_vars_num
;
217 static struct pointer_map_t
*decl_to_stack_part
;
219 /* Conflict bitmaps go on this obstack. This allows us to destroy
220 all of them in one big sweep. */
221 static bitmap_obstack stack_var_bitmap_obstack
;
223 /* An array of indices such that stack_vars[stack_vars_sorted[i]].size
224 is non-decreasing. */
225 static size_t *stack_vars_sorted
;
227 /* The phase of the stack frame. This is the known misalignment of
228 virtual_stack_vars_rtx from PREFERRED_STACK_BOUNDARY. That is,
229 (frame_offset+frame_phase) % PREFERRED_STACK_BOUNDARY == 0. */
230 static int frame_phase
;
232 /* Used during expand_used_vars to remember if we saw any decls for
233 which we'd like to enable stack smashing protection. */
234 static bool has_protected_decls
;
236 /* Used during expand_used_vars. Remember if we say a character buffer
237 smaller than our cutoff threshold. Used for -Wstack-protector. */
238 static bool has_short_buffer
;
240 /* Compute the byte alignment to use for DECL. Ignore alignment
241 we can't do with expected alignment of the stack boundary. */
244 align_local_variable (tree decl
)
246 unsigned int align
= LOCAL_DECL_ALIGNMENT (decl
);
247 DECL_ALIGN (decl
) = align
;
248 return align
/ BITS_PER_UNIT
;
251 /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
252 Return the frame offset. */
255 alloc_stack_frame_space (HOST_WIDE_INT size
, unsigned HOST_WIDE_INT align
)
257 HOST_WIDE_INT offset
, new_frame_offset
;
259 new_frame_offset
= frame_offset
;
260 if (FRAME_GROWS_DOWNWARD
)
262 new_frame_offset
-= size
+ frame_phase
;
263 new_frame_offset
&= -align
;
264 new_frame_offset
+= frame_phase
;
265 offset
= new_frame_offset
;
269 new_frame_offset
-= frame_phase
;
270 new_frame_offset
+= align
- 1;
271 new_frame_offset
&= -align
;
272 new_frame_offset
+= frame_phase
;
273 offset
= new_frame_offset
;
274 new_frame_offset
+= size
;
276 frame_offset
= new_frame_offset
;
278 if (frame_offset_overflow (frame_offset
, cfun
->decl
))
279 frame_offset
= offset
= 0;
284 /* Accumulate DECL into STACK_VARS. */
287 add_stack_var (tree decl
)
291 if (stack_vars_num
>= stack_vars_alloc
)
293 if (stack_vars_alloc
)
294 stack_vars_alloc
= stack_vars_alloc
* 3 / 2;
296 stack_vars_alloc
= 32;
298 = XRESIZEVEC (struct stack_var
, stack_vars
, stack_vars_alloc
);
300 if (!decl_to_stack_part
)
301 decl_to_stack_part
= pointer_map_create ();
303 v
= &stack_vars
[stack_vars_num
];
304 * (size_t *)pointer_map_insert (decl_to_stack_part
, decl
) = stack_vars_num
;
307 v
->size
= tree_to_uhwi (DECL_SIZE_UNIT (SSAVAR (decl
)));
308 /* Ensure that all variables have size, so that &a != &b for any two
309 variables that are simultaneously live. */
312 v
->alignb
= align_local_variable (SSAVAR (decl
));
313 /* An alignment of zero can mightily confuse us later. */
314 gcc_assert (v
->alignb
!= 0);
316 /* All variables are initially in their own partition. */
317 v
->representative
= stack_vars_num
;
320 /* All variables initially conflict with no other. */
323 /* Ensure that this decl doesn't get put onto the list twice. */
324 set_rtl (decl
, pc_rtx
);
329 /* Make the decls associated with luid's X and Y conflict. */
332 add_stack_var_conflict (size_t x
, size_t y
)
334 struct stack_var
*a
= &stack_vars
[x
];
335 struct stack_var
*b
= &stack_vars
[y
];
337 a
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
339 b
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
340 bitmap_set_bit (a
->conflicts
, y
);
341 bitmap_set_bit (b
->conflicts
, x
);
344 /* Check whether the decls associated with luid's X and Y conflict. */
347 stack_var_conflict_p (size_t x
, size_t y
)
349 struct stack_var
*a
= &stack_vars
[x
];
350 struct stack_var
*b
= &stack_vars
[y
];
353 /* Partitions containing an SSA name result from gimple registers
354 with things like unsupported modes. They are top-level and
355 hence conflict with everything else. */
356 if (TREE_CODE (a
->decl
) == SSA_NAME
|| TREE_CODE (b
->decl
) == SSA_NAME
)
359 if (!a
->conflicts
|| !b
->conflicts
)
361 return bitmap_bit_p (a
->conflicts
, y
);
364 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
365 enter its partition number into bitmap DATA. */
368 visit_op (gimple
, tree op
, tree
, void *data
)
370 bitmap active
= (bitmap
)data
;
371 op
= get_base_address (op
);
374 && DECL_RTL_IF_SET (op
) == pc_rtx
)
376 size_t *v
= (size_t *) pointer_map_contains (decl_to_stack_part
, op
);
378 bitmap_set_bit (active
, *v
);
383 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
384 record conflicts between it and all currently active other partitions
388 visit_conflict (gimple
, tree op
, tree
, void *data
)
390 bitmap active
= (bitmap
)data
;
391 op
= get_base_address (op
);
394 && DECL_RTL_IF_SET (op
) == pc_rtx
)
397 (size_t *) pointer_map_contains (decl_to_stack_part
, op
);
398 if (v
&& bitmap_set_bit (active
, *v
))
403 gcc_assert (num
< stack_vars_num
);
404 EXECUTE_IF_SET_IN_BITMAP (active
, 0, i
, bi
)
405 add_stack_var_conflict (num
, i
);
411 /* Helper routine for add_scope_conflicts, calculating the active partitions
412 at the end of BB, leaving the result in WORK. We're called to generate
413 conflicts when FOR_CONFLICT is true, otherwise we're just tracking
417 add_scope_conflicts_1 (basic_block bb
, bitmap work
, bool for_conflict
)
421 gimple_stmt_iterator gsi
;
422 walk_stmt_load_store_addr_fn visit
;
425 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
426 bitmap_ior_into (work
, (bitmap
)e
->src
->aux
);
430 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
432 gimple stmt
= gsi_stmt (gsi
);
433 walk_stmt_load_store_addr_ops (stmt
, work
, NULL
, NULL
, visit
);
435 for (gsi
= gsi_after_labels (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
437 gimple stmt
= gsi_stmt (gsi
);
439 if (gimple_clobber_p (stmt
))
441 tree lhs
= gimple_assign_lhs (stmt
);
443 /* Nested function lowering might introduce LHSs
444 that are COMPONENT_REFs. */
445 if (TREE_CODE (lhs
) != VAR_DECL
)
447 if (DECL_RTL_IF_SET (lhs
) == pc_rtx
449 pointer_map_contains (decl_to_stack_part
, lhs
)))
450 bitmap_clear_bit (work
, *v
);
452 else if (!is_gimple_debug (stmt
))
455 && visit
== visit_op
)
457 /* If this is the first real instruction in this BB we need
458 to add conflicts for everything live at this point now.
459 Unlike classical liveness for named objects we can't
460 rely on seeing a def/use of the names we're interested in.
461 There might merely be indirect loads/stores. We'd not add any
462 conflicts for such partitions. */
465 EXECUTE_IF_SET_IN_BITMAP (work
, 0, i
, bi
)
467 struct stack_var
*a
= &stack_vars
[i
];
469 a
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
470 bitmap_ior_into (a
->conflicts
, work
);
472 visit
= visit_conflict
;
474 walk_stmt_load_store_addr_ops (stmt
, work
, visit
, visit
, visit
);
479 /* Generate stack partition conflicts between all partitions that are
480 simultaneously live. */
483 add_scope_conflicts (void)
487 bitmap work
= BITMAP_ALLOC (NULL
);
491 /* We approximate the live range of a stack variable by taking the first
492 mention of its name as starting point(s), and by the end-of-scope
493 death clobber added by gimplify as ending point(s) of the range.
494 This overapproximates in the case we for instance moved an address-taken
495 operation upward, without also moving a dereference to it upwards.
496 But it's conservatively correct as a variable never can hold values
497 before its name is mentioned at least once.
499 We then do a mostly classical bitmap liveness algorithm. */
501 FOR_ALL_BB_FN (bb
, cfun
)
502 bb
->aux
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
504 rpo
= XNEWVEC (int, last_basic_block_for_fn (cfun
));
505 n_bbs
= pre_and_rev_post_order_compute (NULL
, rpo
, false);
512 for (i
= 0; i
< n_bbs
; i
++)
515 bb
= BASIC_BLOCK_FOR_FN (cfun
, rpo
[i
]);
516 active
= (bitmap
)bb
->aux
;
517 add_scope_conflicts_1 (bb
, work
, false);
518 if (bitmap_ior_into (active
, work
))
523 FOR_EACH_BB_FN (bb
, cfun
)
524 add_scope_conflicts_1 (bb
, work
, true);
528 FOR_ALL_BB_FN (bb
, cfun
)
529 BITMAP_FREE (bb
->aux
);
532 /* A subroutine of partition_stack_vars. A comparison function for qsort,
533 sorting an array of indices by the properties of the object. */
536 stack_var_cmp (const void *a
, const void *b
)
538 size_t ia
= *(const size_t *)a
;
539 size_t ib
= *(const size_t *)b
;
540 unsigned int aligna
= stack_vars
[ia
].alignb
;
541 unsigned int alignb
= stack_vars
[ib
].alignb
;
542 HOST_WIDE_INT sizea
= stack_vars
[ia
].size
;
543 HOST_WIDE_INT sizeb
= stack_vars
[ib
].size
;
544 tree decla
= stack_vars
[ia
].decl
;
545 tree declb
= stack_vars
[ib
].decl
;
547 unsigned int uida
, uidb
;
549 /* Primary compare on "large" alignment. Large comes first. */
550 largea
= (aligna
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
551 largeb
= (alignb
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
552 if (largea
!= largeb
)
553 return (int)largeb
- (int)largea
;
555 /* Secondary compare on size, decreasing */
561 /* Tertiary compare on true alignment, decreasing. */
567 /* Final compare on ID for sort stability, increasing.
568 Two SSA names are compared by their version, SSA names come before
569 non-SSA names, and two normal decls are compared by their DECL_UID. */
570 if (TREE_CODE (decla
) == SSA_NAME
)
572 if (TREE_CODE (declb
) == SSA_NAME
)
573 uida
= SSA_NAME_VERSION (decla
), uidb
= SSA_NAME_VERSION (declb
);
577 else if (TREE_CODE (declb
) == SSA_NAME
)
580 uida
= DECL_UID (decla
), uidb
= DECL_UID (declb
);
589 /* If the points-to solution *PI points to variables that are in a partition
590 together with other variables add all partition members to the pointed-to
594 add_partitioned_vars_to_ptset (struct pt_solution
*pt
,
595 struct pointer_map_t
*decls_to_partitions
,
596 struct pointer_set_t
*visited
, bitmap temp
)
604 /* The pointed-to vars bitmap is shared, it is enough to
606 || pointer_set_insert (visited
, pt
->vars
))
611 /* By using a temporary bitmap to store all members of the partitions
612 we have to add we make sure to visit each of the partitions only
614 EXECUTE_IF_SET_IN_BITMAP (pt
->vars
, 0, i
, bi
)
616 || !bitmap_bit_p (temp
, i
))
617 && (part
= (bitmap
*) pointer_map_contains (decls_to_partitions
,
618 (void *)(size_t) i
)))
619 bitmap_ior_into (temp
, *part
);
620 if (!bitmap_empty_p (temp
))
621 bitmap_ior_into (pt
->vars
, temp
);
624 /* Update points-to sets based on partition info, so we can use them on RTL.
625 The bitmaps representing stack partitions will be saved until expand,
626 where partitioned decls used as bases in memory expressions will be
630 update_alias_info_with_stack_vars (void)
632 struct pointer_map_t
*decls_to_partitions
= NULL
;
634 tree var
= NULL_TREE
;
636 for (i
= 0; i
< stack_vars_num
; i
++)
640 struct ptr_info_def
*pi
;
642 /* Not interested in partitions with single variable. */
643 if (stack_vars
[i
].representative
!= i
644 || stack_vars
[i
].next
== EOC
)
647 if (!decls_to_partitions
)
649 decls_to_partitions
= pointer_map_create ();
650 cfun
->gimple_df
->decls_to_pointers
= pointer_map_create ();
653 /* Create an SSA_NAME that points to the partition for use
654 as base during alias-oracle queries on RTL for bases that
655 have been partitioned. */
656 if (var
== NULL_TREE
)
657 var
= create_tmp_var (ptr_type_node
, NULL
);
658 name
= make_ssa_name (var
, NULL
);
660 /* Create bitmaps representing partitions. They will be used for
661 points-to sets later, so use GGC alloc. */
662 part
= BITMAP_GGC_ALLOC ();
663 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
665 tree decl
= stack_vars
[j
].decl
;
666 unsigned int uid
= DECL_PT_UID (decl
);
667 bitmap_set_bit (part
, uid
);
668 *((bitmap
*) pointer_map_insert (decls_to_partitions
,
669 (void *)(size_t) uid
)) = part
;
670 *((tree
*) pointer_map_insert (cfun
->gimple_df
->decls_to_pointers
,
672 if (TREE_ADDRESSABLE (decl
))
673 TREE_ADDRESSABLE (name
) = 1;
676 /* Make the SSA name point to all partition members. */
677 pi
= get_ptr_info (name
);
678 pt_solution_set (&pi
->pt
, part
, false);
681 /* Make all points-to sets that contain one member of a partition
682 contain all members of the partition. */
683 if (decls_to_partitions
)
686 struct pointer_set_t
*visited
= pointer_set_create ();
687 bitmap temp
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
689 for (i
= 1; i
< num_ssa_names
; i
++)
691 tree name
= ssa_name (i
);
692 struct ptr_info_def
*pi
;
695 && POINTER_TYPE_P (TREE_TYPE (name
))
696 && ((pi
= SSA_NAME_PTR_INFO (name
)) != NULL
))
697 add_partitioned_vars_to_ptset (&pi
->pt
, decls_to_partitions
,
701 add_partitioned_vars_to_ptset (&cfun
->gimple_df
->escaped
,
702 decls_to_partitions
, visited
, temp
);
704 pointer_set_destroy (visited
);
705 pointer_map_destroy (decls_to_partitions
);
710 /* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
711 partitioning algorithm. Partitions A and B are known to be non-conflicting.
712 Merge them into a single partition A. */
715 union_stack_vars (size_t a
, size_t b
)
717 struct stack_var
*vb
= &stack_vars
[b
];
721 gcc_assert (stack_vars
[b
].next
== EOC
);
722 /* Add B to A's partition. */
723 stack_vars
[b
].next
= stack_vars
[a
].next
;
724 stack_vars
[b
].representative
= a
;
725 stack_vars
[a
].next
= b
;
727 /* Update the required alignment of partition A to account for B. */
728 if (stack_vars
[a
].alignb
< stack_vars
[b
].alignb
)
729 stack_vars
[a
].alignb
= stack_vars
[b
].alignb
;
731 /* Update the interference graph and merge the conflicts. */
734 EXECUTE_IF_SET_IN_BITMAP (vb
->conflicts
, 0, u
, bi
)
735 add_stack_var_conflict (a
, stack_vars
[u
].representative
);
736 BITMAP_FREE (vb
->conflicts
);
740 /* A subroutine of expand_used_vars. Binpack the variables into
741 partitions constrained by the interference graph. The overall
742 algorithm used is as follows:
744 Sort the objects by size in descending order.
749 Look for the largest non-conflicting object B with size <= S.
756 partition_stack_vars (void)
758 size_t si
, sj
, n
= stack_vars_num
;
760 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
761 for (si
= 0; si
< n
; ++si
)
762 stack_vars_sorted
[si
] = si
;
767 qsort (stack_vars_sorted
, n
, sizeof (size_t), stack_var_cmp
);
769 for (si
= 0; si
< n
; ++si
)
771 size_t i
= stack_vars_sorted
[si
];
772 unsigned int ialign
= stack_vars
[i
].alignb
;
773 HOST_WIDE_INT isize
= stack_vars
[i
].size
;
775 /* Ignore objects that aren't partition representatives. If we
776 see a var that is not a partition representative, it must
777 have been merged earlier. */
778 if (stack_vars
[i
].representative
!= i
)
781 for (sj
= si
+ 1; sj
< n
; ++sj
)
783 size_t j
= stack_vars_sorted
[sj
];
784 unsigned int jalign
= stack_vars
[j
].alignb
;
785 HOST_WIDE_INT jsize
= stack_vars
[j
].size
;
787 /* Ignore objects that aren't partition representatives. */
788 if (stack_vars
[j
].representative
!= j
)
791 /* Do not mix objects of "small" (supported) alignment
792 and "large" (unsupported) alignment. */
793 if ((ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
794 != (jalign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
))
797 /* For Address Sanitizer do not mix objects with different
798 sizes, as the shorter vars wouldn't be adequately protected.
799 Don't do that for "large" (unsupported) alignment objects,
800 those aren't protected anyway. */
801 if ((flag_sanitize
& SANITIZE_ADDRESS
) && ASAN_STACK
&& isize
!= jsize
802 && ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
805 /* Ignore conflicting objects. */
806 if (stack_var_conflict_p (i
, j
))
809 /* UNION the objects, placing J at OFFSET. */
810 union_stack_vars (i
, j
);
814 update_alias_info_with_stack_vars ();
817 /* A debugging aid for expand_used_vars. Dump the generated partitions. */
820 dump_stack_var_partition (void)
822 size_t si
, i
, j
, n
= stack_vars_num
;
824 for (si
= 0; si
< n
; ++si
)
826 i
= stack_vars_sorted
[si
];
828 /* Skip variables that aren't partition representatives, for now. */
829 if (stack_vars
[i
].representative
!= i
)
832 fprintf (dump_file
, "Partition %lu: size " HOST_WIDE_INT_PRINT_DEC
833 " align %u\n", (unsigned long) i
, stack_vars
[i
].size
,
834 stack_vars
[i
].alignb
);
836 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
838 fputc ('\t', dump_file
);
839 print_generic_expr (dump_file
, stack_vars
[j
].decl
, dump_flags
);
841 fputc ('\n', dump_file
);
845 /* Assign rtl to DECL at BASE + OFFSET. */
848 expand_one_stack_var_at (tree decl
, rtx base
, unsigned base_align
,
849 HOST_WIDE_INT offset
)
854 /* If this fails, we've overflowed the stack frame. Error nicely? */
855 gcc_assert (offset
== trunc_int_for_mode (offset
, Pmode
));
857 x
= plus_constant (Pmode
, base
, offset
);
858 x
= gen_rtx_MEM (DECL_MODE (SSAVAR (decl
)), x
);
860 if (TREE_CODE (decl
) != SSA_NAME
)
862 /* Set alignment we actually gave this decl if it isn't an SSA name.
863 If it is we generate stack slots only accidentally so it isn't as
864 important, we'll simply use the alignment that is already set. */
865 if (base
== virtual_stack_vars_rtx
)
866 offset
-= frame_phase
;
867 align
= offset
& -offset
;
868 align
*= BITS_PER_UNIT
;
869 if (align
== 0 || align
> base_align
)
872 /* One would think that we could assert that we're not decreasing
873 alignment here, but (at least) the i386 port does exactly this
874 via the MINIMUM_ALIGNMENT hook. */
876 DECL_ALIGN (decl
) = align
;
877 DECL_USER_ALIGN (decl
) = 0;
880 set_mem_attributes (x
, SSAVAR (decl
), true);
884 struct stack_vars_data
886 /* Vector of offset pairs, always end of some padding followed
887 by start of the padding that needs Address Sanitizer protection.
888 The vector is in reversed, highest offset pairs come first. */
889 vec
<HOST_WIDE_INT
> asan_vec
;
891 /* Vector of partition representative decls in between the paddings. */
892 vec
<tree
> asan_decl_vec
;
894 /* Base pseudo register for Address Sanitizer protected automatic vars. */
897 /* Alignment needed for the Address Sanitizer protected automatic vars. */
898 unsigned int asan_alignb
;
901 /* A subroutine of expand_used_vars. Give each partition representative
902 a unique location within the stack frame. Update each partition member
903 with that location. */
906 expand_stack_vars (bool (*pred
) (size_t), struct stack_vars_data
*data
)
908 size_t si
, i
, j
, n
= stack_vars_num
;
909 HOST_WIDE_INT large_size
= 0, large_alloc
= 0;
910 rtx large_base
= NULL
;
911 unsigned large_align
= 0;
914 /* Determine if there are any variables requiring "large" alignment.
915 Since these are dynamically allocated, we only process these if
916 no predicate involved. */
917 large_align
= stack_vars
[stack_vars_sorted
[0]].alignb
* BITS_PER_UNIT
;
918 if (pred
== NULL
&& large_align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
920 /* Find the total size of these variables. */
921 for (si
= 0; si
< n
; ++si
)
925 i
= stack_vars_sorted
[si
];
926 alignb
= stack_vars
[i
].alignb
;
928 /* Stop when we get to the first decl with "small" alignment. */
929 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
932 /* Skip variables that aren't partition representatives. */
933 if (stack_vars
[i
].representative
!= i
)
936 /* Skip variables that have already had rtl assigned. See also
937 add_stack_var where we perpetrate this pc_rtx hack. */
938 decl
= stack_vars
[i
].decl
;
939 if ((TREE_CODE (decl
) == SSA_NAME
940 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)]
941 : DECL_RTL (decl
)) != pc_rtx
)
944 large_size
+= alignb
- 1;
945 large_size
&= -(HOST_WIDE_INT
)alignb
;
946 large_size
+= stack_vars
[i
].size
;
949 /* If there were any, allocate space. */
951 large_base
= allocate_dynamic_stack_space (GEN_INT (large_size
), 0,
955 for (si
= 0; si
< n
; ++si
)
958 unsigned base_align
, alignb
;
959 HOST_WIDE_INT offset
;
961 i
= stack_vars_sorted
[si
];
963 /* Skip variables that aren't partition representatives, for now. */
964 if (stack_vars
[i
].representative
!= i
)
967 /* Skip variables that have already had rtl assigned. See also
968 add_stack_var where we perpetrate this pc_rtx hack. */
969 decl
= stack_vars
[i
].decl
;
970 if ((TREE_CODE (decl
) == SSA_NAME
971 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)]
972 : DECL_RTL (decl
)) != pc_rtx
)
975 /* Check the predicate to see whether this variable should be
976 allocated in this pass. */
977 if (pred
&& !pred (i
))
980 alignb
= stack_vars
[i
].alignb
;
981 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
983 base
= virtual_stack_vars_rtx
;
984 if ((flag_sanitize
& SANITIZE_ADDRESS
) && ASAN_STACK
&& pred
)
986 HOST_WIDE_INT prev_offset
= frame_offset
;
987 tree repr_decl
= NULL_TREE
;
990 = alloc_stack_frame_space (stack_vars
[i
].size
991 + ASAN_RED_ZONE_SIZE
,
992 MAX (alignb
, ASAN_RED_ZONE_SIZE
));
993 data
->asan_vec
.safe_push (prev_offset
);
994 data
->asan_vec
.safe_push (offset
+ stack_vars
[i
].size
);
995 /* Find best representative of the partition.
996 Prefer those with DECL_NAME, even better
997 satisfying asan_protect_stack_decl predicate. */
998 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
999 if (asan_protect_stack_decl (stack_vars
[j
].decl
)
1000 && DECL_NAME (stack_vars
[j
].decl
))
1002 repr_decl
= stack_vars
[j
].decl
;
1005 else if (repr_decl
== NULL_TREE
1006 && DECL_P (stack_vars
[j
].decl
)
1007 && DECL_NAME (stack_vars
[j
].decl
))
1008 repr_decl
= stack_vars
[j
].decl
;
1009 if (repr_decl
== NULL_TREE
)
1010 repr_decl
= stack_vars
[i
].decl
;
1011 data
->asan_decl_vec
.safe_push (repr_decl
);
1012 data
->asan_alignb
= MAX (data
->asan_alignb
, alignb
);
1013 if (data
->asan_base
== NULL
)
1014 data
->asan_base
= gen_reg_rtx (Pmode
);
1015 base
= data
->asan_base
;
1017 if (!STRICT_ALIGNMENT
)
1018 base_align
= crtl
->max_used_stack_slot_alignment
;
1020 base_align
= MAX (crtl
->max_used_stack_slot_alignment
,
1021 GET_MODE_ALIGNMENT (SImode
)
1022 << ASAN_SHADOW_SHIFT
);
1026 offset
= alloc_stack_frame_space (stack_vars
[i
].size
, alignb
);
1027 base_align
= crtl
->max_used_stack_slot_alignment
;
1032 /* Large alignment is only processed in the last pass. */
1035 gcc_assert (large_base
!= NULL
);
1037 large_alloc
+= alignb
- 1;
1038 large_alloc
&= -(HOST_WIDE_INT
)alignb
;
1039 offset
= large_alloc
;
1040 large_alloc
+= stack_vars
[i
].size
;
1043 base_align
= large_align
;
1046 /* Create rtl for each variable based on their location within the
1048 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1050 expand_one_stack_var_at (stack_vars
[j
].decl
,
1056 gcc_assert (large_alloc
== large_size
);
1059 /* Take into account all sizes of partitions and reset DECL_RTLs. */
1060 static HOST_WIDE_INT
1061 account_stack_vars (void)
1063 size_t si
, j
, i
, n
= stack_vars_num
;
1064 HOST_WIDE_INT size
= 0;
1066 for (si
= 0; si
< n
; ++si
)
1068 i
= stack_vars_sorted
[si
];
1070 /* Skip variables that aren't partition representatives, for now. */
1071 if (stack_vars
[i
].representative
!= i
)
1074 size
+= stack_vars
[i
].size
;
1075 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1076 set_rtl (stack_vars
[j
].decl
, NULL
);
1081 /* A subroutine of expand_one_var. Called to immediately assign rtl
1082 to a variable to be allocated in the stack frame. */
1085 expand_one_stack_var (tree var
)
1087 HOST_WIDE_INT size
, offset
;
1088 unsigned byte_align
;
1090 size
= tree_to_uhwi (DECL_SIZE_UNIT (SSAVAR (var
)));
1091 byte_align
= align_local_variable (SSAVAR (var
));
1093 /* We handle highly aligned variables in expand_stack_vars. */
1094 gcc_assert (byte_align
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
);
1096 offset
= alloc_stack_frame_space (size
, byte_align
);
1098 expand_one_stack_var_at (var
, virtual_stack_vars_rtx
,
1099 crtl
->max_used_stack_slot_alignment
, offset
);
1102 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1103 that will reside in a hard register. */
1106 expand_one_hard_reg_var (tree var
)
1108 rest_of_decl_compilation (var
, 0, 0);
1111 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1112 that will reside in a pseudo register. */
1115 expand_one_register_var (tree var
)
1117 tree decl
= SSAVAR (var
);
1118 tree type
= TREE_TYPE (decl
);
1119 enum machine_mode reg_mode
= promote_decl_mode (decl
, NULL
);
1120 rtx x
= gen_reg_rtx (reg_mode
);
1124 /* Note if the object is a user variable. */
1125 if (!DECL_ARTIFICIAL (decl
))
1128 if (POINTER_TYPE_P (type
))
1129 mark_reg_pointer (x
, get_pointer_alignment (var
));
1132 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
1133 has some associated error, e.g. its type is error-mark. We just need
1134 to pick something that won't crash the rest of the compiler. */
1137 expand_one_error_var (tree var
)
1139 enum machine_mode mode
= DECL_MODE (var
);
1142 if (mode
== BLKmode
)
1143 x
= gen_rtx_MEM (BLKmode
, const0_rtx
);
1144 else if (mode
== VOIDmode
)
1147 x
= gen_reg_rtx (mode
);
1149 SET_DECL_RTL (var
, x
);
1152 /* A subroutine of expand_one_var. VAR is a variable that will be
1153 allocated to the local stack frame. Return true if we wish to
1154 add VAR to STACK_VARS so that it will be coalesced with other
1155 variables. Return false to allocate VAR immediately.
1157 This function is used to reduce the number of variables considered
1158 for coalescing, which reduces the size of the quadratic problem. */
1161 defer_stack_allocation (tree var
, bool toplevel
)
1163 /* Whether the variable is small enough for immediate allocation not to be
1164 a problem with regard to the frame size. */
1166 = ((HOST_WIDE_INT
) tree_to_uhwi (DECL_SIZE_UNIT (var
))
1167 < PARAM_VALUE (PARAM_MIN_SIZE_FOR_STACK_SHARING
));
1169 /* If stack protection is enabled, *all* stack variables must be deferred,
1170 so that we can re-order the strings to the top of the frame.
1171 Similarly for Address Sanitizer. */
1172 if (flag_stack_protect
|| ((flag_sanitize
& SANITIZE_ADDRESS
) && ASAN_STACK
))
1175 /* We handle "large" alignment via dynamic allocation. We want to handle
1176 this extra complication in only one place, so defer them. */
1177 if (DECL_ALIGN (var
) > MAX_SUPPORTED_STACK_ALIGNMENT
)
1180 /* When optimization is enabled, DECL_IGNORED_P variables originally scoped
1181 might be detached from their block and appear at toplevel when we reach
1182 here. We want to coalesce them with variables from other blocks when
1183 the immediate contribution to the frame size would be noticeable. */
1184 if (toplevel
&& optimize
> 0 && DECL_IGNORED_P (var
) && !smallish
)
1187 /* Variables declared in the outermost scope automatically conflict
1188 with every other variable. The only reason to want to defer them
1189 at all is that, after sorting, we can more efficiently pack
1190 small variables in the stack frame. Continue to defer at -O2. */
1191 if (toplevel
&& optimize
< 2)
1194 /* Without optimization, *most* variables are allocated from the
1195 stack, which makes the quadratic problem large exactly when we
1196 want compilation to proceed as quickly as possible. On the
1197 other hand, we don't want the function's stack frame size to
1198 get completely out of hand. So we avoid adding scalars and
1199 "small" aggregates to the list at all. */
1200 if (optimize
== 0 && smallish
)
1206 /* A subroutine of expand_used_vars. Expand one variable according to
1207 its flavor. Variables to be placed on the stack are not actually
1208 expanded yet, merely recorded.
1209 When REALLY_EXPAND is false, only add stack values to be allocated.
1210 Return stack usage this variable is supposed to take.
1213 static HOST_WIDE_INT
1214 expand_one_var (tree var
, bool toplevel
, bool really_expand
)
1216 unsigned int align
= BITS_PER_UNIT
;
1221 if (TREE_TYPE (var
) != error_mark_node
&& TREE_CODE (var
) == VAR_DECL
)
1223 /* Because we don't know if VAR will be in register or on stack,
1224 we conservatively assume it will be on stack even if VAR is
1225 eventually put into register after RA pass. For non-automatic
1226 variables, which won't be on stack, we collect alignment of
1227 type and ignore user specified alignment. Similarly for
1228 SSA_NAMEs for which use_register_for_decl returns true. */
1229 if (TREE_STATIC (var
)
1230 || DECL_EXTERNAL (var
)
1231 || (TREE_CODE (origvar
) == SSA_NAME
&& use_register_for_decl (var
)))
1232 align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1233 TYPE_MODE (TREE_TYPE (var
)),
1234 TYPE_ALIGN (TREE_TYPE (var
)));
1235 else if (DECL_HAS_VALUE_EXPR_P (var
)
1236 || (DECL_RTL_SET_P (var
) && MEM_P (DECL_RTL (var
))))
1237 /* Don't consider debug only variables with DECL_HAS_VALUE_EXPR_P set
1238 or variables which were assigned a stack slot already by
1239 expand_one_stack_var_at - in the latter case DECL_ALIGN has been
1240 changed from the offset chosen to it. */
1241 align
= crtl
->stack_alignment_estimated
;
1243 align
= MINIMUM_ALIGNMENT (var
, DECL_MODE (var
), DECL_ALIGN (var
));
1245 /* If the variable alignment is very large we'll dynamicaly allocate
1246 it, which means that in-frame portion is just a pointer. */
1247 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1248 align
= POINTER_SIZE
;
1251 if (SUPPORTS_STACK_ALIGNMENT
1252 && crtl
->stack_alignment_estimated
< align
)
1254 /* stack_alignment_estimated shouldn't change after stack
1255 realign decision made */
1256 gcc_assert (!crtl
->stack_realign_processed
);
1257 crtl
->stack_alignment_estimated
= align
;
1260 /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
1261 So here we only make sure stack_alignment_needed >= align. */
1262 if (crtl
->stack_alignment_needed
< align
)
1263 crtl
->stack_alignment_needed
= align
;
1264 if (crtl
->max_used_stack_slot_alignment
< align
)
1265 crtl
->max_used_stack_slot_alignment
= align
;
1267 if (TREE_CODE (origvar
) == SSA_NAME
)
1269 gcc_assert (TREE_CODE (var
) != VAR_DECL
1270 || (!DECL_EXTERNAL (var
)
1271 && !DECL_HAS_VALUE_EXPR_P (var
)
1272 && !TREE_STATIC (var
)
1273 && TREE_TYPE (var
) != error_mark_node
1274 && !DECL_HARD_REGISTER (var
)
1277 if (TREE_CODE (var
) != VAR_DECL
&& TREE_CODE (origvar
) != SSA_NAME
)
1279 else if (DECL_EXTERNAL (var
))
1281 else if (DECL_HAS_VALUE_EXPR_P (var
))
1283 else if (TREE_STATIC (var
))
1285 else if (TREE_CODE (origvar
) != SSA_NAME
&& DECL_RTL_SET_P (var
))
1287 else if (TREE_TYPE (var
) == error_mark_node
)
1290 expand_one_error_var (var
);
1292 else if (TREE_CODE (var
) == VAR_DECL
&& DECL_HARD_REGISTER (var
))
1295 expand_one_hard_reg_var (var
);
1297 else if (use_register_for_decl (var
))
1300 expand_one_register_var (origvar
);
1302 else if (! valid_constant_size_p (DECL_SIZE_UNIT (var
)))
1304 /* Reject variables which cover more than half of the address-space. */
1307 error ("size of variable %q+D is too large", var
);
1308 expand_one_error_var (var
);
1311 else if (defer_stack_allocation (var
, toplevel
))
1312 add_stack_var (origvar
);
1316 expand_one_stack_var (origvar
);
1317 return tree_to_uhwi (DECL_SIZE_UNIT (var
));
1322 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1323 expanding variables. Those variables that can be put into registers
1324 are allocated pseudos; those that can't are put on the stack.
1326 TOPLEVEL is true if this is the outermost BLOCK. */
1329 expand_used_vars_for_block (tree block
, bool toplevel
)
1333 /* Expand all variables at this level. */
1334 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1336 && ((TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != RESULT_DECL
)
1337 || !DECL_NONSHAREABLE (t
)))
1338 expand_one_var (t
, toplevel
, true);
1340 /* Expand all variables at containing levels. */
1341 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1342 expand_used_vars_for_block (t
, false);
1345 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1346 and clear TREE_USED on all local variables. */
1349 clear_tree_used (tree block
)
1353 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1354 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
1355 if ((TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != RESULT_DECL
)
1356 || !DECL_NONSHAREABLE (t
))
1359 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1360 clear_tree_used (t
);
1364 SPCT_FLAG_DEFAULT
= 1,
1366 SPCT_FLAG_STRONG
= 3
1369 /* Examine TYPE and determine a bit mask of the following features. */
1371 #define SPCT_HAS_LARGE_CHAR_ARRAY 1
1372 #define SPCT_HAS_SMALL_CHAR_ARRAY 2
1373 #define SPCT_HAS_ARRAY 4
1374 #define SPCT_HAS_AGGREGATE 8
1377 stack_protect_classify_type (tree type
)
1379 unsigned int ret
= 0;
1382 switch (TREE_CODE (type
))
1385 t
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1386 if (t
== char_type_node
1387 || t
== signed_char_type_node
1388 || t
== unsigned_char_type_node
)
1390 unsigned HOST_WIDE_INT max
= PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
);
1391 unsigned HOST_WIDE_INT len
;
1393 if (!TYPE_SIZE_UNIT (type
)
1394 || !tree_fits_uhwi_p (TYPE_SIZE_UNIT (type
)))
1397 len
= tree_to_uhwi (TYPE_SIZE_UNIT (type
));
1400 ret
= SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1402 ret
= SPCT_HAS_LARGE_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1405 ret
= SPCT_HAS_ARRAY
;
1409 case QUAL_UNION_TYPE
:
1411 ret
= SPCT_HAS_AGGREGATE
;
1412 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
1413 if (TREE_CODE (t
) == FIELD_DECL
)
1414 ret
|= stack_protect_classify_type (TREE_TYPE (t
));
1424 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
1425 part of the local stack frame. Remember if we ever return nonzero for
1426 any variable in this function. The return value is the phase number in
1427 which the variable should be allocated. */
1430 stack_protect_decl_phase (tree decl
)
1432 unsigned int bits
= stack_protect_classify_type (TREE_TYPE (decl
));
1435 if (bits
& SPCT_HAS_SMALL_CHAR_ARRAY
)
1436 has_short_buffer
= true;
1438 if (flag_stack_protect
== SPCT_FLAG_ALL
1439 || flag_stack_protect
== SPCT_FLAG_STRONG
)
1441 if ((bits
& (SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_LARGE_CHAR_ARRAY
))
1442 && !(bits
& SPCT_HAS_AGGREGATE
))
1444 else if (bits
& SPCT_HAS_ARRAY
)
1448 ret
= (bits
& SPCT_HAS_LARGE_CHAR_ARRAY
) != 0;
1451 has_protected_decls
= true;
1456 /* Two helper routines that check for phase 1 and phase 2. These are used
1457 as callbacks for expand_stack_vars. */
1460 stack_protect_decl_phase_1 (size_t i
)
1462 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 1;
1466 stack_protect_decl_phase_2 (size_t i
)
1468 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 2;
1471 /* And helper function that checks for asan phase (with stack protector
1472 it is phase 3). This is used as callback for expand_stack_vars.
1473 Returns true if any of the vars in the partition need to be protected. */
1476 asan_decl_phase_3 (size_t i
)
1480 if (asan_protect_stack_decl (stack_vars
[i
].decl
))
1482 i
= stack_vars
[i
].next
;
1487 /* Ensure that variables in different stack protection phases conflict
1488 so that they are not merged and share the same stack slot. */
1491 add_stack_protection_conflicts (void)
1493 size_t i
, j
, n
= stack_vars_num
;
1494 unsigned char *phase
;
1496 phase
= XNEWVEC (unsigned char, n
);
1497 for (i
= 0; i
< n
; ++i
)
1498 phase
[i
] = stack_protect_decl_phase (stack_vars
[i
].decl
);
1500 for (i
= 0; i
< n
; ++i
)
1502 unsigned char ph_i
= phase
[i
];
1503 for (j
= i
+ 1; j
< n
; ++j
)
1504 if (ph_i
!= phase
[j
])
1505 add_stack_var_conflict (i
, j
);
1511 /* Create a decl for the guard at the top of the stack frame. */
1514 create_stack_guard (void)
1516 tree guard
= build_decl (DECL_SOURCE_LOCATION (current_function_decl
),
1517 VAR_DECL
, NULL
, ptr_type_node
);
1518 TREE_THIS_VOLATILE (guard
) = 1;
1519 TREE_USED (guard
) = 1;
1520 expand_one_stack_var (guard
);
1521 crtl
->stack_protect_guard
= guard
;
1524 /* Prepare for expanding variables. */
1526 init_vars_expansion (void)
1528 /* Conflict bitmaps, and a few related temporary bitmaps, go here. */
1529 bitmap_obstack_initialize (&stack_var_bitmap_obstack
);
1531 /* A map from decl to stack partition. */
1532 decl_to_stack_part
= pointer_map_create ();
1534 /* Initialize local stack smashing state. */
1535 has_protected_decls
= false;
1536 has_short_buffer
= false;
1539 /* Free up stack variable graph data. */
1541 fini_vars_expansion (void)
1543 bitmap_obstack_release (&stack_var_bitmap_obstack
);
1545 XDELETEVEC (stack_vars
);
1546 if (stack_vars_sorted
)
1547 XDELETEVEC (stack_vars_sorted
);
1549 stack_vars_sorted
= NULL
;
1550 stack_vars_alloc
= stack_vars_num
= 0;
1551 pointer_map_destroy (decl_to_stack_part
);
1552 decl_to_stack_part
= NULL
;
1555 /* Make a fair guess for the size of the stack frame of the function
1556 in NODE. This doesn't have to be exact, the result is only used in
1557 the inline heuristics. So we don't want to run the full stack var
1558 packing algorithm (which is quadratic in the number of stack vars).
1559 Instead, we calculate the total size of all stack vars. This turns
1560 out to be a pretty fair estimate -- packing of stack vars doesn't
1561 happen very often. */
1564 estimated_stack_frame_size (struct cgraph_node
*node
)
1566 HOST_WIDE_INT size
= 0;
1569 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
1573 init_vars_expansion ();
1575 FOR_EACH_LOCAL_DECL (fn
, i
, var
)
1576 if (auto_var_in_fn_p (var
, fn
->decl
))
1577 size
+= expand_one_var (var
, true, false);
1579 if (stack_vars_num
> 0)
1581 /* Fake sorting the stack vars for account_stack_vars (). */
1582 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
1583 for (i
= 0; i
< stack_vars_num
; ++i
)
1584 stack_vars_sorted
[i
] = i
;
1585 size
+= account_stack_vars ();
1588 fini_vars_expansion ();
1593 /* Helper routine to check if a record or union contains an array field. */
1596 record_or_union_type_has_array_p (const_tree tree_type
)
1598 tree fields
= TYPE_FIELDS (tree_type
);
1601 for (f
= fields
; f
; f
= DECL_CHAIN (f
))
1602 if (TREE_CODE (f
) == FIELD_DECL
)
1604 tree field_type
= TREE_TYPE (f
);
1605 if (RECORD_OR_UNION_TYPE_P (field_type
)
1606 && record_or_union_type_has_array_p (field_type
))
1608 if (TREE_CODE (field_type
) == ARRAY_TYPE
)
1614 /* Check if the current function has local referenced variables that
1615 have their addresses taken, contain an array, or are arrays. */
1618 stack_protect_decl_p ()
1623 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
1624 if (!is_global_var (var
))
1626 tree var_type
= TREE_TYPE (var
);
1627 if (TREE_CODE (var
) == VAR_DECL
1628 && (TREE_CODE (var_type
) == ARRAY_TYPE
1629 || TREE_ADDRESSABLE (var
)
1630 || (RECORD_OR_UNION_TYPE_P (var_type
)
1631 && record_or_union_type_has_array_p (var_type
))))
1637 /* Check if the current function has calls that use a return slot. */
1640 stack_protect_return_slot_p ()
1644 FOR_ALL_BB_FN (bb
, cfun
)
1645 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
1646 !gsi_end_p (gsi
); gsi_next (&gsi
))
1648 gimple stmt
= gsi_stmt (gsi
);
1649 /* This assumes that calls to internal-only functions never
1650 use a return slot. */
1651 if (is_gimple_call (stmt
)
1652 && !gimple_call_internal_p (stmt
)
1653 && aggregate_value_p (TREE_TYPE (gimple_call_fntype (stmt
)),
1654 gimple_call_fndecl (stmt
)))
1660 /* Expand all variables used in the function. */
1663 expand_used_vars (void)
1665 tree var
, outer_block
= DECL_INITIAL (current_function_decl
);
1666 vec
<tree
> maybe_local_decls
= vNULL
;
1667 rtx var_end_seq
= NULL_RTX
;
1668 struct pointer_map_t
*ssa_name_decls
;
1671 bool gen_stack_protect_signal
= false;
1673 /* Compute the phase of the stack frame for this function. */
1675 int align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
1676 int off
= STARTING_FRAME_OFFSET
% align
;
1677 frame_phase
= off
? align
- off
: 0;
1680 /* Set TREE_USED on all variables in the local_decls. */
1681 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
1682 TREE_USED (var
) = 1;
1683 /* Clear TREE_USED on all variables associated with a block scope. */
1684 clear_tree_used (DECL_INITIAL (current_function_decl
));
1686 init_vars_expansion ();
1688 ssa_name_decls
= pointer_map_create ();
1689 for (i
= 0; i
< SA
.map
->num_partitions
; i
++)
1691 tree var
= partition_to_var (SA
.map
, i
);
1693 gcc_assert (!virtual_operand_p (var
));
1695 /* Assign decls to each SSA name partition, share decls for partitions
1696 we could have coalesced (those with the same type). */
1697 if (SSA_NAME_VAR (var
) == NULL_TREE
)
1699 void **slot
= pointer_map_insert (ssa_name_decls
, TREE_TYPE (var
));
1701 *slot
= (void *) create_tmp_reg (TREE_TYPE (var
), NULL
);
1702 replace_ssa_name_symbol (var
, (tree
) *slot
);
1705 /* Always allocate space for partitions based on VAR_DECLs. But for
1706 those based on PARM_DECLs or RESULT_DECLs and which matter for the
1707 debug info, there is no need to do so if optimization is disabled
1708 because all the SSA_NAMEs based on these DECLs have been coalesced
1709 into a single partition, which is thus assigned the canonical RTL
1710 location of the DECLs. If in_lto_p, we can't rely on optimize,
1711 a function could be compiled with -O1 -flto first and only the
1712 link performed at -O0. */
1713 if (TREE_CODE (SSA_NAME_VAR (var
)) == VAR_DECL
)
1714 expand_one_var (var
, true, true);
1715 else if (DECL_IGNORED_P (SSA_NAME_VAR (var
)) || optimize
|| in_lto_p
)
1717 /* This is a PARM_DECL or RESULT_DECL. For those partitions that
1718 contain the default def (representing the parm or result itself)
1719 we don't do anything here. But those which don't contain the
1720 default def (representing a temporary based on the parm/result)
1721 we need to allocate space just like for normal VAR_DECLs. */
1722 if (!bitmap_bit_p (SA
.partition_has_default_def
, i
))
1724 expand_one_var (var
, true, true);
1725 gcc_assert (SA
.partition_to_pseudo
[i
]);
1729 pointer_map_destroy (ssa_name_decls
);
1731 if (flag_stack_protect
== SPCT_FLAG_STRONG
)
1732 gen_stack_protect_signal
1733 = stack_protect_decl_p () || stack_protect_return_slot_p ();
1735 /* At this point all variables on the local_decls with TREE_USED
1736 set are not associated with any block scope. Lay them out. */
1738 len
= vec_safe_length (cfun
->local_decls
);
1739 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
1741 bool expand_now
= false;
1743 /* Expanded above already. */
1744 if (is_gimple_reg (var
))
1746 TREE_USED (var
) = 0;
1749 /* We didn't set a block for static or extern because it's hard
1750 to tell the difference between a global variable (re)declared
1751 in a local scope, and one that's really declared there to
1752 begin with. And it doesn't really matter much, since we're
1753 not giving them stack space. Expand them now. */
1754 else if (TREE_STATIC (var
) || DECL_EXTERNAL (var
))
1757 /* Expand variables not associated with any block now. Those created by
1758 the optimizers could be live anywhere in the function. Those that
1759 could possibly have been scoped originally and detached from their
1760 block will have their allocation deferred so we coalesce them with
1761 others when optimization is enabled. */
1762 else if (TREE_USED (var
))
1765 /* Finally, mark all variables on the list as used. We'll use
1766 this in a moment when we expand those associated with scopes. */
1767 TREE_USED (var
) = 1;
1770 expand_one_var (var
, true, true);
1773 if (DECL_ARTIFICIAL (var
) && !DECL_IGNORED_P (var
))
1775 rtx rtl
= DECL_RTL_IF_SET (var
);
1777 /* Keep artificial non-ignored vars in cfun->local_decls
1778 chain until instantiate_decls. */
1779 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
1780 add_local_decl (cfun
, var
);
1781 else if (rtl
== NULL_RTX
)
1782 /* If rtl isn't set yet, which can happen e.g. with
1783 -fstack-protector, retry before returning from this
1785 maybe_local_decls
.safe_push (var
);
1789 /* We duplicated some of the decls in CFUN->LOCAL_DECLS.
1791 +-----------------+-----------------+
1792 | ...processed... | ...duplicates...|
1793 +-----------------+-----------------+
1795 +-- LEN points here.
1797 We just want the duplicates, as those are the artificial
1798 non-ignored vars that we want to keep until instantiate_decls.
1799 Move them down and truncate the array. */
1800 if (!vec_safe_is_empty (cfun
->local_decls
))
1801 cfun
->local_decls
->block_remove (0, len
);
1803 /* At this point, all variables within the block tree with TREE_USED
1804 set are actually used by the optimized function. Lay them out. */
1805 expand_used_vars_for_block (outer_block
, true);
1807 if (stack_vars_num
> 0)
1809 add_scope_conflicts ();
1811 /* If stack protection is enabled, we don't share space between
1812 vulnerable data and non-vulnerable data. */
1813 if (flag_stack_protect
)
1814 add_stack_protection_conflicts ();
1816 /* Now that we have collected all stack variables, and have computed a
1817 minimal interference graph, attempt to save some stack space. */
1818 partition_stack_vars ();
1820 dump_stack_var_partition ();
1823 switch (flag_stack_protect
)
1826 create_stack_guard ();
1829 case SPCT_FLAG_STRONG
:
1830 if (gen_stack_protect_signal
1831 || cfun
->calls_alloca
|| has_protected_decls
)
1832 create_stack_guard ();
1835 case SPCT_FLAG_DEFAULT
:
1836 if (cfun
->calls_alloca
|| has_protected_decls
)
1837 create_stack_guard ();
1844 /* Assign rtl to each variable based on these partitions. */
1845 if (stack_vars_num
> 0)
1847 struct stack_vars_data data
;
1849 data
.asan_vec
= vNULL
;
1850 data
.asan_decl_vec
= vNULL
;
1851 data
.asan_base
= NULL_RTX
;
1852 data
.asan_alignb
= 0;
1854 /* Reorder decls to be protected by iterating over the variables
1855 array multiple times, and allocating out of each phase in turn. */
1856 /* ??? We could probably integrate this into the qsort we did
1857 earlier, such that we naturally see these variables first,
1858 and thus naturally allocate things in the right order. */
1859 if (has_protected_decls
)
1861 /* Phase 1 contains only character arrays. */
1862 expand_stack_vars (stack_protect_decl_phase_1
, &data
);
1864 /* Phase 2 contains other kinds of arrays. */
1865 if (flag_stack_protect
== 2)
1866 expand_stack_vars (stack_protect_decl_phase_2
, &data
);
1869 if ((flag_sanitize
& SANITIZE_ADDRESS
) && ASAN_STACK
)
1870 /* Phase 3, any partitions that need asan protection
1871 in addition to phase 1 and 2. */
1872 expand_stack_vars (asan_decl_phase_3
, &data
);
1874 if (!data
.asan_vec
.is_empty ())
1876 HOST_WIDE_INT prev_offset
= frame_offset
;
1877 HOST_WIDE_INT offset
, sz
, redzonesz
;
1878 redzonesz
= ASAN_RED_ZONE_SIZE
;
1879 sz
= data
.asan_vec
[0] - prev_offset
;
1880 if (data
.asan_alignb
> ASAN_RED_ZONE_SIZE
1881 && data
.asan_alignb
<= 4096
1882 && sz
+ ASAN_RED_ZONE_SIZE
>= (int) data
.asan_alignb
)
1883 redzonesz
= ((sz
+ ASAN_RED_ZONE_SIZE
+ data
.asan_alignb
- 1)
1884 & ~(data
.asan_alignb
- HOST_WIDE_INT_1
)) - sz
;
1886 = alloc_stack_frame_space (redzonesz
, ASAN_RED_ZONE_SIZE
);
1887 data
.asan_vec
.safe_push (prev_offset
);
1888 data
.asan_vec
.safe_push (offset
);
1889 /* Leave space for alignment if STRICT_ALIGNMENT. */
1890 if (STRICT_ALIGNMENT
)
1891 alloc_stack_frame_space ((GET_MODE_ALIGNMENT (SImode
)
1892 << ASAN_SHADOW_SHIFT
)
1893 / BITS_PER_UNIT
, 1);
1896 = asan_emit_stack_protection (virtual_stack_vars_rtx
,
1899 data
.asan_vec
.address (),
1900 data
.asan_decl_vec
.address (),
1901 data
.asan_vec
.length ());
1904 expand_stack_vars (NULL
, &data
);
1906 data
.asan_vec
.release ();
1907 data
.asan_decl_vec
.release ();
1910 fini_vars_expansion ();
1912 /* If there were any artificial non-ignored vars without rtl
1913 found earlier, see if deferred stack allocation hasn't assigned
1915 FOR_EACH_VEC_ELT_REVERSE (maybe_local_decls
, i
, var
)
1917 rtx rtl
= DECL_RTL_IF_SET (var
);
1919 /* Keep artificial non-ignored vars in cfun->local_decls
1920 chain until instantiate_decls. */
1921 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
1922 add_local_decl (cfun
, var
);
1924 maybe_local_decls
.release ();
1926 /* If the target requires that FRAME_OFFSET be aligned, do it. */
1927 if (STACK_ALIGNMENT_NEEDED
)
1929 HOST_WIDE_INT align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
1930 if (!FRAME_GROWS_DOWNWARD
)
1931 frame_offset
+= align
- 1;
1932 frame_offset
&= -align
;
1939 /* If we need to produce a detailed dump, print the tree representation
1940 for STMT to the dump file. SINCE is the last RTX after which the RTL
1941 generated for STMT should have been appended. */
1944 maybe_dump_rtl_for_gimple_stmt (gimple stmt
, rtx since
)
1946 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1948 fprintf (dump_file
, "\n;; ");
1949 print_gimple_stmt (dump_file
, stmt
, 0,
1950 TDF_SLIM
| (dump_flags
& TDF_LINENO
));
1951 fprintf (dump_file
, "\n");
1953 print_rtl (dump_file
, since
? NEXT_INSN (since
) : since
);
1957 /* Maps the blocks that do not contain tree labels to rtx labels. */
1959 static struct pointer_map_t
*lab_rtx_for_bb
;
1961 /* Returns the label_rtx expression for a label starting basic block BB. */
1964 label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED
)
1966 gimple_stmt_iterator gsi
;
1971 if (bb
->flags
& BB_RTL
)
1972 return block_label (bb
);
1974 elt
= pointer_map_contains (lab_rtx_for_bb
, bb
);
1978 /* Find the tree label if it is present. */
1980 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1982 lab_stmt
= gsi_stmt (gsi
);
1983 if (gimple_code (lab_stmt
) != GIMPLE_LABEL
)
1986 lab
= gimple_label_label (lab_stmt
);
1987 if (DECL_NONLOCAL (lab
))
1990 return label_rtx (lab
);
1993 elt
= pointer_map_insert (lab_rtx_for_bb
, bb
);
1994 *elt
= gen_label_rtx ();
1999 /* A subroutine of expand_gimple_cond. Given E, a fallthrough edge
2000 of a basic block where we just expanded the conditional at the end,
2001 possibly clean up the CFG and instruction sequence. LAST is the
2002 last instruction before the just emitted jump sequence. */
2005 maybe_cleanup_end_of_block (edge e
, rtx last
)
2007 /* Special case: when jumpif decides that the condition is
2008 trivial it emits an unconditional jump (and the necessary
2009 barrier). But we still have two edges, the fallthru one is
2010 wrong. purge_dead_edges would clean this up later. Unfortunately
2011 we have to insert insns (and split edges) before
2012 find_many_sub_basic_blocks and hence before purge_dead_edges.
2013 But splitting edges might create new blocks which depend on the
2014 fact that if there are two edges there's no barrier. So the
2015 barrier would get lost and verify_flow_info would ICE. Instead
2016 of auditing all edge splitters to care for the barrier (which
2017 normally isn't there in a cleaned CFG), fix it here. */
2018 if (BARRIER_P (get_last_insn ()))
2022 /* Now, we have a single successor block, if we have insns to
2023 insert on the remaining edge we potentially will insert
2024 it at the end of this block (if the dest block isn't feasible)
2025 in order to avoid splitting the edge. This insertion will take
2026 place in front of the last jump. But we might have emitted
2027 multiple jumps (conditional and one unconditional) to the
2028 same destination. Inserting in front of the last one then
2029 is a problem. See PR 40021. We fix this by deleting all
2030 jumps except the last unconditional one. */
2031 insn
= PREV_INSN (get_last_insn ());
2032 /* Make sure we have an unconditional jump. Otherwise we're
2034 gcc_assert (JUMP_P (insn
) && !any_condjump_p (insn
));
2035 for (insn
= PREV_INSN (insn
); insn
!= last
;)
2037 insn
= PREV_INSN (insn
);
2038 if (JUMP_P (NEXT_INSN (insn
)))
2040 if (!any_condjump_p (NEXT_INSN (insn
)))
2042 gcc_assert (BARRIER_P (NEXT_INSN (NEXT_INSN (insn
))));
2043 delete_insn (NEXT_INSN (NEXT_INSN (insn
)));
2045 delete_insn (NEXT_INSN (insn
));
2051 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_COND.
2052 Returns a new basic block if we've terminated the current basic
2053 block and created a new one. */
2056 expand_gimple_cond (basic_block bb
, gimple stmt
)
2058 basic_block new_bb
, dest
;
2063 enum tree_code code
;
2066 code
= gimple_cond_code (stmt
);
2067 op0
= gimple_cond_lhs (stmt
);
2068 op1
= gimple_cond_rhs (stmt
);
2069 /* We're sometimes presented with such code:
2073 This would expand to two comparisons which then later might
2074 be cleaned up by combine. But some pattern matchers like if-conversion
2075 work better when there's only one compare, so make up for this
2076 here as special exception if TER would have made the same change. */
2078 && TREE_CODE (op0
) == SSA_NAME
2079 && TREE_CODE (TREE_TYPE (op0
)) == BOOLEAN_TYPE
2080 && TREE_CODE (op1
) == INTEGER_CST
2081 && ((gimple_cond_code (stmt
) == NE_EXPR
2082 && integer_zerop (op1
))
2083 || (gimple_cond_code (stmt
) == EQ_EXPR
2084 && integer_onep (op1
)))
2085 && bitmap_bit_p (SA
.values
, SSA_NAME_VERSION (op0
)))
2087 gimple second
= SSA_NAME_DEF_STMT (op0
);
2088 if (gimple_code (second
) == GIMPLE_ASSIGN
)
2090 enum tree_code code2
= gimple_assign_rhs_code (second
);
2091 if (TREE_CODE_CLASS (code2
) == tcc_comparison
)
2094 op0
= gimple_assign_rhs1 (second
);
2095 op1
= gimple_assign_rhs2 (second
);
2097 /* If jumps are cheap turn some more codes into
2099 else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4)
2101 if ((code2
== BIT_AND_EXPR
2102 && TYPE_PRECISION (TREE_TYPE (op0
)) == 1
2103 && TREE_CODE (gimple_assign_rhs2 (second
)) != INTEGER_CST
)
2104 || code2
== TRUTH_AND_EXPR
)
2106 code
= TRUTH_ANDIF_EXPR
;
2107 op0
= gimple_assign_rhs1 (second
);
2108 op1
= gimple_assign_rhs2 (second
);
2110 else if (code2
== BIT_IOR_EXPR
|| code2
== TRUTH_OR_EXPR
)
2112 code
= TRUTH_ORIF_EXPR
;
2113 op0
= gimple_assign_rhs1 (second
);
2114 op1
= gimple_assign_rhs2 (second
);
2120 last2
= last
= get_last_insn ();
2122 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
2123 set_curr_insn_location (gimple_location (stmt
));
2125 /* These flags have no purpose in RTL land. */
2126 true_edge
->flags
&= ~EDGE_TRUE_VALUE
;
2127 false_edge
->flags
&= ~EDGE_FALSE_VALUE
;
2129 /* We can either have a pure conditional jump with one fallthru edge or
2130 two-way jump that needs to be decomposed into two basic blocks. */
2131 if (false_edge
->dest
== bb
->next_bb
)
2133 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2134 true_edge
->probability
);
2135 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2136 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2137 set_curr_insn_location (true_edge
->goto_locus
);
2138 false_edge
->flags
|= EDGE_FALLTHRU
;
2139 maybe_cleanup_end_of_block (false_edge
, last
);
2142 if (true_edge
->dest
== bb
->next_bb
)
2144 jumpifnot_1 (code
, op0
, op1
, label_rtx_for_bb (false_edge
->dest
),
2145 false_edge
->probability
);
2146 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2147 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2148 set_curr_insn_location (false_edge
->goto_locus
);
2149 true_edge
->flags
|= EDGE_FALLTHRU
;
2150 maybe_cleanup_end_of_block (true_edge
, last
);
2154 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2155 true_edge
->probability
);
2156 last
= get_last_insn ();
2157 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2158 set_curr_insn_location (false_edge
->goto_locus
);
2159 emit_jump (label_rtx_for_bb (false_edge
->dest
));
2162 if (BARRIER_P (BB_END (bb
)))
2163 BB_END (bb
) = PREV_INSN (BB_END (bb
));
2164 update_bb_for_insn (bb
);
2166 new_bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
2167 dest
= false_edge
->dest
;
2168 redirect_edge_succ (false_edge
, new_bb
);
2169 false_edge
->flags
|= EDGE_FALLTHRU
;
2170 new_bb
->count
= false_edge
->count
;
2171 new_bb
->frequency
= EDGE_FREQUENCY (false_edge
);
2172 if (current_loops
&& bb
->loop_father
)
2173 add_bb_to_loop (new_bb
, bb
->loop_father
);
2174 new_edge
= make_edge (new_bb
, dest
, 0);
2175 new_edge
->probability
= REG_BR_PROB_BASE
;
2176 new_edge
->count
= new_bb
->count
;
2177 if (BARRIER_P (BB_END (new_bb
)))
2178 BB_END (new_bb
) = PREV_INSN (BB_END (new_bb
));
2179 update_bb_for_insn (new_bb
);
2181 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
2183 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2185 set_curr_insn_location (true_edge
->goto_locus
);
2186 true_edge
->goto_locus
= curr_insn_location ();
2192 /* Mark all calls that can have a transaction restart. */
2195 mark_transaction_restart_calls (gimple stmt
)
2197 struct tm_restart_node dummy
;
2200 if (!cfun
->gimple_df
->tm_restart
)
2204 slot
= htab_find_slot (cfun
->gimple_df
->tm_restart
, &dummy
, NO_INSERT
);
2207 struct tm_restart_node
*n
= (struct tm_restart_node
*) *slot
;
2208 tree list
= n
->label_or_list
;
2211 for (insn
= next_real_insn (get_last_insn ());
2213 insn
= next_real_insn (insn
))
2216 if (TREE_CODE (list
) == LABEL_DECL
)
2217 add_reg_note (insn
, REG_TM
, label_rtx (list
));
2219 for (; list
; list
= TREE_CHAIN (list
))
2220 add_reg_note (insn
, REG_TM
, label_rtx (TREE_VALUE (list
)));
2224 /* A subroutine of expand_gimple_stmt_1, expanding one GIMPLE_CALL
2228 expand_call_stmt (gimple stmt
)
2230 tree exp
, decl
, lhs
;
2234 if (gimple_call_internal_p (stmt
))
2236 expand_internal_call (stmt
);
2240 exp
= build_vl_exp (CALL_EXPR
, gimple_call_num_args (stmt
) + 3);
2242 CALL_EXPR_FN (exp
) = gimple_call_fn (stmt
);
2243 decl
= gimple_call_fndecl (stmt
);
2244 builtin_p
= decl
&& DECL_BUILT_IN (decl
);
2246 /* If this is not a builtin function, the function type through which the
2247 call is made may be different from the type of the function. */
2250 = fold_convert (build_pointer_type (gimple_call_fntype (stmt
)),
2251 CALL_EXPR_FN (exp
));
2253 TREE_TYPE (exp
) = gimple_call_return_type (stmt
);
2254 CALL_EXPR_STATIC_CHAIN (exp
) = gimple_call_chain (stmt
);
2256 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2258 tree arg
= gimple_call_arg (stmt
, i
);
2260 /* TER addresses into arguments of builtin functions so we have a
2261 chance to infer more correct alignment information. See PR39954. */
2263 && TREE_CODE (arg
) == SSA_NAME
2264 && (def
= get_gimple_for_ssa_name (arg
))
2265 && gimple_assign_rhs_code (def
) == ADDR_EXPR
)
2266 arg
= gimple_assign_rhs1 (def
);
2267 CALL_EXPR_ARG (exp
, i
) = arg
;
2270 if (gimple_has_side_effects (stmt
))
2271 TREE_SIDE_EFFECTS (exp
) = 1;
2273 if (gimple_call_nothrow_p (stmt
))
2274 TREE_NOTHROW (exp
) = 1;
2276 CALL_EXPR_TAILCALL (exp
) = gimple_call_tail_p (stmt
);
2277 CALL_EXPR_RETURN_SLOT_OPT (exp
) = gimple_call_return_slot_opt_p (stmt
);
2279 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
2280 && (DECL_FUNCTION_CODE (decl
) == BUILT_IN_ALLOCA
2281 || DECL_FUNCTION_CODE (decl
) == BUILT_IN_ALLOCA_WITH_ALIGN
))
2282 CALL_ALLOCA_FOR_VAR_P (exp
) = gimple_call_alloca_for_var_p (stmt
);
2284 CALL_FROM_THUNK_P (exp
) = gimple_call_from_thunk_p (stmt
);
2285 CALL_EXPR_VA_ARG_PACK (exp
) = gimple_call_va_arg_pack_p (stmt
);
2286 SET_EXPR_LOCATION (exp
, gimple_location (stmt
));
2288 /* Ensure RTL is created for debug args. */
2289 if (decl
&& DECL_HAS_DEBUG_ARGS_P (decl
))
2291 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (decl
);
2296 for (ix
= 1; (*debug_args
)->iterate (ix
, &dtemp
); ix
+= 2)
2298 gcc_assert (TREE_CODE (dtemp
) == DEBUG_EXPR_DECL
);
2299 expand_debug_expr (dtemp
);
2303 lhs
= gimple_call_lhs (stmt
);
2305 expand_assignment (lhs
, exp
, false);
2307 expand_expr (exp
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2309 mark_transaction_restart_calls (stmt
);
2313 /* Generate RTL for an asm statement (explicit assembler code).
2314 STRING is a STRING_CST node containing the assembler code text,
2315 or an ADDR_EXPR containing a STRING_CST. VOL nonzero means the
2316 insn is volatile; don't optimize it. */
2319 expand_asm_loc (tree string
, int vol
, location_t locus
)
2323 if (TREE_CODE (string
) == ADDR_EXPR
)
2324 string
= TREE_OPERAND (string
, 0);
2326 body
= gen_rtx_ASM_INPUT_loc (VOIDmode
,
2327 ggc_strdup (TREE_STRING_POINTER (string
)),
2330 MEM_VOLATILE_P (body
) = vol
;
2335 /* Return the number of times character C occurs in string S. */
2337 n_occurrences (int c
, const char *s
)
2345 /* A subroutine of expand_asm_operands. Check that all operands have
2346 the same number of alternatives. Return true if so. */
2349 check_operand_nalternatives (tree outputs
, tree inputs
)
2351 if (outputs
|| inputs
)
2353 tree tmp
= TREE_PURPOSE (outputs
? outputs
: inputs
);
2355 = n_occurrences (',', TREE_STRING_POINTER (TREE_VALUE (tmp
)));
2358 if (nalternatives
+ 1 > MAX_RECOG_ALTERNATIVES
)
2360 error ("too many alternatives in %<asm%>");
2367 const char *constraint
2368 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tmp
)));
2370 if (n_occurrences (',', constraint
) != nalternatives
)
2372 error ("operand constraints for %<asm%> differ "
2373 "in number of alternatives");
2377 if (TREE_CHAIN (tmp
))
2378 tmp
= TREE_CHAIN (tmp
);
2380 tmp
= next
, next
= 0;
2387 /* Check for overlap between registers marked in CLOBBERED_REGS and
2388 anything inappropriate in T. Emit error and return the register
2389 variable definition for error, NULL_TREE for ok. */
2392 tree_conflicts_with_clobbers_p (tree t
, HARD_REG_SET
*clobbered_regs
)
2394 /* Conflicts between asm-declared register variables and the clobber
2395 list are not allowed. */
2396 tree overlap
= tree_overlaps_hard_reg_set (t
, clobbered_regs
);
2400 error ("asm-specifier for variable %qE conflicts with asm clobber list",
2401 DECL_NAME (overlap
));
2403 /* Reset registerness to stop multiple errors emitted for a single
2405 DECL_REGISTER (overlap
) = 0;
2412 /* Generate RTL for an asm statement with arguments.
2413 STRING is the instruction template.
2414 OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
2415 Each output or input has an expression in the TREE_VALUE and
2416 a tree list in TREE_PURPOSE which in turn contains a constraint
2417 name in TREE_VALUE (or NULL_TREE) and a constraint string
2419 CLOBBERS is a list of STRING_CST nodes each naming a hard register
2420 that is clobbered by this insn.
2422 LABELS is a list of labels, and if LABELS is non-NULL, FALLTHRU_BB
2423 should be the fallthru basic block of the asm goto.
2425 Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
2426 Some elements of OUTPUTS may be replaced with trees representing temporary
2427 values. The caller should copy those temporary values to the originally
2430 VOL nonzero means the insn is volatile; don't optimize it. */
2433 expand_asm_operands (tree string
, tree outputs
, tree inputs
,
2434 tree clobbers
, tree labels
, basic_block fallthru_bb
,
2435 int vol
, location_t locus
)
2437 rtvec argvec
, constraintvec
, labelvec
;
2439 int ninputs
= list_length (inputs
);
2440 int noutputs
= list_length (outputs
);
2441 int nlabels
= list_length (labels
);
2444 HARD_REG_SET clobbered_regs
;
2445 int clobber_conflict_found
= 0;
2449 /* Vector of RTX's of evaluated output operands. */
2450 rtx
*output_rtx
= XALLOCAVEC (rtx
, noutputs
);
2451 int *inout_opnum
= XALLOCAVEC (int, noutputs
);
2452 rtx
*real_output_rtx
= XALLOCAVEC (rtx
, noutputs
);
2453 enum machine_mode
*inout_mode
= XALLOCAVEC (enum machine_mode
, noutputs
);
2454 const char **constraints
= XALLOCAVEC (const char *, noutputs
+ ninputs
);
2455 int old_generating_concat_p
= generating_concat_p
;
2456 rtx fallthru_label
= NULL_RTX
;
2458 /* An ASM with no outputs needs to be treated as volatile, for now. */
2462 if (! check_operand_nalternatives (outputs
, inputs
))
2465 string
= resolve_asm_operand_names (string
, outputs
, inputs
, labels
);
2467 /* Collect constraints. */
2469 for (t
= outputs
; t
; t
= TREE_CHAIN (t
), i
++)
2470 constraints
[i
] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
2471 for (t
= inputs
; t
; t
= TREE_CHAIN (t
), i
++)
2472 constraints
[i
] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
2474 /* Sometimes we wish to automatically clobber registers across an asm.
2475 Case in point is when the i386 backend moved from cc0 to a hard reg --
2476 maintaining source-level compatibility means automatically clobbering
2477 the flags register. */
2478 clobbers
= targetm
.md_asm_clobbers (outputs
, inputs
, clobbers
);
2480 /* Count the number of meaningful clobbered registers, ignoring what
2481 we would ignore later. */
2483 CLEAR_HARD_REG_SET (clobbered_regs
);
2484 for (tail
= clobbers
; tail
; tail
= TREE_CHAIN (tail
))
2486 const char *regname
;
2489 if (TREE_VALUE (tail
) == error_mark_node
)
2491 regname
= TREE_STRING_POINTER (TREE_VALUE (tail
));
2493 i
= decode_reg_name_and_count (regname
, &nregs
);
2497 error ("unknown register name %qs in %<asm%>", regname
);
2499 /* Mark clobbered registers. */
2504 for (reg
= i
; reg
< i
+ nregs
; reg
++)
2508 /* Clobbering the PIC register is an error. */
2509 if (reg
== (int) PIC_OFFSET_TABLE_REGNUM
)
2511 error ("PIC register clobbered by %qs in %<asm%>", regname
);
2515 SET_HARD_REG_BIT (clobbered_regs
, reg
);
2520 /* First pass over inputs and outputs checks validity and sets
2521 mark_addressable if needed. */
2524 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
2526 tree val
= TREE_VALUE (tail
);
2527 tree type
= TREE_TYPE (val
);
2528 const char *constraint
;
2533 /* If there's an erroneous arg, emit no insn. */
2534 if (type
== error_mark_node
)
2537 /* Try to parse the output constraint. If that fails, there's
2538 no point in going further. */
2539 constraint
= constraints
[i
];
2540 if (!parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
2541 &allows_mem
, &allows_reg
, &is_inout
))
2548 && REG_P (DECL_RTL (val
))
2549 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
))))
2550 mark_addressable (val
);
2557 if (ninputs
+ noutputs
> MAX_RECOG_OPERANDS
)
2559 error ("more than %d operands in %<asm%>", MAX_RECOG_OPERANDS
);
2563 for (i
= 0, tail
= inputs
; tail
; i
++, tail
= TREE_CHAIN (tail
))
2565 bool allows_reg
, allows_mem
;
2566 const char *constraint
;
2568 /* If there's an erroneous arg, emit no insn, because the ASM_INPUT
2569 would get VOIDmode and that could cause a crash in reload. */
2570 if (TREE_TYPE (TREE_VALUE (tail
)) == error_mark_node
)
2573 constraint
= constraints
[i
+ noutputs
];
2574 if (! parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, ninout
,
2575 constraints
, &allows_mem
, &allows_reg
))
2578 if (! allows_reg
&& allows_mem
)
2579 mark_addressable (TREE_VALUE (tail
));
2582 /* Second pass evaluates arguments. */
2584 /* Make sure stack is consistent for asm goto. */
2586 do_pending_stack_adjust ();
2589 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
2591 tree val
= TREE_VALUE (tail
);
2592 tree type
= TREE_TYPE (val
);
2599 ok
= parse_output_constraint (&constraints
[i
], i
, ninputs
,
2600 noutputs
, &allows_mem
, &allows_reg
,
2604 /* If an output operand is not a decl or indirect ref and our constraint
2605 allows a register, make a temporary to act as an intermediate.
2606 Make the asm insn write into that, then our caller will copy it to
2607 the real output operand. Likewise for promoted variables. */
2609 generating_concat_p
= 0;
2611 real_output_rtx
[i
] = NULL_RTX
;
2612 if ((TREE_CODE (val
) == INDIRECT_REF
2615 && (allows_mem
|| REG_P (DECL_RTL (val
)))
2616 && ! (REG_P (DECL_RTL (val
))
2617 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
)))
2621 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
2622 !allows_reg
? EXPAND_MEMORY
: EXPAND_WRITE
);
2624 op
= validize_mem (op
);
2626 if (! allows_reg
&& !MEM_P (op
))
2627 error ("output number %d not directly addressable", i
);
2628 if ((! allows_mem
&& MEM_P (op
))
2629 || GET_CODE (op
) == CONCAT
)
2631 real_output_rtx
[i
] = op
;
2632 op
= gen_reg_rtx (GET_MODE (op
));
2634 emit_move_insn (op
, real_output_rtx
[i
]);
2639 op
= assign_temp (type
, 0, 1);
2640 op
= validize_mem (op
);
2641 if (!MEM_P (op
) && TREE_CODE (TREE_VALUE (tail
)) == SSA_NAME
)
2642 set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (TREE_VALUE (tail
)), op
);
2643 TREE_VALUE (tail
) = make_tree (type
, op
);
2647 generating_concat_p
= old_generating_concat_p
;
2651 inout_mode
[ninout
] = TYPE_MODE (type
);
2652 inout_opnum
[ninout
++] = i
;
2655 if (tree_conflicts_with_clobbers_p (val
, &clobbered_regs
))
2656 clobber_conflict_found
= 1;
2659 /* Make vectors for the expression-rtx, constraint strings,
2660 and named operands. */
2662 argvec
= rtvec_alloc (ninputs
);
2663 constraintvec
= rtvec_alloc (ninputs
);
2664 labelvec
= rtvec_alloc (nlabels
);
2666 body
= gen_rtx_ASM_OPERANDS ((noutputs
== 0 ? VOIDmode
2667 : GET_MODE (output_rtx
[0])),
2668 ggc_strdup (TREE_STRING_POINTER (string
)),
2669 empty_string
, 0, argvec
, constraintvec
,
2672 MEM_VOLATILE_P (body
) = vol
;
2674 /* Eval the inputs and put them into ARGVEC.
2675 Put their constraints into ASM_INPUTs and store in CONSTRAINTS. */
2677 for (i
= 0, tail
= inputs
; tail
; tail
= TREE_CHAIN (tail
), ++i
)
2679 bool allows_reg
, allows_mem
;
2680 const char *constraint
;
2685 constraint
= constraints
[i
+ noutputs
];
2686 ok
= parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, ninout
,
2687 constraints
, &allows_mem
, &allows_reg
);
2690 generating_concat_p
= 0;
2692 val
= TREE_VALUE (tail
);
2693 type
= TREE_TYPE (val
);
2694 /* EXPAND_INITIALIZER will not generate code for valid initializer
2695 constants, but will still generate code for other types of operand.
2696 This is the behavior we want for constant constraints. */
2697 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
2698 allows_reg
? EXPAND_NORMAL
2699 : allows_mem
? EXPAND_MEMORY
2700 : EXPAND_INITIALIZER
);
2702 /* Never pass a CONCAT to an ASM. */
2703 if (GET_CODE (op
) == CONCAT
)
2704 op
= force_reg (GET_MODE (op
), op
);
2705 else if (MEM_P (op
))
2706 op
= validize_mem (op
);
2708 if (asm_operand_ok (op
, constraint
, NULL
) <= 0)
2710 if (allows_reg
&& TYPE_MODE (type
) != BLKmode
)
2711 op
= force_reg (TYPE_MODE (type
), op
);
2712 else if (!allows_mem
)
2713 warning (0, "asm operand %d probably doesn%'t match constraints",
2715 else if (MEM_P (op
))
2717 /* We won't recognize either volatile memory or memory
2718 with a queued address as available a memory_operand
2719 at this point. Ignore it: clearly this *is* a memory. */
2725 generating_concat_p
= old_generating_concat_p
;
2726 ASM_OPERANDS_INPUT (body
, i
) = op
;
2728 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body
, i
)
2729 = gen_rtx_ASM_INPUT_loc (TYPE_MODE (type
),
2730 ggc_strdup (constraints
[i
+ noutputs
]),
2733 if (tree_conflicts_with_clobbers_p (val
, &clobbered_regs
))
2734 clobber_conflict_found
= 1;
2737 /* Protect all the operands from the queue now that they have all been
2740 generating_concat_p
= 0;
2742 /* For in-out operands, copy output rtx to input rtx. */
2743 for (i
= 0; i
< ninout
; i
++)
2745 int j
= inout_opnum
[i
];
2748 ASM_OPERANDS_INPUT (body
, ninputs
- ninout
+ i
)
2751 sprintf (buffer
, "%d", j
);
2752 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body
, ninputs
- ninout
+ i
)
2753 = gen_rtx_ASM_INPUT_loc (inout_mode
[i
], ggc_strdup (buffer
), locus
);
2756 /* Copy labels to the vector. */
2757 for (i
= 0, tail
= labels
; i
< nlabels
; ++i
, tail
= TREE_CHAIN (tail
))
2760 /* If asm goto has any labels in the fallthru basic block, use
2761 a label that we emit immediately after the asm goto. Expansion
2762 may insert further instructions into the same basic block after
2763 asm goto and if we don't do this, insertion of instructions on
2764 the fallthru edge might misbehave. See PR58670. */
2766 && label_to_block_fn (cfun
, TREE_VALUE (tail
)) == fallthru_bb
)
2768 if (fallthru_label
== NULL_RTX
)
2769 fallthru_label
= gen_label_rtx ();
2773 r
= label_rtx (TREE_VALUE (tail
));
2774 ASM_OPERANDS_LABEL (body
, i
) = gen_rtx_LABEL_REF (Pmode
, r
);
2777 generating_concat_p
= old_generating_concat_p
;
2779 /* Now, for each output, construct an rtx
2780 (set OUTPUT (asm_operands INSN OUTPUTCONSTRAINT OUTPUTNUMBER
2781 ARGVEC CONSTRAINTS OPNAMES))
2782 If there is more than one, put them inside a PARALLEL. */
2784 if (nlabels
> 0 && nclobbers
== 0)
2786 gcc_assert (noutputs
== 0);
2787 emit_jump_insn (body
);
2789 else if (noutputs
== 0 && nclobbers
== 0)
2791 /* No output operands: put in a raw ASM_OPERANDS rtx. */
2794 else if (noutputs
== 1 && nclobbers
== 0)
2796 ASM_OPERANDS_OUTPUT_CONSTRAINT (body
) = ggc_strdup (constraints
[0]);
2797 emit_insn (gen_rtx_SET (VOIDmode
, output_rtx
[0], body
));
2807 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (num
+ nclobbers
));
2809 /* For each output operand, store a SET. */
2810 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
2812 XVECEXP (body
, 0, i
)
2813 = gen_rtx_SET (VOIDmode
,
2815 gen_rtx_ASM_OPERANDS
2816 (GET_MODE (output_rtx
[i
]),
2817 ggc_strdup (TREE_STRING_POINTER (string
)),
2818 ggc_strdup (constraints
[i
]),
2819 i
, argvec
, constraintvec
, labelvec
, locus
));
2821 MEM_VOLATILE_P (SET_SRC (XVECEXP (body
, 0, i
))) = vol
;
2824 /* If there are no outputs (but there are some clobbers)
2825 store the bare ASM_OPERANDS into the PARALLEL. */
2828 XVECEXP (body
, 0, i
++) = obody
;
2830 /* Store (clobber REG) for each clobbered register specified. */
2832 for (tail
= clobbers
; tail
; tail
= TREE_CHAIN (tail
))
2834 const char *regname
= TREE_STRING_POINTER (TREE_VALUE (tail
));
2836 int j
= decode_reg_name_and_count (regname
, &nregs
);
2841 if (j
== -3) /* `cc', which is not a register */
2844 if (j
== -4) /* `memory', don't cache memory across asm */
2846 XVECEXP (body
, 0, i
++)
2847 = gen_rtx_CLOBBER (VOIDmode
,
2850 gen_rtx_SCRATCH (VOIDmode
)));
2854 /* Ignore unknown register, error already signaled. */
2858 for (reg
= j
; reg
< j
+ nregs
; reg
++)
2860 /* Use QImode since that's guaranteed to clobber just
2862 clobbered_reg
= gen_rtx_REG (QImode
, reg
);
2864 /* Do sanity check for overlap between clobbers and
2865 respectively input and outputs that hasn't been
2866 handled. Such overlap should have been detected and
2868 if (!clobber_conflict_found
)
2872 /* We test the old body (obody) contents to avoid
2873 tripping over the under-construction body. */
2874 for (opno
= 0; opno
< noutputs
; opno
++)
2875 if (reg_overlap_mentioned_p (clobbered_reg
,
2878 ("asm clobber conflict with output operand");
2880 for (opno
= 0; opno
< ninputs
- ninout
; opno
++)
2881 if (reg_overlap_mentioned_p (clobbered_reg
,
2882 ASM_OPERANDS_INPUT (obody
,
2885 ("asm clobber conflict with input operand");
2888 XVECEXP (body
, 0, i
++)
2889 = gen_rtx_CLOBBER (VOIDmode
, clobbered_reg
);
2894 emit_jump_insn (body
);
2900 emit_label (fallthru_label
);
2902 /* For any outputs that needed reloading into registers, spill them
2903 back to where they belong. */
2904 for (i
= 0; i
< noutputs
; ++i
)
2905 if (real_output_rtx
[i
])
2906 emit_move_insn (real_output_rtx
[i
], output_rtx
[i
]);
2908 crtl
->has_asm_statement
= 1;
2914 expand_asm_stmt (gimple stmt
)
2917 tree outputs
, tail
, t
;
2921 tree str
, out
, in
, cl
, labels
;
2922 location_t locus
= gimple_location (stmt
);
2923 basic_block fallthru_bb
= NULL
;
2925 /* Meh... convert the gimple asm operands into real tree lists.
2926 Eventually we should make all routines work on the vectors instead
2927 of relying on TREE_CHAIN. */
2929 n
= gimple_asm_noutputs (stmt
);
2932 t
= out
= gimple_asm_output_op (stmt
, 0);
2933 for (i
= 1; i
< n
; i
++)
2934 t
= TREE_CHAIN (t
) = gimple_asm_output_op (stmt
, i
);
2938 n
= gimple_asm_ninputs (stmt
);
2941 t
= in
= gimple_asm_input_op (stmt
, 0);
2942 for (i
= 1; i
< n
; i
++)
2943 t
= TREE_CHAIN (t
) = gimple_asm_input_op (stmt
, i
);
2947 n
= gimple_asm_nclobbers (stmt
);
2950 t
= cl
= gimple_asm_clobber_op (stmt
, 0);
2951 for (i
= 1; i
< n
; i
++)
2952 t
= TREE_CHAIN (t
) = gimple_asm_clobber_op (stmt
, i
);
2956 n
= gimple_asm_nlabels (stmt
);
2959 edge fallthru
= find_fallthru_edge (gimple_bb (stmt
)->succs
);
2961 fallthru_bb
= fallthru
->dest
;
2962 t
= labels
= gimple_asm_label_op (stmt
, 0);
2963 for (i
= 1; i
< n
; i
++)
2964 t
= TREE_CHAIN (t
) = gimple_asm_label_op (stmt
, i
);
2967 s
= gimple_asm_string (stmt
);
2968 str
= build_string (strlen (s
), s
);
2970 if (gimple_asm_input_p (stmt
))
2972 expand_asm_loc (str
, gimple_asm_volatile_p (stmt
), locus
);
2977 noutputs
= gimple_asm_noutputs (stmt
);
2978 /* o[I] is the place that output number I should be written. */
2979 o
= (tree
*) alloca (noutputs
* sizeof (tree
));
2981 /* Record the contents of OUTPUTS before it is modified. */
2982 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
2983 o
[i
] = TREE_VALUE (tail
);
2985 /* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of
2986 OUTPUTS some trees for where the values were actually stored. */
2987 expand_asm_operands (str
, outputs
, in
, cl
, labels
, fallthru_bb
,
2988 gimple_asm_volatile_p (stmt
), locus
);
2990 /* Copy all the intermediate outputs into the specified outputs. */
2991 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
2993 if (o
[i
] != TREE_VALUE (tail
))
2995 expand_assignment (o
[i
], TREE_VALUE (tail
), false);
2998 /* Restore the original value so that it's correct the next
2999 time we expand this function. */
3000 TREE_VALUE (tail
) = o
[i
];
3005 /* Emit code to jump to the address
3006 specified by the pointer expression EXP. */
3009 expand_computed_goto (tree exp
)
3011 rtx x
= expand_normal (exp
);
3013 x
= convert_memory_address (Pmode
, x
);
3015 do_pending_stack_adjust ();
3016 emit_indirect_jump (x
);
3019 /* Generate RTL code for a `goto' statement with target label LABEL.
3020 LABEL should be a LABEL_DECL tree node that was or will later be
3021 defined with `expand_label'. */
3024 expand_goto (tree label
)
3026 #ifdef ENABLE_CHECKING
3027 /* Check for a nonlocal goto to a containing function. Should have
3028 gotten translated to __builtin_nonlocal_goto. */
3029 tree context
= decl_function_context (label
);
3030 gcc_assert (!context
|| context
== current_function_decl
);
3033 emit_jump (label_rtx (label
));
3036 /* Output a return with no value. */
3039 expand_null_return_1 (void)
3041 clear_pending_stack_adjust ();
3042 do_pending_stack_adjust ();
3043 emit_jump (return_label
);
3046 /* Generate RTL to return from the current function, with no value.
3047 (That is, we do not do anything about returning any value.) */
3050 expand_null_return (void)
3052 /* If this function was declared to return a value, but we
3053 didn't, clobber the return registers so that they are not
3054 propagated live to the rest of the function. */
3055 clobber_return_register ();
3057 expand_null_return_1 ();
3060 /* Generate RTL to return from the current function, with value VAL. */
3063 expand_value_return (rtx val
)
3065 /* Copy the value to the return location unless it's already there. */
3067 tree decl
= DECL_RESULT (current_function_decl
);
3068 rtx return_reg
= DECL_RTL (decl
);
3069 if (return_reg
!= val
)
3071 tree funtype
= TREE_TYPE (current_function_decl
);
3072 tree type
= TREE_TYPE (decl
);
3073 int unsignedp
= TYPE_UNSIGNED (type
);
3074 enum machine_mode old_mode
= DECL_MODE (decl
);
3075 enum machine_mode mode
;
3076 if (DECL_BY_REFERENCE (decl
))
3077 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 2);
3079 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 1);
3081 if (mode
!= old_mode
)
3082 val
= convert_modes (mode
, old_mode
, val
, unsignedp
);
3084 if (GET_CODE (return_reg
) == PARALLEL
)
3085 emit_group_load (return_reg
, val
, type
, int_size_in_bytes (type
));
3087 emit_move_insn (return_reg
, val
);
3090 expand_null_return_1 ();
3093 /* Generate RTL to evaluate the expression RETVAL and return it
3094 from the current function. */
3097 expand_return (tree retval
)
3103 /* If function wants no value, give it none. */
3104 if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl
))) == VOID_TYPE
)
3106 expand_normal (retval
);
3107 expand_null_return ();
3111 if (retval
== error_mark_node
)
3113 /* Treat this like a return of no value from a function that
3115 expand_null_return ();
3118 else if ((TREE_CODE (retval
) == MODIFY_EXPR
3119 || TREE_CODE (retval
) == INIT_EXPR
)
3120 && TREE_CODE (TREE_OPERAND (retval
, 0)) == RESULT_DECL
)
3121 retval_rhs
= TREE_OPERAND (retval
, 1);
3123 retval_rhs
= retval
;
3125 result_rtl
= DECL_RTL (DECL_RESULT (current_function_decl
));
3127 /* If we are returning the RESULT_DECL, then the value has already
3128 been stored into it, so we don't have to do anything special. */
3129 if (TREE_CODE (retval_rhs
) == RESULT_DECL
)
3130 expand_value_return (result_rtl
);
3132 /* If the result is an aggregate that is being returned in one (or more)
3133 registers, load the registers here. */
3135 else if (retval_rhs
!= 0
3136 && TYPE_MODE (TREE_TYPE (retval_rhs
)) == BLKmode
3137 && REG_P (result_rtl
))
3139 val
= copy_blkmode_to_reg (GET_MODE (result_rtl
), retval_rhs
);
3142 /* Use the mode of the result value on the return register. */
3143 PUT_MODE (result_rtl
, GET_MODE (val
));
3144 expand_value_return (val
);
3147 expand_null_return ();
3149 else if (retval_rhs
!= 0
3150 && !VOID_TYPE_P (TREE_TYPE (retval_rhs
))
3151 && (REG_P (result_rtl
)
3152 || (GET_CODE (result_rtl
) == PARALLEL
)))
3154 /* Compute the return value into a temporary (usually a pseudo reg). */
3156 = assign_temp (TREE_TYPE (DECL_RESULT (current_function_decl
)), 0, 1);
3157 val
= expand_expr (retval_rhs
, val
, GET_MODE (val
), EXPAND_NORMAL
);
3158 val
= force_not_mem (val
);
3159 expand_value_return (val
);
3163 /* No hard reg used; calculate value into hard return reg. */
3164 expand_expr (retval
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3165 expand_value_return (result_rtl
);
3169 /* A subroutine of expand_gimple_stmt, expanding one gimple statement
3170 STMT that doesn't require special handling for outgoing edges. That
3171 is no tailcalls and no GIMPLE_COND. */
3174 expand_gimple_stmt_1 (gimple stmt
)
3178 set_curr_insn_location (gimple_location (stmt
));
3180 switch (gimple_code (stmt
))
3183 op0
= gimple_goto_dest (stmt
);
3184 if (TREE_CODE (op0
) == LABEL_DECL
)
3187 expand_computed_goto (op0
);
3190 expand_label (gimple_label_label (stmt
));
3193 case GIMPLE_PREDICT
:
3199 expand_asm_stmt (stmt
);
3202 expand_call_stmt (stmt
);
3206 op0
= gimple_return_retval (stmt
);
3208 if (op0
&& op0
!= error_mark_node
)
3210 tree result
= DECL_RESULT (current_function_decl
);
3212 /* If we are not returning the current function's RESULT_DECL,
3213 build an assignment to it. */
3216 /* I believe that a function's RESULT_DECL is unique. */
3217 gcc_assert (TREE_CODE (op0
) != RESULT_DECL
);
3219 /* ??? We'd like to use simply expand_assignment here,
3220 but this fails if the value is of BLKmode but the return
3221 decl is a register. expand_return has special handling
3222 for this combination, which eventually should move
3223 to common code. See comments there. Until then, let's
3224 build a modify expression :-/ */
3225 op0
= build2 (MODIFY_EXPR
, TREE_TYPE (result
),
3230 expand_null_return ();
3232 expand_return (op0
);
3237 tree lhs
= gimple_assign_lhs (stmt
);
3239 /* Tree expand used to fiddle with |= and &= of two bitfield
3240 COMPONENT_REFs here. This can't happen with gimple, the LHS
3241 of binary assigns must be a gimple reg. */
3243 if (TREE_CODE (lhs
) != SSA_NAME
3244 || get_gimple_rhs_class (gimple_expr_code (stmt
))
3245 == GIMPLE_SINGLE_RHS
)
3247 tree rhs
= gimple_assign_rhs1 (stmt
);
3248 gcc_assert (get_gimple_rhs_class (gimple_expr_code (stmt
))
3249 == GIMPLE_SINGLE_RHS
);
3250 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (rhs
))
3251 SET_EXPR_LOCATION (rhs
, gimple_location (stmt
));
3252 if (TREE_CLOBBER_P (rhs
))
3253 /* This is a clobber to mark the going out of scope for
3257 expand_assignment (lhs
, rhs
,
3258 gimple_assign_nontemporal_move_p (stmt
));
3263 bool nontemporal
= gimple_assign_nontemporal_move_p (stmt
);
3264 struct separate_ops ops
;
3265 bool promoted
= false;
3267 target
= expand_expr (lhs
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
3268 if (GET_CODE (target
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (target
))
3271 ops
.code
= gimple_assign_rhs_code (stmt
);
3272 ops
.type
= TREE_TYPE (lhs
);
3273 switch (get_gimple_rhs_class (gimple_expr_code (stmt
)))
3275 case GIMPLE_TERNARY_RHS
:
3276 ops
.op2
= gimple_assign_rhs3 (stmt
);
3278 case GIMPLE_BINARY_RHS
:
3279 ops
.op1
= gimple_assign_rhs2 (stmt
);
3281 case GIMPLE_UNARY_RHS
:
3282 ops
.op0
= gimple_assign_rhs1 (stmt
);
3287 ops
.location
= gimple_location (stmt
);
3289 /* If we want to use a nontemporal store, force the value to
3290 register first. If we store into a promoted register,
3291 don't directly expand to target. */
3292 temp
= nontemporal
|| promoted
? NULL_RTX
: target
;
3293 temp
= expand_expr_real_2 (&ops
, temp
, GET_MODE (target
),
3300 int unsignedp
= SUBREG_PROMOTED_UNSIGNED_P (target
);
3301 /* If TEMP is a VOIDmode constant, use convert_modes to make
3302 sure that we properly convert it. */
3303 if (CONSTANT_P (temp
) && GET_MODE (temp
) == VOIDmode
)
3305 temp
= convert_modes (GET_MODE (target
),
3306 TYPE_MODE (ops
.type
),
3308 temp
= convert_modes (GET_MODE (SUBREG_REG (target
)),
3309 GET_MODE (target
), temp
, unsignedp
);
3312 convert_move (SUBREG_REG (target
), temp
, unsignedp
);
3314 else if (nontemporal
&& emit_storent_insn (target
, temp
))
3318 temp
= force_operand (temp
, target
);
3320 emit_move_insn (target
, temp
);
3331 /* Expand one gimple statement STMT and return the last RTL instruction
3332 before any of the newly generated ones.
3334 In addition to generating the necessary RTL instructions this also
3335 sets REG_EH_REGION notes if necessary and sets the current source
3336 location for diagnostics. */
3339 expand_gimple_stmt (gimple stmt
)
3341 location_t saved_location
= input_location
;
3342 rtx last
= get_last_insn ();
3347 /* We need to save and restore the current source location so that errors
3348 discovered during expansion are emitted with the right location. But
3349 it would be better if the diagnostic routines used the source location
3350 embedded in the tree nodes rather than globals. */
3351 if (gimple_has_location (stmt
))
3352 input_location
= gimple_location (stmt
);
3354 expand_gimple_stmt_1 (stmt
);
3356 /* Free any temporaries used to evaluate this statement. */
3359 input_location
= saved_location
;
3361 /* Mark all insns that may trap. */
3362 lp_nr
= lookup_stmt_eh_lp (stmt
);
3366 for (insn
= next_real_insn (last
); insn
;
3367 insn
= next_real_insn (insn
))
3369 if (! find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
3370 /* If we want exceptions for non-call insns, any
3371 may_trap_p instruction may throw. */
3372 && GET_CODE (PATTERN (insn
)) != CLOBBER
3373 && GET_CODE (PATTERN (insn
)) != USE
3374 && insn_could_throw_p (insn
))
3375 make_reg_eh_region_note (insn
, 0, lp_nr
);
3382 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_CALL
3383 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
3384 generated a tail call (something that might be denied by the ABI
3385 rules governing the call; see calls.c).
3387 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
3388 can still reach the rest of BB. The case here is __builtin_sqrt,
3389 where the NaN result goes through the external function (with a
3390 tailcall) and the normal result happens via a sqrt instruction. */
3393 expand_gimple_tailcall (basic_block bb
, gimple stmt
, bool *can_fallthru
)
3401 last2
= last
= expand_gimple_stmt (stmt
);
3403 for (last
= NEXT_INSN (last
); last
; last
= NEXT_INSN (last
))
3404 if (CALL_P (last
) && SIBLING_CALL_P (last
))
3407 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
3409 *can_fallthru
= true;
3413 /* ??? Wouldn't it be better to just reset any pending stack adjust?
3414 Any instructions emitted here are about to be deleted. */
3415 do_pending_stack_adjust ();
3417 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
3418 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
3419 EH or abnormal edges, we shouldn't have created a tail call in
3420 the first place. So it seems to me we should just be removing
3421 all edges here, or redirecting the existing fallthru edge to
3427 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
3429 if (!(e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
)))
3431 if (e
->dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
3433 e
->dest
->count
-= e
->count
;
3434 e
->dest
->frequency
-= EDGE_FREQUENCY (e
);
3435 if (e
->dest
->count
< 0)
3437 if (e
->dest
->frequency
< 0)
3438 e
->dest
->frequency
= 0;
3441 probability
+= e
->probability
;
3448 /* This is somewhat ugly: the call_expr expander often emits instructions
3449 after the sibcall (to perform the function return). These confuse the
3450 find_many_sub_basic_blocks code, so we need to get rid of these. */
3451 last
= NEXT_INSN (last
);
3452 gcc_assert (BARRIER_P (last
));
3454 *can_fallthru
= false;
3455 while (NEXT_INSN (last
))
3457 /* For instance an sqrt builtin expander expands if with
3458 sibcall in the then and label for `else`. */
3459 if (LABEL_P (NEXT_INSN (last
)))
3461 *can_fallthru
= true;
3464 delete_insn (NEXT_INSN (last
));
3467 e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_ABNORMAL
3469 e
->probability
+= probability
;
3472 update_bb_for_insn (bb
);
3474 if (NEXT_INSN (last
))
3476 bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
3479 if (BARRIER_P (last
))
3480 BB_END (bb
) = PREV_INSN (last
);
3483 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
3488 /* Return the difference between the floor and the truncated result of
3489 a signed division by OP1 with remainder MOD. */
3491 floor_sdiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1
)
3493 /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
3494 return gen_rtx_IF_THEN_ELSE
3495 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3496 gen_rtx_IF_THEN_ELSE
3497 (mode
, gen_rtx_LT (BImode
,
3498 gen_rtx_DIV (mode
, op1
, mod
),
3500 constm1_rtx
, const0_rtx
),
3504 /* Return the difference between the ceil and the truncated result of
3505 a signed division by OP1 with remainder MOD. */
3507 ceil_sdiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1
)
3509 /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
3510 return gen_rtx_IF_THEN_ELSE
3511 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3512 gen_rtx_IF_THEN_ELSE
3513 (mode
, gen_rtx_GT (BImode
,
3514 gen_rtx_DIV (mode
, op1
, mod
),
3516 const1_rtx
, const0_rtx
),
3520 /* Return the difference between the ceil and the truncated result of
3521 an unsigned division by OP1 with remainder MOD. */
3523 ceil_udiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1 ATTRIBUTE_UNUSED
)
3525 /* (mod != 0 ? 1 : 0) */
3526 return gen_rtx_IF_THEN_ELSE
3527 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3528 const1_rtx
, const0_rtx
);
3531 /* Return the difference between the rounded and the truncated result
3532 of a signed division by OP1 with remainder MOD. Halfway cases are
3533 rounded away from zero, rather than to the nearest even number. */
3535 round_sdiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1
)
3537 /* (abs (mod) >= abs (op1) - abs (mod)
3538 ? (op1 / mod > 0 ? 1 : -1)
3540 return gen_rtx_IF_THEN_ELSE
3541 (mode
, gen_rtx_GE (BImode
, gen_rtx_ABS (mode
, mod
),
3542 gen_rtx_MINUS (mode
,
3543 gen_rtx_ABS (mode
, op1
),
3544 gen_rtx_ABS (mode
, mod
))),
3545 gen_rtx_IF_THEN_ELSE
3546 (mode
, gen_rtx_GT (BImode
,
3547 gen_rtx_DIV (mode
, op1
, mod
),
3549 const1_rtx
, constm1_rtx
),
3553 /* Return the difference between the rounded and the truncated result
3554 of a unsigned division by OP1 with remainder MOD. Halfway cases
3555 are rounded away from zero, rather than to the nearest even
3558 round_udiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1
)
3560 /* (mod >= op1 - mod ? 1 : 0) */
3561 return gen_rtx_IF_THEN_ELSE
3562 (mode
, gen_rtx_GE (BImode
, mod
,
3563 gen_rtx_MINUS (mode
, op1
, mod
)),
3564 const1_rtx
, const0_rtx
);
3567 /* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
3571 convert_debug_memory_address (enum machine_mode mode
, rtx x
,
3574 enum machine_mode xmode
= GET_MODE (x
);
3576 #ifndef POINTERS_EXTEND_UNSIGNED
3577 gcc_assert (mode
== Pmode
3578 || mode
== targetm
.addr_space
.address_mode (as
));
3579 gcc_assert (xmode
== mode
|| xmode
== VOIDmode
);
3583 gcc_assert (targetm
.addr_space
.valid_pointer_mode (mode
, as
));
3585 if (GET_MODE (x
) == mode
|| GET_MODE (x
) == VOIDmode
)
3588 if (GET_MODE_PRECISION (mode
) < GET_MODE_PRECISION (xmode
))
3589 x
= simplify_gen_subreg (mode
, x
, xmode
,
3590 subreg_lowpart_offset
3592 else if (POINTERS_EXTEND_UNSIGNED
> 0)
3593 x
= gen_rtx_ZERO_EXTEND (mode
, x
);
3594 else if (!POINTERS_EXTEND_UNSIGNED
)
3595 x
= gen_rtx_SIGN_EXTEND (mode
, x
);
3598 switch (GET_CODE (x
))
3601 if ((SUBREG_PROMOTED_VAR_P (x
)
3602 || (REG_P (SUBREG_REG (x
)) && REG_POINTER (SUBREG_REG (x
)))
3603 || (GET_CODE (SUBREG_REG (x
)) == PLUS
3604 && REG_P (XEXP (SUBREG_REG (x
), 0))
3605 && REG_POINTER (XEXP (SUBREG_REG (x
), 0))
3606 && CONST_INT_P (XEXP (SUBREG_REG (x
), 1))))
3607 && GET_MODE (SUBREG_REG (x
)) == mode
)
3608 return SUBREG_REG (x
);
3611 temp
= gen_rtx_LABEL_REF (mode
, XEXP (x
, 0));
3612 LABEL_REF_NONLOCAL_P (temp
) = LABEL_REF_NONLOCAL_P (x
);
3615 temp
= shallow_copy_rtx (x
);
3616 PUT_MODE (temp
, mode
);
3619 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
3621 temp
= gen_rtx_CONST (mode
, temp
);
3625 if (CONST_INT_P (XEXP (x
, 1)))
3627 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
3629 return gen_rtx_fmt_ee (GET_CODE (x
), mode
, temp
, XEXP (x
, 1));
3635 /* Don't know how to express ptr_extend as operation in debug info. */
3638 #endif /* POINTERS_EXTEND_UNSIGNED */
3643 /* Return an RTX equivalent to the value of the parameter DECL. */
3646 expand_debug_parm_decl (tree decl
)
3648 rtx incoming
= DECL_INCOMING_RTL (decl
);
3651 && GET_MODE (incoming
) != BLKmode
3652 && ((REG_P (incoming
) && HARD_REGISTER_P (incoming
))
3653 || (MEM_P (incoming
)
3654 && REG_P (XEXP (incoming
, 0))
3655 && HARD_REGISTER_P (XEXP (incoming
, 0)))))
3657 rtx rtl
= gen_rtx_ENTRY_VALUE (GET_MODE (incoming
));
3659 #ifdef HAVE_window_save
3660 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
3661 If the target machine has an explicit window save instruction, the
3662 actual entry value is the corresponding OUTGOING_REGNO instead. */
3663 if (REG_P (incoming
)
3664 && OUTGOING_REGNO (REGNO (incoming
)) != REGNO (incoming
))
3666 = gen_rtx_REG_offset (incoming
, GET_MODE (incoming
),
3667 OUTGOING_REGNO (REGNO (incoming
)), 0);
3668 else if (MEM_P (incoming
))
3670 rtx reg
= XEXP (incoming
, 0);
3671 if (OUTGOING_REGNO (REGNO (reg
)) != REGNO (reg
))
3673 reg
= gen_raw_REG (GET_MODE (reg
), OUTGOING_REGNO (REGNO (reg
)));
3674 incoming
= replace_equiv_address_nv (incoming
, reg
);
3677 incoming
= copy_rtx (incoming
);
3681 ENTRY_VALUE_EXP (rtl
) = incoming
;
3686 && GET_MODE (incoming
) != BLKmode
3687 && !TREE_ADDRESSABLE (decl
)
3689 && (XEXP (incoming
, 0) == virtual_incoming_args_rtx
3690 || (GET_CODE (XEXP (incoming
, 0)) == PLUS
3691 && XEXP (XEXP (incoming
, 0), 0) == virtual_incoming_args_rtx
3692 && CONST_INT_P (XEXP (XEXP (incoming
, 0), 1)))))
3693 return copy_rtx (incoming
);
3698 /* Return an RTX equivalent to the value of the tree expression EXP. */
3701 expand_debug_expr (tree exp
)
3703 rtx op0
= NULL_RTX
, op1
= NULL_RTX
, op2
= NULL_RTX
;
3704 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
3705 enum machine_mode inner_mode
= VOIDmode
;
3706 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (exp
));
3709 switch (TREE_CODE_CLASS (TREE_CODE (exp
)))
3711 case tcc_expression
:
3712 switch (TREE_CODE (exp
))
3716 case WIDEN_MULT_PLUS_EXPR
:
3717 case WIDEN_MULT_MINUS_EXPR
:
3721 case TRUTH_ANDIF_EXPR
:
3722 case TRUTH_ORIF_EXPR
:
3723 case TRUTH_AND_EXPR
:
3725 case TRUTH_XOR_EXPR
:
3728 case TRUTH_NOT_EXPR
:
3737 op2
= expand_debug_expr (TREE_OPERAND (exp
, 2));
3744 case tcc_comparison
:
3745 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
3752 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
3753 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
3763 case tcc_exceptional
:
3764 case tcc_declaration
:
3770 switch (TREE_CODE (exp
))
3773 if (!lookup_constant_def (exp
))
3775 if (strlen (TREE_STRING_POINTER (exp
)) + 1
3776 != (size_t) TREE_STRING_LENGTH (exp
))
3778 op0
= gen_rtx_CONST_STRING (Pmode
, TREE_STRING_POINTER (exp
));
3779 op0
= gen_rtx_MEM (BLKmode
, op0
);
3780 set_mem_attributes (op0
, exp
, 0);
3783 /* Fall through... */
3788 op0
= expand_expr (exp
, NULL_RTX
, mode
, EXPAND_INITIALIZER
);
3792 gcc_assert (COMPLEX_MODE_P (mode
));
3793 op0
= expand_debug_expr (TREE_REALPART (exp
));
3794 op1
= expand_debug_expr (TREE_IMAGPART (exp
));
3795 return gen_rtx_CONCAT (mode
, op0
, op1
);
3797 case DEBUG_EXPR_DECL
:
3798 op0
= DECL_RTL_IF_SET (exp
);
3803 op0
= gen_rtx_DEBUG_EXPR (mode
);
3804 DEBUG_EXPR_TREE_DECL (op0
) = exp
;
3805 SET_DECL_RTL (exp
, op0
);
3815 op0
= DECL_RTL_IF_SET (exp
);
3817 /* This decl was probably optimized away. */
3820 if (TREE_CODE (exp
) != VAR_DECL
3821 || DECL_EXTERNAL (exp
)
3822 || !TREE_STATIC (exp
)
3824 || DECL_HARD_REGISTER (exp
)
3825 || DECL_IN_CONSTANT_POOL (exp
)
3826 || mode
== VOIDmode
)
3829 op0
= make_decl_rtl_for_debug (exp
);
3831 || GET_CODE (XEXP (op0
, 0)) != SYMBOL_REF
3832 || SYMBOL_REF_DECL (XEXP (op0
, 0)) != exp
)
3836 op0
= copy_rtx (op0
);
3838 if (GET_MODE (op0
) == BLKmode
3839 /* If op0 is not BLKmode, but BLKmode is, adjust_mode
3840 below would ICE. While it is likely a FE bug,
3841 try to be robust here. See PR43166. */
3843 || (mode
== VOIDmode
&& GET_MODE (op0
) != VOIDmode
))
3845 gcc_assert (MEM_P (op0
));
3846 op0
= adjust_address_nv (op0
, mode
, 0);
3857 inner_mode
= GET_MODE (op0
);
3859 if (mode
== inner_mode
)
3862 if (inner_mode
== VOIDmode
)
3864 if (TREE_CODE (exp
) == SSA_NAME
)
3865 inner_mode
= TYPE_MODE (TREE_TYPE (exp
));
3867 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
3868 if (mode
== inner_mode
)
3872 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
3874 if (GET_MODE_BITSIZE (mode
) == GET_MODE_BITSIZE (inner_mode
))
3875 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
3876 else if (GET_MODE_BITSIZE (mode
) < GET_MODE_BITSIZE (inner_mode
))
3877 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
3879 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
3881 else if (FLOAT_MODE_P (mode
))
3883 gcc_assert (TREE_CODE (exp
) != SSA_NAME
);
3884 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
3885 op0
= simplify_gen_unary (UNSIGNED_FLOAT
, mode
, op0
, inner_mode
);
3887 op0
= simplify_gen_unary (FLOAT
, mode
, op0
, inner_mode
);
3889 else if (FLOAT_MODE_P (inner_mode
))
3892 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
3894 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
3896 else if (CONSTANT_P (op0
)
3897 || GET_MODE_PRECISION (mode
) <= GET_MODE_PRECISION (inner_mode
))
3898 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
,
3899 subreg_lowpart_offset (mode
,
3901 else if (TREE_CODE_CLASS (TREE_CODE (exp
)) == tcc_unary
3902 ? TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)))
3904 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
3906 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
3912 if (!is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
3914 tree newexp
= fold_binary (MEM_REF
, TREE_TYPE (exp
),
3915 TREE_OPERAND (exp
, 0),
3916 TREE_OPERAND (exp
, 1));
3918 return expand_debug_expr (newexp
);
3922 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
3923 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
3927 if (TREE_CODE (exp
) == MEM_REF
)
3929 if (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
3930 || (GET_CODE (op0
) == PLUS
3931 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
))
3932 /* (mem (debug_implicit_ptr)) might confuse aliasing.
3933 Instead just use get_inner_reference. */
3936 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
3937 if (!op1
|| !CONST_INT_P (op1
))
3940 op0
= plus_constant (inner_mode
, op0
, INTVAL (op1
));
3943 if (POINTER_TYPE_P (TREE_TYPE (exp
)))
3944 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)));
3946 as
= ADDR_SPACE_GENERIC
;
3948 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
3950 if (op0
== NULL_RTX
)
3953 op0
= gen_rtx_MEM (mode
, op0
);
3954 set_mem_attributes (op0
, exp
, 0);
3955 if (TREE_CODE (exp
) == MEM_REF
3956 && !is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
3957 set_mem_expr (op0
, NULL_TREE
);
3958 set_mem_addr_space (op0
, as
);
3962 case TARGET_MEM_REF
:
3963 if (TREE_CODE (TMR_BASE (exp
)) == ADDR_EXPR
3964 && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp
), 0)))
3967 op0
= expand_debug_expr
3968 (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp
)), exp
));
3972 if (POINTER_TYPE_P (TREE_TYPE (exp
)))
3973 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)));
3975 as
= ADDR_SPACE_GENERIC
;
3977 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
3979 if (op0
== NULL_RTX
)
3982 op0
= gen_rtx_MEM (mode
, op0
);
3984 set_mem_attributes (op0
, exp
, 0);
3985 set_mem_addr_space (op0
, as
);
3991 case ARRAY_RANGE_REF
:
3996 case VIEW_CONVERT_EXPR
:
3998 enum machine_mode mode1
;
3999 HOST_WIDE_INT bitsize
, bitpos
;
4002 tree tem
= get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
,
4003 &mode1
, &unsignedp
, &volatilep
, false);
4009 orig_op0
= op0
= expand_debug_expr (tem
);
4016 enum machine_mode addrmode
, offmode
;
4021 op0
= XEXP (op0
, 0);
4022 addrmode
= GET_MODE (op0
);
4023 if (addrmode
== VOIDmode
)
4026 op1
= expand_debug_expr (offset
);
4030 offmode
= GET_MODE (op1
);
4031 if (offmode
== VOIDmode
)
4032 offmode
= TYPE_MODE (TREE_TYPE (offset
));
4034 if (addrmode
!= offmode
)
4035 op1
= simplify_gen_subreg (addrmode
, op1
, offmode
,
4036 subreg_lowpart_offset (addrmode
,
4039 /* Don't use offset_address here, we don't need a
4040 recognizable address, and we don't want to generate
4042 op0
= gen_rtx_MEM (mode
, simplify_gen_binary (PLUS
, addrmode
,
4048 if (mode1
== VOIDmode
)
4050 mode1
= smallest_mode_for_size (bitsize
, MODE_INT
);
4051 if (bitpos
>= BITS_PER_UNIT
)
4053 op0
= adjust_address_nv (op0
, mode1
, bitpos
/ BITS_PER_UNIT
);
4054 bitpos
%= BITS_PER_UNIT
;
4056 else if (bitpos
< 0)
4059 = (-bitpos
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
4060 op0
= adjust_address_nv (op0
, mode1
, units
);
4061 bitpos
+= units
* BITS_PER_UNIT
;
4063 else if (bitpos
== 0 && bitsize
== GET_MODE_BITSIZE (mode
))
4064 op0
= adjust_address_nv (op0
, mode
, 0);
4065 else if (GET_MODE (op0
) != mode1
)
4066 op0
= adjust_address_nv (op0
, mode1
, 0);
4068 op0
= copy_rtx (op0
);
4069 if (op0
== orig_op0
)
4070 op0
= shallow_copy_rtx (op0
);
4071 set_mem_attributes (op0
, exp
, 0);
4074 if (bitpos
== 0 && mode
== GET_MODE (op0
))
4080 if (GET_MODE (op0
) == BLKmode
)
4083 if ((bitpos
% BITS_PER_UNIT
) == 0
4084 && bitsize
== GET_MODE_BITSIZE (mode1
))
4086 enum machine_mode opmode
= GET_MODE (op0
);
4088 if (opmode
== VOIDmode
)
4089 opmode
= TYPE_MODE (TREE_TYPE (tem
));
4091 /* This condition may hold if we're expanding the address
4092 right past the end of an array that turned out not to
4093 be addressable (i.e., the address was only computed in
4094 debug stmts). The gen_subreg below would rightfully
4095 crash, and the address doesn't really exist, so just
4097 if (bitpos
>= GET_MODE_BITSIZE (opmode
))
4100 if ((bitpos
% GET_MODE_BITSIZE (mode
)) == 0)
4101 return simplify_gen_subreg (mode
, op0
, opmode
,
4102 bitpos
/ BITS_PER_UNIT
);
4105 return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0
))
4106 && TYPE_UNSIGNED (TREE_TYPE (exp
))
4108 : ZERO_EXTRACT
, mode
,
4109 GET_MODE (op0
) != VOIDmode
4111 : TYPE_MODE (TREE_TYPE (tem
)),
4112 op0
, GEN_INT (bitsize
), GEN_INT (bitpos
));
4116 return simplify_gen_unary (ABS
, mode
, op0
, mode
);
4119 return simplify_gen_unary (NEG
, mode
, op0
, mode
);
4122 return simplify_gen_unary (NOT
, mode
, op0
, mode
);
4125 return simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4127 ? UNSIGNED_FLOAT
: FLOAT
, mode
, op0
,
4130 case FIX_TRUNC_EXPR
:
4131 return simplify_gen_unary (unsignedp
? UNSIGNED_FIX
: FIX
, mode
, op0
,
4134 case POINTER_PLUS_EXPR
:
4135 /* For the rare target where pointers are not the same size as
4136 size_t, we need to check for mis-matched modes and correct
4139 && GET_MODE (op0
) != VOIDmode
&& GET_MODE (op1
) != VOIDmode
4140 && GET_MODE (op0
) != GET_MODE (op1
))
4142 if (GET_MODE_BITSIZE (GET_MODE (op0
)) < GET_MODE_BITSIZE (GET_MODE (op1
))
4143 /* If OP0 is a partial mode, then we must truncate, even if it has
4144 the same bitsize as OP1 as GCC's representation of partial modes
4146 || (GET_MODE_CLASS (GET_MODE (op0
)) == MODE_PARTIAL_INT
4147 && GET_MODE_BITSIZE (GET_MODE (op0
)) == GET_MODE_BITSIZE (GET_MODE (op1
))))
4148 op1
= simplify_gen_unary (TRUNCATE
, GET_MODE (op0
), op1
,
4151 /* We always sign-extend, regardless of the signedness of
4152 the operand, because the operand is always unsigned
4153 here even if the original C expression is signed. */
4154 op1
= simplify_gen_unary (SIGN_EXTEND
, GET_MODE (op0
), op1
,
4159 return simplify_gen_binary (PLUS
, mode
, op0
, op1
);
4162 return simplify_gen_binary (MINUS
, mode
, op0
, op1
);
4165 return simplify_gen_binary (MULT
, mode
, op0
, op1
);
4168 case TRUNC_DIV_EXPR
:
4169 case EXACT_DIV_EXPR
:
4171 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4173 return simplify_gen_binary (DIV
, mode
, op0
, op1
);
4175 case TRUNC_MOD_EXPR
:
4176 return simplify_gen_binary (unsignedp
? UMOD
: MOD
, mode
, op0
, op1
);
4178 case FLOOR_DIV_EXPR
:
4180 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4183 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4184 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4185 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4186 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4189 case FLOOR_MOD_EXPR
:
4191 return simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4194 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4195 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4196 adj
= simplify_gen_unary (NEG
, mode
,
4197 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4199 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4205 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4206 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4207 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4208 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4212 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4213 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4214 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4215 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4221 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4222 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4223 adj
= simplify_gen_unary (NEG
, mode
,
4224 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4226 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4230 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4231 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4232 adj
= simplify_gen_unary (NEG
, mode
,
4233 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4235 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4238 case ROUND_DIV_EXPR
:
4241 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4242 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4243 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4244 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4248 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4249 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4250 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4251 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4254 case ROUND_MOD_EXPR
:
4257 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4258 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4259 adj
= simplify_gen_unary (NEG
, mode
,
4260 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4262 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4266 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4267 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4268 adj
= simplify_gen_unary (NEG
, mode
,
4269 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4271 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4275 return simplify_gen_binary (ASHIFT
, mode
, op0
, op1
);
4279 return simplify_gen_binary (LSHIFTRT
, mode
, op0
, op1
);
4281 return simplify_gen_binary (ASHIFTRT
, mode
, op0
, op1
);
4284 return simplify_gen_binary (ROTATE
, mode
, op0
, op1
);
4287 return simplify_gen_binary (ROTATERT
, mode
, op0
, op1
);
4290 return simplify_gen_binary (unsignedp
? UMIN
: SMIN
, mode
, op0
, op1
);
4293 return simplify_gen_binary (unsignedp
? UMAX
: SMAX
, mode
, op0
, op1
);
4296 case TRUTH_AND_EXPR
:
4297 return simplify_gen_binary (AND
, mode
, op0
, op1
);
4301 return simplify_gen_binary (IOR
, mode
, op0
, op1
);
4304 case TRUTH_XOR_EXPR
:
4305 return simplify_gen_binary (XOR
, mode
, op0
, op1
);
4307 case TRUTH_ANDIF_EXPR
:
4308 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, const0_rtx
);
4310 case TRUTH_ORIF_EXPR
:
4311 return gen_rtx_IF_THEN_ELSE (mode
, op0
, const_true_rtx
, op1
);
4313 case TRUTH_NOT_EXPR
:
4314 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, const0_rtx
);
4317 return simplify_gen_relational (unsignedp
? LTU
: LT
, mode
, inner_mode
,
4321 return simplify_gen_relational (unsignedp
? LEU
: LE
, mode
, inner_mode
,
4325 return simplify_gen_relational (unsignedp
? GTU
: GT
, mode
, inner_mode
,
4329 return simplify_gen_relational (unsignedp
? GEU
: GE
, mode
, inner_mode
,
4333 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, op1
);
4336 return simplify_gen_relational (NE
, mode
, inner_mode
, op0
, op1
);
4338 case UNORDERED_EXPR
:
4339 return simplify_gen_relational (UNORDERED
, mode
, inner_mode
, op0
, op1
);
4342 return simplify_gen_relational (ORDERED
, mode
, inner_mode
, op0
, op1
);
4345 return simplify_gen_relational (UNLT
, mode
, inner_mode
, op0
, op1
);
4348 return simplify_gen_relational (UNLE
, mode
, inner_mode
, op0
, op1
);
4351 return simplify_gen_relational (UNGT
, mode
, inner_mode
, op0
, op1
);
4354 return simplify_gen_relational (UNGE
, mode
, inner_mode
, op0
, op1
);
4357 return simplify_gen_relational (UNEQ
, mode
, inner_mode
, op0
, op1
);
4360 return simplify_gen_relational (LTGT
, mode
, inner_mode
, op0
, op1
);
4363 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, op2
);
4366 gcc_assert (COMPLEX_MODE_P (mode
));
4367 if (GET_MODE (op0
) == VOIDmode
)
4368 op0
= gen_rtx_CONST (GET_MODE_INNER (mode
), op0
);
4369 if (GET_MODE (op1
) == VOIDmode
)
4370 op1
= gen_rtx_CONST (GET_MODE_INNER (mode
), op1
);
4371 return gen_rtx_CONCAT (mode
, op0
, op1
);
4374 if (GET_CODE (op0
) == CONCAT
)
4375 return gen_rtx_CONCAT (mode
, XEXP (op0
, 0),
4376 simplify_gen_unary (NEG
, GET_MODE_INNER (mode
),
4378 GET_MODE_INNER (mode
)));
4381 enum machine_mode imode
= GET_MODE_INNER (mode
);
4386 re
= adjust_address_nv (op0
, imode
, 0);
4387 im
= adjust_address_nv (op0
, imode
, GET_MODE_SIZE (imode
));
4391 enum machine_mode ifmode
= int_mode_for_mode (mode
);
4392 enum machine_mode ihmode
= int_mode_for_mode (imode
);
4394 if (ifmode
== BLKmode
|| ihmode
== BLKmode
)
4396 halfsize
= GEN_INT (GET_MODE_BITSIZE (ihmode
));
4399 re
= gen_rtx_SUBREG (ifmode
, re
, 0);
4400 re
= gen_rtx_ZERO_EXTRACT (ihmode
, re
, halfsize
, const0_rtx
);
4401 if (imode
!= ihmode
)
4402 re
= gen_rtx_SUBREG (imode
, re
, 0);
4403 im
= copy_rtx (op0
);
4405 im
= gen_rtx_SUBREG (ifmode
, im
, 0);
4406 im
= gen_rtx_ZERO_EXTRACT (ihmode
, im
, halfsize
, halfsize
);
4407 if (imode
!= ihmode
)
4408 im
= gen_rtx_SUBREG (imode
, im
, 0);
4410 im
= gen_rtx_NEG (imode
, im
);
4411 return gen_rtx_CONCAT (mode
, re
, im
);
4415 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4416 if (!op0
|| !MEM_P (op0
))
4418 if ((TREE_CODE (TREE_OPERAND (exp
, 0)) == VAR_DECL
4419 || TREE_CODE (TREE_OPERAND (exp
, 0)) == PARM_DECL
4420 || TREE_CODE (TREE_OPERAND (exp
, 0)) == RESULT_DECL
)
4421 && (!TREE_ADDRESSABLE (TREE_OPERAND (exp
, 0))
4422 || target_for_debug_bind (TREE_OPERAND (exp
, 0))))
4423 return gen_rtx_DEBUG_IMPLICIT_PTR (mode
, TREE_OPERAND (exp
, 0));
4425 if (handled_component_p (TREE_OPERAND (exp
, 0)))
4427 HOST_WIDE_INT bitoffset
, bitsize
, maxsize
;
4429 = get_ref_base_and_extent (TREE_OPERAND (exp
, 0),
4430 &bitoffset
, &bitsize
, &maxsize
);
4431 if ((TREE_CODE (decl
) == VAR_DECL
4432 || TREE_CODE (decl
) == PARM_DECL
4433 || TREE_CODE (decl
) == RESULT_DECL
)
4434 && (!TREE_ADDRESSABLE (decl
)
4435 || target_for_debug_bind (decl
))
4436 && (bitoffset
% BITS_PER_UNIT
) == 0
4438 && bitsize
== maxsize
)
4440 rtx base
= gen_rtx_DEBUG_IMPLICIT_PTR (mode
, decl
);
4441 return plus_constant (mode
, base
, bitoffset
/ BITS_PER_UNIT
);
4445 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == MEM_REF
4446 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
4449 op0
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
4452 && (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
4453 || (GET_CODE (op0
) == PLUS
4454 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
4455 && CONST_INT_P (XEXP (op0
, 1)))))
4457 op1
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
4459 if (!op1
|| !CONST_INT_P (op1
))
4462 return plus_constant (mode
, op0
, INTVAL (op1
));
4469 as
= TYPE_ADDR_SPACE (TREE_TYPE (exp
));
4470 op0
= convert_debug_memory_address (mode
, XEXP (op0
, 0), as
);
4478 op0
= gen_rtx_CONCATN
4479 (mode
, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
))));
4481 for (i
= 0; i
< VECTOR_CST_NELTS (exp
); ++i
)
4483 op1
= expand_debug_expr (VECTOR_CST_ELT (exp
, i
));
4486 XVECEXP (op0
, 0, i
) = op1
;
4493 if (TREE_CLOBBER_P (exp
))
4495 else if (TREE_CODE (TREE_TYPE (exp
)) == VECTOR_TYPE
)
4500 op0
= gen_rtx_CONCATN
4501 (mode
, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
))));
4503 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), i
, val
)
4505 op1
= expand_debug_expr (val
);
4508 XVECEXP (op0
, 0, i
) = op1
;
4511 if (i
< TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)))
4513 op1
= expand_debug_expr
4514 (build_zero_cst (TREE_TYPE (TREE_TYPE (exp
))));
4519 for (; i
< TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)); i
++)
4520 XVECEXP (op0
, 0, i
) = op1
;
4526 goto flag_unsupported
;
4529 /* ??? Maybe handle some builtins? */
4534 gimple g
= get_gimple_for_ssa_name (exp
);
4537 op0
= expand_debug_expr (gimple_assign_rhs_to_tree (g
));
4543 int part
= var_to_partition (SA
.map
, exp
);
4545 if (part
== NO_PARTITION
)
4547 /* If this is a reference to an incoming value of parameter
4548 that is never used in the code or where the incoming
4549 value is never used in the code, use PARM_DECL's
4551 if (SSA_NAME_IS_DEFAULT_DEF (exp
)
4552 && TREE_CODE (SSA_NAME_VAR (exp
)) == PARM_DECL
)
4554 op0
= expand_debug_parm_decl (SSA_NAME_VAR (exp
));
4557 op0
= expand_debug_expr (SSA_NAME_VAR (exp
));
4564 gcc_assert (part
>= 0 && (unsigned)part
< SA
.map
->num_partitions
);
4566 op0
= copy_rtx (SA
.partition_to_pseudo
[part
]);
4574 /* Vector stuff. For most of the codes we don't have rtl codes. */
4575 case REALIGN_LOAD_EXPR
:
4576 case REDUC_MAX_EXPR
:
4577 case REDUC_MIN_EXPR
:
4578 case REDUC_PLUS_EXPR
:
4580 case VEC_LSHIFT_EXPR
:
4581 case VEC_PACK_FIX_TRUNC_EXPR
:
4582 case VEC_PACK_SAT_EXPR
:
4583 case VEC_PACK_TRUNC_EXPR
:
4584 case VEC_RSHIFT_EXPR
:
4585 case VEC_UNPACK_FLOAT_HI_EXPR
:
4586 case VEC_UNPACK_FLOAT_LO_EXPR
:
4587 case VEC_UNPACK_HI_EXPR
:
4588 case VEC_UNPACK_LO_EXPR
:
4589 case VEC_WIDEN_MULT_HI_EXPR
:
4590 case VEC_WIDEN_MULT_LO_EXPR
:
4591 case VEC_WIDEN_MULT_EVEN_EXPR
:
4592 case VEC_WIDEN_MULT_ODD_EXPR
:
4593 case VEC_WIDEN_LSHIFT_HI_EXPR
:
4594 case VEC_WIDEN_LSHIFT_LO_EXPR
:
4599 case ADDR_SPACE_CONVERT_EXPR
:
4600 case FIXED_CONVERT_EXPR
:
4602 case WITH_SIZE_EXPR
:
4606 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
4607 && SCALAR_INT_MODE_P (mode
))
4610 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4612 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
4615 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4617 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op1
,
4619 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
4620 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
4624 case WIDEN_MULT_EXPR
:
4625 case WIDEN_MULT_PLUS_EXPR
:
4626 case WIDEN_MULT_MINUS_EXPR
:
4627 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
4628 && SCALAR_INT_MODE_P (mode
))
4630 inner_mode
= GET_MODE (op0
);
4631 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
4632 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
4634 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
4635 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 1))))
4636 op1
= simplify_gen_unary (ZERO_EXTEND
, mode
, op1
, inner_mode
);
4638 op1
= simplify_gen_unary (SIGN_EXTEND
, mode
, op1
, inner_mode
);
4639 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
4640 if (TREE_CODE (exp
) == WIDEN_MULT_EXPR
)
4642 else if (TREE_CODE (exp
) == WIDEN_MULT_PLUS_EXPR
)
4643 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
4645 return simplify_gen_binary (MINUS
, mode
, op2
, op0
);
4649 case MULT_HIGHPART_EXPR
:
4650 /* ??? Similar to the above. */
4653 case WIDEN_SUM_EXPR
:
4654 case WIDEN_LSHIFT_EXPR
:
4655 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
4656 && SCALAR_INT_MODE_P (mode
))
4659 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4661 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
4663 return simplify_gen_binary (TREE_CODE (exp
) == WIDEN_LSHIFT_EXPR
4664 ? ASHIFT
: PLUS
, mode
, op0
, op1
);
4669 return simplify_gen_ternary (FMA
, mode
, inner_mode
, op0
, op1
, op2
);
4673 #ifdef ENABLE_CHECKING
4682 /* Return an RTX equivalent to the source bind value of the tree expression
4686 expand_debug_source_expr (tree exp
)
4689 enum machine_mode mode
= VOIDmode
, inner_mode
;
4691 switch (TREE_CODE (exp
))
4695 mode
= DECL_MODE (exp
);
4696 op0
= expand_debug_parm_decl (exp
);
4699 /* See if this isn't an argument that has been completely
4701 if (!DECL_RTL_SET_P (exp
)
4702 && !DECL_INCOMING_RTL (exp
)
4703 && DECL_ABSTRACT_ORIGIN (current_function_decl
))
4705 tree aexp
= DECL_ORIGIN (exp
);
4706 if (DECL_CONTEXT (aexp
)
4707 == DECL_ABSTRACT_ORIGIN (current_function_decl
))
4709 vec
<tree
, va_gc
> **debug_args
;
4712 debug_args
= decl_debug_args_lookup (current_function_decl
);
4713 if (debug_args
!= NULL
)
4715 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, &ddecl
);
4718 return gen_rtx_DEBUG_PARAMETER_REF (mode
, aexp
);
4728 if (op0
== NULL_RTX
)
4731 inner_mode
= GET_MODE (op0
);
4732 if (mode
== inner_mode
)
4735 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
4737 if (GET_MODE_BITSIZE (mode
) == GET_MODE_BITSIZE (inner_mode
))
4738 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
4739 else if (GET_MODE_BITSIZE (mode
) < GET_MODE_BITSIZE (inner_mode
))
4740 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
4742 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
4744 else if (FLOAT_MODE_P (mode
))
4746 else if (FLOAT_MODE_P (inner_mode
))
4748 if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
4749 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
4751 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
4753 else if (CONSTANT_P (op0
)
4754 || GET_MODE_BITSIZE (mode
) <= GET_MODE_BITSIZE (inner_mode
))
4755 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
,
4756 subreg_lowpart_offset (mode
, inner_mode
));
4757 else if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
4758 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
4760 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
4765 /* Ensure INSN_VAR_LOCATION_LOC (insn) doesn't have unbound complexity.
4766 Allow 4 levels of rtl nesting for most rtl codes, and if we see anything
4767 deeper than that, create DEBUG_EXPRs and emit DEBUG_INSNs before INSN. */
4770 avoid_complex_debug_insns (rtx insn
, rtx
*exp_p
, int depth
)
4774 if (exp
== NULL_RTX
)
4777 if ((OBJECT_P (exp
) && !MEM_P (exp
)) || GET_CODE (exp
) == CLOBBER
)
4782 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
4783 rtx dval
= make_debug_expr_from_rtl (exp
);
4785 /* Emit a debug bind insn before INSN. */
4786 rtx bind
= gen_rtx_VAR_LOCATION (GET_MODE (exp
),
4787 DEBUG_EXPR_TREE_DECL (dval
), exp
,
4788 VAR_INIT_STATUS_INITIALIZED
);
4790 emit_debug_insn_before (bind
, insn
);
4795 const char *format_ptr
= GET_RTX_FORMAT (GET_CODE (exp
));
4797 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
4798 switch (*format_ptr
++)
4801 avoid_complex_debug_insns (insn
, &XEXP (exp
, i
), depth
+ 1);
4806 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4807 avoid_complex_debug_insns (insn
, &XVECEXP (exp
, i
, j
), depth
+ 1);
4815 /* Expand the _LOCs in debug insns. We run this after expanding all
4816 regular insns, so that any variables referenced in the function
4817 will have their DECL_RTLs set. */
4820 expand_debug_locations (void)
4823 rtx last
= get_last_insn ();
4824 int save_strict_alias
= flag_strict_aliasing
;
4826 /* New alias sets while setting up memory attributes cause
4827 -fcompare-debug failures, even though it doesn't bring about any
4829 flag_strict_aliasing
= 0;
4831 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
4832 if (DEBUG_INSN_P (insn
))
4834 tree value
= (tree
)INSN_VAR_LOCATION_LOC (insn
);
4835 rtx val
, prev_insn
, insn2
;
4836 enum machine_mode mode
;
4838 if (value
== NULL_TREE
)
4842 if (INSN_VAR_LOCATION_STATUS (insn
)
4843 == VAR_INIT_STATUS_UNINITIALIZED
)
4844 val
= expand_debug_source_expr (value
);
4846 val
= expand_debug_expr (value
);
4847 gcc_assert (last
== get_last_insn ());
4851 val
= gen_rtx_UNKNOWN_VAR_LOC ();
4854 mode
= GET_MODE (INSN_VAR_LOCATION (insn
));
4856 gcc_assert (mode
== GET_MODE (val
)
4857 || (GET_MODE (val
) == VOIDmode
4858 && (CONST_SCALAR_INT_P (val
)
4859 || GET_CODE (val
) == CONST_FIXED
4860 || GET_CODE (val
) == LABEL_REF
)));
4863 INSN_VAR_LOCATION_LOC (insn
) = val
;
4864 prev_insn
= PREV_INSN (insn
);
4865 for (insn2
= insn
; insn2
!= prev_insn
; insn2
= PREV_INSN (insn2
))
4866 avoid_complex_debug_insns (insn2
, &INSN_VAR_LOCATION_LOC (insn2
), 0);
4869 flag_strict_aliasing
= save_strict_alias
;
4872 /* Expand basic block BB from GIMPLE trees to RTL. */
4875 expand_gimple_basic_block (basic_block bb
, bool disable_tail_calls
)
4877 gimple_stmt_iterator gsi
;
4886 fprintf (dump_file
, "\n;; Generating RTL for gimple basic block %d\n",
4889 /* Note that since we are now transitioning from GIMPLE to RTL, we
4890 cannot use the gsi_*_bb() routines because they expect the basic
4891 block to be in GIMPLE, instead of RTL. Therefore, we need to
4892 access the BB sequence directly. */
4893 stmts
= bb_seq (bb
);
4894 bb
->il
.gimple
.seq
= NULL
;
4895 bb
->il
.gimple
.phi_nodes
= NULL
;
4896 rtl_profile_for_bb (bb
);
4897 init_rtl_bb_info (bb
);
4898 bb
->flags
|= BB_RTL
;
4900 /* Remove the RETURN_EXPR if we may fall though to the exit
4902 gsi
= gsi_last (stmts
);
4903 if (!gsi_end_p (gsi
)
4904 && gimple_code (gsi_stmt (gsi
)) == GIMPLE_RETURN
)
4906 gimple ret_stmt
= gsi_stmt (gsi
);
4908 gcc_assert (single_succ_p (bb
));
4909 gcc_assert (single_succ (bb
) == EXIT_BLOCK_PTR_FOR_FN (cfun
));
4911 if (bb
->next_bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
)
4912 && !gimple_return_retval (ret_stmt
))
4914 gsi_remove (&gsi
, false);
4915 single_succ_edge (bb
)->flags
|= EDGE_FALLTHRU
;
4919 gsi
= gsi_start (stmts
);
4920 if (!gsi_end_p (gsi
))
4922 stmt
= gsi_stmt (gsi
);
4923 if (gimple_code (stmt
) != GIMPLE_LABEL
)
4927 elt
= pointer_map_contains (lab_rtx_for_bb
, bb
);
4931 last
= get_last_insn ();
4935 expand_gimple_stmt (stmt
);
4940 emit_label ((rtx
) *elt
);
4942 /* Java emits line number notes in the top of labels.
4943 ??? Make this go away once line number notes are obsoleted. */
4944 BB_HEAD (bb
) = NEXT_INSN (last
);
4945 if (NOTE_P (BB_HEAD (bb
)))
4946 BB_HEAD (bb
) = NEXT_INSN (BB_HEAD (bb
));
4947 note
= emit_note_after (NOTE_INSN_BASIC_BLOCK
, BB_HEAD (bb
));
4949 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
4952 note
= BB_HEAD (bb
) = emit_note (NOTE_INSN_BASIC_BLOCK
);
4954 NOTE_BASIC_BLOCK (note
) = bb
;
4956 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
4960 stmt
= gsi_stmt (gsi
);
4962 /* If this statement is a non-debug one, and we generate debug
4963 insns, then this one might be the last real use of a TERed
4964 SSA_NAME, but where there are still some debug uses further
4965 down. Expanding the current SSA name in such further debug
4966 uses by their RHS might lead to wrong debug info, as coalescing
4967 might make the operands of such RHS be placed into the same
4968 pseudo as something else. Like so:
4969 a_1 = a_0 + 1; // Assume a_1 is TERed and a_0 is dead
4973 As a_0 and a_2 don't overlap in lifetime, assume they are coalesced.
4974 If we now would expand a_1 by it's RHS (a_0 + 1) in the debug use,
4975 the write to a_2 would actually have clobbered the place which
4978 So, instead of that, we recognize the situation, and generate
4979 debug temporaries at the last real use of TERed SSA names:
4986 if (MAY_HAVE_DEBUG_INSNS
4988 && !is_gimple_debug (stmt
))
4994 location_t sloc
= curr_insn_location ();
4996 /* Look for SSA names that have their last use here (TERed
4997 names always have only one real use). */
4998 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
)
4999 if ((def
= get_gimple_for_ssa_name (op
)))
5001 imm_use_iterator imm_iter
;
5002 use_operand_p use_p
;
5003 bool have_debug_uses
= false;
5005 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, op
)
5007 if (gimple_debug_bind_p (USE_STMT (use_p
)))
5009 have_debug_uses
= true;
5014 if (have_debug_uses
)
5016 /* OP is a TERed SSA name, with DEF it's defining
5017 statement, and where OP is used in further debug
5018 instructions. Generate a debug temporary, and
5019 replace all uses of OP in debug insns with that
5022 tree value
= gimple_assign_rhs_to_tree (def
);
5023 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
5025 enum machine_mode mode
;
5027 set_curr_insn_location (gimple_location (def
));
5029 DECL_ARTIFICIAL (vexpr
) = 1;
5030 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
5032 mode
= DECL_MODE (value
);
5034 mode
= TYPE_MODE (TREE_TYPE (value
));
5035 DECL_MODE (vexpr
) = mode
;
5037 val
= gen_rtx_VAR_LOCATION
5038 (mode
, vexpr
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5040 emit_debug_insn (val
);
5042 FOR_EACH_IMM_USE_STMT (debugstmt
, imm_iter
, op
)
5044 if (!gimple_debug_bind_p (debugstmt
))
5047 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
5048 SET_USE (use_p
, vexpr
);
5050 update_stmt (debugstmt
);
5054 set_curr_insn_location (sloc
);
5057 currently_expanding_gimple_stmt
= stmt
;
5059 /* Expand this statement, then evaluate the resulting RTL and
5060 fixup the CFG accordingly. */
5061 if (gimple_code (stmt
) == GIMPLE_COND
)
5063 new_bb
= expand_gimple_cond (bb
, stmt
);
5067 else if (gimple_debug_bind_p (stmt
))
5069 location_t sloc
= curr_insn_location ();
5070 gimple_stmt_iterator nsi
= gsi
;
5074 tree var
= gimple_debug_bind_get_var (stmt
);
5077 enum machine_mode mode
;
5079 if (TREE_CODE (var
) != DEBUG_EXPR_DECL
5080 && TREE_CODE (var
) != LABEL_DECL
5081 && !target_for_debug_bind (var
))
5082 goto delink_debug_stmt
;
5084 if (gimple_debug_bind_has_value_p (stmt
))
5085 value
= gimple_debug_bind_get_value (stmt
);
5089 last
= get_last_insn ();
5091 set_curr_insn_location (gimple_location (stmt
));
5094 mode
= DECL_MODE (var
);
5096 mode
= TYPE_MODE (TREE_TYPE (var
));
5098 val
= gen_rtx_VAR_LOCATION
5099 (mode
, var
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5101 emit_debug_insn (val
);
5103 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5105 /* We can't dump the insn with a TREE where an RTX
5107 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
5108 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5109 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
5113 /* In order not to generate too many debug temporaries,
5114 we delink all uses of debug statements we already expanded.
5115 Therefore debug statements between definition and real
5116 use of TERed SSA names will continue to use the SSA name,
5117 and not be replaced with debug temps. */
5118 delink_stmt_imm_use (stmt
);
5122 if (gsi_end_p (nsi
))
5124 stmt
= gsi_stmt (nsi
);
5125 if (!gimple_debug_bind_p (stmt
))
5129 set_curr_insn_location (sloc
);
5131 else if (gimple_debug_source_bind_p (stmt
))
5133 location_t sloc
= curr_insn_location ();
5134 tree var
= gimple_debug_source_bind_get_var (stmt
);
5135 tree value
= gimple_debug_source_bind_get_value (stmt
);
5137 enum machine_mode mode
;
5139 last
= get_last_insn ();
5141 set_curr_insn_location (gimple_location (stmt
));
5143 mode
= DECL_MODE (var
);
5145 val
= gen_rtx_VAR_LOCATION (mode
, var
, (rtx
)value
,
5146 VAR_INIT_STATUS_UNINITIALIZED
);
5148 emit_debug_insn (val
);
5150 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5152 /* We can't dump the insn with a TREE where an RTX
5154 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
5155 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5156 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
5159 set_curr_insn_location (sloc
);
5163 if (is_gimple_call (stmt
)
5164 && gimple_call_tail_p (stmt
)
5165 && disable_tail_calls
)
5166 gimple_call_set_tail (stmt
, false);
5168 if (is_gimple_call (stmt
) && gimple_call_tail_p (stmt
))
5171 new_bb
= expand_gimple_tailcall (bb
, stmt
, &can_fallthru
);
5182 def_operand_p def_p
;
5183 def_p
= SINGLE_SSA_DEF_OPERAND (stmt
, SSA_OP_DEF
);
5187 /* Ignore this stmt if it is in the list of
5188 replaceable expressions. */
5190 && bitmap_bit_p (SA
.values
,
5191 SSA_NAME_VERSION (DEF_FROM_PTR (def_p
))))
5194 last
= expand_gimple_stmt (stmt
);
5195 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5200 currently_expanding_gimple_stmt
= NULL
;
5202 /* Expand implicit goto and convert goto_locus. */
5203 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5205 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
5206 set_curr_insn_location (e
->goto_locus
);
5207 if ((e
->flags
& EDGE_FALLTHRU
) && e
->dest
!= bb
->next_bb
)
5209 emit_jump (label_rtx_for_bb (e
->dest
));
5210 e
->flags
&= ~EDGE_FALLTHRU
;
5214 /* Expanded RTL can create a jump in the last instruction of block.
5215 This later might be assumed to be a jump to successor and break edge insertion.
5216 We need to insert dummy move to prevent this. PR41440. */
5217 if (single_succ_p (bb
)
5218 && (single_succ_edge (bb
)->flags
& EDGE_FALLTHRU
)
5219 && (last
= get_last_insn ())
5222 rtx dummy
= gen_reg_rtx (SImode
);
5223 emit_insn_after_noloc (gen_move_insn (dummy
, dummy
), last
, NULL
);
5226 do_pending_stack_adjust ();
5228 /* Find the block tail. The last insn in the block is the insn
5229 before a barrier and/or table jump insn. */
5230 last
= get_last_insn ();
5231 if (BARRIER_P (last
))
5232 last
= PREV_INSN (last
);
5233 if (JUMP_TABLE_DATA_P (last
))
5234 last
= PREV_INSN (PREV_INSN (last
));
5237 update_bb_for_insn (bb
);
5243 /* Create a basic block for initialization code. */
5246 construct_init_block (void)
5248 basic_block init_block
, first_block
;
5252 /* Multiple entry points not supported yet. */
5253 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
) == 1);
5254 init_rtl_bb_info (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5255 init_rtl_bb_info (EXIT_BLOCK_PTR_FOR_FN (cfun
));
5256 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
5257 EXIT_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
5259 e
= EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun
), 0);
5261 /* When entry edge points to first basic block, we don't need jump,
5262 otherwise we have to jump into proper target. */
5263 if (e
&& e
->dest
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
)
5265 tree label
= gimple_block_label (e
->dest
);
5267 emit_jump (label_rtx (label
));
5271 flags
= EDGE_FALLTHRU
;
5273 init_block
= create_basic_block (NEXT_INSN (get_insns ()),
5275 ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5276 init_block
->frequency
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
;
5277 init_block
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
5278 if (current_loops
&& ENTRY_BLOCK_PTR_FOR_FN (cfun
)->loop_father
)
5279 add_bb_to_loop (init_block
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
5282 first_block
= e
->dest
;
5283 redirect_edge_succ (e
, init_block
);
5284 e
= make_edge (init_block
, first_block
, flags
);
5287 e
= make_edge (init_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_FALLTHRU
);
5288 e
->probability
= REG_BR_PROB_BASE
;
5289 e
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
5291 update_bb_for_insn (init_block
);
5295 /* For each lexical block, set BLOCK_NUMBER to the depth at which it is
5296 found in the block tree. */
5299 set_block_levels (tree block
, int level
)
5303 BLOCK_NUMBER (block
) = level
;
5304 set_block_levels (BLOCK_SUBBLOCKS (block
), level
+ 1);
5305 block
= BLOCK_CHAIN (block
);
5309 /* Create a block containing landing pads and similar stuff. */
5312 construct_exit_block (void)
5314 rtx head
= get_last_insn ();
5316 basic_block exit_block
;
5320 basic_block prev_bb
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
;
5321 rtx orig_end
= BB_END (prev_bb
);
5323 rtl_profile_for_bb (EXIT_BLOCK_PTR_FOR_FN (cfun
));
5325 /* Make sure the locus is set to the end of the function, so that
5326 epilogue line numbers and warnings are set properly. */
5327 if (LOCATION_LOCUS (cfun
->function_end_locus
) != UNKNOWN_LOCATION
)
5328 input_location
= cfun
->function_end_locus
;
5330 /* Generate rtl for function exit. */
5331 expand_function_end ();
5333 end
= get_last_insn ();
5336 /* While emitting the function end we could move end of the last basic
5338 BB_END (prev_bb
) = orig_end
;
5339 while (NEXT_INSN (head
) && NOTE_P (NEXT_INSN (head
)))
5340 head
= NEXT_INSN (head
);
5341 /* But make sure exit_block starts with RETURN_LABEL, otherwise the
5342 bb frequency counting will be confused. Any instructions before that
5343 label are emitted for the case where PREV_BB falls through into the
5344 exit block, so append those instructions to prev_bb in that case. */
5345 if (NEXT_INSN (head
) != return_label
)
5347 while (NEXT_INSN (head
) != return_label
)
5349 if (!NOTE_P (NEXT_INSN (head
)))
5350 BB_END (prev_bb
) = NEXT_INSN (head
);
5351 head
= NEXT_INSN (head
);
5354 exit_block
= create_basic_block (NEXT_INSN (head
), end
, prev_bb
);
5355 exit_block
->frequency
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->frequency
;
5356 exit_block
->count
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
;
5357 if (current_loops
&& EXIT_BLOCK_PTR_FOR_FN (cfun
)->loop_father
)
5358 add_bb_to_loop (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
5361 while (ix
< EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
))
5363 e
= EDGE_PRED (EXIT_BLOCK_PTR_FOR_FN (cfun
), ix
);
5364 if (!(e
->flags
& EDGE_ABNORMAL
))
5365 redirect_edge_succ (e
, exit_block
);
5370 e
= make_edge (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_FALLTHRU
);
5371 e
->probability
= REG_BR_PROB_BASE
;
5372 e
->count
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
;
5373 FOR_EACH_EDGE (e2
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
5376 e
->count
-= e2
->count
;
5377 exit_block
->count
-= e2
->count
;
5378 exit_block
->frequency
-= EDGE_FREQUENCY (e2
);
5382 if (exit_block
->count
< 0)
5383 exit_block
->count
= 0;
5384 if (exit_block
->frequency
< 0)
5385 exit_block
->frequency
= 0;
5386 update_bb_for_insn (exit_block
);
5389 /* Helper function for discover_nonconstant_array_refs.
5390 Look for ARRAY_REF nodes with non-constant indexes and mark them
5394 discover_nonconstant_array_refs_r (tree
* tp
, int *walk_subtrees
,
5395 void *data ATTRIBUTE_UNUSED
)
5399 if (IS_TYPE_OR_DECL_P (t
))
5401 else if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5403 while (((TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5404 && is_gimple_min_invariant (TREE_OPERAND (t
, 1))
5405 && (!TREE_OPERAND (t
, 2)
5406 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
5407 || (TREE_CODE (t
) == COMPONENT_REF
5408 && (!TREE_OPERAND (t
,2)
5409 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
5410 || TREE_CODE (t
) == BIT_FIELD_REF
5411 || TREE_CODE (t
) == REALPART_EXPR
5412 || TREE_CODE (t
) == IMAGPART_EXPR
5413 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5414 || CONVERT_EXPR_P (t
))
5415 t
= TREE_OPERAND (t
, 0);
5417 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5419 t
= get_base_address (t
);
5421 && DECL_MODE (t
) != BLKmode
)
5422 TREE_ADDRESSABLE (t
) = 1;
5431 /* RTL expansion is not able to compile array references with variable
5432 offsets for arrays stored in single register. Discover such
5433 expressions and mark variables as addressable to avoid this
5437 discover_nonconstant_array_refs (void)
5440 gimple_stmt_iterator gsi
;
5442 FOR_EACH_BB_FN (bb
, cfun
)
5443 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5445 gimple stmt
= gsi_stmt (gsi
);
5446 if (!is_gimple_debug (stmt
))
5447 walk_gimple_op (stmt
, discover_nonconstant_array_refs_r
, NULL
);
5451 /* This function sets crtl->args.internal_arg_pointer to a virtual
5452 register if DRAP is needed. Local register allocator will replace
5453 virtual_incoming_args_rtx with the virtual register. */
5456 expand_stack_alignment (void)
5459 unsigned int preferred_stack_boundary
;
5461 if (! SUPPORTS_STACK_ALIGNMENT
)
5464 if (cfun
->calls_alloca
5465 || cfun
->has_nonlocal_label
5466 || crtl
->has_nonlocal_goto
)
5467 crtl
->need_drap
= true;
5469 /* Call update_stack_boundary here again to update incoming stack
5470 boundary. It may set incoming stack alignment to a different
5471 value after RTL expansion. TARGET_FUNCTION_OK_FOR_SIBCALL may
5472 use the minimum incoming stack alignment to check if it is OK
5473 to perform sibcall optimization since sibcall optimization will
5474 only align the outgoing stack to incoming stack boundary. */
5475 if (targetm
.calls
.update_stack_boundary
)
5476 targetm
.calls
.update_stack_boundary ();
5478 /* The incoming stack frame has to be aligned at least at
5479 parm_stack_boundary. */
5480 gcc_assert (crtl
->parm_stack_boundary
<= INCOMING_STACK_BOUNDARY
);
5482 /* Update crtl->stack_alignment_estimated and use it later to align
5483 stack. We check PREFERRED_STACK_BOUNDARY if there may be non-call
5484 exceptions since callgraph doesn't collect incoming stack alignment
5486 if (cfun
->can_throw_non_call_exceptions
5487 && PREFERRED_STACK_BOUNDARY
> crtl
->preferred_stack_boundary
)
5488 preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
5490 preferred_stack_boundary
= crtl
->preferred_stack_boundary
;
5491 if (preferred_stack_boundary
> crtl
->stack_alignment_estimated
)
5492 crtl
->stack_alignment_estimated
= preferred_stack_boundary
;
5493 if (preferred_stack_boundary
> crtl
->stack_alignment_needed
)
5494 crtl
->stack_alignment_needed
= preferred_stack_boundary
;
5496 gcc_assert (crtl
->stack_alignment_needed
5497 <= crtl
->stack_alignment_estimated
);
5499 crtl
->stack_realign_needed
5500 = INCOMING_STACK_BOUNDARY
< crtl
->stack_alignment_estimated
;
5501 crtl
->stack_realign_tried
= crtl
->stack_realign_needed
;
5503 crtl
->stack_realign_processed
= true;
5505 /* Target has to redefine TARGET_GET_DRAP_RTX to support stack
5507 gcc_assert (targetm
.calls
.get_drap_rtx
!= NULL
);
5508 drap_rtx
= targetm
.calls
.get_drap_rtx ();
5510 /* stack_realign_drap and drap_rtx must match. */
5511 gcc_assert ((stack_realign_drap
!= 0) == (drap_rtx
!= NULL
));
5513 /* Do nothing if NULL is returned, which means DRAP is not needed. */
5514 if (NULL
!= drap_rtx
)
5516 crtl
->args
.internal_arg_pointer
= drap_rtx
;
5518 /* Call fixup_tail_calls to clean up REG_EQUIV note if DRAP is
5520 fixup_tail_calls ();
5526 expand_main_function (void)
5528 #if (defined(INVOKE__main) \
5529 || (!defined(HAS_INIT_SECTION) \
5530 && !defined(INIT_SECTION_ASM_OP) \
5531 && !defined(INIT_ARRAY_SECTION_ASM_OP)))
5532 emit_library_call (init_one_libfunc (NAME__MAIN
), LCT_NORMAL
, VOIDmode
, 0);
5537 /* Expand code to initialize the stack_protect_guard. This is invoked at
5538 the beginning of a function to be protected. */
5540 #ifndef HAVE_stack_protect_set
5541 # define HAVE_stack_protect_set 0
5542 # define gen_stack_protect_set(x,y) (gcc_unreachable (), NULL_RTX)
5546 stack_protect_prologue (void)
5548 tree guard_decl
= targetm
.stack_protect_guard ();
5551 x
= expand_normal (crtl
->stack_protect_guard
);
5552 y
= expand_normal (guard_decl
);
5554 /* Allow the target to copy from Y to X without leaking Y into a
5556 if (HAVE_stack_protect_set
)
5558 rtx insn
= gen_stack_protect_set (x
, y
);
5566 /* Otherwise do a straight move. */
5567 emit_move_insn (x
, y
);
5570 /* Translate the intermediate representation contained in the CFG
5571 from GIMPLE trees to RTL.
5573 We do conversion per basic block and preserve/update the tree CFG.
5574 This implies we have to do some magic as the CFG can simultaneously
5575 consist of basic blocks containing RTL and GIMPLE trees. This can
5576 confuse the CFG hooks, so be careful to not manipulate CFG during
5581 const pass_data pass_data_expand
=
5583 RTL_PASS
, /* type */
5584 "expand", /* name */
5585 OPTGROUP_NONE
, /* optinfo_flags */
5586 true, /* has_execute */
5587 TV_EXPAND
, /* tv_id */
5588 ( PROP_ssa
| PROP_gimple_leh
| PROP_cfg
5590 | PROP_gimple_lvec
), /* properties_required */
5591 PROP_rtl
, /* properties_provided */
5592 ( PROP_ssa
| PROP_trees
), /* properties_destroyed */
5593 0, /* todo_flags_start */
5594 0, /* todo_flags_finish */
5597 class pass_expand
: public rtl_opt_pass
5600 pass_expand (gcc::context
*ctxt
)
5601 : rtl_opt_pass (pass_data_expand
, ctxt
)
5604 /* opt_pass methods: */
5605 virtual unsigned int execute (function
*);
5607 }; // class pass_expand
5610 pass_expand::execute (function
*fun
)
5612 basic_block bb
, init_block
;
5616 rtx var_seq
, var_ret_seq
;
5619 timevar_push (TV_OUT_OF_SSA
);
5620 rewrite_out_of_ssa (&SA
);
5621 timevar_pop (TV_OUT_OF_SSA
);
5622 SA
.partition_to_pseudo
= XCNEWVEC (rtx
, SA
.map
->num_partitions
);
5624 /* Make sure all values used by the optimization passes have sane
5628 /* Some backends want to know that we are expanding to RTL. */
5629 currently_expanding_to_rtl
= 1;
5630 /* Dominators are not kept up-to-date as we may create new basic-blocks. */
5631 free_dominance_info (CDI_DOMINATORS
);
5633 rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (fun
));
5635 insn_locations_init ();
5636 if (!DECL_IS_BUILTIN (current_function_decl
))
5638 /* Eventually, all FEs should explicitly set function_start_locus. */
5639 if (LOCATION_LOCUS (fun
->function_start_locus
) == UNKNOWN_LOCATION
)
5640 set_curr_insn_location
5641 (DECL_SOURCE_LOCATION (current_function_decl
));
5643 set_curr_insn_location (fun
->function_start_locus
);
5646 set_curr_insn_location (UNKNOWN_LOCATION
);
5647 prologue_location
= curr_insn_location ();
5649 #ifdef INSN_SCHEDULING
5650 init_sched_attrs ();
5653 /* Make sure first insn is a note even if we don't want linenums.
5654 This makes sure the first insn will never be deleted.
5655 Also, final expects a note to appear there. */
5656 emit_note (NOTE_INSN_DELETED
);
5658 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
5659 discover_nonconstant_array_refs ();
5661 targetm
.expand_to_rtl_hook ();
5662 crtl
->stack_alignment_needed
= STACK_BOUNDARY
;
5663 crtl
->max_used_stack_slot_alignment
= STACK_BOUNDARY
;
5664 crtl
->stack_alignment_estimated
= 0;
5665 crtl
->preferred_stack_boundary
= STACK_BOUNDARY
;
5666 fun
->cfg
->max_jumptable_ents
= 0;
5668 /* Resovle the function section. Some targets, like ARM EABI rely on knowledge
5669 of the function section at exapnsion time to predict distance of calls. */
5670 resolve_unique_section (current_function_decl
, 0, flag_function_sections
);
5672 /* Expand the variables recorded during gimple lowering. */
5673 timevar_push (TV_VAR_EXPAND
);
5676 var_ret_seq
= expand_used_vars ();
5678 var_seq
= get_insns ();
5680 timevar_pop (TV_VAR_EXPAND
);
5682 /* Honor stack protection warnings. */
5683 if (warn_stack_protect
)
5685 if (fun
->calls_alloca
)
5686 warning (OPT_Wstack_protector
,
5687 "stack protector not protecting local variables: "
5688 "variable length buffer");
5689 if (has_short_buffer
&& !crtl
->stack_protect_guard
)
5690 warning (OPT_Wstack_protector
,
5691 "stack protector not protecting function: "
5692 "all local arrays are less than %d bytes long",
5693 (int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
));
5696 /* Set up parameters and prepare for return, for the function. */
5697 expand_function_start (current_function_decl
);
5699 /* If we emitted any instructions for setting up the variables,
5700 emit them before the FUNCTION_START note. */
5703 emit_insn_before (var_seq
, parm_birth_insn
);
5705 /* In expand_function_end we'll insert the alloca save/restore
5706 before parm_birth_insn. We've just insertted an alloca call.
5707 Adjust the pointer to match. */
5708 parm_birth_insn
= var_seq
;
5711 /* Now that we also have the parameter RTXs, copy them over to our
5713 for (i
= 0; i
< SA
.map
->num_partitions
; i
++)
5715 tree var
= SSA_NAME_VAR (partition_to_var (SA
.map
, i
));
5717 if (TREE_CODE (var
) != VAR_DECL
5718 && !SA
.partition_to_pseudo
[i
])
5719 SA
.partition_to_pseudo
[i
] = DECL_RTL_IF_SET (var
);
5720 gcc_assert (SA
.partition_to_pseudo
[i
]);
5722 /* If this decl was marked as living in multiple places, reset
5723 this now to NULL. */
5724 if (DECL_RTL_IF_SET (var
) == pc_rtx
)
5725 SET_DECL_RTL (var
, NULL
);
5727 /* Some RTL parts really want to look at DECL_RTL(x) when x
5728 was a decl marked in REG_ATTR or MEM_ATTR. We could use
5729 SET_DECL_RTL here making this available, but that would mean
5730 to select one of the potentially many RTLs for one DECL. Instead
5731 of doing that we simply reset the MEM_EXPR of the RTL in question,
5732 then nobody can get at it and hence nobody can call DECL_RTL on it. */
5733 if (!DECL_RTL_SET_P (var
))
5735 if (MEM_P (SA
.partition_to_pseudo
[i
]))
5736 set_mem_expr (SA
.partition_to_pseudo
[i
], NULL
);
5740 /* If we have a class containing differently aligned pointers
5741 we need to merge those into the corresponding RTL pointer
5743 for (i
= 1; i
< num_ssa_names
; i
++)
5745 tree name
= ssa_name (i
);
5750 /* We might have generated new SSA names in
5751 update_alias_info_with_stack_vars. They will have a NULL
5752 defining statements, and won't be part of the partitioning,
5754 || !SSA_NAME_DEF_STMT (name
))
5756 part
= var_to_partition (SA
.map
, name
);
5757 if (part
== NO_PARTITION
)
5760 /* Adjust all partition members to get the underlying decl of
5761 the representative which we might have created in expand_one_var. */
5762 if (SSA_NAME_VAR (name
) == NULL_TREE
)
5764 tree leader
= partition_to_var (SA
.map
, part
);
5765 gcc_assert (SSA_NAME_VAR (leader
) != NULL_TREE
);
5766 replace_ssa_name_symbol (name
, SSA_NAME_VAR (leader
));
5768 if (!POINTER_TYPE_P (TREE_TYPE (name
)))
5771 r
= SA
.partition_to_pseudo
[part
];
5773 mark_reg_pointer (r
, get_pointer_alignment (name
));
5776 /* If this function is `main', emit a call to `__main'
5777 to run global initializers, etc. */
5778 if (DECL_NAME (current_function_decl
)
5779 && MAIN_NAME_P (DECL_NAME (current_function_decl
))
5780 && DECL_FILE_SCOPE_P (current_function_decl
))
5781 expand_main_function ();
5783 /* Initialize the stack_protect_guard field. This must happen after the
5784 call to __main (if any) so that the external decl is initialized. */
5785 if (crtl
->stack_protect_guard
)
5786 stack_protect_prologue ();
5788 expand_phi_nodes (&SA
);
5790 /* Register rtl specific functions for cfg. */
5791 rtl_register_cfg_hooks ();
5793 init_block
= construct_init_block ();
5795 /* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
5796 remaining edges later. */
5797 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->succs
)
5798 e
->flags
&= ~EDGE_EXECUTABLE
;
5800 lab_rtx_for_bb
= pointer_map_create ();
5801 FOR_BB_BETWEEN (bb
, init_block
->next_bb
, EXIT_BLOCK_PTR_FOR_FN (fun
),
5803 bb
= expand_gimple_basic_block (bb
, var_ret_seq
!= NULL_RTX
);
5805 if (MAY_HAVE_DEBUG_INSNS
)
5806 expand_debug_locations ();
5808 /* Free stuff we no longer need after GIMPLE optimizations. */
5809 free_dominance_info (CDI_DOMINATORS
);
5810 free_dominance_info (CDI_POST_DOMINATORS
);
5811 delete_tree_cfg_annotations ();
5813 timevar_push (TV_OUT_OF_SSA
);
5814 finish_out_of_ssa (&SA
);
5815 timevar_pop (TV_OUT_OF_SSA
);
5817 timevar_push (TV_POST_EXPAND
);
5818 /* We are no longer in SSA form. */
5819 fun
->gimple_df
->in_ssa_p
= false;
5821 loops_state_clear (LOOP_CLOSED_SSA
);
5823 /* Expansion is used by optimization passes too, set maybe_hot_insn_p
5824 conservatively to true until they are all profile aware. */
5825 pointer_map_destroy (lab_rtx_for_bb
);
5828 construct_exit_block ();
5829 insn_locations_finalize ();
5833 rtx after
= return_label
;
5834 rtx next
= NEXT_INSN (after
);
5835 if (next
&& NOTE_INSN_BASIC_BLOCK_P (next
))
5837 emit_insn_after (var_ret_seq
, after
);
5840 /* Zap the tree EH table. */
5841 set_eh_throw_stmt_table (fun
, NULL
);
5843 /* We need JUMP_LABEL be set in order to redirect jumps, and hence
5844 split edges which edge insertions might do. */
5845 rebuild_jump_labels (get_insns ());
5847 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (fun
),
5848 EXIT_BLOCK_PTR_FOR_FN (fun
), next_bb
)
5852 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
5856 rebuild_jump_labels_chain (e
->insns
.r
);
5857 /* Put insns after parm birth, but before
5858 NOTE_INSNS_FUNCTION_BEG. */
5859 if (e
->src
== ENTRY_BLOCK_PTR_FOR_FN (fun
)
5860 && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (fun
)))
5862 rtx insns
= e
->insns
.r
;
5863 e
->insns
.r
= NULL_RTX
;
5864 if (NOTE_P (parm_birth_insn
)
5865 && NOTE_KIND (parm_birth_insn
) == NOTE_INSN_FUNCTION_BEG
)
5866 emit_insn_before_noloc (insns
, parm_birth_insn
, e
->dest
);
5868 emit_insn_after_noloc (insns
, parm_birth_insn
, e
->dest
);
5871 commit_one_edge_insertion (e
);
5878 /* We're done expanding trees to RTL. */
5879 currently_expanding_to_rtl
= 0;
5881 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->next_bb
,
5882 EXIT_BLOCK_PTR_FOR_FN (fun
), next_bb
)
5886 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
5888 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
5889 e
->flags
&= ~EDGE_EXECUTABLE
;
5891 /* At the moment not all abnormal edges match the RTL
5892 representation. It is safe to remove them here as
5893 find_many_sub_basic_blocks will rediscover them.
5894 In the future we should get this fixed properly. */
5895 if ((e
->flags
& EDGE_ABNORMAL
)
5896 && !(e
->flags
& EDGE_SIBCALL
))
5903 blocks
= sbitmap_alloc (last_basic_block_for_fn (fun
));
5904 bitmap_ones (blocks
);
5905 find_many_sub_basic_blocks (blocks
);
5906 sbitmap_free (blocks
);
5907 purge_all_dead_edges ();
5909 expand_stack_alignment ();
5911 /* Fixup REG_EQUIV notes in the prologue if there are tailcalls in this
5913 if (crtl
->tail_call_emit
)
5914 fixup_tail_calls ();
5916 /* After initial rtl generation, call back to finish generating
5917 exception support code. We need to do this before cleaning up
5918 the CFG as the code does not expect dead landing pads. */
5919 if (fun
->eh
->region_tree
!= NULL
)
5920 finish_eh_generation ();
5922 /* Remove unreachable blocks, otherwise we cannot compute dominators
5923 which are needed for loop state verification. As a side-effect
5924 this also compacts blocks.
5925 ??? We cannot remove trivially dead insns here as for example
5926 the DRAP reg on i?86 is not magically live at this point.
5927 gcc.c-torture/execute/ipa-sra-2.c execution, -Os -m32 fails otherwise. */
5928 cleanup_cfg (CLEANUP_NO_INSN_DEL
);
5930 #ifdef ENABLE_CHECKING
5931 verify_flow_info ();
5934 /* Initialize pseudos allocated for hard registers. */
5935 emit_initial_value_sets ();
5937 /* And finally unshare all RTL. */
5940 /* There's no need to defer outputting this function any more; we
5941 know we want to output it. */
5942 DECL_DEFER_OUTPUT (current_function_decl
) = 0;
5944 /* Now that we're done expanding trees to RTL, we shouldn't have any
5945 more CONCATs anywhere. */
5946 generating_concat_p
= 0;
5951 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
5952 /* And the pass manager will dump RTL for us. */
5955 /* If we're emitting a nested function, make sure its parent gets
5956 emitted as well. Doing otherwise confuses debug info. */
5959 for (parent
= DECL_CONTEXT (current_function_decl
);
5960 parent
!= NULL_TREE
;
5961 parent
= get_containing_scope (parent
))
5962 if (TREE_CODE (parent
) == FUNCTION_DECL
)
5963 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent
)) = 1;
5966 /* We are now committed to emitting code for this function. Do any
5967 preparation, such as emitting abstract debug info for the inline
5968 before it gets mangled by optimization. */
5969 if (cgraph_function_possibly_inlined_p (current_function_decl
))
5970 (*debug_hooks
->outlining_inline_function
) (current_function_decl
);
5972 TREE_ASM_WRITTEN (current_function_decl
) = 1;
5974 /* After expanding, the return labels are no longer needed. */
5975 return_label
= NULL
;
5976 naked_return_label
= NULL
;
5978 /* After expanding, the tm_restart map is no longer needed. */
5979 if (fun
->gimple_df
->tm_restart
)
5981 htab_delete (fun
->gimple_df
->tm_restart
);
5982 fun
->gimple_df
->tm_restart
= NULL
;
5985 /* Tag the blocks with a depth number so that change_scope can find
5986 the common parent easily. */
5987 set_block_levels (DECL_INITIAL (fun
->decl
), 0);
5988 default_rtl_profile ();
5990 timevar_pop (TV_POST_EXPAND
);
5998 make_pass_expand (gcc::context
*ctxt
)
6000 return new pass_expand (ctxt
);