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
;
1018 offset
= alloc_stack_frame_space (stack_vars
[i
].size
, alignb
);
1019 base_align
= crtl
->max_used_stack_slot_alignment
;
1023 /* Large alignment is only processed in the last pass. */
1026 gcc_assert (large_base
!= NULL
);
1028 large_alloc
+= alignb
- 1;
1029 large_alloc
&= -(HOST_WIDE_INT
)alignb
;
1030 offset
= large_alloc
;
1031 large_alloc
+= stack_vars
[i
].size
;
1034 base_align
= large_align
;
1037 /* Create rtl for each variable based on their location within the
1039 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1041 expand_one_stack_var_at (stack_vars
[j
].decl
,
1047 gcc_assert (large_alloc
== large_size
);
1050 /* Take into account all sizes of partitions and reset DECL_RTLs. */
1051 static HOST_WIDE_INT
1052 account_stack_vars (void)
1054 size_t si
, j
, i
, n
= stack_vars_num
;
1055 HOST_WIDE_INT size
= 0;
1057 for (si
= 0; si
< n
; ++si
)
1059 i
= stack_vars_sorted
[si
];
1061 /* Skip variables that aren't partition representatives, for now. */
1062 if (stack_vars
[i
].representative
!= i
)
1065 size
+= stack_vars
[i
].size
;
1066 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1067 set_rtl (stack_vars
[j
].decl
, NULL
);
1072 /* A subroutine of expand_one_var. Called to immediately assign rtl
1073 to a variable to be allocated in the stack frame. */
1076 expand_one_stack_var (tree var
)
1078 HOST_WIDE_INT size
, offset
;
1079 unsigned byte_align
;
1081 size
= tree_to_uhwi (DECL_SIZE_UNIT (SSAVAR (var
)));
1082 byte_align
= align_local_variable (SSAVAR (var
));
1084 /* We handle highly aligned variables in expand_stack_vars. */
1085 gcc_assert (byte_align
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
);
1087 offset
= alloc_stack_frame_space (size
, byte_align
);
1089 expand_one_stack_var_at (var
, virtual_stack_vars_rtx
,
1090 crtl
->max_used_stack_slot_alignment
, offset
);
1093 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1094 that will reside in a hard register. */
1097 expand_one_hard_reg_var (tree var
)
1099 rest_of_decl_compilation (var
, 0, 0);
1102 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1103 that will reside in a pseudo register. */
1106 expand_one_register_var (tree var
)
1108 tree decl
= SSAVAR (var
);
1109 tree type
= TREE_TYPE (decl
);
1110 enum machine_mode reg_mode
= promote_decl_mode (decl
, NULL
);
1111 rtx x
= gen_reg_rtx (reg_mode
);
1115 /* Note if the object is a user variable. */
1116 if (!DECL_ARTIFICIAL (decl
))
1119 if (POINTER_TYPE_P (type
))
1120 mark_reg_pointer (x
, get_pointer_alignment (var
));
1123 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
1124 has some associated error, e.g. its type is error-mark. We just need
1125 to pick something that won't crash the rest of the compiler. */
1128 expand_one_error_var (tree var
)
1130 enum machine_mode mode
= DECL_MODE (var
);
1133 if (mode
== BLKmode
)
1134 x
= gen_rtx_MEM (BLKmode
, const0_rtx
);
1135 else if (mode
== VOIDmode
)
1138 x
= gen_reg_rtx (mode
);
1140 SET_DECL_RTL (var
, x
);
1143 /* A subroutine of expand_one_var. VAR is a variable that will be
1144 allocated to the local stack frame. Return true if we wish to
1145 add VAR to STACK_VARS so that it will be coalesced with other
1146 variables. Return false to allocate VAR immediately.
1148 This function is used to reduce the number of variables considered
1149 for coalescing, which reduces the size of the quadratic problem. */
1152 defer_stack_allocation (tree var
, bool toplevel
)
1154 /* Whether the variable is small enough for immediate allocation not to be
1155 a problem with regard to the frame size. */
1157 = ((HOST_WIDE_INT
) tree_to_uhwi (DECL_SIZE_UNIT (var
))
1158 < PARAM_VALUE (PARAM_MIN_SIZE_FOR_STACK_SHARING
));
1160 /* If stack protection is enabled, *all* stack variables must be deferred,
1161 so that we can re-order the strings to the top of the frame.
1162 Similarly for Address Sanitizer. */
1163 if (flag_stack_protect
|| ((flag_sanitize
& SANITIZE_ADDRESS
) && ASAN_STACK
))
1166 /* We handle "large" alignment via dynamic allocation. We want to handle
1167 this extra complication in only one place, so defer them. */
1168 if (DECL_ALIGN (var
) > MAX_SUPPORTED_STACK_ALIGNMENT
)
1171 /* When optimization is enabled, DECL_IGNORED_P variables originally scoped
1172 might be detached from their block and appear at toplevel when we reach
1173 here. We want to coalesce them with variables from other blocks when
1174 the immediate contribution to the frame size would be noticeable. */
1175 if (toplevel
&& optimize
> 0 && DECL_IGNORED_P (var
) && !smallish
)
1178 /* Variables declared in the outermost scope automatically conflict
1179 with every other variable. The only reason to want to defer them
1180 at all is that, after sorting, we can more efficiently pack
1181 small variables in the stack frame. Continue to defer at -O2. */
1182 if (toplevel
&& optimize
< 2)
1185 /* Without optimization, *most* variables are allocated from the
1186 stack, which makes the quadratic problem large exactly when we
1187 want compilation to proceed as quickly as possible. On the
1188 other hand, we don't want the function's stack frame size to
1189 get completely out of hand. So we avoid adding scalars and
1190 "small" aggregates to the list at all. */
1191 if (optimize
== 0 && smallish
)
1197 /* A subroutine of expand_used_vars. Expand one variable according to
1198 its flavor. Variables to be placed on the stack are not actually
1199 expanded yet, merely recorded.
1200 When REALLY_EXPAND is false, only add stack values to be allocated.
1201 Return stack usage this variable is supposed to take.
1204 static HOST_WIDE_INT
1205 expand_one_var (tree var
, bool toplevel
, bool really_expand
)
1207 unsigned int align
= BITS_PER_UNIT
;
1212 if (TREE_TYPE (var
) != error_mark_node
&& TREE_CODE (var
) == VAR_DECL
)
1214 /* Because we don't know if VAR will be in register or on stack,
1215 we conservatively assume it will be on stack even if VAR is
1216 eventually put into register after RA pass. For non-automatic
1217 variables, which won't be on stack, we collect alignment of
1218 type and ignore user specified alignment. Similarly for
1219 SSA_NAMEs for which use_register_for_decl returns true. */
1220 if (TREE_STATIC (var
)
1221 || DECL_EXTERNAL (var
)
1222 || (TREE_CODE (origvar
) == SSA_NAME
&& use_register_for_decl (var
)))
1223 align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1224 TYPE_MODE (TREE_TYPE (var
)),
1225 TYPE_ALIGN (TREE_TYPE (var
)));
1226 else if (DECL_HAS_VALUE_EXPR_P (var
)
1227 || (DECL_RTL_SET_P (var
) && MEM_P (DECL_RTL (var
))))
1228 /* Don't consider debug only variables with DECL_HAS_VALUE_EXPR_P set
1229 or variables which were assigned a stack slot already by
1230 expand_one_stack_var_at - in the latter case DECL_ALIGN has been
1231 changed from the offset chosen to it. */
1232 align
= crtl
->stack_alignment_estimated
;
1234 align
= MINIMUM_ALIGNMENT (var
, DECL_MODE (var
), DECL_ALIGN (var
));
1236 /* If the variable alignment is very large we'll dynamicaly allocate
1237 it, which means that in-frame portion is just a pointer. */
1238 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1239 align
= POINTER_SIZE
;
1242 if (SUPPORTS_STACK_ALIGNMENT
1243 && crtl
->stack_alignment_estimated
< align
)
1245 /* stack_alignment_estimated shouldn't change after stack
1246 realign decision made */
1247 gcc_assert (!crtl
->stack_realign_processed
);
1248 crtl
->stack_alignment_estimated
= align
;
1251 /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
1252 So here we only make sure stack_alignment_needed >= align. */
1253 if (crtl
->stack_alignment_needed
< align
)
1254 crtl
->stack_alignment_needed
= align
;
1255 if (crtl
->max_used_stack_slot_alignment
< align
)
1256 crtl
->max_used_stack_slot_alignment
= align
;
1258 if (TREE_CODE (origvar
) == SSA_NAME
)
1260 gcc_assert (TREE_CODE (var
) != VAR_DECL
1261 || (!DECL_EXTERNAL (var
)
1262 && !DECL_HAS_VALUE_EXPR_P (var
)
1263 && !TREE_STATIC (var
)
1264 && TREE_TYPE (var
) != error_mark_node
1265 && !DECL_HARD_REGISTER (var
)
1268 if (TREE_CODE (var
) != VAR_DECL
&& TREE_CODE (origvar
) != SSA_NAME
)
1270 else if (DECL_EXTERNAL (var
))
1272 else if (DECL_HAS_VALUE_EXPR_P (var
))
1274 else if (TREE_STATIC (var
))
1276 else if (TREE_CODE (origvar
) != SSA_NAME
&& DECL_RTL_SET_P (var
))
1278 else if (TREE_TYPE (var
) == error_mark_node
)
1281 expand_one_error_var (var
);
1283 else if (TREE_CODE (var
) == VAR_DECL
&& DECL_HARD_REGISTER (var
))
1286 expand_one_hard_reg_var (var
);
1288 else if (use_register_for_decl (var
))
1291 expand_one_register_var (origvar
);
1293 else if (! valid_constant_size_p (DECL_SIZE_UNIT (var
)))
1295 /* Reject variables which cover more than half of the address-space. */
1298 error ("size of variable %q+D is too large", var
);
1299 expand_one_error_var (var
);
1302 else if (defer_stack_allocation (var
, toplevel
))
1303 add_stack_var (origvar
);
1307 expand_one_stack_var (origvar
);
1308 return tree_to_uhwi (DECL_SIZE_UNIT (var
));
1313 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1314 expanding variables. Those variables that can be put into registers
1315 are allocated pseudos; those that can't are put on the stack.
1317 TOPLEVEL is true if this is the outermost BLOCK. */
1320 expand_used_vars_for_block (tree block
, bool toplevel
)
1324 /* Expand all variables at this level. */
1325 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1327 && ((TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != RESULT_DECL
)
1328 || !DECL_NONSHAREABLE (t
)))
1329 expand_one_var (t
, toplevel
, true);
1331 /* Expand all variables at containing levels. */
1332 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1333 expand_used_vars_for_block (t
, false);
1336 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1337 and clear TREE_USED on all local variables. */
1340 clear_tree_used (tree block
)
1344 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1345 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
1346 if ((TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != RESULT_DECL
)
1347 || !DECL_NONSHAREABLE (t
))
1350 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1351 clear_tree_used (t
);
1355 SPCT_FLAG_DEFAULT
= 1,
1357 SPCT_FLAG_STRONG
= 3
1360 /* Examine TYPE and determine a bit mask of the following features. */
1362 #define SPCT_HAS_LARGE_CHAR_ARRAY 1
1363 #define SPCT_HAS_SMALL_CHAR_ARRAY 2
1364 #define SPCT_HAS_ARRAY 4
1365 #define SPCT_HAS_AGGREGATE 8
1368 stack_protect_classify_type (tree type
)
1370 unsigned int ret
= 0;
1373 switch (TREE_CODE (type
))
1376 t
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1377 if (t
== char_type_node
1378 || t
== signed_char_type_node
1379 || t
== unsigned_char_type_node
)
1381 unsigned HOST_WIDE_INT max
= PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
);
1382 unsigned HOST_WIDE_INT len
;
1384 if (!TYPE_SIZE_UNIT (type
)
1385 || !tree_fits_uhwi_p (TYPE_SIZE_UNIT (type
)))
1388 len
= tree_to_uhwi (TYPE_SIZE_UNIT (type
));
1391 ret
= SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1393 ret
= SPCT_HAS_LARGE_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1396 ret
= SPCT_HAS_ARRAY
;
1400 case QUAL_UNION_TYPE
:
1402 ret
= SPCT_HAS_AGGREGATE
;
1403 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
1404 if (TREE_CODE (t
) == FIELD_DECL
)
1405 ret
|= stack_protect_classify_type (TREE_TYPE (t
));
1415 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
1416 part of the local stack frame. Remember if we ever return nonzero for
1417 any variable in this function. The return value is the phase number in
1418 which the variable should be allocated. */
1421 stack_protect_decl_phase (tree decl
)
1423 unsigned int bits
= stack_protect_classify_type (TREE_TYPE (decl
));
1426 if (bits
& SPCT_HAS_SMALL_CHAR_ARRAY
)
1427 has_short_buffer
= true;
1429 if (flag_stack_protect
== SPCT_FLAG_ALL
1430 || flag_stack_protect
== SPCT_FLAG_STRONG
)
1432 if ((bits
& (SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_LARGE_CHAR_ARRAY
))
1433 && !(bits
& SPCT_HAS_AGGREGATE
))
1435 else if (bits
& SPCT_HAS_ARRAY
)
1439 ret
= (bits
& SPCT_HAS_LARGE_CHAR_ARRAY
) != 0;
1442 has_protected_decls
= true;
1447 /* Two helper routines that check for phase 1 and phase 2. These are used
1448 as callbacks for expand_stack_vars. */
1451 stack_protect_decl_phase_1 (size_t i
)
1453 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 1;
1457 stack_protect_decl_phase_2 (size_t i
)
1459 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 2;
1462 /* And helper function that checks for asan phase (with stack protector
1463 it is phase 3). This is used as callback for expand_stack_vars.
1464 Returns true if any of the vars in the partition need to be protected. */
1467 asan_decl_phase_3 (size_t i
)
1471 if (asan_protect_stack_decl (stack_vars
[i
].decl
))
1473 i
= stack_vars
[i
].next
;
1478 /* Ensure that variables in different stack protection phases conflict
1479 so that they are not merged and share the same stack slot. */
1482 add_stack_protection_conflicts (void)
1484 size_t i
, j
, n
= stack_vars_num
;
1485 unsigned char *phase
;
1487 phase
= XNEWVEC (unsigned char, n
);
1488 for (i
= 0; i
< n
; ++i
)
1489 phase
[i
] = stack_protect_decl_phase (stack_vars
[i
].decl
);
1491 for (i
= 0; i
< n
; ++i
)
1493 unsigned char ph_i
= phase
[i
];
1494 for (j
= i
+ 1; j
< n
; ++j
)
1495 if (ph_i
!= phase
[j
])
1496 add_stack_var_conflict (i
, j
);
1502 /* Create a decl for the guard at the top of the stack frame. */
1505 create_stack_guard (void)
1507 tree guard
= build_decl (DECL_SOURCE_LOCATION (current_function_decl
),
1508 VAR_DECL
, NULL
, ptr_type_node
);
1509 TREE_THIS_VOLATILE (guard
) = 1;
1510 TREE_USED (guard
) = 1;
1511 expand_one_stack_var (guard
);
1512 crtl
->stack_protect_guard
= guard
;
1515 /* Prepare for expanding variables. */
1517 init_vars_expansion (void)
1519 /* Conflict bitmaps, and a few related temporary bitmaps, go here. */
1520 bitmap_obstack_initialize (&stack_var_bitmap_obstack
);
1522 /* A map from decl to stack partition. */
1523 decl_to_stack_part
= pointer_map_create ();
1525 /* Initialize local stack smashing state. */
1526 has_protected_decls
= false;
1527 has_short_buffer
= false;
1530 /* Free up stack variable graph data. */
1532 fini_vars_expansion (void)
1534 bitmap_obstack_release (&stack_var_bitmap_obstack
);
1536 XDELETEVEC (stack_vars
);
1537 if (stack_vars_sorted
)
1538 XDELETEVEC (stack_vars_sorted
);
1540 stack_vars_sorted
= NULL
;
1541 stack_vars_alloc
= stack_vars_num
= 0;
1542 pointer_map_destroy (decl_to_stack_part
);
1543 decl_to_stack_part
= NULL
;
1546 /* Make a fair guess for the size of the stack frame of the function
1547 in NODE. This doesn't have to be exact, the result is only used in
1548 the inline heuristics. So we don't want to run the full stack var
1549 packing algorithm (which is quadratic in the number of stack vars).
1550 Instead, we calculate the total size of all stack vars. This turns
1551 out to be a pretty fair estimate -- packing of stack vars doesn't
1552 happen very often. */
1555 estimated_stack_frame_size (struct cgraph_node
*node
)
1557 HOST_WIDE_INT size
= 0;
1560 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
1564 init_vars_expansion ();
1566 FOR_EACH_LOCAL_DECL (fn
, i
, var
)
1567 if (auto_var_in_fn_p (var
, fn
->decl
))
1568 size
+= expand_one_var (var
, true, false);
1570 if (stack_vars_num
> 0)
1572 /* Fake sorting the stack vars for account_stack_vars (). */
1573 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
1574 for (i
= 0; i
< stack_vars_num
; ++i
)
1575 stack_vars_sorted
[i
] = i
;
1576 size
+= account_stack_vars ();
1579 fini_vars_expansion ();
1584 /* Helper routine to check if a record or union contains an array field. */
1587 record_or_union_type_has_array_p (const_tree tree_type
)
1589 tree fields
= TYPE_FIELDS (tree_type
);
1592 for (f
= fields
; f
; f
= DECL_CHAIN (f
))
1593 if (TREE_CODE (f
) == FIELD_DECL
)
1595 tree field_type
= TREE_TYPE (f
);
1596 if (RECORD_OR_UNION_TYPE_P (field_type
)
1597 && record_or_union_type_has_array_p (field_type
))
1599 if (TREE_CODE (field_type
) == ARRAY_TYPE
)
1605 /* Expand all variables used in the function. */
1608 expand_used_vars (void)
1610 tree var
, outer_block
= DECL_INITIAL (current_function_decl
);
1611 vec
<tree
> maybe_local_decls
= vNULL
;
1612 rtx var_end_seq
= NULL_RTX
;
1613 struct pointer_map_t
*ssa_name_decls
;
1616 bool gen_stack_protect_signal
= false;
1618 /* Compute the phase of the stack frame for this function. */
1620 int align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
1621 int off
= STARTING_FRAME_OFFSET
% align
;
1622 frame_phase
= off
? align
- off
: 0;
1625 /* Set TREE_USED on all variables in the local_decls. */
1626 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
1627 TREE_USED (var
) = 1;
1628 /* Clear TREE_USED on all variables associated with a block scope. */
1629 clear_tree_used (DECL_INITIAL (current_function_decl
));
1631 init_vars_expansion ();
1633 ssa_name_decls
= pointer_map_create ();
1634 for (i
= 0; i
< SA
.map
->num_partitions
; i
++)
1636 tree var
= partition_to_var (SA
.map
, i
);
1638 gcc_assert (!virtual_operand_p (var
));
1640 /* Assign decls to each SSA name partition, share decls for partitions
1641 we could have coalesced (those with the same type). */
1642 if (SSA_NAME_VAR (var
) == NULL_TREE
)
1644 void **slot
= pointer_map_insert (ssa_name_decls
, TREE_TYPE (var
));
1646 *slot
= (void *) create_tmp_reg (TREE_TYPE (var
), NULL
);
1647 replace_ssa_name_symbol (var
, (tree
) *slot
);
1650 /* Always allocate space for partitions based on VAR_DECLs. But for
1651 those based on PARM_DECLs or RESULT_DECLs and which matter for the
1652 debug info, there is no need to do so if optimization is disabled
1653 because all the SSA_NAMEs based on these DECLs have been coalesced
1654 into a single partition, which is thus assigned the canonical RTL
1655 location of the DECLs. If in_lto_p, we can't rely on optimize,
1656 a function could be compiled with -O1 -flto first and only the
1657 link performed at -O0. */
1658 if (TREE_CODE (SSA_NAME_VAR (var
)) == VAR_DECL
)
1659 expand_one_var (var
, true, true);
1660 else if (DECL_IGNORED_P (SSA_NAME_VAR (var
)) || optimize
|| in_lto_p
)
1662 /* This is a PARM_DECL or RESULT_DECL. For those partitions that
1663 contain the default def (representing the parm or result itself)
1664 we don't do anything here. But those which don't contain the
1665 default def (representing a temporary based on the parm/result)
1666 we need to allocate space just like for normal VAR_DECLs. */
1667 if (!bitmap_bit_p (SA
.partition_has_default_def
, i
))
1669 expand_one_var (var
, true, true);
1670 gcc_assert (SA
.partition_to_pseudo
[i
]);
1674 pointer_map_destroy (ssa_name_decls
);
1676 if (flag_stack_protect
== SPCT_FLAG_STRONG
)
1677 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
1678 if (!is_global_var (var
))
1680 tree var_type
= TREE_TYPE (var
);
1681 /* Examine local referenced variables that have their addresses taken,
1682 contain an array, or are arrays. */
1683 if (TREE_CODE (var
) == VAR_DECL
1684 && (TREE_CODE (var_type
) == ARRAY_TYPE
1685 || TREE_ADDRESSABLE (var
)
1686 || (RECORD_OR_UNION_TYPE_P (var_type
)
1687 && record_or_union_type_has_array_p (var_type
))))
1689 gen_stack_protect_signal
= true;
1694 /* At this point all variables on the local_decls with TREE_USED
1695 set are not associated with any block scope. Lay them out. */
1697 len
= vec_safe_length (cfun
->local_decls
);
1698 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
1700 bool expand_now
= false;
1702 /* Expanded above already. */
1703 if (is_gimple_reg (var
))
1705 TREE_USED (var
) = 0;
1708 /* We didn't set a block for static or extern because it's hard
1709 to tell the difference between a global variable (re)declared
1710 in a local scope, and one that's really declared there to
1711 begin with. And it doesn't really matter much, since we're
1712 not giving them stack space. Expand them now. */
1713 else if (TREE_STATIC (var
) || DECL_EXTERNAL (var
))
1716 /* Expand variables not associated with any block now. Those created by
1717 the optimizers could be live anywhere in the function. Those that
1718 could possibly have been scoped originally and detached from their
1719 block will have their allocation deferred so we coalesce them with
1720 others when optimization is enabled. */
1721 else if (TREE_USED (var
))
1724 /* Finally, mark all variables on the list as used. We'll use
1725 this in a moment when we expand those associated with scopes. */
1726 TREE_USED (var
) = 1;
1729 expand_one_var (var
, true, true);
1732 if (DECL_ARTIFICIAL (var
) && !DECL_IGNORED_P (var
))
1734 rtx rtl
= DECL_RTL_IF_SET (var
);
1736 /* Keep artificial non-ignored vars in cfun->local_decls
1737 chain until instantiate_decls. */
1738 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
1739 add_local_decl (cfun
, var
);
1740 else if (rtl
== NULL_RTX
)
1741 /* If rtl isn't set yet, which can happen e.g. with
1742 -fstack-protector, retry before returning from this
1744 maybe_local_decls
.safe_push (var
);
1748 /* We duplicated some of the decls in CFUN->LOCAL_DECLS.
1750 +-----------------+-----------------+
1751 | ...processed... | ...duplicates...|
1752 +-----------------+-----------------+
1754 +-- LEN points here.
1756 We just want the duplicates, as those are the artificial
1757 non-ignored vars that we want to keep until instantiate_decls.
1758 Move them down and truncate the array. */
1759 if (!vec_safe_is_empty (cfun
->local_decls
))
1760 cfun
->local_decls
->block_remove (0, len
);
1762 /* At this point, all variables within the block tree with TREE_USED
1763 set are actually used by the optimized function. Lay them out. */
1764 expand_used_vars_for_block (outer_block
, true);
1766 if (stack_vars_num
> 0)
1768 add_scope_conflicts ();
1770 /* If stack protection is enabled, we don't share space between
1771 vulnerable data and non-vulnerable data. */
1772 if (flag_stack_protect
)
1773 add_stack_protection_conflicts ();
1775 /* Now that we have collected all stack variables, and have computed a
1776 minimal interference graph, attempt to save some stack space. */
1777 partition_stack_vars ();
1779 dump_stack_var_partition ();
1782 switch (flag_stack_protect
)
1785 create_stack_guard ();
1788 case SPCT_FLAG_STRONG
:
1789 if (gen_stack_protect_signal
1790 || cfun
->calls_alloca
|| has_protected_decls
)
1791 create_stack_guard ();
1794 case SPCT_FLAG_DEFAULT
:
1795 if (cfun
->calls_alloca
|| has_protected_decls
)
1796 create_stack_guard ();
1803 /* Assign rtl to each variable based on these partitions. */
1804 if (stack_vars_num
> 0)
1806 struct stack_vars_data data
;
1808 data
.asan_vec
= vNULL
;
1809 data
.asan_decl_vec
= vNULL
;
1810 data
.asan_base
= NULL_RTX
;
1811 data
.asan_alignb
= 0;
1813 /* Reorder decls to be protected by iterating over the variables
1814 array multiple times, and allocating out of each phase in turn. */
1815 /* ??? We could probably integrate this into the qsort we did
1816 earlier, such that we naturally see these variables first,
1817 and thus naturally allocate things in the right order. */
1818 if (has_protected_decls
)
1820 /* Phase 1 contains only character arrays. */
1821 expand_stack_vars (stack_protect_decl_phase_1
, &data
);
1823 /* Phase 2 contains other kinds of arrays. */
1824 if (flag_stack_protect
== 2)
1825 expand_stack_vars (stack_protect_decl_phase_2
, &data
);
1828 if ((flag_sanitize
& SANITIZE_ADDRESS
) && ASAN_STACK
)
1829 /* Phase 3, any partitions that need asan protection
1830 in addition to phase 1 and 2. */
1831 expand_stack_vars (asan_decl_phase_3
, &data
);
1833 if (!data
.asan_vec
.is_empty ())
1835 HOST_WIDE_INT prev_offset
= frame_offset
;
1836 HOST_WIDE_INT offset
, sz
, redzonesz
;
1837 redzonesz
= ASAN_RED_ZONE_SIZE
;
1838 sz
= data
.asan_vec
[0] - prev_offset
;
1839 if (data
.asan_alignb
> ASAN_RED_ZONE_SIZE
1840 && data
.asan_alignb
<= 4096
1841 && sz
+ ASAN_RED_ZONE_SIZE
>= (int) data
.asan_alignb
)
1842 redzonesz
= ((sz
+ ASAN_RED_ZONE_SIZE
+ data
.asan_alignb
- 1)
1843 & ~(data
.asan_alignb
- HOST_WIDE_INT_1
)) - sz
;
1845 = alloc_stack_frame_space (redzonesz
, ASAN_RED_ZONE_SIZE
);
1846 data
.asan_vec
.safe_push (prev_offset
);
1847 data
.asan_vec
.safe_push (offset
);
1850 = asan_emit_stack_protection (virtual_stack_vars_rtx
,
1853 data
.asan_vec
.address (),
1854 data
.asan_decl_vec
.address (),
1855 data
.asan_vec
.length ());
1858 expand_stack_vars (NULL
, &data
);
1860 data
.asan_vec
.release ();
1861 data
.asan_decl_vec
.release ();
1864 fini_vars_expansion ();
1866 /* If there were any artificial non-ignored vars without rtl
1867 found earlier, see if deferred stack allocation hasn't assigned
1869 FOR_EACH_VEC_ELT_REVERSE (maybe_local_decls
, i
, var
)
1871 rtx rtl
= DECL_RTL_IF_SET (var
);
1873 /* Keep artificial non-ignored vars in cfun->local_decls
1874 chain until instantiate_decls. */
1875 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
1876 add_local_decl (cfun
, var
);
1878 maybe_local_decls
.release ();
1880 /* If the target requires that FRAME_OFFSET be aligned, do it. */
1881 if (STACK_ALIGNMENT_NEEDED
)
1883 HOST_WIDE_INT align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
1884 if (!FRAME_GROWS_DOWNWARD
)
1885 frame_offset
+= align
- 1;
1886 frame_offset
&= -align
;
1893 /* If we need to produce a detailed dump, print the tree representation
1894 for STMT to the dump file. SINCE is the last RTX after which the RTL
1895 generated for STMT should have been appended. */
1898 maybe_dump_rtl_for_gimple_stmt (gimple stmt
, rtx since
)
1900 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1902 fprintf (dump_file
, "\n;; ");
1903 print_gimple_stmt (dump_file
, stmt
, 0,
1904 TDF_SLIM
| (dump_flags
& TDF_LINENO
));
1905 fprintf (dump_file
, "\n");
1907 print_rtl (dump_file
, since
? NEXT_INSN (since
) : since
);
1911 /* Maps the blocks that do not contain tree labels to rtx labels. */
1913 static struct pointer_map_t
*lab_rtx_for_bb
;
1915 /* Returns the label_rtx expression for a label starting basic block BB. */
1918 label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED
)
1920 gimple_stmt_iterator gsi
;
1925 if (bb
->flags
& BB_RTL
)
1926 return block_label (bb
);
1928 elt
= pointer_map_contains (lab_rtx_for_bb
, bb
);
1932 /* Find the tree label if it is present. */
1934 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1936 lab_stmt
= gsi_stmt (gsi
);
1937 if (gimple_code (lab_stmt
) != GIMPLE_LABEL
)
1940 lab
= gimple_label_label (lab_stmt
);
1941 if (DECL_NONLOCAL (lab
))
1944 return label_rtx (lab
);
1947 elt
= pointer_map_insert (lab_rtx_for_bb
, bb
);
1948 *elt
= gen_label_rtx ();
1953 /* A subroutine of expand_gimple_cond. Given E, a fallthrough edge
1954 of a basic block where we just expanded the conditional at the end,
1955 possibly clean up the CFG and instruction sequence. LAST is the
1956 last instruction before the just emitted jump sequence. */
1959 maybe_cleanup_end_of_block (edge e
, rtx last
)
1961 /* Special case: when jumpif decides that the condition is
1962 trivial it emits an unconditional jump (and the necessary
1963 barrier). But we still have two edges, the fallthru one is
1964 wrong. purge_dead_edges would clean this up later. Unfortunately
1965 we have to insert insns (and split edges) before
1966 find_many_sub_basic_blocks and hence before purge_dead_edges.
1967 But splitting edges might create new blocks which depend on the
1968 fact that if there are two edges there's no barrier. So the
1969 barrier would get lost and verify_flow_info would ICE. Instead
1970 of auditing all edge splitters to care for the barrier (which
1971 normally isn't there in a cleaned CFG), fix it here. */
1972 if (BARRIER_P (get_last_insn ()))
1976 /* Now, we have a single successor block, if we have insns to
1977 insert on the remaining edge we potentially will insert
1978 it at the end of this block (if the dest block isn't feasible)
1979 in order to avoid splitting the edge. This insertion will take
1980 place in front of the last jump. But we might have emitted
1981 multiple jumps (conditional and one unconditional) to the
1982 same destination. Inserting in front of the last one then
1983 is a problem. See PR 40021. We fix this by deleting all
1984 jumps except the last unconditional one. */
1985 insn
= PREV_INSN (get_last_insn ());
1986 /* Make sure we have an unconditional jump. Otherwise we're
1988 gcc_assert (JUMP_P (insn
) && !any_condjump_p (insn
));
1989 for (insn
= PREV_INSN (insn
); insn
!= last
;)
1991 insn
= PREV_INSN (insn
);
1992 if (JUMP_P (NEXT_INSN (insn
)))
1994 if (!any_condjump_p (NEXT_INSN (insn
)))
1996 gcc_assert (BARRIER_P (NEXT_INSN (NEXT_INSN (insn
))));
1997 delete_insn (NEXT_INSN (NEXT_INSN (insn
)));
1999 delete_insn (NEXT_INSN (insn
));
2005 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_COND.
2006 Returns a new basic block if we've terminated the current basic
2007 block and created a new one. */
2010 expand_gimple_cond (basic_block bb
, gimple stmt
)
2012 basic_block new_bb
, dest
;
2017 enum tree_code code
;
2020 code
= gimple_cond_code (stmt
);
2021 op0
= gimple_cond_lhs (stmt
);
2022 op1
= gimple_cond_rhs (stmt
);
2023 /* We're sometimes presented with such code:
2027 This would expand to two comparisons which then later might
2028 be cleaned up by combine. But some pattern matchers like if-conversion
2029 work better when there's only one compare, so make up for this
2030 here as special exception if TER would have made the same change. */
2032 && TREE_CODE (op0
) == SSA_NAME
2033 && TREE_CODE (TREE_TYPE (op0
)) == BOOLEAN_TYPE
2034 && TREE_CODE (op1
) == INTEGER_CST
2035 && ((gimple_cond_code (stmt
) == NE_EXPR
2036 && integer_zerop (op1
))
2037 || (gimple_cond_code (stmt
) == EQ_EXPR
2038 && integer_onep (op1
)))
2039 && bitmap_bit_p (SA
.values
, SSA_NAME_VERSION (op0
)))
2041 gimple second
= SSA_NAME_DEF_STMT (op0
);
2042 if (gimple_code (second
) == GIMPLE_ASSIGN
)
2044 enum tree_code code2
= gimple_assign_rhs_code (second
);
2045 if (TREE_CODE_CLASS (code2
) == tcc_comparison
)
2048 op0
= gimple_assign_rhs1 (second
);
2049 op1
= gimple_assign_rhs2 (second
);
2051 /* If jumps are cheap turn some more codes into
2053 else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4)
2055 if ((code2
== BIT_AND_EXPR
2056 && TYPE_PRECISION (TREE_TYPE (op0
)) == 1
2057 && TREE_CODE (gimple_assign_rhs2 (second
)) != INTEGER_CST
)
2058 || code2
== TRUTH_AND_EXPR
)
2060 code
= TRUTH_ANDIF_EXPR
;
2061 op0
= gimple_assign_rhs1 (second
);
2062 op1
= gimple_assign_rhs2 (second
);
2064 else if (code2
== BIT_IOR_EXPR
|| code2
== TRUTH_OR_EXPR
)
2066 code
= TRUTH_ORIF_EXPR
;
2067 op0
= gimple_assign_rhs1 (second
);
2068 op1
= gimple_assign_rhs2 (second
);
2074 last2
= last
= get_last_insn ();
2076 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
2077 set_curr_insn_location (gimple_location (stmt
));
2079 /* These flags have no purpose in RTL land. */
2080 true_edge
->flags
&= ~EDGE_TRUE_VALUE
;
2081 false_edge
->flags
&= ~EDGE_FALSE_VALUE
;
2083 /* We can either have a pure conditional jump with one fallthru edge or
2084 two-way jump that needs to be decomposed into two basic blocks. */
2085 if (false_edge
->dest
== bb
->next_bb
)
2087 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2088 true_edge
->probability
);
2089 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2090 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2091 set_curr_insn_location (true_edge
->goto_locus
);
2092 false_edge
->flags
|= EDGE_FALLTHRU
;
2093 maybe_cleanup_end_of_block (false_edge
, last
);
2096 if (true_edge
->dest
== bb
->next_bb
)
2098 jumpifnot_1 (code
, op0
, op1
, label_rtx_for_bb (false_edge
->dest
),
2099 false_edge
->probability
);
2100 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2101 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2102 set_curr_insn_location (false_edge
->goto_locus
);
2103 true_edge
->flags
|= EDGE_FALLTHRU
;
2104 maybe_cleanup_end_of_block (true_edge
, last
);
2108 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2109 true_edge
->probability
);
2110 last
= get_last_insn ();
2111 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2112 set_curr_insn_location (false_edge
->goto_locus
);
2113 emit_jump (label_rtx_for_bb (false_edge
->dest
));
2116 if (BARRIER_P (BB_END (bb
)))
2117 BB_END (bb
) = PREV_INSN (BB_END (bb
));
2118 update_bb_for_insn (bb
);
2120 new_bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
2121 dest
= false_edge
->dest
;
2122 redirect_edge_succ (false_edge
, new_bb
);
2123 false_edge
->flags
|= EDGE_FALLTHRU
;
2124 new_bb
->count
= false_edge
->count
;
2125 new_bb
->frequency
= EDGE_FREQUENCY (false_edge
);
2126 if (current_loops
&& bb
->loop_father
)
2127 add_bb_to_loop (new_bb
, bb
->loop_father
);
2128 new_edge
= make_edge (new_bb
, dest
, 0);
2129 new_edge
->probability
= REG_BR_PROB_BASE
;
2130 new_edge
->count
= new_bb
->count
;
2131 if (BARRIER_P (BB_END (new_bb
)))
2132 BB_END (new_bb
) = PREV_INSN (BB_END (new_bb
));
2133 update_bb_for_insn (new_bb
);
2135 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
2137 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2139 set_curr_insn_location (true_edge
->goto_locus
);
2140 true_edge
->goto_locus
= curr_insn_location ();
2146 /* Mark all calls that can have a transaction restart. */
2149 mark_transaction_restart_calls (gimple stmt
)
2151 struct tm_restart_node dummy
;
2154 if (!cfun
->gimple_df
->tm_restart
)
2158 slot
= htab_find_slot (cfun
->gimple_df
->tm_restart
, &dummy
, NO_INSERT
);
2161 struct tm_restart_node
*n
= (struct tm_restart_node
*) *slot
;
2162 tree list
= n
->label_or_list
;
2165 for (insn
= next_real_insn (get_last_insn ());
2167 insn
= next_real_insn (insn
))
2170 if (TREE_CODE (list
) == LABEL_DECL
)
2171 add_reg_note (insn
, REG_TM
, label_rtx (list
));
2173 for (; list
; list
= TREE_CHAIN (list
))
2174 add_reg_note (insn
, REG_TM
, label_rtx (TREE_VALUE (list
)));
2178 /* A subroutine of expand_gimple_stmt_1, expanding one GIMPLE_CALL
2182 expand_call_stmt (gimple stmt
)
2184 tree exp
, decl
, lhs
;
2188 if (gimple_call_internal_p (stmt
))
2190 expand_internal_call (stmt
);
2194 exp
= build_vl_exp (CALL_EXPR
, gimple_call_num_args (stmt
) + 3);
2196 CALL_EXPR_FN (exp
) = gimple_call_fn (stmt
);
2197 decl
= gimple_call_fndecl (stmt
);
2198 builtin_p
= decl
&& DECL_BUILT_IN (decl
);
2200 /* If this is not a builtin function, the function type through which the
2201 call is made may be different from the type of the function. */
2204 = fold_convert (build_pointer_type (gimple_call_fntype (stmt
)),
2205 CALL_EXPR_FN (exp
));
2207 TREE_TYPE (exp
) = gimple_call_return_type (stmt
);
2208 CALL_EXPR_STATIC_CHAIN (exp
) = gimple_call_chain (stmt
);
2210 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2212 tree arg
= gimple_call_arg (stmt
, i
);
2214 /* TER addresses into arguments of builtin functions so we have a
2215 chance to infer more correct alignment information. See PR39954. */
2217 && TREE_CODE (arg
) == SSA_NAME
2218 && (def
= get_gimple_for_ssa_name (arg
))
2219 && gimple_assign_rhs_code (def
) == ADDR_EXPR
)
2220 arg
= gimple_assign_rhs1 (def
);
2221 CALL_EXPR_ARG (exp
, i
) = arg
;
2224 if (gimple_has_side_effects (stmt
))
2225 TREE_SIDE_EFFECTS (exp
) = 1;
2227 if (gimple_call_nothrow_p (stmt
))
2228 TREE_NOTHROW (exp
) = 1;
2230 CALL_EXPR_TAILCALL (exp
) = gimple_call_tail_p (stmt
);
2231 CALL_EXPR_RETURN_SLOT_OPT (exp
) = gimple_call_return_slot_opt_p (stmt
);
2233 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
2234 && (DECL_FUNCTION_CODE (decl
) == BUILT_IN_ALLOCA
2235 || DECL_FUNCTION_CODE (decl
) == BUILT_IN_ALLOCA_WITH_ALIGN
))
2236 CALL_ALLOCA_FOR_VAR_P (exp
) = gimple_call_alloca_for_var_p (stmt
);
2238 CALL_FROM_THUNK_P (exp
) = gimple_call_from_thunk_p (stmt
);
2239 CALL_EXPR_VA_ARG_PACK (exp
) = gimple_call_va_arg_pack_p (stmt
);
2240 SET_EXPR_LOCATION (exp
, gimple_location (stmt
));
2242 /* Ensure RTL is created for debug args. */
2243 if (decl
&& DECL_HAS_DEBUG_ARGS_P (decl
))
2245 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (decl
);
2250 for (ix
= 1; (*debug_args
)->iterate (ix
, &dtemp
); ix
+= 2)
2252 gcc_assert (TREE_CODE (dtemp
) == DEBUG_EXPR_DECL
);
2253 expand_debug_expr (dtemp
);
2257 lhs
= gimple_call_lhs (stmt
);
2259 expand_assignment (lhs
, exp
, false);
2261 expand_expr (exp
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2263 mark_transaction_restart_calls (stmt
);
2267 /* Generate RTL for an asm statement (explicit assembler code).
2268 STRING is a STRING_CST node containing the assembler code text,
2269 or an ADDR_EXPR containing a STRING_CST. VOL nonzero means the
2270 insn is volatile; don't optimize it. */
2273 expand_asm_loc (tree string
, int vol
, location_t locus
)
2277 if (TREE_CODE (string
) == ADDR_EXPR
)
2278 string
= TREE_OPERAND (string
, 0);
2280 body
= gen_rtx_ASM_INPUT_loc (VOIDmode
,
2281 ggc_strdup (TREE_STRING_POINTER (string
)),
2284 MEM_VOLATILE_P (body
) = vol
;
2289 /* Return the number of times character C occurs in string S. */
2291 n_occurrences (int c
, const char *s
)
2299 /* A subroutine of expand_asm_operands. Check that all operands have
2300 the same number of alternatives. Return true if so. */
2303 check_operand_nalternatives (tree outputs
, tree inputs
)
2305 if (outputs
|| inputs
)
2307 tree tmp
= TREE_PURPOSE (outputs
? outputs
: inputs
);
2309 = n_occurrences (',', TREE_STRING_POINTER (TREE_VALUE (tmp
)));
2312 if (nalternatives
+ 1 > MAX_RECOG_ALTERNATIVES
)
2314 error ("too many alternatives in %<asm%>");
2321 const char *constraint
2322 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tmp
)));
2324 if (n_occurrences (',', constraint
) != nalternatives
)
2326 error ("operand constraints for %<asm%> differ "
2327 "in number of alternatives");
2331 if (TREE_CHAIN (tmp
))
2332 tmp
= TREE_CHAIN (tmp
);
2334 tmp
= next
, next
= 0;
2341 /* Check for overlap between registers marked in CLOBBERED_REGS and
2342 anything inappropriate in T. Emit error and return the register
2343 variable definition for error, NULL_TREE for ok. */
2346 tree_conflicts_with_clobbers_p (tree t
, HARD_REG_SET
*clobbered_regs
)
2348 /* Conflicts between asm-declared register variables and the clobber
2349 list are not allowed. */
2350 tree overlap
= tree_overlaps_hard_reg_set (t
, clobbered_regs
);
2354 error ("asm-specifier for variable %qE conflicts with asm clobber list",
2355 DECL_NAME (overlap
));
2357 /* Reset registerness to stop multiple errors emitted for a single
2359 DECL_REGISTER (overlap
) = 0;
2366 /* Generate RTL for an asm statement with arguments.
2367 STRING is the instruction template.
2368 OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
2369 Each output or input has an expression in the TREE_VALUE and
2370 a tree list in TREE_PURPOSE which in turn contains a constraint
2371 name in TREE_VALUE (or NULL_TREE) and a constraint string
2373 CLOBBERS is a list of STRING_CST nodes each naming a hard register
2374 that is clobbered by this insn.
2376 LABELS is a list of labels, and if LABELS is non-NULL, FALLTHRU_BB
2377 should be the fallthru basic block of the asm goto.
2379 Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
2380 Some elements of OUTPUTS may be replaced with trees representing temporary
2381 values. The caller should copy those temporary values to the originally
2384 VOL nonzero means the insn is volatile; don't optimize it. */
2387 expand_asm_operands (tree string
, tree outputs
, tree inputs
,
2388 tree clobbers
, tree labels
, basic_block fallthru_bb
,
2389 int vol
, location_t locus
)
2391 rtvec argvec
, constraintvec
, labelvec
;
2393 int ninputs
= list_length (inputs
);
2394 int noutputs
= list_length (outputs
);
2395 int nlabels
= list_length (labels
);
2398 HARD_REG_SET clobbered_regs
;
2399 int clobber_conflict_found
= 0;
2403 /* Vector of RTX's of evaluated output operands. */
2404 rtx
*output_rtx
= XALLOCAVEC (rtx
, noutputs
);
2405 int *inout_opnum
= XALLOCAVEC (int, noutputs
);
2406 rtx
*real_output_rtx
= XALLOCAVEC (rtx
, noutputs
);
2407 enum machine_mode
*inout_mode
= XALLOCAVEC (enum machine_mode
, noutputs
);
2408 const char **constraints
= XALLOCAVEC (const char *, noutputs
+ ninputs
);
2409 int old_generating_concat_p
= generating_concat_p
;
2410 rtx fallthru_label
= NULL_RTX
;
2412 /* An ASM with no outputs needs to be treated as volatile, for now. */
2416 if (! check_operand_nalternatives (outputs
, inputs
))
2419 string
= resolve_asm_operand_names (string
, outputs
, inputs
, labels
);
2421 /* Collect constraints. */
2423 for (t
= outputs
; t
; t
= TREE_CHAIN (t
), i
++)
2424 constraints
[i
] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
2425 for (t
= inputs
; t
; t
= TREE_CHAIN (t
), i
++)
2426 constraints
[i
] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
2428 /* Sometimes we wish to automatically clobber registers across an asm.
2429 Case in point is when the i386 backend moved from cc0 to a hard reg --
2430 maintaining source-level compatibility means automatically clobbering
2431 the flags register. */
2432 clobbers
= targetm
.md_asm_clobbers (outputs
, inputs
, clobbers
);
2434 /* Count the number of meaningful clobbered registers, ignoring what
2435 we would ignore later. */
2437 CLEAR_HARD_REG_SET (clobbered_regs
);
2438 for (tail
= clobbers
; tail
; tail
= TREE_CHAIN (tail
))
2440 const char *regname
;
2443 if (TREE_VALUE (tail
) == error_mark_node
)
2445 regname
= TREE_STRING_POINTER (TREE_VALUE (tail
));
2447 i
= decode_reg_name_and_count (regname
, &nregs
);
2451 error ("unknown register name %qs in %<asm%>", regname
);
2453 /* Mark clobbered registers. */
2458 for (reg
= i
; reg
< i
+ nregs
; reg
++)
2462 /* Clobbering the PIC register is an error. */
2463 if (reg
== (int) PIC_OFFSET_TABLE_REGNUM
)
2465 error ("PIC register clobbered by %qs in %<asm%>", regname
);
2469 SET_HARD_REG_BIT (clobbered_regs
, reg
);
2474 /* First pass over inputs and outputs checks validity and sets
2475 mark_addressable if needed. */
2478 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
2480 tree val
= TREE_VALUE (tail
);
2481 tree type
= TREE_TYPE (val
);
2482 const char *constraint
;
2487 /* If there's an erroneous arg, emit no insn. */
2488 if (type
== error_mark_node
)
2491 /* Try to parse the output constraint. If that fails, there's
2492 no point in going further. */
2493 constraint
= constraints
[i
];
2494 if (!parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
2495 &allows_mem
, &allows_reg
, &is_inout
))
2502 && REG_P (DECL_RTL (val
))
2503 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
))))
2504 mark_addressable (val
);
2511 if (ninputs
+ noutputs
> MAX_RECOG_OPERANDS
)
2513 error ("more than %d operands in %<asm%>", MAX_RECOG_OPERANDS
);
2517 for (i
= 0, tail
= inputs
; tail
; i
++, tail
= TREE_CHAIN (tail
))
2519 bool allows_reg
, allows_mem
;
2520 const char *constraint
;
2522 /* If there's an erroneous arg, emit no insn, because the ASM_INPUT
2523 would get VOIDmode and that could cause a crash in reload. */
2524 if (TREE_TYPE (TREE_VALUE (tail
)) == error_mark_node
)
2527 constraint
= constraints
[i
+ noutputs
];
2528 if (! parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, ninout
,
2529 constraints
, &allows_mem
, &allows_reg
))
2532 if (! allows_reg
&& allows_mem
)
2533 mark_addressable (TREE_VALUE (tail
));
2536 /* Second pass evaluates arguments. */
2538 /* Make sure stack is consistent for asm goto. */
2540 do_pending_stack_adjust ();
2543 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
2545 tree val
= TREE_VALUE (tail
);
2546 tree type
= TREE_TYPE (val
);
2553 ok
= parse_output_constraint (&constraints
[i
], i
, ninputs
,
2554 noutputs
, &allows_mem
, &allows_reg
,
2558 /* If an output operand is not a decl or indirect ref and our constraint
2559 allows a register, make a temporary to act as an intermediate.
2560 Make the asm insn write into that, then our caller will copy it to
2561 the real output operand. Likewise for promoted variables. */
2563 generating_concat_p
= 0;
2565 real_output_rtx
[i
] = NULL_RTX
;
2566 if ((TREE_CODE (val
) == INDIRECT_REF
2569 && (allows_mem
|| REG_P (DECL_RTL (val
)))
2570 && ! (REG_P (DECL_RTL (val
))
2571 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
)))
2575 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
2576 !allows_reg
? EXPAND_MEMORY
: EXPAND_WRITE
);
2578 op
= validize_mem (op
);
2580 if (! allows_reg
&& !MEM_P (op
))
2581 error ("output number %d not directly addressable", i
);
2582 if ((! allows_mem
&& MEM_P (op
))
2583 || GET_CODE (op
) == CONCAT
)
2585 real_output_rtx
[i
] = op
;
2586 op
= gen_reg_rtx (GET_MODE (op
));
2588 emit_move_insn (op
, real_output_rtx
[i
]);
2593 op
= assign_temp (type
, 0, 1);
2594 op
= validize_mem (op
);
2595 if (!MEM_P (op
) && TREE_CODE (TREE_VALUE (tail
)) == SSA_NAME
)
2596 set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (TREE_VALUE (tail
)), op
);
2597 TREE_VALUE (tail
) = make_tree (type
, op
);
2601 generating_concat_p
= old_generating_concat_p
;
2605 inout_mode
[ninout
] = TYPE_MODE (type
);
2606 inout_opnum
[ninout
++] = i
;
2609 if (tree_conflicts_with_clobbers_p (val
, &clobbered_regs
))
2610 clobber_conflict_found
= 1;
2613 /* Make vectors for the expression-rtx, constraint strings,
2614 and named operands. */
2616 argvec
= rtvec_alloc (ninputs
);
2617 constraintvec
= rtvec_alloc (ninputs
);
2618 labelvec
= rtvec_alloc (nlabels
);
2620 body
= gen_rtx_ASM_OPERANDS ((noutputs
== 0 ? VOIDmode
2621 : GET_MODE (output_rtx
[0])),
2622 ggc_strdup (TREE_STRING_POINTER (string
)),
2623 empty_string
, 0, argvec
, constraintvec
,
2626 MEM_VOLATILE_P (body
) = vol
;
2628 /* Eval the inputs and put them into ARGVEC.
2629 Put their constraints into ASM_INPUTs and store in CONSTRAINTS. */
2631 for (i
= 0, tail
= inputs
; tail
; tail
= TREE_CHAIN (tail
), ++i
)
2633 bool allows_reg
, allows_mem
;
2634 const char *constraint
;
2639 constraint
= constraints
[i
+ noutputs
];
2640 ok
= parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, ninout
,
2641 constraints
, &allows_mem
, &allows_reg
);
2644 generating_concat_p
= 0;
2646 val
= TREE_VALUE (tail
);
2647 type
= TREE_TYPE (val
);
2648 /* EXPAND_INITIALIZER will not generate code for valid initializer
2649 constants, but will still generate code for other types of operand.
2650 This is the behavior we want for constant constraints. */
2651 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
2652 allows_reg
? EXPAND_NORMAL
2653 : allows_mem
? EXPAND_MEMORY
2654 : EXPAND_INITIALIZER
);
2656 /* Never pass a CONCAT to an ASM. */
2657 if (GET_CODE (op
) == CONCAT
)
2658 op
= force_reg (GET_MODE (op
), op
);
2659 else if (MEM_P (op
))
2660 op
= validize_mem (op
);
2662 if (asm_operand_ok (op
, constraint
, NULL
) <= 0)
2664 if (allows_reg
&& TYPE_MODE (type
) != BLKmode
)
2665 op
= force_reg (TYPE_MODE (type
), op
);
2666 else if (!allows_mem
)
2667 warning (0, "asm operand %d probably doesn%'t match constraints",
2669 else if (MEM_P (op
))
2671 /* We won't recognize either volatile memory or memory
2672 with a queued address as available a memory_operand
2673 at this point. Ignore it: clearly this *is* a memory. */
2679 generating_concat_p
= old_generating_concat_p
;
2680 ASM_OPERANDS_INPUT (body
, i
) = op
;
2682 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body
, i
)
2683 = gen_rtx_ASM_INPUT_loc (TYPE_MODE (type
),
2684 ggc_strdup (constraints
[i
+ noutputs
]),
2687 if (tree_conflicts_with_clobbers_p (val
, &clobbered_regs
))
2688 clobber_conflict_found
= 1;
2691 /* Protect all the operands from the queue now that they have all been
2694 generating_concat_p
= 0;
2696 /* For in-out operands, copy output rtx to input rtx. */
2697 for (i
= 0; i
< ninout
; i
++)
2699 int j
= inout_opnum
[i
];
2702 ASM_OPERANDS_INPUT (body
, ninputs
- ninout
+ i
)
2705 sprintf (buffer
, "%d", j
);
2706 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body
, ninputs
- ninout
+ i
)
2707 = gen_rtx_ASM_INPUT_loc (inout_mode
[i
], ggc_strdup (buffer
), locus
);
2710 /* Copy labels to the vector. */
2711 for (i
= 0, tail
= labels
; i
< nlabels
; ++i
, tail
= TREE_CHAIN (tail
))
2714 /* If asm goto has any labels in the fallthru basic block, use
2715 a label that we emit immediately after the asm goto. Expansion
2716 may insert further instructions into the same basic block after
2717 asm goto and if we don't do this, insertion of instructions on
2718 the fallthru edge might misbehave. See PR58670. */
2720 && label_to_block_fn (cfun
, TREE_VALUE (tail
)) == fallthru_bb
)
2722 if (fallthru_label
== NULL_RTX
)
2723 fallthru_label
= gen_label_rtx ();
2727 r
= label_rtx (TREE_VALUE (tail
));
2728 ASM_OPERANDS_LABEL (body
, i
) = gen_rtx_LABEL_REF (Pmode
, r
);
2731 generating_concat_p
= old_generating_concat_p
;
2733 /* Now, for each output, construct an rtx
2734 (set OUTPUT (asm_operands INSN OUTPUTCONSTRAINT OUTPUTNUMBER
2735 ARGVEC CONSTRAINTS OPNAMES))
2736 If there is more than one, put them inside a PARALLEL. */
2738 if (nlabels
> 0 && nclobbers
== 0)
2740 gcc_assert (noutputs
== 0);
2741 emit_jump_insn (body
);
2743 else if (noutputs
== 0 && nclobbers
== 0)
2745 /* No output operands: put in a raw ASM_OPERANDS rtx. */
2748 else if (noutputs
== 1 && nclobbers
== 0)
2750 ASM_OPERANDS_OUTPUT_CONSTRAINT (body
) = ggc_strdup (constraints
[0]);
2751 emit_insn (gen_rtx_SET (VOIDmode
, output_rtx
[0], body
));
2761 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (num
+ nclobbers
));
2763 /* For each output operand, store a SET. */
2764 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
2766 XVECEXP (body
, 0, i
)
2767 = gen_rtx_SET (VOIDmode
,
2769 gen_rtx_ASM_OPERANDS
2770 (GET_MODE (output_rtx
[i
]),
2771 ggc_strdup (TREE_STRING_POINTER (string
)),
2772 ggc_strdup (constraints
[i
]),
2773 i
, argvec
, constraintvec
, labelvec
, locus
));
2775 MEM_VOLATILE_P (SET_SRC (XVECEXP (body
, 0, i
))) = vol
;
2778 /* If there are no outputs (but there are some clobbers)
2779 store the bare ASM_OPERANDS into the PARALLEL. */
2782 XVECEXP (body
, 0, i
++) = obody
;
2784 /* Store (clobber REG) for each clobbered register specified. */
2786 for (tail
= clobbers
; tail
; tail
= TREE_CHAIN (tail
))
2788 const char *regname
= TREE_STRING_POINTER (TREE_VALUE (tail
));
2790 int j
= decode_reg_name_and_count (regname
, &nregs
);
2795 if (j
== -3) /* `cc', which is not a register */
2798 if (j
== -4) /* `memory', don't cache memory across asm */
2800 XVECEXP (body
, 0, i
++)
2801 = gen_rtx_CLOBBER (VOIDmode
,
2804 gen_rtx_SCRATCH (VOIDmode
)));
2808 /* Ignore unknown register, error already signaled. */
2812 for (reg
= j
; reg
< j
+ nregs
; reg
++)
2814 /* Use QImode since that's guaranteed to clobber just
2816 clobbered_reg
= gen_rtx_REG (QImode
, reg
);
2818 /* Do sanity check for overlap between clobbers and
2819 respectively input and outputs that hasn't been
2820 handled. Such overlap should have been detected and
2822 if (!clobber_conflict_found
)
2826 /* We test the old body (obody) contents to avoid
2827 tripping over the under-construction body. */
2828 for (opno
= 0; opno
< noutputs
; opno
++)
2829 if (reg_overlap_mentioned_p (clobbered_reg
,
2832 ("asm clobber conflict with output operand");
2834 for (opno
= 0; opno
< ninputs
- ninout
; opno
++)
2835 if (reg_overlap_mentioned_p (clobbered_reg
,
2836 ASM_OPERANDS_INPUT (obody
,
2839 ("asm clobber conflict with input operand");
2842 XVECEXP (body
, 0, i
++)
2843 = gen_rtx_CLOBBER (VOIDmode
, clobbered_reg
);
2848 emit_jump_insn (body
);
2854 emit_label (fallthru_label
);
2856 /* For any outputs that needed reloading into registers, spill them
2857 back to where they belong. */
2858 for (i
= 0; i
< noutputs
; ++i
)
2859 if (real_output_rtx
[i
])
2860 emit_move_insn (real_output_rtx
[i
], output_rtx
[i
]);
2862 crtl
->has_asm_statement
= 1;
2868 expand_asm_stmt (gimple stmt
)
2871 tree outputs
, tail
, t
;
2875 tree str
, out
, in
, cl
, labels
;
2876 location_t locus
= gimple_location (stmt
);
2877 basic_block fallthru_bb
= NULL
;
2879 /* Meh... convert the gimple asm operands into real tree lists.
2880 Eventually we should make all routines work on the vectors instead
2881 of relying on TREE_CHAIN. */
2883 n
= gimple_asm_noutputs (stmt
);
2886 t
= out
= gimple_asm_output_op (stmt
, 0);
2887 for (i
= 1; i
< n
; i
++)
2888 t
= TREE_CHAIN (t
) = gimple_asm_output_op (stmt
, i
);
2892 n
= gimple_asm_ninputs (stmt
);
2895 t
= in
= gimple_asm_input_op (stmt
, 0);
2896 for (i
= 1; i
< n
; i
++)
2897 t
= TREE_CHAIN (t
) = gimple_asm_input_op (stmt
, i
);
2901 n
= gimple_asm_nclobbers (stmt
);
2904 t
= cl
= gimple_asm_clobber_op (stmt
, 0);
2905 for (i
= 1; i
< n
; i
++)
2906 t
= TREE_CHAIN (t
) = gimple_asm_clobber_op (stmt
, i
);
2910 n
= gimple_asm_nlabels (stmt
);
2913 edge fallthru
= find_fallthru_edge (gimple_bb (stmt
)->succs
);
2915 fallthru_bb
= fallthru
->dest
;
2916 t
= labels
= gimple_asm_label_op (stmt
, 0);
2917 for (i
= 1; i
< n
; i
++)
2918 t
= TREE_CHAIN (t
) = gimple_asm_label_op (stmt
, i
);
2921 s
= gimple_asm_string (stmt
);
2922 str
= build_string (strlen (s
), s
);
2924 if (gimple_asm_input_p (stmt
))
2926 expand_asm_loc (str
, gimple_asm_volatile_p (stmt
), locus
);
2931 noutputs
= gimple_asm_noutputs (stmt
);
2932 /* o[I] is the place that output number I should be written. */
2933 o
= (tree
*) alloca (noutputs
* sizeof (tree
));
2935 /* Record the contents of OUTPUTS before it is modified. */
2936 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
2937 o
[i
] = TREE_VALUE (tail
);
2939 /* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of
2940 OUTPUTS some trees for where the values were actually stored. */
2941 expand_asm_operands (str
, outputs
, in
, cl
, labels
, fallthru_bb
,
2942 gimple_asm_volatile_p (stmt
), locus
);
2944 /* Copy all the intermediate outputs into the specified outputs. */
2945 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
2947 if (o
[i
] != TREE_VALUE (tail
))
2949 expand_assignment (o
[i
], TREE_VALUE (tail
), false);
2952 /* Restore the original value so that it's correct the next
2953 time we expand this function. */
2954 TREE_VALUE (tail
) = o
[i
];
2959 /* Emit code to jump to the address
2960 specified by the pointer expression EXP. */
2963 expand_computed_goto (tree exp
)
2965 rtx x
= expand_normal (exp
);
2967 x
= convert_memory_address (Pmode
, x
);
2969 do_pending_stack_adjust ();
2970 emit_indirect_jump (x
);
2973 /* Generate RTL code for a `goto' statement with target label LABEL.
2974 LABEL should be a LABEL_DECL tree node that was or will later be
2975 defined with `expand_label'. */
2978 expand_goto (tree label
)
2980 #ifdef ENABLE_CHECKING
2981 /* Check for a nonlocal goto to a containing function. Should have
2982 gotten translated to __builtin_nonlocal_goto. */
2983 tree context
= decl_function_context (label
);
2984 gcc_assert (!context
|| context
== current_function_decl
);
2987 emit_jump (label_rtx (label
));
2990 /* Output a return with no value. */
2993 expand_null_return_1 (void)
2995 clear_pending_stack_adjust ();
2996 do_pending_stack_adjust ();
2997 emit_jump (return_label
);
3000 /* Generate RTL to return from the current function, with no value.
3001 (That is, we do not do anything about returning any value.) */
3004 expand_null_return (void)
3006 /* If this function was declared to return a value, but we
3007 didn't, clobber the return registers so that they are not
3008 propagated live to the rest of the function. */
3009 clobber_return_register ();
3011 expand_null_return_1 ();
3014 /* Generate RTL to return from the current function, with value VAL. */
3017 expand_value_return (rtx val
)
3019 /* Copy the value to the return location unless it's already there. */
3021 tree decl
= DECL_RESULT (current_function_decl
);
3022 rtx return_reg
= DECL_RTL (decl
);
3023 if (return_reg
!= val
)
3025 tree funtype
= TREE_TYPE (current_function_decl
);
3026 tree type
= TREE_TYPE (decl
);
3027 int unsignedp
= TYPE_UNSIGNED (type
);
3028 enum machine_mode old_mode
= DECL_MODE (decl
);
3029 enum machine_mode mode
;
3030 if (DECL_BY_REFERENCE (decl
))
3031 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 2);
3033 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 1);
3035 if (mode
!= old_mode
)
3036 val
= convert_modes (mode
, old_mode
, val
, unsignedp
);
3038 if (GET_CODE (return_reg
) == PARALLEL
)
3039 emit_group_load (return_reg
, val
, type
, int_size_in_bytes (type
));
3041 emit_move_insn (return_reg
, val
);
3044 expand_null_return_1 ();
3047 /* Generate RTL to evaluate the expression RETVAL and return it
3048 from the current function. */
3051 expand_return (tree retval
)
3057 /* If function wants no value, give it none. */
3058 if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl
))) == VOID_TYPE
)
3060 expand_normal (retval
);
3061 expand_null_return ();
3065 if (retval
== error_mark_node
)
3067 /* Treat this like a return of no value from a function that
3069 expand_null_return ();
3072 else if ((TREE_CODE (retval
) == MODIFY_EXPR
3073 || TREE_CODE (retval
) == INIT_EXPR
)
3074 && TREE_CODE (TREE_OPERAND (retval
, 0)) == RESULT_DECL
)
3075 retval_rhs
= TREE_OPERAND (retval
, 1);
3077 retval_rhs
= retval
;
3079 result_rtl
= DECL_RTL (DECL_RESULT (current_function_decl
));
3081 /* If we are returning the RESULT_DECL, then the value has already
3082 been stored into it, so we don't have to do anything special. */
3083 if (TREE_CODE (retval_rhs
) == RESULT_DECL
)
3084 expand_value_return (result_rtl
);
3086 /* If the result is an aggregate that is being returned in one (or more)
3087 registers, load the registers here. */
3089 else if (retval_rhs
!= 0
3090 && TYPE_MODE (TREE_TYPE (retval_rhs
)) == BLKmode
3091 && REG_P (result_rtl
))
3093 val
= copy_blkmode_to_reg (GET_MODE (result_rtl
), retval_rhs
);
3096 /* Use the mode of the result value on the return register. */
3097 PUT_MODE (result_rtl
, GET_MODE (val
));
3098 expand_value_return (val
);
3101 expand_null_return ();
3103 else if (retval_rhs
!= 0
3104 && !VOID_TYPE_P (TREE_TYPE (retval_rhs
))
3105 && (REG_P (result_rtl
)
3106 || (GET_CODE (result_rtl
) == PARALLEL
)))
3108 /* Calculate the return value into a temporary (usually a pseudo
3110 tree ot
= TREE_TYPE (DECL_RESULT (current_function_decl
));
3111 tree nt
= build_qualified_type (ot
, TYPE_QUALS (ot
) | TYPE_QUAL_CONST
);
3113 val
= assign_temp (nt
, 0, 1);
3114 val
= expand_expr (retval_rhs
, val
, GET_MODE (val
), EXPAND_NORMAL
);
3115 val
= force_not_mem (val
);
3116 /* Return the calculated value. */
3117 expand_value_return (val
);
3121 /* No hard reg used; calculate value into hard return reg. */
3122 expand_expr (retval
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3123 expand_value_return (result_rtl
);
3127 /* A subroutine of expand_gimple_stmt, expanding one gimple statement
3128 STMT that doesn't require special handling for outgoing edges. That
3129 is no tailcalls and no GIMPLE_COND. */
3132 expand_gimple_stmt_1 (gimple stmt
)
3136 set_curr_insn_location (gimple_location (stmt
));
3138 switch (gimple_code (stmt
))
3141 op0
= gimple_goto_dest (stmt
);
3142 if (TREE_CODE (op0
) == LABEL_DECL
)
3145 expand_computed_goto (op0
);
3148 expand_label (gimple_label_label (stmt
));
3151 case GIMPLE_PREDICT
:
3157 expand_asm_stmt (stmt
);
3160 expand_call_stmt (stmt
);
3164 op0
= gimple_return_retval (stmt
);
3166 if (op0
&& op0
!= error_mark_node
)
3168 tree result
= DECL_RESULT (current_function_decl
);
3170 /* If we are not returning the current function's RESULT_DECL,
3171 build an assignment to it. */
3174 /* I believe that a function's RESULT_DECL is unique. */
3175 gcc_assert (TREE_CODE (op0
) != RESULT_DECL
);
3177 /* ??? We'd like to use simply expand_assignment here,
3178 but this fails if the value is of BLKmode but the return
3179 decl is a register. expand_return has special handling
3180 for this combination, which eventually should move
3181 to common code. See comments there. Until then, let's
3182 build a modify expression :-/ */
3183 op0
= build2 (MODIFY_EXPR
, TREE_TYPE (result
),
3188 expand_null_return ();
3190 expand_return (op0
);
3195 tree lhs
= gimple_assign_lhs (stmt
);
3197 /* Tree expand used to fiddle with |= and &= of two bitfield
3198 COMPONENT_REFs here. This can't happen with gimple, the LHS
3199 of binary assigns must be a gimple reg. */
3201 if (TREE_CODE (lhs
) != SSA_NAME
3202 || get_gimple_rhs_class (gimple_expr_code (stmt
))
3203 == GIMPLE_SINGLE_RHS
)
3205 tree rhs
= gimple_assign_rhs1 (stmt
);
3206 gcc_assert (get_gimple_rhs_class (gimple_expr_code (stmt
))
3207 == GIMPLE_SINGLE_RHS
);
3208 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (rhs
))
3209 SET_EXPR_LOCATION (rhs
, gimple_location (stmt
));
3210 if (TREE_CLOBBER_P (rhs
))
3211 /* This is a clobber to mark the going out of scope for
3215 expand_assignment (lhs
, rhs
,
3216 gimple_assign_nontemporal_move_p (stmt
));
3221 bool nontemporal
= gimple_assign_nontemporal_move_p (stmt
);
3222 struct separate_ops ops
;
3223 bool promoted
= false;
3225 target
= expand_expr (lhs
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
3226 if (GET_CODE (target
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (target
))
3229 ops
.code
= gimple_assign_rhs_code (stmt
);
3230 ops
.type
= TREE_TYPE (lhs
);
3231 switch (get_gimple_rhs_class (gimple_expr_code (stmt
)))
3233 case GIMPLE_TERNARY_RHS
:
3234 ops
.op2
= gimple_assign_rhs3 (stmt
);
3236 case GIMPLE_BINARY_RHS
:
3237 ops
.op1
= gimple_assign_rhs2 (stmt
);
3239 case GIMPLE_UNARY_RHS
:
3240 ops
.op0
= gimple_assign_rhs1 (stmt
);
3245 ops
.location
= gimple_location (stmt
);
3247 /* If we want to use a nontemporal store, force the value to
3248 register first. If we store into a promoted register,
3249 don't directly expand to target. */
3250 temp
= nontemporal
|| promoted
? NULL_RTX
: target
;
3251 temp
= expand_expr_real_2 (&ops
, temp
, GET_MODE (target
),
3258 int unsignedp
= SUBREG_PROMOTED_UNSIGNED_P (target
);
3259 /* If TEMP is a VOIDmode constant, use convert_modes to make
3260 sure that we properly convert it. */
3261 if (CONSTANT_P (temp
) && GET_MODE (temp
) == VOIDmode
)
3263 temp
= convert_modes (GET_MODE (target
),
3264 TYPE_MODE (ops
.type
),
3266 temp
= convert_modes (GET_MODE (SUBREG_REG (target
)),
3267 GET_MODE (target
), temp
, unsignedp
);
3270 convert_move (SUBREG_REG (target
), temp
, unsignedp
);
3272 else if (nontemporal
&& emit_storent_insn (target
, temp
))
3276 temp
= force_operand (temp
, target
);
3278 emit_move_insn (target
, temp
);
3289 /* Expand one gimple statement STMT and return the last RTL instruction
3290 before any of the newly generated ones.
3292 In addition to generating the necessary RTL instructions this also
3293 sets REG_EH_REGION notes if necessary and sets the current source
3294 location for diagnostics. */
3297 expand_gimple_stmt (gimple stmt
)
3299 location_t saved_location
= input_location
;
3300 rtx last
= get_last_insn ();
3305 /* We need to save and restore the current source location so that errors
3306 discovered during expansion are emitted with the right location. But
3307 it would be better if the diagnostic routines used the source location
3308 embedded in the tree nodes rather than globals. */
3309 if (gimple_has_location (stmt
))
3310 input_location
= gimple_location (stmt
);
3312 expand_gimple_stmt_1 (stmt
);
3314 /* Free any temporaries used to evaluate this statement. */
3317 input_location
= saved_location
;
3319 /* Mark all insns that may trap. */
3320 lp_nr
= lookup_stmt_eh_lp (stmt
);
3324 for (insn
= next_real_insn (last
); insn
;
3325 insn
= next_real_insn (insn
))
3327 if (! find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
3328 /* If we want exceptions for non-call insns, any
3329 may_trap_p instruction may throw. */
3330 && GET_CODE (PATTERN (insn
)) != CLOBBER
3331 && GET_CODE (PATTERN (insn
)) != USE
3332 && insn_could_throw_p (insn
))
3333 make_reg_eh_region_note (insn
, 0, lp_nr
);
3340 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_CALL
3341 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
3342 generated a tail call (something that might be denied by the ABI
3343 rules governing the call; see calls.c).
3345 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
3346 can still reach the rest of BB. The case here is __builtin_sqrt,
3347 where the NaN result goes through the external function (with a
3348 tailcall) and the normal result happens via a sqrt instruction. */
3351 expand_gimple_tailcall (basic_block bb
, gimple stmt
, bool *can_fallthru
)
3359 last2
= last
= expand_gimple_stmt (stmt
);
3361 for (last
= NEXT_INSN (last
); last
; last
= NEXT_INSN (last
))
3362 if (CALL_P (last
) && SIBLING_CALL_P (last
))
3365 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
3367 *can_fallthru
= true;
3371 /* ??? Wouldn't it be better to just reset any pending stack adjust?
3372 Any instructions emitted here are about to be deleted. */
3373 do_pending_stack_adjust ();
3375 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
3376 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
3377 EH or abnormal edges, we shouldn't have created a tail call in
3378 the first place. So it seems to me we should just be removing
3379 all edges here, or redirecting the existing fallthru edge to
3385 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
3387 if (!(e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
)))
3389 if (e
->dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
3391 e
->dest
->count
-= e
->count
;
3392 e
->dest
->frequency
-= EDGE_FREQUENCY (e
);
3393 if (e
->dest
->count
< 0)
3395 if (e
->dest
->frequency
< 0)
3396 e
->dest
->frequency
= 0;
3399 probability
+= e
->probability
;
3406 /* This is somewhat ugly: the call_expr expander often emits instructions
3407 after the sibcall (to perform the function return). These confuse the
3408 find_many_sub_basic_blocks code, so we need to get rid of these. */
3409 last
= NEXT_INSN (last
);
3410 gcc_assert (BARRIER_P (last
));
3412 *can_fallthru
= false;
3413 while (NEXT_INSN (last
))
3415 /* For instance an sqrt builtin expander expands if with
3416 sibcall in the then and label for `else`. */
3417 if (LABEL_P (NEXT_INSN (last
)))
3419 *can_fallthru
= true;
3422 delete_insn (NEXT_INSN (last
));
3425 e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_ABNORMAL
3427 e
->probability
+= probability
;
3430 update_bb_for_insn (bb
);
3432 if (NEXT_INSN (last
))
3434 bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
3437 if (BARRIER_P (last
))
3438 BB_END (bb
) = PREV_INSN (last
);
3441 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
3446 /* Return the difference between the floor and the truncated result of
3447 a signed division by OP1 with remainder MOD. */
3449 floor_sdiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1
)
3451 /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
3452 return gen_rtx_IF_THEN_ELSE
3453 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3454 gen_rtx_IF_THEN_ELSE
3455 (mode
, gen_rtx_LT (BImode
,
3456 gen_rtx_DIV (mode
, op1
, mod
),
3458 constm1_rtx
, const0_rtx
),
3462 /* Return the difference between the ceil and the truncated result of
3463 a signed division by OP1 with remainder MOD. */
3465 ceil_sdiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1
)
3467 /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
3468 return gen_rtx_IF_THEN_ELSE
3469 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3470 gen_rtx_IF_THEN_ELSE
3471 (mode
, gen_rtx_GT (BImode
,
3472 gen_rtx_DIV (mode
, op1
, mod
),
3474 const1_rtx
, const0_rtx
),
3478 /* Return the difference between the ceil and the truncated result of
3479 an unsigned division by OP1 with remainder MOD. */
3481 ceil_udiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1 ATTRIBUTE_UNUSED
)
3483 /* (mod != 0 ? 1 : 0) */
3484 return gen_rtx_IF_THEN_ELSE
3485 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3486 const1_rtx
, const0_rtx
);
3489 /* Return the difference between the rounded and the truncated result
3490 of a signed division by OP1 with remainder MOD. Halfway cases are
3491 rounded away from zero, rather than to the nearest even number. */
3493 round_sdiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1
)
3495 /* (abs (mod) >= abs (op1) - abs (mod)
3496 ? (op1 / mod > 0 ? 1 : -1)
3498 return gen_rtx_IF_THEN_ELSE
3499 (mode
, gen_rtx_GE (BImode
, gen_rtx_ABS (mode
, mod
),
3500 gen_rtx_MINUS (mode
,
3501 gen_rtx_ABS (mode
, op1
),
3502 gen_rtx_ABS (mode
, mod
))),
3503 gen_rtx_IF_THEN_ELSE
3504 (mode
, gen_rtx_GT (BImode
,
3505 gen_rtx_DIV (mode
, op1
, mod
),
3507 const1_rtx
, constm1_rtx
),
3511 /* Return the difference between the rounded and the truncated result
3512 of a unsigned division by OP1 with remainder MOD. Halfway cases
3513 are rounded away from zero, rather than to the nearest even
3516 round_udiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1
)
3518 /* (mod >= op1 - mod ? 1 : 0) */
3519 return gen_rtx_IF_THEN_ELSE
3520 (mode
, gen_rtx_GE (BImode
, mod
,
3521 gen_rtx_MINUS (mode
, op1
, mod
)),
3522 const1_rtx
, const0_rtx
);
3525 /* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
3529 convert_debug_memory_address (enum machine_mode mode
, rtx x
,
3532 enum machine_mode xmode
= GET_MODE (x
);
3534 #ifndef POINTERS_EXTEND_UNSIGNED
3535 gcc_assert (mode
== Pmode
3536 || mode
== targetm
.addr_space
.address_mode (as
));
3537 gcc_assert (xmode
== mode
|| xmode
== VOIDmode
);
3541 gcc_assert (targetm
.addr_space
.valid_pointer_mode (mode
, as
));
3543 if (GET_MODE (x
) == mode
|| GET_MODE (x
) == VOIDmode
)
3546 if (GET_MODE_PRECISION (mode
) < GET_MODE_PRECISION (xmode
))
3547 x
= simplify_gen_subreg (mode
, x
, xmode
,
3548 subreg_lowpart_offset
3550 else if (POINTERS_EXTEND_UNSIGNED
> 0)
3551 x
= gen_rtx_ZERO_EXTEND (mode
, x
);
3552 else if (!POINTERS_EXTEND_UNSIGNED
)
3553 x
= gen_rtx_SIGN_EXTEND (mode
, x
);
3556 switch (GET_CODE (x
))
3559 if ((SUBREG_PROMOTED_VAR_P (x
)
3560 || (REG_P (SUBREG_REG (x
)) && REG_POINTER (SUBREG_REG (x
)))
3561 || (GET_CODE (SUBREG_REG (x
)) == PLUS
3562 && REG_P (XEXP (SUBREG_REG (x
), 0))
3563 && REG_POINTER (XEXP (SUBREG_REG (x
), 0))
3564 && CONST_INT_P (XEXP (SUBREG_REG (x
), 1))))
3565 && GET_MODE (SUBREG_REG (x
)) == mode
)
3566 return SUBREG_REG (x
);
3569 temp
= gen_rtx_LABEL_REF (mode
, XEXP (x
, 0));
3570 LABEL_REF_NONLOCAL_P (temp
) = LABEL_REF_NONLOCAL_P (x
);
3573 temp
= shallow_copy_rtx (x
);
3574 PUT_MODE (temp
, mode
);
3577 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
3579 temp
= gen_rtx_CONST (mode
, temp
);
3583 if (CONST_INT_P (XEXP (x
, 1)))
3585 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
3587 return gen_rtx_fmt_ee (GET_CODE (x
), mode
, temp
, XEXP (x
, 1));
3593 /* Don't know how to express ptr_extend as operation in debug info. */
3596 #endif /* POINTERS_EXTEND_UNSIGNED */
3601 /* Return an RTX equivalent to the value of the parameter DECL. */
3604 expand_debug_parm_decl (tree decl
)
3606 rtx incoming
= DECL_INCOMING_RTL (decl
);
3609 && GET_MODE (incoming
) != BLKmode
3610 && ((REG_P (incoming
) && HARD_REGISTER_P (incoming
))
3611 || (MEM_P (incoming
)
3612 && REG_P (XEXP (incoming
, 0))
3613 && HARD_REGISTER_P (XEXP (incoming
, 0)))))
3615 rtx rtl
= gen_rtx_ENTRY_VALUE (GET_MODE (incoming
));
3617 #ifdef HAVE_window_save
3618 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
3619 If the target machine has an explicit window save instruction, the
3620 actual entry value is the corresponding OUTGOING_REGNO instead. */
3621 if (REG_P (incoming
)
3622 && OUTGOING_REGNO (REGNO (incoming
)) != REGNO (incoming
))
3624 = gen_rtx_REG_offset (incoming
, GET_MODE (incoming
),
3625 OUTGOING_REGNO (REGNO (incoming
)), 0);
3626 else if (MEM_P (incoming
))
3628 rtx reg
= XEXP (incoming
, 0);
3629 if (OUTGOING_REGNO (REGNO (reg
)) != REGNO (reg
))
3631 reg
= gen_raw_REG (GET_MODE (reg
), OUTGOING_REGNO (REGNO (reg
)));
3632 incoming
= replace_equiv_address_nv (incoming
, reg
);
3635 incoming
= copy_rtx (incoming
);
3639 ENTRY_VALUE_EXP (rtl
) = incoming
;
3644 && GET_MODE (incoming
) != BLKmode
3645 && !TREE_ADDRESSABLE (decl
)
3647 && (XEXP (incoming
, 0) == virtual_incoming_args_rtx
3648 || (GET_CODE (XEXP (incoming
, 0)) == PLUS
3649 && XEXP (XEXP (incoming
, 0), 0) == virtual_incoming_args_rtx
3650 && CONST_INT_P (XEXP (XEXP (incoming
, 0), 1)))))
3651 return copy_rtx (incoming
);
3656 /* Return an RTX equivalent to the value of the tree expression EXP. */
3659 expand_debug_expr (tree exp
)
3661 rtx op0
= NULL_RTX
, op1
= NULL_RTX
, op2
= NULL_RTX
;
3662 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
3663 enum machine_mode inner_mode
= VOIDmode
;
3664 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (exp
));
3667 switch (TREE_CODE_CLASS (TREE_CODE (exp
)))
3669 case tcc_expression
:
3670 switch (TREE_CODE (exp
))
3674 case WIDEN_MULT_PLUS_EXPR
:
3675 case WIDEN_MULT_MINUS_EXPR
:
3679 case TRUTH_ANDIF_EXPR
:
3680 case TRUTH_ORIF_EXPR
:
3681 case TRUTH_AND_EXPR
:
3683 case TRUTH_XOR_EXPR
:
3686 case TRUTH_NOT_EXPR
:
3695 op2
= expand_debug_expr (TREE_OPERAND (exp
, 2));
3702 case tcc_comparison
:
3703 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
3710 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
3711 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
3721 case tcc_exceptional
:
3722 case tcc_declaration
:
3728 switch (TREE_CODE (exp
))
3731 if (!lookup_constant_def (exp
))
3733 if (strlen (TREE_STRING_POINTER (exp
)) + 1
3734 != (size_t) TREE_STRING_LENGTH (exp
))
3736 op0
= gen_rtx_CONST_STRING (Pmode
, TREE_STRING_POINTER (exp
));
3737 op0
= gen_rtx_MEM (BLKmode
, op0
);
3738 set_mem_attributes (op0
, exp
, 0);
3741 /* Fall through... */
3746 op0
= expand_expr (exp
, NULL_RTX
, mode
, EXPAND_INITIALIZER
);
3750 gcc_assert (COMPLEX_MODE_P (mode
));
3751 op0
= expand_debug_expr (TREE_REALPART (exp
));
3752 op1
= expand_debug_expr (TREE_IMAGPART (exp
));
3753 return gen_rtx_CONCAT (mode
, op0
, op1
);
3755 case DEBUG_EXPR_DECL
:
3756 op0
= DECL_RTL_IF_SET (exp
);
3761 op0
= gen_rtx_DEBUG_EXPR (mode
);
3762 DEBUG_EXPR_TREE_DECL (op0
) = exp
;
3763 SET_DECL_RTL (exp
, op0
);
3773 op0
= DECL_RTL_IF_SET (exp
);
3775 /* This decl was probably optimized away. */
3778 if (TREE_CODE (exp
) != VAR_DECL
3779 || DECL_EXTERNAL (exp
)
3780 || !TREE_STATIC (exp
)
3782 || DECL_HARD_REGISTER (exp
)
3783 || DECL_IN_CONSTANT_POOL (exp
)
3784 || mode
== VOIDmode
)
3787 op0
= make_decl_rtl_for_debug (exp
);
3789 || GET_CODE (XEXP (op0
, 0)) != SYMBOL_REF
3790 || SYMBOL_REF_DECL (XEXP (op0
, 0)) != exp
)
3794 op0
= copy_rtx (op0
);
3796 if (GET_MODE (op0
) == BLKmode
3797 /* If op0 is not BLKmode, but BLKmode is, adjust_mode
3798 below would ICE. While it is likely a FE bug,
3799 try to be robust here. See PR43166. */
3801 || (mode
== VOIDmode
&& GET_MODE (op0
) != VOIDmode
))
3803 gcc_assert (MEM_P (op0
));
3804 op0
= adjust_address_nv (op0
, mode
, 0);
3815 inner_mode
= GET_MODE (op0
);
3817 if (mode
== inner_mode
)
3820 if (inner_mode
== VOIDmode
)
3822 if (TREE_CODE (exp
) == SSA_NAME
)
3823 inner_mode
= TYPE_MODE (TREE_TYPE (exp
));
3825 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
3826 if (mode
== inner_mode
)
3830 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
3832 if (GET_MODE_BITSIZE (mode
) == GET_MODE_BITSIZE (inner_mode
))
3833 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
3834 else if (GET_MODE_BITSIZE (mode
) < GET_MODE_BITSIZE (inner_mode
))
3835 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
3837 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
3839 else if (FLOAT_MODE_P (mode
))
3841 gcc_assert (TREE_CODE (exp
) != SSA_NAME
);
3842 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
3843 op0
= simplify_gen_unary (UNSIGNED_FLOAT
, mode
, op0
, inner_mode
);
3845 op0
= simplify_gen_unary (FLOAT
, mode
, op0
, inner_mode
);
3847 else if (FLOAT_MODE_P (inner_mode
))
3850 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
3852 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
3854 else if (CONSTANT_P (op0
)
3855 || GET_MODE_PRECISION (mode
) <= GET_MODE_PRECISION (inner_mode
))
3856 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
,
3857 subreg_lowpart_offset (mode
,
3859 else if (TREE_CODE_CLASS (TREE_CODE (exp
)) == tcc_unary
3860 ? TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)))
3862 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
3864 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
3870 if (!is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
3872 tree newexp
= fold_binary (MEM_REF
, TREE_TYPE (exp
),
3873 TREE_OPERAND (exp
, 0),
3874 TREE_OPERAND (exp
, 1));
3876 return expand_debug_expr (newexp
);
3880 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
3881 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
3885 if (TREE_CODE (exp
) == MEM_REF
)
3887 if (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
3888 || (GET_CODE (op0
) == PLUS
3889 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
))
3890 /* (mem (debug_implicit_ptr)) might confuse aliasing.
3891 Instead just use get_inner_reference. */
3894 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
3895 if (!op1
|| !CONST_INT_P (op1
))
3898 op0
= plus_constant (inner_mode
, op0
, INTVAL (op1
));
3901 if (POINTER_TYPE_P (TREE_TYPE (exp
)))
3902 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)));
3904 as
= ADDR_SPACE_GENERIC
;
3906 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
3908 if (op0
== NULL_RTX
)
3911 op0
= gen_rtx_MEM (mode
, op0
);
3912 set_mem_attributes (op0
, exp
, 0);
3913 if (TREE_CODE (exp
) == MEM_REF
3914 && !is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
3915 set_mem_expr (op0
, NULL_TREE
);
3916 set_mem_addr_space (op0
, as
);
3920 case TARGET_MEM_REF
:
3921 if (TREE_CODE (TMR_BASE (exp
)) == ADDR_EXPR
3922 && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp
), 0)))
3925 op0
= expand_debug_expr
3926 (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp
)), exp
));
3930 if (POINTER_TYPE_P (TREE_TYPE (exp
)))
3931 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)));
3933 as
= ADDR_SPACE_GENERIC
;
3935 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
3937 if (op0
== NULL_RTX
)
3940 op0
= gen_rtx_MEM (mode
, op0
);
3942 set_mem_attributes (op0
, exp
, 0);
3943 set_mem_addr_space (op0
, as
);
3949 case ARRAY_RANGE_REF
:
3954 case VIEW_CONVERT_EXPR
:
3956 enum machine_mode mode1
;
3957 HOST_WIDE_INT bitsize
, bitpos
;
3960 tree tem
= get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
,
3961 &mode1
, &unsignedp
, &volatilep
, false);
3967 orig_op0
= op0
= expand_debug_expr (tem
);
3974 enum machine_mode addrmode
, offmode
;
3979 op0
= XEXP (op0
, 0);
3980 addrmode
= GET_MODE (op0
);
3981 if (addrmode
== VOIDmode
)
3984 op1
= expand_debug_expr (offset
);
3988 offmode
= GET_MODE (op1
);
3989 if (offmode
== VOIDmode
)
3990 offmode
= TYPE_MODE (TREE_TYPE (offset
));
3992 if (addrmode
!= offmode
)
3993 op1
= simplify_gen_subreg (addrmode
, op1
, offmode
,
3994 subreg_lowpart_offset (addrmode
,
3997 /* Don't use offset_address here, we don't need a
3998 recognizable address, and we don't want to generate
4000 op0
= gen_rtx_MEM (mode
, simplify_gen_binary (PLUS
, addrmode
,
4006 if (mode1
== VOIDmode
)
4008 mode1
= smallest_mode_for_size (bitsize
, MODE_INT
);
4009 if (bitpos
>= BITS_PER_UNIT
)
4011 op0
= adjust_address_nv (op0
, mode1
, bitpos
/ BITS_PER_UNIT
);
4012 bitpos
%= BITS_PER_UNIT
;
4014 else if (bitpos
< 0)
4017 = (-bitpos
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
4018 op0
= adjust_address_nv (op0
, mode1
, units
);
4019 bitpos
+= units
* BITS_PER_UNIT
;
4021 else if (bitpos
== 0 && bitsize
== GET_MODE_BITSIZE (mode
))
4022 op0
= adjust_address_nv (op0
, mode
, 0);
4023 else if (GET_MODE (op0
) != mode1
)
4024 op0
= adjust_address_nv (op0
, mode1
, 0);
4026 op0
= copy_rtx (op0
);
4027 if (op0
== orig_op0
)
4028 op0
= shallow_copy_rtx (op0
);
4029 set_mem_attributes (op0
, exp
, 0);
4032 if (bitpos
== 0 && mode
== GET_MODE (op0
))
4038 if (GET_MODE (op0
) == BLKmode
)
4041 if ((bitpos
% BITS_PER_UNIT
) == 0
4042 && bitsize
== GET_MODE_BITSIZE (mode1
))
4044 enum machine_mode opmode
= GET_MODE (op0
);
4046 if (opmode
== VOIDmode
)
4047 opmode
= TYPE_MODE (TREE_TYPE (tem
));
4049 /* This condition may hold if we're expanding the address
4050 right past the end of an array that turned out not to
4051 be addressable (i.e., the address was only computed in
4052 debug stmts). The gen_subreg below would rightfully
4053 crash, and the address doesn't really exist, so just
4055 if (bitpos
>= GET_MODE_BITSIZE (opmode
))
4058 if ((bitpos
% GET_MODE_BITSIZE (mode
)) == 0)
4059 return simplify_gen_subreg (mode
, op0
, opmode
,
4060 bitpos
/ BITS_PER_UNIT
);
4063 return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0
))
4064 && TYPE_UNSIGNED (TREE_TYPE (exp
))
4066 : ZERO_EXTRACT
, mode
,
4067 GET_MODE (op0
) != VOIDmode
4069 : TYPE_MODE (TREE_TYPE (tem
)),
4070 op0
, GEN_INT (bitsize
), GEN_INT (bitpos
));
4074 return simplify_gen_unary (ABS
, mode
, op0
, mode
);
4077 return simplify_gen_unary (NEG
, mode
, op0
, mode
);
4080 return simplify_gen_unary (NOT
, mode
, op0
, mode
);
4083 return simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4085 ? UNSIGNED_FLOAT
: FLOAT
, mode
, op0
,
4088 case FIX_TRUNC_EXPR
:
4089 return simplify_gen_unary (unsignedp
? UNSIGNED_FIX
: FIX
, mode
, op0
,
4092 case POINTER_PLUS_EXPR
:
4093 /* For the rare target where pointers are not the same size as
4094 size_t, we need to check for mis-matched modes and correct
4097 && GET_MODE (op0
) != VOIDmode
&& GET_MODE (op1
) != VOIDmode
4098 && GET_MODE (op0
) != GET_MODE (op1
))
4100 if (GET_MODE_BITSIZE (GET_MODE (op0
)) < GET_MODE_BITSIZE (GET_MODE (op1
))
4101 /* If OP0 is a partial mode, then we must truncate, even if it has
4102 the same bitsize as OP1 as GCC's representation of partial modes
4104 || (GET_MODE_CLASS (GET_MODE (op0
)) == MODE_PARTIAL_INT
4105 && GET_MODE_BITSIZE (GET_MODE (op0
)) == GET_MODE_BITSIZE (GET_MODE (op1
))))
4106 op1
= simplify_gen_unary (TRUNCATE
, GET_MODE (op0
), op1
,
4109 /* We always sign-extend, regardless of the signedness of
4110 the operand, because the operand is always unsigned
4111 here even if the original C expression is signed. */
4112 op1
= simplify_gen_unary (SIGN_EXTEND
, GET_MODE (op0
), op1
,
4117 return simplify_gen_binary (PLUS
, mode
, op0
, op1
);
4120 return simplify_gen_binary (MINUS
, mode
, op0
, op1
);
4123 return simplify_gen_binary (MULT
, mode
, op0
, op1
);
4126 case TRUNC_DIV_EXPR
:
4127 case EXACT_DIV_EXPR
:
4129 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4131 return simplify_gen_binary (DIV
, mode
, op0
, op1
);
4133 case TRUNC_MOD_EXPR
:
4134 return simplify_gen_binary (unsignedp
? UMOD
: MOD
, mode
, op0
, op1
);
4136 case FLOOR_DIV_EXPR
:
4138 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4141 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4142 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4143 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4144 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4147 case FLOOR_MOD_EXPR
:
4149 return simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4152 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4153 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4154 adj
= simplify_gen_unary (NEG
, mode
,
4155 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4157 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4163 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4164 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4165 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4166 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4170 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4171 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4172 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4173 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4179 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4180 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4181 adj
= simplify_gen_unary (NEG
, mode
,
4182 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4184 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4188 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4189 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4190 adj
= simplify_gen_unary (NEG
, mode
,
4191 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4193 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4196 case ROUND_DIV_EXPR
:
4199 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4200 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4201 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4202 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4206 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4207 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4208 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4209 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4212 case ROUND_MOD_EXPR
:
4215 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4216 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4217 adj
= simplify_gen_unary (NEG
, mode
,
4218 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4220 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4224 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4225 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4226 adj
= simplify_gen_unary (NEG
, mode
,
4227 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4229 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4233 return simplify_gen_binary (ASHIFT
, mode
, op0
, op1
);
4237 return simplify_gen_binary (LSHIFTRT
, mode
, op0
, op1
);
4239 return simplify_gen_binary (ASHIFTRT
, mode
, op0
, op1
);
4242 return simplify_gen_binary (ROTATE
, mode
, op0
, op1
);
4245 return simplify_gen_binary (ROTATERT
, mode
, op0
, op1
);
4248 return simplify_gen_binary (unsignedp
? UMIN
: SMIN
, mode
, op0
, op1
);
4251 return simplify_gen_binary (unsignedp
? UMAX
: SMAX
, mode
, op0
, op1
);
4254 case TRUTH_AND_EXPR
:
4255 return simplify_gen_binary (AND
, mode
, op0
, op1
);
4259 return simplify_gen_binary (IOR
, mode
, op0
, op1
);
4262 case TRUTH_XOR_EXPR
:
4263 return simplify_gen_binary (XOR
, mode
, op0
, op1
);
4265 case TRUTH_ANDIF_EXPR
:
4266 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, const0_rtx
);
4268 case TRUTH_ORIF_EXPR
:
4269 return gen_rtx_IF_THEN_ELSE (mode
, op0
, const_true_rtx
, op1
);
4271 case TRUTH_NOT_EXPR
:
4272 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, const0_rtx
);
4275 return simplify_gen_relational (unsignedp
? LTU
: LT
, mode
, inner_mode
,
4279 return simplify_gen_relational (unsignedp
? LEU
: LE
, mode
, inner_mode
,
4283 return simplify_gen_relational (unsignedp
? GTU
: GT
, mode
, inner_mode
,
4287 return simplify_gen_relational (unsignedp
? GEU
: GE
, mode
, inner_mode
,
4291 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, op1
);
4294 return simplify_gen_relational (NE
, mode
, inner_mode
, op0
, op1
);
4296 case UNORDERED_EXPR
:
4297 return simplify_gen_relational (UNORDERED
, mode
, inner_mode
, op0
, op1
);
4300 return simplify_gen_relational (ORDERED
, mode
, inner_mode
, op0
, op1
);
4303 return simplify_gen_relational (UNLT
, mode
, inner_mode
, op0
, op1
);
4306 return simplify_gen_relational (UNLE
, mode
, inner_mode
, op0
, op1
);
4309 return simplify_gen_relational (UNGT
, mode
, inner_mode
, op0
, op1
);
4312 return simplify_gen_relational (UNGE
, mode
, inner_mode
, op0
, op1
);
4315 return simplify_gen_relational (UNEQ
, mode
, inner_mode
, op0
, op1
);
4318 return simplify_gen_relational (LTGT
, mode
, inner_mode
, op0
, op1
);
4321 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, op2
);
4324 gcc_assert (COMPLEX_MODE_P (mode
));
4325 if (GET_MODE (op0
) == VOIDmode
)
4326 op0
= gen_rtx_CONST (GET_MODE_INNER (mode
), op0
);
4327 if (GET_MODE (op1
) == VOIDmode
)
4328 op1
= gen_rtx_CONST (GET_MODE_INNER (mode
), op1
);
4329 return gen_rtx_CONCAT (mode
, op0
, op1
);
4332 if (GET_CODE (op0
) == CONCAT
)
4333 return gen_rtx_CONCAT (mode
, XEXP (op0
, 0),
4334 simplify_gen_unary (NEG
, GET_MODE_INNER (mode
),
4336 GET_MODE_INNER (mode
)));
4339 enum machine_mode imode
= GET_MODE_INNER (mode
);
4344 re
= adjust_address_nv (op0
, imode
, 0);
4345 im
= adjust_address_nv (op0
, imode
, GET_MODE_SIZE (imode
));
4349 enum machine_mode ifmode
= int_mode_for_mode (mode
);
4350 enum machine_mode ihmode
= int_mode_for_mode (imode
);
4352 if (ifmode
== BLKmode
|| ihmode
== BLKmode
)
4354 halfsize
= GEN_INT (GET_MODE_BITSIZE (ihmode
));
4357 re
= gen_rtx_SUBREG (ifmode
, re
, 0);
4358 re
= gen_rtx_ZERO_EXTRACT (ihmode
, re
, halfsize
, const0_rtx
);
4359 if (imode
!= ihmode
)
4360 re
= gen_rtx_SUBREG (imode
, re
, 0);
4361 im
= copy_rtx (op0
);
4363 im
= gen_rtx_SUBREG (ifmode
, im
, 0);
4364 im
= gen_rtx_ZERO_EXTRACT (ihmode
, im
, halfsize
, halfsize
);
4365 if (imode
!= ihmode
)
4366 im
= gen_rtx_SUBREG (imode
, im
, 0);
4368 im
= gen_rtx_NEG (imode
, im
);
4369 return gen_rtx_CONCAT (mode
, re
, im
);
4373 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4374 if (!op0
|| !MEM_P (op0
))
4376 if ((TREE_CODE (TREE_OPERAND (exp
, 0)) == VAR_DECL
4377 || TREE_CODE (TREE_OPERAND (exp
, 0)) == PARM_DECL
4378 || TREE_CODE (TREE_OPERAND (exp
, 0)) == RESULT_DECL
)
4379 && (!TREE_ADDRESSABLE (TREE_OPERAND (exp
, 0))
4380 || target_for_debug_bind (TREE_OPERAND (exp
, 0))))
4381 return gen_rtx_DEBUG_IMPLICIT_PTR (mode
, TREE_OPERAND (exp
, 0));
4383 if (handled_component_p (TREE_OPERAND (exp
, 0)))
4385 HOST_WIDE_INT bitoffset
, bitsize
, maxsize
;
4387 = get_ref_base_and_extent (TREE_OPERAND (exp
, 0),
4388 &bitoffset
, &bitsize
, &maxsize
);
4389 if ((TREE_CODE (decl
) == VAR_DECL
4390 || TREE_CODE (decl
) == PARM_DECL
4391 || TREE_CODE (decl
) == RESULT_DECL
)
4392 && (!TREE_ADDRESSABLE (decl
)
4393 || target_for_debug_bind (decl
))
4394 && (bitoffset
% BITS_PER_UNIT
) == 0
4396 && bitsize
== maxsize
)
4398 rtx base
= gen_rtx_DEBUG_IMPLICIT_PTR (mode
, decl
);
4399 return plus_constant (mode
, base
, bitoffset
/ BITS_PER_UNIT
);
4403 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == MEM_REF
4404 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
4407 op0
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
4410 && (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
4411 || (GET_CODE (op0
) == PLUS
4412 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
4413 && CONST_INT_P (XEXP (op0
, 1)))))
4415 op1
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
4417 if (!op1
|| !CONST_INT_P (op1
))
4420 return plus_constant (mode
, op0
, INTVAL (op1
));
4427 as
= TYPE_ADDR_SPACE (TREE_TYPE (exp
));
4428 op0
= convert_debug_memory_address (mode
, XEXP (op0
, 0), as
);
4436 op0
= gen_rtx_CONCATN
4437 (mode
, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
))));
4439 for (i
= 0; i
< VECTOR_CST_NELTS (exp
); ++i
)
4441 op1
= expand_debug_expr (VECTOR_CST_ELT (exp
, i
));
4444 XVECEXP (op0
, 0, i
) = op1
;
4451 if (TREE_CLOBBER_P (exp
))
4453 else if (TREE_CODE (TREE_TYPE (exp
)) == VECTOR_TYPE
)
4458 op0
= gen_rtx_CONCATN
4459 (mode
, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
))));
4461 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), i
, val
)
4463 op1
= expand_debug_expr (val
);
4466 XVECEXP (op0
, 0, i
) = op1
;
4469 if (i
< TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)))
4471 op1
= expand_debug_expr
4472 (build_zero_cst (TREE_TYPE (TREE_TYPE (exp
))));
4477 for (; i
< TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)); i
++)
4478 XVECEXP (op0
, 0, i
) = op1
;
4484 goto flag_unsupported
;
4487 /* ??? Maybe handle some builtins? */
4492 gimple g
= get_gimple_for_ssa_name (exp
);
4495 op0
= expand_debug_expr (gimple_assign_rhs_to_tree (g
));
4501 int part
= var_to_partition (SA
.map
, exp
);
4503 if (part
== NO_PARTITION
)
4505 /* If this is a reference to an incoming value of parameter
4506 that is never used in the code or where the incoming
4507 value is never used in the code, use PARM_DECL's
4509 if (SSA_NAME_IS_DEFAULT_DEF (exp
)
4510 && TREE_CODE (SSA_NAME_VAR (exp
)) == PARM_DECL
)
4512 op0
= expand_debug_parm_decl (SSA_NAME_VAR (exp
));
4515 op0
= expand_debug_expr (SSA_NAME_VAR (exp
));
4522 gcc_assert (part
>= 0 && (unsigned)part
< SA
.map
->num_partitions
);
4524 op0
= copy_rtx (SA
.partition_to_pseudo
[part
]);
4532 /* Vector stuff. For most of the codes we don't have rtl codes. */
4533 case REALIGN_LOAD_EXPR
:
4534 case REDUC_MAX_EXPR
:
4535 case REDUC_MIN_EXPR
:
4536 case REDUC_PLUS_EXPR
:
4538 case VEC_LSHIFT_EXPR
:
4539 case VEC_PACK_FIX_TRUNC_EXPR
:
4540 case VEC_PACK_SAT_EXPR
:
4541 case VEC_PACK_TRUNC_EXPR
:
4542 case VEC_RSHIFT_EXPR
:
4543 case VEC_UNPACK_FLOAT_HI_EXPR
:
4544 case VEC_UNPACK_FLOAT_LO_EXPR
:
4545 case VEC_UNPACK_HI_EXPR
:
4546 case VEC_UNPACK_LO_EXPR
:
4547 case VEC_WIDEN_MULT_HI_EXPR
:
4548 case VEC_WIDEN_MULT_LO_EXPR
:
4549 case VEC_WIDEN_MULT_EVEN_EXPR
:
4550 case VEC_WIDEN_MULT_ODD_EXPR
:
4551 case VEC_WIDEN_LSHIFT_HI_EXPR
:
4552 case VEC_WIDEN_LSHIFT_LO_EXPR
:
4557 case ADDR_SPACE_CONVERT_EXPR
:
4558 case FIXED_CONVERT_EXPR
:
4560 case WITH_SIZE_EXPR
:
4564 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
4565 && SCALAR_INT_MODE_P (mode
))
4568 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4570 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
4573 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4575 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op1
,
4577 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
4578 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
4582 case WIDEN_MULT_EXPR
:
4583 case WIDEN_MULT_PLUS_EXPR
:
4584 case WIDEN_MULT_MINUS_EXPR
:
4585 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
4586 && SCALAR_INT_MODE_P (mode
))
4588 inner_mode
= GET_MODE (op0
);
4589 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
4590 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
4592 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
4593 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 1))))
4594 op1
= simplify_gen_unary (ZERO_EXTEND
, mode
, op1
, inner_mode
);
4596 op1
= simplify_gen_unary (SIGN_EXTEND
, mode
, op1
, inner_mode
);
4597 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
4598 if (TREE_CODE (exp
) == WIDEN_MULT_EXPR
)
4600 else if (TREE_CODE (exp
) == WIDEN_MULT_PLUS_EXPR
)
4601 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
4603 return simplify_gen_binary (MINUS
, mode
, op2
, op0
);
4607 case MULT_HIGHPART_EXPR
:
4608 /* ??? Similar to the above. */
4611 case WIDEN_SUM_EXPR
:
4612 case WIDEN_LSHIFT_EXPR
:
4613 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
4614 && SCALAR_INT_MODE_P (mode
))
4617 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4619 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
4621 return simplify_gen_binary (TREE_CODE (exp
) == WIDEN_LSHIFT_EXPR
4622 ? ASHIFT
: PLUS
, mode
, op0
, op1
);
4627 return simplify_gen_ternary (FMA
, mode
, inner_mode
, op0
, op1
, op2
);
4631 #ifdef ENABLE_CHECKING
4640 /* Return an RTX equivalent to the source bind value of the tree expression
4644 expand_debug_source_expr (tree exp
)
4647 enum machine_mode mode
= VOIDmode
, inner_mode
;
4649 switch (TREE_CODE (exp
))
4653 mode
= DECL_MODE (exp
);
4654 op0
= expand_debug_parm_decl (exp
);
4657 /* See if this isn't an argument that has been completely
4659 if (!DECL_RTL_SET_P (exp
)
4660 && !DECL_INCOMING_RTL (exp
)
4661 && DECL_ABSTRACT_ORIGIN (current_function_decl
))
4663 tree aexp
= DECL_ORIGIN (exp
);
4664 if (DECL_CONTEXT (aexp
)
4665 == DECL_ABSTRACT_ORIGIN (current_function_decl
))
4667 vec
<tree
, va_gc
> **debug_args
;
4670 debug_args
= decl_debug_args_lookup (current_function_decl
);
4671 if (debug_args
!= NULL
)
4673 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, &ddecl
);
4676 return gen_rtx_DEBUG_PARAMETER_REF (mode
, aexp
);
4686 if (op0
== NULL_RTX
)
4689 inner_mode
= GET_MODE (op0
);
4690 if (mode
== inner_mode
)
4693 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
4695 if (GET_MODE_BITSIZE (mode
) == GET_MODE_BITSIZE (inner_mode
))
4696 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
4697 else if (GET_MODE_BITSIZE (mode
) < GET_MODE_BITSIZE (inner_mode
))
4698 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
4700 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
4702 else if (FLOAT_MODE_P (mode
))
4704 else if (FLOAT_MODE_P (inner_mode
))
4706 if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
4707 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
4709 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
4711 else if (CONSTANT_P (op0
)
4712 || GET_MODE_BITSIZE (mode
) <= GET_MODE_BITSIZE (inner_mode
))
4713 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
,
4714 subreg_lowpart_offset (mode
, inner_mode
));
4715 else if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
4716 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
4718 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
4723 /* Ensure INSN_VAR_LOCATION_LOC (insn) doesn't have unbound complexity.
4724 Allow 4 levels of rtl nesting for most rtl codes, and if we see anything
4725 deeper than that, create DEBUG_EXPRs and emit DEBUG_INSNs before INSN. */
4728 avoid_complex_debug_insns (rtx insn
, rtx
*exp_p
, int depth
)
4732 if (exp
== NULL_RTX
)
4735 if ((OBJECT_P (exp
) && !MEM_P (exp
)) || GET_CODE (exp
) == CLOBBER
)
4740 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
4741 rtx dval
= make_debug_expr_from_rtl (exp
);
4743 /* Emit a debug bind insn before INSN. */
4744 rtx bind
= gen_rtx_VAR_LOCATION (GET_MODE (exp
),
4745 DEBUG_EXPR_TREE_DECL (dval
), exp
,
4746 VAR_INIT_STATUS_INITIALIZED
);
4748 emit_debug_insn_before (bind
, insn
);
4753 const char *format_ptr
= GET_RTX_FORMAT (GET_CODE (exp
));
4755 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
4756 switch (*format_ptr
++)
4759 avoid_complex_debug_insns (insn
, &XEXP (exp
, i
), depth
+ 1);
4764 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4765 avoid_complex_debug_insns (insn
, &XVECEXP (exp
, i
, j
), depth
+ 1);
4773 /* Expand the _LOCs in debug insns. We run this after expanding all
4774 regular insns, so that any variables referenced in the function
4775 will have their DECL_RTLs set. */
4778 expand_debug_locations (void)
4781 rtx last
= get_last_insn ();
4782 int save_strict_alias
= flag_strict_aliasing
;
4784 /* New alias sets while setting up memory attributes cause
4785 -fcompare-debug failures, even though it doesn't bring about any
4787 flag_strict_aliasing
= 0;
4789 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
4790 if (DEBUG_INSN_P (insn
))
4792 tree value
= (tree
)INSN_VAR_LOCATION_LOC (insn
);
4793 rtx val
, prev_insn
, insn2
;
4794 enum machine_mode mode
;
4796 if (value
== NULL_TREE
)
4800 if (INSN_VAR_LOCATION_STATUS (insn
)
4801 == VAR_INIT_STATUS_UNINITIALIZED
)
4802 val
= expand_debug_source_expr (value
);
4804 val
= expand_debug_expr (value
);
4805 gcc_assert (last
== get_last_insn ());
4809 val
= gen_rtx_UNKNOWN_VAR_LOC ();
4812 mode
= GET_MODE (INSN_VAR_LOCATION (insn
));
4814 gcc_assert (mode
== GET_MODE (val
)
4815 || (GET_MODE (val
) == VOIDmode
4816 && (CONST_SCALAR_INT_P (val
)
4817 || GET_CODE (val
) == CONST_FIXED
4818 || GET_CODE (val
) == LABEL_REF
)));
4821 INSN_VAR_LOCATION_LOC (insn
) = val
;
4822 prev_insn
= PREV_INSN (insn
);
4823 for (insn2
= insn
; insn2
!= prev_insn
; insn2
= PREV_INSN (insn2
))
4824 avoid_complex_debug_insns (insn2
, &INSN_VAR_LOCATION_LOC (insn2
), 0);
4827 flag_strict_aliasing
= save_strict_alias
;
4830 /* Expand basic block BB from GIMPLE trees to RTL. */
4833 expand_gimple_basic_block (basic_block bb
, bool disable_tail_calls
)
4835 gimple_stmt_iterator gsi
;
4844 fprintf (dump_file
, "\n;; Generating RTL for gimple basic block %d\n",
4847 /* Note that since we are now transitioning from GIMPLE to RTL, we
4848 cannot use the gsi_*_bb() routines because they expect the basic
4849 block to be in GIMPLE, instead of RTL. Therefore, we need to
4850 access the BB sequence directly. */
4851 stmts
= bb_seq (bb
);
4852 bb
->il
.gimple
.seq
= NULL
;
4853 bb
->il
.gimple
.phi_nodes
= NULL
;
4854 rtl_profile_for_bb (bb
);
4855 init_rtl_bb_info (bb
);
4856 bb
->flags
|= BB_RTL
;
4858 /* Remove the RETURN_EXPR if we may fall though to the exit
4860 gsi
= gsi_last (stmts
);
4861 if (!gsi_end_p (gsi
)
4862 && gimple_code (gsi_stmt (gsi
)) == GIMPLE_RETURN
)
4864 gimple ret_stmt
= gsi_stmt (gsi
);
4866 gcc_assert (single_succ_p (bb
));
4867 gcc_assert (single_succ (bb
) == EXIT_BLOCK_PTR_FOR_FN (cfun
));
4869 if (bb
->next_bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
)
4870 && !gimple_return_retval (ret_stmt
))
4872 gsi_remove (&gsi
, false);
4873 single_succ_edge (bb
)->flags
|= EDGE_FALLTHRU
;
4877 gsi
= gsi_start (stmts
);
4878 if (!gsi_end_p (gsi
))
4880 stmt
= gsi_stmt (gsi
);
4881 if (gimple_code (stmt
) != GIMPLE_LABEL
)
4885 elt
= pointer_map_contains (lab_rtx_for_bb
, bb
);
4889 last
= get_last_insn ();
4893 expand_gimple_stmt (stmt
);
4898 emit_label ((rtx
) *elt
);
4900 /* Java emits line number notes in the top of labels.
4901 ??? Make this go away once line number notes are obsoleted. */
4902 BB_HEAD (bb
) = NEXT_INSN (last
);
4903 if (NOTE_P (BB_HEAD (bb
)))
4904 BB_HEAD (bb
) = NEXT_INSN (BB_HEAD (bb
));
4905 note
= emit_note_after (NOTE_INSN_BASIC_BLOCK
, BB_HEAD (bb
));
4907 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
4910 note
= BB_HEAD (bb
) = emit_note (NOTE_INSN_BASIC_BLOCK
);
4912 NOTE_BASIC_BLOCK (note
) = bb
;
4914 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
4918 stmt
= gsi_stmt (gsi
);
4920 /* If this statement is a non-debug one, and we generate debug
4921 insns, then this one might be the last real use of a TERed
4922 SSA_NAME, but where there are still some debug uses further
4923 down. Expanding the current SSA name in such further debug
4924 uses by their RHS might lead to wrong debug info, as coalescing
4925 might make the operands of such RHS be placed into the same
4926 pseudo as something else. Like so:
4927 a_1 = a_0 + 1; // Assume a_1 is TERed and a_0 is dead
4931 As a_0 and a_2 don't overlap in lifetime, assume they are coalesced.
4932 If we now would expand a_1 by it's RHS (a_0 + 1) in the debug use,
4933 the write to a_2 would actually have clobbered the place which
4936 So, instead of that, we recognize the situation, and generate
4937 debug temporaries at the last real use of TERed SSA names:
4944 if (MAY_HAVE_DEBUG_INSNS
4946 && !is_gimple_debug (stmt
))
4952 location_t sloc
= curr_insn_location ();
4954 /* Look for SSA names that have their last use here (TERed
4955 names always have only one real use). */
4956 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
)
4957 if ((def
= get_gimple_for_ssa_name (op
)))
4959 imm_use_iterator imm_iter
;
4960 use_operand_p use_p
;
4961 bool have_debug_uses
= false;
4963 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, op
)
4965 if (gimple_debug_bind_p (USE_STMT (use_p
)))
4967 have_debug_uses
= true;
4972 if (have_debug_uses
)
4974 /* OP is a TERed SSA name, with DEF it's defining
4975 statement, and where OP is used in further debug
4976 instructions. Generate a debug temporary, and
4977 replace all uses of OP in debug insns with that
4980 tree value
= gimple_assign_rhs_to_tree (def
);
4981 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
4983 enum machine_mode mode
;
4985 set_curr_insn_location (gimple_location (def
));
4987 DECL_ARTIFICIAL (vexpr
) = 1;
4988 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
4990 mode
= DECL_MODE (value
);
4992 mode
= TYPE_MODE (TREE_TYPE (value
));
4993 DECL_MODE (vexpr
) = mode
;
4995 val
= gen_rtx_VAR_LOCATION
4996 (mode
, vexpr
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
4998 emit_debug_insn (val
);
5000 FOR_EACH_IMM_USE_STMT (debugstmt
, imm_iter
, op
)
5002 if (!gimple_debug_bind_p (debugstmt
))
5005 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
5006 SET_USE (use_p
, vexpr
);
5008 update_stmt (debugstmt
);
5012 set_curr_insn_location (sloc
);
5015 currently_expanding_gimple_stmt
= stmt
;
5017 /* Expand this statement, then evaluate the resulting RTL and
5018 fixup the CFG accordingly. */
5019 if (gimple_code (stmt
) == GIMPLE_COND
)
5021 new_bb
= expand_gimple_cond (bb
, stmt
);
5025 else if (gimple_debug_bind_p (stmt
))
5027 location_t sloc
= curr_insn_location ();
5028 gimple_stmt_iterator nsi
= gsi
;
5032 tree var
= gimple_debug_bind_get_var (stmt
);
5035 enum machine_mode mode
;
5037 if (TREE_CODE (var
) != DEBUG_EXPR_DECL
5038 && TREE_CODE (var
) != LABEL_DECL
5039 && !target_for_debug_bind (var
))
5040 goto delink_debug_stmt
;
5042 if (gimple_debug_bind_has_value_p (stmt
))
5043 value
= gimple_debug_bind_get_value (stmt
);
5047 last
= get_last_insn ();
5049 set_curr_insn_location (gimple_location (stmt
));
5052 mode
= DECL_MODE (var
);
5054 mode
= TYPE_MODE (TREE_TYPE (var
));
5056 val
= gen_rtx_VAR_LOCATION
5057 (mode
, var
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5059 emit_debug_insn (val
);
5061 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5063 /* We can't dump the insn with a TREE where an RTX
5065 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
5066 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5067 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
5071 /* In order not to generate too many debug temporaries,
5072 we delink all uses of debug statements we already expanded.
5073 Therefore debug statements between definition and real
5074 use of TERed SSA names will continue to use the SSA name,
5075 and not be replaced with debug temps. */
5076 delink_stmt_imm_use (stmt
);
5080 if (gsi_end_p (nsi
))
5082 stmt
= gsi_stmt (nsi
);
5083 if (!gimple_debug_bind_p (stmt
))
5087 set_curr_insn_location (sloc
);
5089 else if (gimple_debug_source_bind_p (stmt
))
5091 location_t sloc
= curr_insn_location ();
5092 tree var
= gimple_debug_source_bind_get_var (stmt
);
5093 tree value
= gimple_debug_source_bind_get_value (stmt
);
5095 enum machine_mode mode
;
5097 last
= get_last_insn ();
5099 set_curr_insn_location (gimple_location (stmt
));
5101 mode
= DECL_MODE (var
);
5103 val
= gen_rtx_VAR_LOCATION (mode
, var
, (rtx
)value
,
5104 VAR_INIT_STATUS_UNINITIALIZED
);
5106 emit_debug_insn (val
);
5108 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5110 /* We can't dump the insn with a TREE where an RTX
5112 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
5113 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5114 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
5117 set_curr_insn_location (sloc
);
5121 if (is_gimple_call (stmt
)
5122 && gimple_call_tail_p (stmt
)
5123 && disable_tail_calls
)
5124 gimple_call_set_tail (stmt
, false);
5126 if (is_gimple_call (stmt
) && gimple_call_tail_p (stmt
))
5129 new_bb
= expand_gimple_tailcall (bb
, stmt
, &can_fallthru
);
5140 def_operand_p def_p
;
5141 def_p
= SINGLE_SSA_DEF_OPERAND (stmt
, SSA_OP_DEF
);
5145 /* Ignore this stmt if it is in the list of
5146 replaceable expressions. */
5148 && bitmap_bit_p (SA
.values
,
5149 SSA_NAME_VERSION (DEF_FROM_PTR (def_p
))))
5152 last
= expand_gimple_stmt (stmt
);
5153 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5158 currently_expanding_gimple_stmt
= NULL
;
5160 /* Expand implicit goto and convert goto_locus. */
5161 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5163 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
5164 set_curr_insn_location (e
->goto_locus
);
5165 if ((e
->flags
& EDGE_FALLTHRU
) && e
->dest
!= bb
->next_bb
)
5167 emit_jump (label_rtx_for_bb (e
->dest
));
5168 e
->flags
&= ~EDGE_FALLTHRU
;
5172 /* Expanded RTL can create a jump in the last instruction of block.
5173 This later might be assumed to be a jump to successor and break edge insertion.
5174 We need to insert dummy move to prevent this. PR41440. */
5175 if (single_succ_p (bb
)
5176 && (single_succ_edge (bb
)->flags
& EDGE_FALLTHRU
)
5177 && (last
= get_last_insn ())
5180 rtx dummy
= gen_reg_rtx (SImode
);
5181 emit_insn_after_noloc (gen_move_insn (dummy
, dummy
), last
, NULL
);
5184 do_pending_stack_adjust ();
5186 /* Find the block tail. The last insn in the block is the insn
5187 before a barrier and/or table jump insn. */
5188 last
= get_last_insn ();
5189 if (BARRIER_P (last
))
5190 last
= PREV_INSN (last
);
5191 if (JUMP_TABLE_DATA_P (last
))
5192 last
= PREV_INSN (PREV_INSN (last
));
5195 update_bb_for_insn (bb
);
5201 /* Create a basic block for initialization code. */
5204 construct_init_block (void)
5206 basic_block init_block
, first_block
;
5210 /* Multiple entry points not supported yet. */
5211 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
) == 1);
5212 init_rtl_bb_info (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5213 init_rtl_bb_info (EXIT_BLOCK_PTR_FOR_FN (cfun
));
5214 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
5215 EXIT_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
5217 e
= EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun
), 0);
5219 /* When entry edge points to first basic block, we don't need jump,
5220 otherwise we have to jump into proper target. */
5221 if (e
&& e
->dest
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
)
5223 tree label
= gimple_block_label (e
->dest
);
5225 emit_jump (label_rtx (label
));
5229 flags
= EDGE_FALLTHRU
;
5231 init_block
= create_basic_block (NEXT_INSN (get_insns ()),
5233 ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5234 init_block
->frequency
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
;
5235 init_block
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
5236 if (current_loops
&& ENTRY_BLOCK_PTR_FOR_FN (cfun
)->loop_father
)
5237 add_bb_to_loop (init_block
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
5240 first_block
= e
->dest
;
5241 redirect_edge_succ (e
, init_block
);
5242 e
= make_edge (init_block
, first_block
, flags
);
5245 e
= make_edge (init_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_FALLTHRU
);
5246 e
->probability
= REG_BR_PROB_BASE
;
5247 e
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
5249 update_bb_for_insn (init_block
);
5253 /* For each lexical block, set BLOCK_NUMBER to the depth at which it is
5254 found in the block tree. */
5257 set_block_levels (tree block
, int level
)
5261 BLOCK_NUMBER (block
) = level
;
5262 set_block_levels (BLOCK_SUBBLOCKS (block
), level
+ 1);
5263 block
= BLOCK_CHAIN (block
);
5267 /* Create a block containing landing pads and similar stuff. */
5270 construct_exit_block (void)
5272 rtx head
= get_last_insn ();
5274 basic_block exit_block
;
5278 basic_block prev_bb
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
;
5279 rtx orig_end
= BB_END (prev_bb
);
5281 rtl_profile_for_bb (EXIT_BLOCK_PTR_FOR_FN (cfun
));
5283 /* Make sure the locus is set to the end of the function, so that
5284 epilogue line numbers and warnings are set properly. */
5285 if (LOCATION_LOCUS (cfun
->function_end_locus
) != UNKNOWN_LOCATION
)
5286 input_location
= cfun
->function_end_locus
;
5288 /* Generate rtl for function exit. */
5289 expand_function_end ();
5291 end
= get_last_insn ();
5294 /* While emitting the function end we could move end of the last basic
5296 BB_END (prev_bb
) = orig_end
;
5297 while (NEXT_INSN (head
) && NOTE_P (NEXT_INSN (head
)))
5298 head
= NEXT_INSN (head
);
5299 /* But make sure exit_block starts with RETURN_LABEL, otherwise the
5300 bb frequency counting will be confused. Any instructions before that
5301 label are emitted for the case where PREV_BB falls through into the
5302 exit block, so append those instructions to prev_bb in that case. */
5303 if (NEXT_INSN (head
) != return_label
)
5305 while (NEXT_INSN (head
) != return_label
)
5307 if (!NOTE_P (NEXT_INSN (head
)))
5308 BB_END (prev_bb
) = NEXT_INSN (head
);
5309 head
= NEXT_INSN (head
);
5312 exit_block
= create_basic_block (NEXT_INSN (head
), end
, prev_bb
);
5313 exit_block
->frequency
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->frequency
;
5314 exit_block
->count
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
;
5315 if (current_loops
&& EXIT_BLOCK_PTR_FOR_FN (cfun
)->loop_father
)
5316 add_bb_to_loop (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
5319 while (ix
< EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
))
5321 e
= EDGE_PRED (EXIT_BLOCK_PTR_FOR_FN (cfun
), ix
);
5322 if (!(e
->flags
& EDGE_ABNORMAL
))
5323 redirect_edge_succ (e
, exit_block
);
5328 e
= make_edge (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_FALLTHRU
);
5329 e
->probability
= REG_BR_PROB_BASE
;
5330 e
->count
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
;
5331 FOR_EACH_EDGE (e2
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
5334 e
->count
-= e2
->count
;
5335 exit_block
->count
-= e2
->count
;
5336 exit_block
->frequency
-= EDGE_FREQUENCY (e2
);
5340 if (exit_block
->count
< 0)
5341 exit_block
->count
= 0;
5342 if (exit_block
->frequency
< 0)
5343 exit_block
->frequency
= 0;
5344 update_bb_for_insn (exit_block
);
5347 /* Helper function for discover_nonconstant_array_refs.
5348 Look for ARRAY_REF nodes with non-constant indexes and mark them
5352 discover_nonconstant_array_refs_r (tree
* tp
, int *walk_subtrees
,
5353 void *data ATTRIBUTE_UNUSED
)
5357 if (IS_TYPE_OR_DECL_P (t
))
5359 else if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5361 while (((TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5362 && is_gimple_min_invariant (TREE_OPERAND (t
, 1))
5363 && (!TREE_OPERAND (t
, 2)
5364 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
5365 || (TREE_CODE (t
) == COMPONENT_REF
5366 && (!TREE_OPERAND (t
,2)
5367 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
5368 || TREE_CODE (t
) == BIT_FIELD_REF
5369 || TREE_CODE (t
) == REALPART_EXPR
5370 || TREE_CODE (t
) == IMAGPART_EXPR
5371 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5372 || CONVERT_EXPR_P (t
))
5373 t
= TREE_OPERAND (t
, 0);
5375 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5377 t
= get_base_address (t
);
5379 && DECL_MODE (t
) != BLKmode
)
5380 TREE_ADDRESSABLE (t
) = 1;
5389 /* RTL expansion is not able to compile array references with variable
5390 offsets for arrays stored in single register. Discover such
5391 expressions and mark variables as addressable to avoid this
5395 discover_nonconstant_array_refs (void)
5398 gimple_stmt_iterator gsi
;
5400 FOR_EACH_BB_FN (bb
, cfun
)
5401 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5403 gimple stmt
= gsi_stmt (gsi
);
5404 if (!is_gimple_debug (stmt
))
5405 walk_gimple_op (stmt
, discover_nonconstant_array_refs_r
, NULL
);
5409 /* This function sets crtl->args.internal_arg_pointer to a virtual
5410 register if DRAP is needed. Local register allocator will replace
5411 virtual_incoming_args_rtx with the virtual register. */
5414 expand_stack_alignment (void)
5417 unsigned int preferred_stack_boundary
;
5419 if (! SUPPORTS_STACK_ALIGNMENT
)
5422 if (cfun
->calls_alloca
5423 || cfun
->has_nonlocal_label
5424 || crtl
->has_nonlocal_goto
)
5425 crtl
->need_drap
= true;
5427 /* Call update_stack_boundary here again to update incoming stack
5428 boundary. It may set incoming stack alignment to a different
5429 value after RTL expansion. TARGET_FUNCTION_OK_FOR_SIBCALL may
5430 use the minimum incoming stack alignment to check if it is OK
5431 to perform sibcall optimization since sibcall optimization will
5432 only align the outgoing stack to incoming stack boundary. */
5433 if (targetm
.calls
.update_stack_boundary
)
5434 targetm
.calls
.update_stack_boundary ();
5436 /* The incoming stack frame has to be aligned at least at
5437 parm_stack_boundary. */
5438 gcc_assert (crtl
->parm_stack_boundary
<= INCOMING_STACK_BOUNDARY
);
5440 /* Update crtl->stack_alignment_estimated and use it later to align
5441 stack. We check PREFERRED_STACK_BOUNDARY if there may be non-call
5442 exceptions since callgraph doesn't collect incoming stack alignment
5444 if (cfun
->can_throw_non_call_exceptions
5445 && PREFERRED_STACK_BOUNDARY
> crtl
->preferred_stack_boundary
)
5446 preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
5448 preferred_stack_boundary
= crtl
->preferred_stack_boundary
;
5449 if (preferred_stack_boundary
> crtl
->stack_alignment_estimated
)
5450 crtl
->stack_alignment_estimated
= preferred_stack_boundary
;
5451 if (preferred_stack_boundary
> crtl
->stack_alignment_needed
)
5452 crtl
->stack_alignment_needed
= preferred_stack_boundary
;
5454 gcc_assert (crtl
->stack_alignment_needed
5455 <= crtl
->stack_alignment_estimated
);
5457 crtl
->stack_realign_needed
5458 = INCOMING_STACK_BOUNDARY
< crtl
->stack_alignment_estimated
;
5459 crtl
->stack_realign_tried
= crtl
->stack_realign_needed
;
5461 crtl
->stack_realign_processed
= true;
5463 /* Target has to redefine TARGET_GET_DRAP_RTX to support stack
5465 gcc_assert (targetm
.calls
.get_drap_rtx
!= NULL
);
5466 drap_rtx
= targetm
.calls
.get_drap_rtx ();
5468 /* stack_realign_drap and drap_rtx must match. */
5469 gcc_assert ((stack_realign_drap
!= 0) == (drap_rtx
!= NULL
));
5471 /* Do nothing if NULL is returned, which means DRAP is not needed. */
5472 if (NULL
!= drap_rtx
)
5474 crtl
->args
.internal_arg_pointer
= drap_rtx
;
5476 /* Call fixup_tail_calls to clean up REG_EQUIV note if DRAP is
5478 fixup_tail_calls ();
5484 expand_main_function (void)
5486 #if (defined(INVOKE__main) \
5487 || (!defined(HAS_INIT_SECTION) \
5488 && !defined(INIT_SECTION_ASM_OP) \
5489 && !defined(INIT_ARRAY_SECTION_ASM_OP)))
5490 emit_library_call (init_one_libfunc (NAME__MAIN
), LCT_NORMAL
, VOIDmode
, 0);
5495 /* Expand code to initialize the stack_protect_guard. This is invoked at
5496 the beginning of a function to be protected. */
5498 #ifndef HAVE_stack_protect_set
5499 # define HAVE_stack_protect_set 0
5500 # define gen_stack_protect_set(x,y) (gcc_unreachable (), NULL_RTX)
5504 stack_protect_prologue (void)
5506 tree guard_decl
= targetm
.stack_protect_guard ();
5509 x
= expand_normal (crtl
->stack_protect_guard
);
5510 y
= expand_normal (guard_decl
);
5512 /* Allow the target to copy from Y to X without leaking Y into a
5514 if (HAVE_stack_protect_set
)
5516 rtx insn
= gen_stack_protect_set (x
, y
);
5524 /* Otherwise do a straight move. */
5525 emit_move_insn (x
, y
);
5528 /* Translate the intermediate representation contained in the CFG
5529 from GIMPLE trees to RTL.
5531 We do conversion per basic block and preserve/update the tree CFG.
5532 This implies we have to do some magic as the CFG can simultaneously
5533 consist of basic blocks containing RTL and GIMPLE trees. This can
5534 confuse the CFG hooks, so be careful to not manipulate CFG during
5538 gimple_expand_cfg (void)
5540 basic_block bb
, init_block
;
5544 rtx var_seq
, var_ret_seq
;
5547 timevar_push (TV_OUT_OF_SSA
);
5548 rewrite_out_of_ssa (&SA
);
5549 timevar_pop (TV_OUT_OF_SSA
);
5550 SA
.partition_to_pseudo
= XCNEWVEC (rtx
, SA
.map
->num_partitions
);
5552 /* Make sure all values used by the optimization passes have sane
5556 /* Some backends want to know that we are expanding to RTL. */
5557 currently_expanding_to_rtl
= 1;
5558 /* Dominators are not kept up-to-date as we may create new basic-blocks. */
5559 free_dominance_info (CDI_DOMINATORS
);
5561 rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5563 insn_locations_init ();
5564 if (!DECL_IS_BUILTIN (current_function_decl
))
5566 /* Eventually, all FEs should explicitly set function_start_locus. */
5567 if (LOCATION_LOCUS (cfun
->function_start_locus
) == UNKNOWN_LOCATION
)
5568 set_curr_insn_location
5569 (DECL_SOURCE_LOCATION (current_function_decl
));
5571 set_curr_insn_location (cfun
->function_start_locus
);
5574 set_curr_insn_location (UNKNOWN_LOCATION
);
5575 prologue_location
= curr_insn_location ();
5577 #ifdef INSN_SCHEDULING
5578 init_sched_attrs ();
5581 /* Make sure first insn is a note even if we don't want linenums.
5582 This makes sure the first insn will never be deleted.
5583 Also, final expects a note to appear there. */
5584 emit_note (NOTE_INSN_DELETED
);
5586 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
5587 discover_nonconstant_array_refs ();
5589 targetm
.expand_to_rtl_hook ();
5590 crtl
->stack_alignment_needed
= STACK_BOUNDARY
;
5591 crtl
->max_used_stack_slot_alignment
= STACK_BOUNDARY
;
5592 crtl
->stack_alignment_estimated
= 0;
5593 crtl
->preferred_stack_boundary
= STACK_BOUNDARY
;
5594 cfun
->cfg
->max_jumptable_ents
= 0;
5596 /* Resovle the function section. Some targets, like ARM EABI rely on knowledge
5597 of the function section at exapnsion time to predict distance of calls. */
5598 resolve_unique_section (current_function_decl
, 0, flag_function_sections
);
5600 /* Expand the variables recorded during gimple lowering. */
5601 timevar_push (TV_VAR_EXPAND
);
5604 var_ret_seq
= expand_used_vars ();
5606 var_seq
= get_insns ();
5608 timevar_pop (TV_VAR_EXPAND
);
5610 /* Honor stack protection warnings. */
5611 if (warn_stack_protect
)
5613 if (cfun
->calls_alloca
)
5614 warning (OPT_Wstack_protector
,
5615 "stack protector not protecting local variables: "
5616 "variable length buffer");
5617 if (has_short_buffer
&& !crtl
->stack_protect_guard
)
5618 warning (OPT_Wstack_protector
,
5619 "stack protector not protecting function: "
5620 "all local arrays are less than %d bytes long",
5621 (int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
));
5624 /* Set up parameters and prepare for return, for the function. */
5625 expand_function_start (current_function_decl
);
5627 /* If we emitted any instructions for setting up the variables,
5628 emit them before the FUNCTION_START note. */
5631 emit_insn_before (var_seq
, parm_birth_insn
);
5633 /* In expand_function_end we'll insert the alloca save/restore
5634 before parm_birth_insn. We've just insertted an alloca call.
5635 Adjust the pointer to match. */
5636 parm_birth_insn
= var_seq
;
5639 /* Now that we also have the parameter RTXs, copy them over to our
5641 for (i
= 0; i
< SA
.map
->num_partitions
; i
++)
5643 tree var
= SSA_NAME_VAR (partition_to_var (SA
.map
, i
));
5645 if (TREE_CODE (var
) != VAR_DECL
5646 && !SA
.partition_to_pseudo
[i
])
5647 SA
.partition_to_pseudo
[i
] = DECL_RTL_IF_SET (var
);
5648 gcc_assert (SA
.partition_to_pseudo
[i
]);
5650 /* If this decl was marked as living in multiple places, reset
5651 this now to NULL. */
5652 if (DECL_RTL_IF_SET (var
) == pc_rtx
)
5653 SET_DECL_RTL (var
, NULL
);
5655 /* Some RTL parts really want to look at DECL_RTL(x) when x
5656 was a decl marked in REG_ATTR or MEM_ATTR. We could use
5657 SET_DECL_RTL here making this available, but that would mean
5658 to select one of the potentially many RTLs for one DECL. Instead
5659 of doing that we simply reset the MEM_EXPR of the RTL in question,
5660 then nobody can get at it and hence nobody can call DECL_RTL on it. */
5661 if (!DECL_RTL_SET_P (var
))
5663 if (MEM_P (SA
.partition_to_pseudo
[i
]))
5664 set_mem_expr (SA
.partition_to_pseudo
[i
], NULL
);
5668 /* If we have a class containing differently aligned pointers
5669 we need to merge those into the corresponding RTL pointer
5671 for (i
= 1; i
< num_ssa_names
; i
++)
5673 tree name
= ssa_name (i
);
5678 /* We might have generated new SSA names in
5679 update_alias_info_with_stack_vars. They will have a NULL
5680 defining statements, and won't be part of the partitioning,
5682 || !SSA_NAME_DEF_STMT (name
))
5684 part
= var_to_partition (SA
.map
, name
);
5685 if (part
== NO_PARTITION
)
5688 /* Adjust all partition members to get the underlying decl of
5689 the representative which we might have created in expand_one_var. */
5690 if (SSA_NAME_VAR (name
) == NULL_TREE
)
5692 tree leader
= partition_to_var (SA
.map
, part
);
5693 gcc_assert (SSA_NAME_VAR (leader
) != NULL_TREE
);
5694 replace_ssa_name_symbol (name
, SSA_NAME_VAR (leader
));
5696 if (!POINTER_TYPE_P (TREE_TYPE (name
)))
5699 r
= SA
.partition_to_pseudo
[part
];
5701 mark_reg_pointer (r
, get_pointer_alignment (name
));
5704 /* If this function is `main', emit a call to `__main'
5705 to run global initializers, etc. */
5706 if (DECL_NAME (current_function_decl
)
5707 && MAIN_NAME_P (DECL_NAME (current_function_decl
))
5708 && DECL_FILE_SCOPE_P (current_function_decl
))
5709 expand_main_function ();
5711 /* Initialize the stack_protect_guard field. This must happen after the
5712 call to __main (if any) so that the external decl is initialized. */
5713 if (crtl
->stack_protect_guard
)
5714 stack_protect_prologue ();
5716 expand_phi_nodes (&SA
);
5718 /* Register rtl specific functions for cfg. */
5719 rtl_register_cfg_hooks ();
5721 init_block
= construct_init_block ();
5723 /* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
5724 remaining edges later. */
5725 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
)
5726 e
->flags
&= ~EDGE_EXECUTABLE
;
5728 lab_rtx_for_bb
= pointer_map_create ();
5729 FOR_BB_BETWEEN (bb
, init_block
->next_bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
),
5731 bb
= expand_gimple_basic_block (bb
, var_ret_seq
!= NULL_RTX
);
5733 if (MAY_HAVE_DEBUG_INSNS
)
5734 expand_debug_locations ();
5736 /* Free stuff we no longer need after GIMPLE optimizations. */
5737 free_dominance_info (CDI_DOMINATORS
);
5738 free_dominance_info (CDI_POST_DOMINATORS
);
5739 delete_tree_cfg_annotations ();
5741 timevar_push (TV_OUT_OF_SSA
);
5742 finish_out_of_ssa (&SA
);
5743 timevar_pop (TV_OUT_OF_SSA
);
5745 timevar_push (TV_POST_EXPAND
);
5746 /* We are no longer in SSA form. */
5747 cfun
->gimple_df
->in_ssa_p
= false;
5749 loops_state_clear (LOOP_CLOSED_SSA
);
5751 /* Expansion is used by optimization passes too, set maybe_hot_insn_p
5752 conservatively to true until they are all profile aware. */
5753 pointer_map_destroy (lab_rtx_for_bb
);
5756 construct_exit_block ();
5757 insn_locations_finalize ();
5761 rtx after
= return_label
;
5762 rtx next
= NEXT_INSN (after
);
5763 if (next
&& NOTE_INSN_BASIC_BLOCK_P (next
))
5765 emit_insn_after (var_ret_seq
, after
);
5768 /* Zap the tree EH table. */
5769 set_eh_throw_stmt_table (cfun
, NULL
);
5771 /* We need JUMP_LABEL be set in order to redirect jumps, and hence
5772 split edges which edge insertions might do. */
5773 rebuild_jump_labels (get_insns ());
5775 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (cfun
),
5776 EXIT_BLOCK_PTR_FOR_FN (cfun
), next_bb
)
5780 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
5784 rebuild_jump_labels_chain (e
->insns
.r
);
5785 /* Put insns after parm birth, but before
5786 NOTE_INSNS_FUNCTION_BEG. */
5787 if (e
->src
== ENTRY_BLOCK_PTR_FOR_FN (cfun
)
5788 && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (cfun
)))
5790 rtx insns
= e
->insns
.r
;
5791 e
->insns
.r
= NULL_RTX
;
5792 if (NOTE_P (parm_birth_insn
)
5793 && NOTE_KIND (parm_birth_insn
) == NOTE_INSN_FUNCTION_BEG
)
5794 emit_insn_before_noloc (insns
, parm_birth_insn
, e
->dest
);
5796 emit_insn_after_noloc (insns
, parm_birth_insn
, e
->dest
);
5799 commit_one_edge_insertion (e
);
5806 /* We're done expanding trees to RTL. */
5807 currently_expanding_to_rtl
= 0;
5809 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
,
5810 EXIT_BLOCK_PTR_FOR_FN (cfun
), next_bb
)
5814 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
5816 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
5817 e
->flags
&= ~EDGE_EXECUTABLE
;
5819 /* At the moment not all abnormal edges match the RTL
5820 representation. It is safe to remove them here as
5821 find_many_sub_basic_blocks will rediscover them.
5822 In the future we should get this fixed properly. */
5823 if ((e
->flags
& EDGE_ABNORMAL
)
5824 && !(e
->flags
& EDGE_SIBCALL
))
5831 blocks
= sbitmap_alloc (last_basic_block_for_fn (cfun
));
5832 bitmap_ones (blocks
);
5833 find_many_sub_basic_blocks (blocks
);
5834 sbitmap_free (blocks
);
5835 purge_all_dead_edges ();
5837 expand_stack_alignment ();
5839 /* Fixup REG_EQUIV notes in the prologue if there are tailcalls in this
5841 if (crtl
->tail_call_emit
)
5842 fixup_tail_calls ();
5844 /* After initial rtl generation, call back to finish generating
5845 exception support code. We need to do this before cleaning up
5846 the CFG as the code does not expect dead landing pads. */
5847 if (cfun
->eh
->region_tree
!= NULL
)
5848 finish_eh_generation ();
5850 /* Remove unreachable blocks, otherwise we cannot compute dominators
5851 which are needed for loop state verification. As a side-effect
5852 this also compacts blocks.
5853 ??? We cannot remove trivially dead insns here as for example
5854 the DRAP reg on i?86 is not magically live at this point.
5855 gcc.c-torture/execute/ipa-sra-2.c execution, -Os -m32 fails otherwise. */
5856 cleanup_cfg (CLEANUP_NO_INSN_DEL
);
5858 #ifdef ENABLE_CHECKING
5859 verify_flow_info ();
5862 /* Initialize pseudos allocated for hard registers. */
5863 emit_initial_value_sets ();
5865 /* And finally unshare all RTL. */
5868 /* There's no need to defer outputting this function any more; we
5869 know we want to output it. */
5870 DECL_DEFER_OUTPUT (current_function_decl
) = 0;
5872 /* Now that we're done expanding trees to RTL, we shouldn't have any
5873 more CONCATs anywhere. */
5874 generating_concat_p
= 0;
5879 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
5880 /* And the pass manager will dump RTL for us. */
5883 /* If we're emitting a nested function, make sure its parent gets
5884 emitted as well. Doing otherwise confuses debug info. */
5887 for (parent
= DECL_CONTEXT (current_function_decl
);
5888 parent
!= NULL_TREE
;
5889 parent
= get_containing_scope (parent
))
5890 if (TREE_CODE (parent
) == FUNCTION_DECL
)
5891 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent
)) = 1;
5894 /* We are now committed to emitting code for this function. Do any
5895 preparation, such as emitting abstract debug info for the inline
5896 before it gets mangled by optimization. */
5897 if (cgraph_function_possibly_inlined_p (current_function_decl
))
5898 (*debug_hooks
->outlining_inline_function
) (current_function_decl
);
5900 TREE_ASM_WRITTEN (current_function_decl
) = 1;
5902 /* After expanding, the return labels are no longer needed. */
5903 return_label
= NULL
;
5904 naked_return_label
= NULL
;
5906 /* After expanding, the tm_restart map is no longer needed. */
5907 if (cfun
->gimple_df
->tm_restart
)
5909 htab_delete (cfun
->gimple_df
->tm_restart
);
5910 cfun
->gimple_df
->tm_restart
= NULL
;
5913 /* Tag the blocks with a depth number so that change_scope can find
5914 the common parent easily. */
5915 set_block_levels (DECL_INITIAL (cfun
->decl
), 0);
5916 default_rtl_profile ();
5918 timevar_pop (TV_POST_EXPAND
);
5925 const pass_data pass_data_expand
=
5927 RTL_PASS
, /* type */
5928 "expand", /* name */
5929 OPTGROUP_NONE
, /* optinfo_flags */
5930 false, /* has_gate */
5931 true, /* has_execute */
5932 TV_EXPAND
, /* tv_id */
5933 ( PROP_ssa
| PROP_gimple_leh
| PROP_cfg
5935 | PROP_gimple_lvec
), /* properties_required */
5936 PROP_rtl
, /* properties_provided */
5937 ( PROP_ssa
| PROP_trees
), /* properties_destroyed */
5938 ( TODO_verify_ssa
| TODO_verify_flow
5939 | TODO_verify_stmts
), /* todo_flags_start */
5940 0, /* todo_flags_finish */
5943 class pass_expand
: public rtl_opt_pass
5946 pass_expand (gcc::context
*ctxt
)
5947 : rtl_opt_pass (pass_data_expand
, ctxt
)
5950 /* opt_pass methods: */
5951 unsigned int execute () { return gimple_expand_cfg (); }
5953 }; // class pass_expand
5958 make_pass_expand (gcc::context
*ctxt
)
5960 return new pass_expand (ctxt
);