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. */
1656 if (TREE_CODE (SSA_NAME_VAR (var
)) == VAR_DECL
)
1657 expand_one_var (var
, true, true);
1658 else if (DECL_IGNORED_P (SSA_NAME_VAR (var
)) || optimize
)
1660 /* This is a PARM_DECL or RESULT_DECL. For those partitions that
1661 contain the default def (representing the parm or result itself)
1662 we don't do anything here. But those which don't contain the
1663 default def (representing a temporary based on the parm/result)
1664 we need to allocate space just like for normal VAR_DECLs. */
1665 if (!bitmap_bit_p (SA
.partition_has_default_def
, i
))
1667 expand_one_var (var
, true, true);
1668 gcc_assert (SA
.partition_to_pseudo
[i
]);
1672 pointer_map_destroy (ssa_name_decls
);
1674 if (flag_stack_protect
== SPCT_FLAG_STRONG
)
1675 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
1676 if (!is_global_var (var
))
1678 tree var_type
= TREE_TYPE (var
);
1679 /* Examine local referenced variables that have their addresses taken,
1680 contain an array, or are arrays. */
1681 if (TREE_CODE (var
) == VAR_DECL
1682 && (TREE_CODE (var_type
) == ARRAY_TYPE
1683 || TREE_ADDRESSABLE (var
)
1684 || (RECORD_OR_UNION_TYPE_P (var_type
)
1685 && record_or_union_type_has_array_p (var_type
))))
1687 gen_stack_protect_signal
= true;
1692 /* At this point all variables on the local_decls with TREE_USED
1693 set are not associated with any block scope. Lay them out. */
1695 len
= vec_safe_length (cfun
->local_decls
);
1696 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
1698 bool expand_now
= false;
1700 /* Expanded above already. */
1701 if (is_gimple_reg (var
))
1703 TREE_USED (var
) = 0;
1706 /* We didn't set a block for static or extern because it's hard
1707 to tell the difference between a global variable (re)declared
1708 in a local scope, and one that's really declared there to
1709 begin with. And it doesn't really matter much, since we're
1710 not giving them stack space. Expand them now. */
1711 else if (TREE_STATIC (var
) || DECL_EXTERNAL (var
))
1714 /* Expand variables not associated with any block now. Those created by
1715 the optimizers could be live anywhere in the function. Those that
1716 could possibly have been scoped originally and detached from their
1717 block will have their allocation deferred so we coalesce them with
1718 others when optimization is enabled. */
1719 else if (TREE_USED (var
))
1722 /* Finally, mark all variables on the list as used. We'll use
1723 this in a moment when we expand those associated with scopes. */
1724 TREE_USED (var
) = 1;
1727 expand_one_var (var
, true, true);
1730 if (DECL_ARTIFICIAL (var
) && !DECL_IGNORED_P (var
))
1732 rtx rtl
= DECL_RTL_IF_SET (var
);
1734 /* Keep artificial non-ignored vars in cfun->local_decls
1735 chain until instantiate_decls. */
1736 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
1737 add_local_decl (cfun
, var
);
1738 else if (rtl
== NULL_RTX
)
1739 /* If rtl isn't set yet, which can happen e.g. with
1740 -fstack-protector, retry before returning from this
1742 maybe_local_decls
.safe_push (var
);
1746 /* We duplicated some of the decls in CFUN->LOCAL_DECLS.
1748 +-----------------+-----------------+
1749 | ...processed... | ...duplicates...|
1750 +-----------------+-----------------+
1752 +-- LEN points here.
1754 We just want the duplicates, as those are the artificial
1755 non-ignored vars that we want to keep until instantiate_decls.
1756 Move them down and truncate the array. */
1757 if (!vec_safe_is_empty (cfun
->local_decls
))
1758 cfun
->local_decls
->block_remove (0, len
);
1760 /* At this point, all variables within the block tree with TREE_USED
1761 set are actually used by the optimized function. Lay them out. */
1762 expand_used_vars_for_block (outer_block
, true);
1764 if (stack_vars_num
> 0)
1766 add_scope_conflicts ();
1768 /* If stack protection is enabled, we don't share space between
1769 vulnerable data and non-vulnerable data. */
1770 if (flag_stack_protect
)
1771 add_stack_protection_conflicts ();
1773 /* Now that we have collected all stack variables, and have computed a
1774 minimal interference graph, attempt to save some stack space. */
1775 partition_stack_vars ();
1777 dump_stack_var_partition ();
1780 switch (flag_stack_protect
)
1783 create_stack_guard ();
1786 case SPCT_FLAG_STRONG
:
1787 if (gen_stack_protect_signal
1788 || cfun
->calls_alloca
|| has_protected_decls
)
1789 create_stack_guard ();
1792 case SPCT_FLAG_DEFAULT
:
1793 if (cfun
->calls_alloca
|| has_protected_decls
)
1794 create_stack_guard ();
1801 /* Assign rtl to each variable based on these partitions. */
1802 if (stack_vars_num
> 0)
1804 struct stack_vars_data data
;
1806 data
.asan_vec
= vNULL
;
1807 data
.asan_decl_vec
= vNULL
;
1808 data
.asan_base
= NULL_RTX
;
1809 data
.asan_alignb
= 0;
1811 /* Reorder decls to be protected by iterating over the variables
1812 array multiple times, and allocating out of each phase in turn. */
1813 /* ??? We could probably integrate this into the qsort we did
1814 earlier, such that we naturally see these variables first,
1815 and thus naturally allocate things in the right order. */
1816 if (has_protected_decls
)
1818 /* Phase 1 contains only character arrays. */
1819 expand_stack_vars (stack_protect_decl_phase_1
, &data
);
1821 /* Phase 2 contains other kinds of arrays. */
1822 if (flag_stack_protect
== 2)
1823 expand_stack_vars (stack_protect_decl_phase_2
, &data
);
1826 if ((flag_sanitize
& SANITIZE_ADDRESS
) && ASAN_STACK
)
1827 /* Phase 3, any partitions that need asan protection
1828 in addition to phase 1 and 2. */
1829 expand_stack_vars (asan_decl_phase_3
, &data
);
1831 if (!data
.asan_vec
.is_empty ())
1833 HOST_WIDE_INT prev_offset
= frame_offset
;
1834 HOST_WIDE_INT offset
, sz
, redzonesz
;
1835 redzonesz
= ASAN_RED_ZONE_SIZE
;
1836 sz
= data
.asan_vec
[0] - prev_offset
;
1837 if (data
.asan_alignb
> ASAN_RED_ZONE_SIZE
1838 && data
.asan_alignb
<= 4096
1839 && sz
+ ASAN_RED_ZONE_SIZE
>= (int) data
.asan_alignb
)
1840 redzonesz
= ((sz
+ ASAN_RED_ZONE_SIZE
+ data
.asan_alignb
- 1)
1841 & ~(data
.asan_alignb
- HOST_WIDE_INT_1
)) - sz
;
1843 = alloc_stack_frame_space (redzonesz
, ASAN_RED_ZONE_SIZE
);
1844 data
.asan_vec
.safe_push (prev_offset
);
1845 data
.asan_vec
.safe_push (offset
);
1848 = asan_emit_stack_protection (virtual_stack_vars_rtx
,
1851 data
.asan_vec
.address (),
1852 data
.asan_decl_vec
.address (),
1853 data
.asan_vec
.length ());
1856 expand_stack_vars (NULL
, &data
);
1858 data
.asan_vec
.release ();
1859 data
.asan_decl_vec
.release ();
1862 fini_vars_expansion ();
1864 /* If there were any artificial non-ignored vars without rtl
1865 found earlier, see if deferred stack allocation hasn't assigned
1867 FOR_EACH_VEC_ELT_REVERSE (maybe_local_decls
, i
, var
)
1869 rtx rtl
= DECL_RTL_IF_SET (var
);
1871 /* Keep artificial non-ignored vars in cfun->local_decls
1872 chain until instantiate_decls. */
1873 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
1874 add_local_decl (cfun
, var
);
1876 maybe_local_decls
.release ();
1878 /* If the target requires that FRAME_OFFSET be aligned, do it. */
1879 if (STACK_ALIGNMENT_NEEDED
)
1881 HOST_WIDE_INT align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
1882 if (!FRAME_GROWS_DOWNWARD
)
1883 frame_offset
+= align
- 1;
1884 frame_offset
&= -align
;
1891 /* If we need to produce a detailed dump, print the tree representation
1892 for STMT to the dump file. SINCE is the last RTX after which the RTL
1893 generated for STMT should have been appended. */
1896 maybe_dump_rtl_for_gimple_stmt (gimple stmt
, rtx since
)
1898 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1900 fprintf (dump_file
, "\n;; ");
1901 print_gimple_stmt (dump_file
, stmt
, 0,
1902 TDF_SLIM
| (dump_flags
& TDF_LINENO
));
1903 fprintf (dump_file
, "\n");
1905 print_rtl (dump_file
, since
? NEXT_INSN (since
) : since
);
1909 /* Maps the blocks that do not contain tree labels to rtx labels. */
1911 static struct pointer_map_t
*lab_rtx_for_bb
;
1913 /* Returns the label_rtx expression for a label starting basic block BB. */
1916 label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED
)
1918 gimple_stmt_iterator gsi
;
1923 if (bb
->flags
& BB_RTL
)
1924 return block_label (bb
);
1926 elt
= pointer_map_contains (lab_rtx_for_bb
, bb
);
1930 /* Find the tree label if it is present. */
1932 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1934 lab_stmt
= gsi_stmt (gsi
);
1935 if (gimple_code (lab_stmt
) != GIMPLE_LABEL
)
1938 lab
= gimple_label_label (lab_stmt
);
1939 if (DECL_NONLOCAL (lab
))
1942 return label_rtx (lab
);
1945 elt
= pointer_map_insert (lab_rtx_for_bb
, bb
);
1946 *elt
= gen_label_rtx ();
1951 /* A subroutine of expand_gimple_cond. Given E, a fallthrough edge
1952 of a basic block where we just expanded the conditional at the end,
1953 possibly clean up the CFG and instruction sequence. LAST is the
1954 last instruction before the just emitted jump sequence. */
1957 maybe_cleanup_end_of_block (edge e
, rtx last
)
1959 /* Special case: when jumpif decides that the condition is
1960 trivial it emits an unconditional jump (and the necessary
1961 barrier). But we still have two edges, the fallthru one is
1962 wrong. purge_dead_edges would clean this up later. Unfortunately
1963 we have to insert insns (and split edges) before
1964 find_many_sub_basic_blocks and hence before purge_dead_edges.
1965 But splitting edges might create new blocks which depend on the
1966 fact that if there are two edges there's no barrier. So the
1967 barrier would get lost and verify_flow_info would ICE. Instead
1968 of auditing all edge splitters to care for the barrier (which
1969 normally isn't there in a cleaned CFG), fix it here. */
1970 if (BARRIER_P (get_last_insn ()))
1974 /* Now, we have a single successor block, if we have insns to
1975 insert on the remaining edge we potentially will insert
1976 it at the end of this block (if the dest block isn't feasible)
1977 in order to avoid splitting the edge. This insertion will take
1978 place in front of the last jump. But we might have emitted
1979 multiple jumps (conditional and one unconditional) to the
1980 same destination. Inserting in front of the last one then
1981 is a problem. See PR 40021. We fix this by deleting all
1982 jumps except the last unconditional one. */
1983 insn
= PREV_INSN (get_last_insn ());
1984 /* Make sure we have an unconditional jump. Otherwise we're
1986 gcc_assert (JUMP_P (insn
) && !any_condjump_p (insn
));
1987 for (insn
= PREV_INSN (insn
); insn
!= last
;)
1989 insn
= PREV_INSN (insn
);
1990 if (JUMP_P (NEXT_INSN (insn
)))
1992 if (!any_condjump_p (NEXT_INSN (insn
)))
1994 gcc_assert (BARRIER_P (NEXT_INSN (NEXT_INSN (insn
))));
1995 delete_insn (NEXT_INSN (NEXT_INSN (insn
)));
1997 delete_insn (NEXT_INSN (insn
));
2003 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_COND.
2004 Returns a new basic block if we've terminated the current basic
2005 block and created a new one. */
2008 expand_gimple_cond (basic_block bb
, gimple stmt
)
2010 basic_block new_bb
, dest
;
2015 enum tree_code code
;
2018 code
= gimple_cond_code (stmt
);
2019 op0
= gimple_cond_lhs (stmt
);
2020 op1
= gimple_cond_rhs (stmt
);
2021 /* We're sometimes presented with such code:
2025 This would expand to two comparisons which then later might
2026 be cleaned up by combine. But some pattern matchers like if-conversion
2027 work better when there's only one compare, so make up for this
2028 here as special exception if TER would have made the same change. */
2030 && TREE_CODE (op0
) == SSA_NAME
2031 && TREE_CODE (TREE_TYPE (op0
)) == BOOLEAN_TYPE
2032 && TREE_CODE (op1
) == INTEGER_CST
2033 && ((gimple_cond_code (stmt
) == NE_EXPR
2034 && integer_zerop (op1
))
2035 || (gimple_cond_code (stmt
) == EQ_EXPR
2036 && integer_onep (op1
)))
2037 && bitmap_bit_p (SA
.values
, SSA_NAME_VERSION (op0
)))
2039 gimple second
= SSA_NAME_DEF_STMT (op0
);
2040 if (gimple_code (second
) == GIMPLE_ASSIGN
)
2042 enum tree_code code2
= gimple_assign_rhs_code (second
);
2043 if (TREE_CODE_CLASS (code2
) == tcc_comparison
)
2046 op0
= gimple_assign_rhs1 (second
);
2047 op1
= gimple_assign_rhs2 (second
);
2049 /* If jumps are cheap turn some more codes into
2051 else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4)
2053 if ((code2
== BIT_AND_EXPR
2054 && TYPE_PRECISION (TREE_TYPE (op0
)) == 1
2055 && TREE_CODE (gimple_assign_rhs2 (second
)) != INTEGER_CST
)
2056 || code2
== TRUTH_AND_EXPR
)
2058 code
= TRUTH_ANDIF_EXPR
;
2059 op0
= gimple_assign_rhs1 (second
);
2060 op1
= gimple_assign_rhs2 (second
);
2062 else if (code2
== BIT_IOR_EXPR
|| code2
== TRUTH_OR_EXPR
)
2064 code
= TRUTH_ORIF_EXPR
;
2065 op0
= gimple_assign_rhs1 (second
);
2066 op1
= gimple_assign_rhs2 (second
);
2072 last2
= last
= get_last_insn ();
2074 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
2075 set_curr_insn_location (gimple_location (stmt
));
2077 /* These flags have no purpose in RTL land. */
2078 true_edge
->flags
&= ~EDGE_TRUE_VALUE
;
2079 false_edge
->flags
&= ~EDGE_FALSE_VALUE
;
2081 /* We can either have a pure conditional jump with one fallthru edge or
2082 two-way jump that needs to be decomposed into two basic blocks. */
2083 if (false_edge
->dest
== bb
->next_bb
)
2085 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2086 true_edge
->probability
);
2087 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2088 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2089 set_curr_insn_location (true_edge
->goto_locus
);
2090 false_edge
->flags
|= EDGE_FALLTHRU
;
2091 maybe_cleanup_end_of_block (false_edge
, last
);
2094 if (true_edge
->dest
== bb
->next_bb
)
2096 jumpifnot_1 (code
, op0
, op1
, label_rtx_for_bb (false_edge
->dest
),
2097 false_edge
->probability
);
2098 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2099 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2100 set_curr_insn_location (false_edge
->goto_locus
);
2101 true_edge
->flags
|= EDGE_FALLTHRU
;
2102 maybe_cleanup_end_of_block (true_edge
, last
);
2106 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2107 true_edge
->probability
);
2108 last
= get_last_insn ();
2109 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2110 set_curr_insn_location (false_edge
->goto_locus
);
2111 emit_jump (label_rtx_for_bb (false_edge
->dest
));
2114 if (BARRIER_P (BB_END (bb
)))
2115 BB_END (bb
) = PREV_INSN (BB_END (bb
));
2116 update_bb_for_insn (bb
);
2118 new_bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
2119 dest
= false_edge
->dest
;
2120 redirect_edge_succ (false_edge
, new_bb
);
2121 false_edge
->flags
|= EDGE_FALLTHRU
;
2122 new_bb
->count
= false_edge
->count
;
2123 new_bb
->frequency
= EDGE_FREQUENCY (false_edge
);
2124 if (current_loops
&& bb
->loop_father
)
2125 add_bb_to_loop (new_bb
, bb
->loop_father
);
2126 new_edge
= make_edge (new_bb
, dest
, 0);
2127 new_edge
->probability
= REG_BR_PROB_BASE
;
2128 new_edge
->count
= new_bb
->count
;
2129 if (BARRIER_P (BB_END (new_bb
)))
2130 BB_END (new_bb
) = PREV_INSN (BB_END (new_bb
));
2131 update_bb_for_insn (new_bb
);
2133 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
2135 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2137 set_curr_insn_location (true_edge
->goto_locus
);
2138 true_edge
->goto_locus
= curr_insn_location ();
2144 /* Mark all calls that can have a transaction restart. */
2147 mark_transaction_restart_calls (gimple stmt
)
2149 struct tm_restart_node dummy
;
2152 if (!cfun
->gimple_df
->tm_restart
)
2156 slot
= htab_find_slot (cfun
->gimple_df
->tm_restart
, &dummy
, NO_INSERT
);
2159 struct tm_restart_node
*n
= (struct tm_restart_node
*) *slot
;
2160 tree list
= n
->label_or_list
;
2163 for (insn
= next_real_insn (get_last_insn ());
2165 insn
= next_real_insn (insn
))
2168 if (TREE_CODE (list
) == LABEL_DECL
)
2169 add_reg_note (insn
, REG_TM
, label_rtx (list
));
2171 for (; list
; list
= TREE_CHAIN (list
))
2172 add_reg_note (insn
, REG_TM
, label_rtx (TREE_VALUE (list
)));
2176 /* A subroutine of expand_gimple_stmt_1, expanding one GIMPLE_CALL
2180 expand_call_stmt (gimple stmt
)
2182 tree exp
, decl
, lhs
;
2186 if (gimple_call_internal_p (stmt
))
2188 expand_internal_call (stmt
);
2192 exp
= build_vl_exp (CALL_EXPR
, gimple_call_num_args (stmt
) + 3);
2194 CALL_EXPR_FN (exp
) = gimple_call_fn (stmt
);
2195 decl
= gimple_call_fndecl (stmt
);
2196 builtin_p
= decl
&& DECL_BUILT_IN (decl
);
2198 /* If this is not a builtin function, the function type through which the
2199 call is made may be different from the type of the function. */
2202 = fold_convert (build_pointer_type (gimple_call_fntype (stmt
)),
2203 CALL_EXPR_FN (exp
));
2205 TREE_TYPE (exp
) = gimple_call_return_type (stmt
);
2206 CALL_EXPR_STATIC_CHAIN (exp
) = gimple_call_chain (stmt
);
2208 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2210 tree arg
= gimple_call_arg (stmt
, i
);
2212 /* TER addresses into arguments of builtin functions so we have a
2213 chance to infer more correct alignment information. See PR39954. */
2215 && TREE_CODE (arg
) == SSA_NAME
2216 && (def
= get_gimple_for_ssa_name (arg
))
2217 && gimple_assign_rhs_code (def
) == ADDR_EXPR
)
2218 arg
= gimple_assign_rhs1 (def
);
2219 CALL_EXPR_ARG (exp
, i
) = arg
;
2222 if (gimple_has_side_effects (stmt
))
2223 TREE_SIDE_EFFECTS (exp
) = 1;
2225 if (gimple_call_nothrow_p (stmt
))
2226 TREE_NOTHROW (exp
) = 1;
2228 CALL_EXPR_TAILCALL (exp
) = gimple_call_tail_p (stmt
);
2229 CALL_EXPR_RETURN_SLOT_OPT (exp
) = gimple_call_return_slot_opt_p (stmt
);
2231 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
2232 && (DECL_FUNCTION_CODE (decl
) == BUILT_IN_ALLOCA
2233 || DECL_FUNCTION_CODE (decl
) == BUILT_IN_ALLOCA_WITH_ALIGN
))
2234 CALL_ALLOCA_FOR_VAR_P (exp
) = gimple_call_alloca_for_var_p (stmt
);
2236 CALL_FROM_THUNK_P (exp
) = gimple_call_from_thunk_p (stmt
);
2237 CALL_EXPR_VA_ARG_PACK (exp
) = gimple_call_va_arg_pack_p (stmt
);
2238 SET_EXPR_LOCATION (exp
, gimple_location (stmt
));
2240 /* Ensure RTL is created for debug args. */
2241 if (decl
&& DECL_HAS_DEBUG_ARGS_P (decl
))
2243 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (decl
);
2248 for (ix
= 1; (*debug_args
)->iterate (ix
, &dtemp
); ix
+= 2)
2250 gcc_assert (TREE_CODE (dtemp
) == DEBUG_EXPR_DECL
);
2251 expand_debug_expr (dtemp
);
2255 lhs
= gimple_call_lhs (stmt
);
2257 expand_assignment (lhs
, exp
, false);
2259 expand_expr (exp
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2261 mark_transaction_restart_calls (stmt
);
2265 /* Generate RTL for an asm statement (explicit assembler code).
2266 STRING is a STRING_CST node containing the assembler code text,
2267 or an ADDR_EXPR containing a STRING_CST. VOL nonzero means the
2268 insn is volatile; don't optimize it. */
2271 expand_asm_loc (tree string
, int vol
, location_t locus
)
2275 if (TREE_CODE (string
) == ADDR_EXPR
)
2276 string
= TREE_OPERAND (string
, 0);
2278 body
= gen_rtx_ASM_INPUT_loc (VOIDmode
,
2279 ggc_strdup (TREE_STRING_POINTER (string
)),
2282 MEM_VOLATILE_P (body
) = vol
;
2287 /* Return the number of times character C occurs in string S. */
2289 n_occurrences (int c
, const char *s
)
2297 /* A subroutine of expand_asm_operands. Check that all operands have
2298 the same number of alternatives. Return true if so. */
2301 check_operand_nalternatives (tree outputs
, tree inputs
)
2303 if (outputs
|| inputs
)
2305 tree tmp
= TREE_PURPOSE (outputs
? outputs
: inputs
);
2307 = n_occurrences (',', TREE_STRING_POINTER (TREE_VALUE (tmp
)));
2310 if (nalternatives
+ 1 > MAX_RECOG_ALTERNATIVES
)
2312 error ("too many alternatives in %<asm%>");
2319 const char *constraint
2320 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tmp
)));
2322 if (n_occurrences (',', constraint
) != nalternatives
)
2324 error ("operand constraints for %<asm%> differ "
2325 "in number of alternatives");
2329 if (TREE_CHAIN (tmp
))
2330 tmp
= TREE_CHAIN (tmp
);
2332 tmp
= next
, next
= 0;
2339 /* Check for overlap between registers marked in CLOBBERED_REGS and
2340 anything inappropriate in T. Emit error and return the register
2341 variable definition for error, NULL_TREE for ok. */
2344 tree_conflicts_with_clobbers_p (tree t
, HARD_REG_SET
*clobbered_regs
)
2346 /* Conflicts between asm-declared register variables and the clobber
2347 list are not allowed. */
2348 tree overlap
= tree_overlaps_hard_reg_set (t
, clobbered_regs
);
2352 error ("asm-specifier for variable %qE conflicts with asm clobber list",
2353 DECL_NAME (overlap
));
2355 /* Reset registerness to stop multiple errors emitted for a single
2357 DECL_REGISTER (overlap
) = 0;
2364 /* Generate RTL for an asm statement with arguments.
2365 STRING is the instruction template.
2366 OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
2367 Each output or input has an expression in the TREE_VALUE and
2368 a tree list in TREE_PURPOSE which in turn contains a constraint
2369 name in TREE_VALUE (or NULL_TREE) and a constraint string
2371 CLOBBERS is a list of STRING_CST nodes each naming a hard register
2372 that is clobbered by this insn.
2374 LABELS is a list of labels, and if LABELS is non-NULL, FALLTHRU_BB
2375 should be the fallthru basic block of the asm goto.
2377 Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
2378 Some elements of OUTPUTS may be replaced with trees representing temporary
2379 values. The caller should copy those temporary values to the originally
2382 VOL nonzero means the insn is volatile; don't optimize it. */
2385 expand_asm_operands (tree string
, tree outputs
, tree inputs
,
2386 tree clobbers
, tree labels
, basic_block fallthru_bb
,
2387 int vol
, location_t locus
)
2389 rtvec argvec
, constraintvec
, labelvec
;
2391 int ninputs
= list_length (inputs
);
2392 int noutputs
= list_length (outputs
);
2393 int nlabels
= list_length (labels
);
2396 HARD_REG_SET clobbered_regs
;
2397 int clobber_conflict_found
= 0;
2401 /* Vector of RTX's of evaluated output operands. */
2402 rtx
*output_rtx
= XALLOCAVEC (rtx
, noutputs
);
2403 int *inout_opnum
= XALLOCAVEC (int, noutputs
);
2404 rtx
*real_output_rtx
= XALLOCAVEC (rtx
, noutputs
);
2405 enum machine_mode
*inout_mode
= XALLOCAVEC (enum machine_mode
, noutputs
);
2406 const char **constraints
= XALLOCAVEC (const char *, noutputs
+ ninputs
);
2407 int old_generating_concat_p
= generating_concat_p
;
2408 rtx fallthru_label
= NULL_RTX
;
2410 /* An ASM with no outputs needs to be treated as volatile, for now. */
2414 if (! check_operand_nalternatives (outputs
, inputs
))
2417 string
= resolve_asm_operand_names (string
, outputs
, inputs
, labels
);
2419 /* Collect constraints. */
2421 for (t
= outputs
; t
; t
= TREE_CHAIN (t
), i
++)
2422 constraints
[i
] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
2423 for (t
= inputs
; t
; t
= TREE_CHAIN (t
), i
++)
2424 constraints
[i
] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
2426 /* Sometimes we wish to automatically clobber registers across an asm.
2427 Case in point is when the i386 backend moved from cc0 to a hard reg --
2428 maintaining source-level compatibility means automatically clobbering
2429 the flags register. */
2430 clobbers
= targetm
.md_asm_clobbers (outputs
, inputs
, clobbers
);
2432 /* Count the number of meaningful clobbered registers, ignoring what
2433 we would ignore later. */
2435 CLEAR_HARD_REG_SET (clobbered_regs
);
2436 for (tail
= clobbers
; tail
; tail
= TREE_CHAIN (tail
))
2438 const char *regname
;
2441 if (TREE_VALUE (tail
) == error_mark_node
)
2443 regname
= TREE_STRING_POINTER (TREE_VALUE (tail
));
2445 i
= decode_reg_name_and_count (regname
, &nregs
);
2449 error ("unknown register name %qs in %<asm%>", regname
);
2451 /* Mark clobbered registers. */
2456 for (reg
= i
; reg
< i
+ nregs
; reg
++)
2460 /* Clobbering the PIC register is an error. */
2461 if (reg
== (int) PIC_OFFSET_TABLE_REGNUM
)
2463 error ("PIC register clobbered by %qs in %<asm%>", regname
);
2467 SET_HARD_REG_BIT (clobbered_regs
, reg
);
2472 /* First pass over inputs and outputs checks validity and sets
2473 mark_addressable if needed. */
2476 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
2478 tree val
= TREE_VALUE (tail
);
2479 tree type
= TREE_TYPE (val
);
2480 const char *constraint
;
2485 /* If there's an erroneous arg, emit no insn. */
2486 if (type
== error_mark_node
)
2489 /* Try to parse the output constraint. If that fails, there's
2490 no point in going further. */
2491 constraint
= constraints
[i
];
2492 if (!parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
2493 &allows_mem
, &allows_reg
, &is_inout
))
2500 && REG_P (DECL_RTL (val
))
2501 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
))))
2502 mark_addressable (val
);
2509 if (ninputs
+ noutputs
> MAX_RECOG_OPERANDS
)
2511 error ("more than %d operands in %<asm%>", MAX_RECOG_OPERANDS
);
2515 for (i
= 0, tail
= inputs
; tail
; i
++, tail
= TREE_CHAIN (tail
))
2517 bool allows_reg
, allows_mem
;
2518 const char *constraint
;
2520 /* If there's an erroneous arg, emit no insn, because the ASM_INPUT
2521 would get VOIDmode and that could cause a crash in reload. */
2522 if (TREE_TYPE (TREE_VALUE (tail
)) == error_mark_node
)
2525 constraint
= constraints
[i
+ noutputs
];
2526 if (! parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, ninout
,
2527 constraints
, &allows_mem
, &allows_reg
))
2530 if (! allows_reg
&& allows_mem
)
2531 mark_addressable (TREE_VALUE (tail
));
2534 /* Second pass evaluates arguments. */
2536 /* Make sure stack is consistent for asm goto. */
2538 do_pending_stack_adjust ();
2541 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
2543 tree val
= TREE_VALUE (tail
);
2544 tree type
= TREE_TYPE (val
);
2551 ok
= parse_output_constraint (&constraints
[i
], i
, ninputs
,
2552 noutputs
, &allows_mem
, &allows_reg
,
2556 /* If an output operand is not a decl or indirect ref and our constraint
2557 allows a register, make a temporary to act as an intermediate.
2558 Make the asm insn write into that, then our caller will copy it to
2559 the real output operand. Likewise for promoted variables. */
2561 generating_concat_p
= 0;
2563 real_output_rtx
[i
] = NULL_RTX
;
2564 if ((TREE_CODE (val
) == INDIRECT_REF
2567 && (allows_mem
|| REG_P (DECL_RTL (val
)))
2568 && ! (REG_P (DECL_RTL (val
))
2569 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
)))
2573 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
2574 !allows_reg
? EXPAND_MEMORY
: EXPAND_WRITE
);
2576 op
= validize_mem (op
);
2578 if (! allows_reg
&& !MEM_P (op
))
2579 error ("output number %d not directly addressable", i
);
2580 if ((! allows_mem
&& MEM_P (op
))
2581 || GET_CODE (op
) == CONCAT
)
2583 real_output_rtx
[i
] = op
;
2584 op
= gen_reg_rtx (GET_MODE (op
));
2586 emit_move_insn (op
, real_output_rtx
[i
]);
2591 op
= assign_temp (type
, 0, 1);
2592 op
= validize_mem (op
);
2593 if (!MEM_P (op
) && TREE_CODE (TREE_VALUE (tail
)) == SSA_NAME
)
2594 set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (TREE_VALUE (tail
)), op
);
2595 TREE_VALUE (tail
) = make_tree (type
, op
);
2599 generating_concat_p
= old_generating_concat_p
;
2603 inout_mode
[ninout
] = TYPE_MODE (type
);
2604 inout_opnum
[ninout
++] = i
;
2607 if (tree_conflicts_with_clobbers_p (val
, &clobbered_regs
))
2608 clobber_conflict_found
= 1;
2611 /* Make vectors for the expression-rtx, constraint strings,
2612 and named operands. */
2614 argvec
= rtvec_alloc (ninputs
);
2615 constraintvec
= rtvec_alloc (ninputs
);
2616 labelvec
= rtvec_alloc (nlabels
);
2618 body
= gen_rtx_ASM_OPERANDS ((noutputs
== 0 ? VOIDmode
2619 : GET_MODE (output_rtx
[0])),
2620 ggc_strdup (TREE_STRING_POINTER (string
)),
2621 empty_string
, 0, argvec
, constraintvec
,
2624 MEM_VOLATILE_P (body
) = vol
;
2626 /* Eval the inputs and put them into ARGVEC.
2627 Put their constraints into ASM_INPUTs and store in CONSTRAINTS. */
2629 for (i
= 0, tail
= inputs
; tail
; tail
= TREE_CHAIN (tail
), ++i
)
2631 bool allows_reg
, allows_mem
;
2632 const char *constraint
;
2637 constraint
= constraints
[i
+ noutputs
];
2638 ok
= parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, ninout
,
2639 constraints
, &allows_mem
, &allows_reg
);
2642 generating_concat_p
= 0;
2644 val
= TREE_VALUE (tail
);
2645 type
= TREE_TYPE (val
);
2646 /* EXPAND_INITIALIZER will not generate code for valid initializer
2647 constants, but will still generate code for other types of operand.
2648 This is the behavior we want for constant constraints. */
2649 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
2650 allows_reg
? EXPAND_NORMAL
2651 : allows_mem
? EXPAND_MEMORY
2652 : EXPAND_INITIALIZER
);
2654 /* Never pass a CONCAT to an ASM. */
2655 if (GET_CODE (op
) == CONCAT
)
2656 op
= force_reg (GET_MODE (op
), op
);
2657 else if (MEM_P (op
))
2658 op
= validize_mem (op
);
2660 if (asm_operand_ok (op
, constraint
, NULL
) <= 0)
2662 if (allows_reg
&& TYPE_MODE (type
) != BLKmode
)
2663 op
= force_reg (TYPE_MODE (type
), op
);
2664 else if (!allows_mem
)
2665 warning (0, "asm operand %d probably doesn%'t match constraints",
2667 else if (MEM_P (op
))
2669 /* We won't recognize either volatile memory or memory
2670 with a queued address as available a memory_operand
2671 at this point. Ignore it: clearly this *is* a memory. */
2677 generating_concat_p
= old_generating_concat_p
;
2678 ASM_OPERANDS_INPUT (body
, i
) = op
;
2680 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body
, i
)
2681 = gen_rtx_ASM_INPUT_loc (TYPE_MODE (type
),
2682 ggc_strdup (constraints
[i
+ noutputs
]),
2685 if (tree_conflicts_with_clobbers_p (val
, &clobbered_regs
))
2686 clobber_conflict_found
= 1;
2689 /* Protect all the operands from the queue now that they have all been
2692 generating_concat_p
= 0;
2694 /* For in-out operands, copy output rtx to input rtx. */
2695 for (i
= 0; i
< ninout
; i
++)
2697 int j
= inout_opnum
[i
];
2700 ASM_OPERANDS_INPUT (body
, ninputs
- ninout
+ i
)
2703 sprintf (buffer
, "%d", j
);
2704 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body
, ninputs
- ninout
+ i
)
2705 = gen_rtx_ASM_INPUT_loc (inout_mode
[i
], ggc_strdup (buffer
), locus
);
2708 /* Copy labels to the vector. */
2709 for (i
= 0, tail
= labels
; i
< nlabels
; ++i
, tail
= TREE_CHAIN (tail
))
2712 /* If asm goto has any labels in the fallthru basic block, use
2713 a label that we emit immediately after the asm goto. Expansion
2714 may insert further instructions into the same basic block after
2715 asm goto and if we don't do this, insertion of instructions on
2716 the fallthru edge might misbehave. See PR58670. */
2718 && label_to_block_fn (cfun
, TREE_VALUE (tail
)) == fallthru_bb
)
2720 if (fallthru_label
== NULL_RTX
)
2721 fallthru_label
= gen_label_rtx ();
2725 r
= label_rtx (TREE_VALUE (tail
));
2726 ASM_OPERANDS_LABEL (body
, i
) = gen_rtx_LABEL_REF (Pmode
, r
);
2729 generating_concat_p
= old_generating_concat_p
;
2731 /* Now, for each output, construct an rtx
2732 (set OUTPUT (asm_operands INSN OUTPUTCONSTRAINT OUTPUTNUMBER
2733 ARGVEC CONSTRAINTS OPNAMES))
2734 If there is more than one, put them inside a PARALLEL. */
2736 if (nlabels
> 0 && nclobbers
== 0)
2738 gcc_assert (noutputs
== 0);
2739 emit_jump_insn (body
);
2741 else if (noutputs
== 0 && nclobbers
== 0)
2743 /* No output operands: put in a raw ASM_OPERANDS rtx. */
2746 else if (noutputs
== 1 && nclobbers
== 0)
2748 ASM_OPERANDS_OUTPUT_CONSTRAINT (body
) = ggc_strdup (constraints
[0]);
2749 emit_insn (gen_rtx_SET (VOIDmode
, output_rtx
[0], body
));
2759 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (num
+ nclobbers
));
2761 /* For each output operand, store a SET. */
2762 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
2764 XVECEXP (body
, 0, i
)
2765 = gen_rtx_SET (VOIDmode
,
2767 gen_rtx_ASM_OPERANDS
2768 (GET_MODE (output_rtx
[i
]),
2769 ggc_strdup (TREE_STRING_POINTER (string
)),
2770 ggc_strdup (constraints
[i
]),
2771 i
, argvec
, constraintvec
, labelvec
, locus
));
2773 MEM_VOLATILE_P (SET_SRC (XVECEXP (body
, 0, i
))) = vol
;
2776 /* If there are no outputs (but there are some clobbers)
2777 store the bare ASM_OPERANDS into the PARALLEL. */
2780 XVECEXP (body
, 0, i
++) = obody
;
2782 /* Store (clobber REG) for each clobbered register specified. */
2784 for (tail
= clobbers
; tail
; tail
= TREE_CHAIN (tail
))
2786 const char *regname
= TREE_STRING_POINTER (TREE_VALUE (tail
));
2788 int j
= decode_reg_name_and_count (regname
, &nregs
);
2793 if (j
== -3) /* `cc', which is not a register */
2796 if (j
== -4) /* `memory', don't cache memory across asm */
2798 XVECEXP (body
, 0, i
++)
2799 = gen_rtx_CLOBBER (VOIDmode
,
2802 gen_rtx_SCRATCH (VOIDmode
)));
2806 /* Ignore unknown register, error already signaled. */
2810 for (reg
= j
; reg
< j
+ nregs
; reg
++)
2812 /* Use QImode since that's guaranteed to clobber just
2814 clobbered_reg
= gen_rtx_REG (QImode
, reg
);
2816 /* Do sanity check for overlap between clobbers and
2817 respectively input and outputs that hasn't been
2818 handled. Such overlap should have been detected and
2820 if (!clobber_conflict_found
)
2824 /* We test the old body (obody) contents to avoid
2825 tripping over the under-construction body. */
2826 for (opno
= 0; opno
< noutputs
; opno
++)
2827 if (reg_overlap_mentioned_p (clobbered_reg
,
2830 ("asm clobber conflict with output operand");
2832 for (opno
= 0; opno
< ninputs
- ninout
; opno
++)
2833 if (reg_overlap_mentioned_p (clobbered_reg
,
2834 ASM_OPERANDS_INPUT (obody
,
2837 ("asm clobber conflict with input operand");
2840 XVECEXP (body
, 0, i
++)
2841 = gen_rtx_CLOBBER (VOIDmode
, clobbered_reg
);
2846 emit_jump_insn (body
);
2852 emit_label (fallthru_label
);
2854 /* For any outputs that needed reloading into registers, spill them
2855 back to where they belong. */
2856 for (i
= 0; i
< noutputs
; ++i
)
2857 if (real_output_rtx
[i
])
2858 emit_move_insn (real_output_rtx
[i
], output_rtx
[i
]);
2860 crtl
->has_asm_statement
= 1;
2866 expand_asm_stmt (gimple stmt
)
2869 tree outputs
, tail
, t
;
2873 tree str
, out
, in
, cl
, labels
;
2874 location_t locus
= gimple_location (stmt
);
2875 basic_block fallthru_bb
= NULL
;
2877 /* Meh... convert the gimple asm operands into real tree lists.
2878 Eventually we should make all routines work on the vectors instead
2879 of relying on TREE_CHAIN. */
2881 n
= gimple_asm_noutputs (stmt
);
2884 t
= out
= gimple_asm_output_op (stmt
, 0);
2885 for (i
= 1; i
< n
; i
++)
2886 t
= TREE_CHAIN (t
) = gimple_asm_output_op (stmt
, i
);
2890 n
= gimple_asm_ninputs (stmt
);
2893 t
= in
= gimple_asm_input_op (stmt
, 0);
2894 for (i
= 1; i
< n
; i
++)
2895 t
= TREE_CHAIN (t
) = gimple_asm_input_op (stmt
, i
);
2899 n
= gimple_asm_nclobbers (stmt
);
2902 t
= cl
= gimple_asm_clobber_op (stmt
, 0);
2903 for (i
= 1; i
< n
; i
++)
2904 t
= TREE_CHAIN (t
) = gimple_asm_clobber_op (stmt
, i
);
2908 n
= gimple_asm_nlabels (stmt
);
2911 edge fallthru
= find_fallthru_edge (gimple_bb (stmt
)->succs
);
2913 fallthru_bb
= fallthru
->dest
;
2914 t
= labels
= gimple_asm_label_op (stmt
, 0);
2915 for (i
= 1; i
< n
; i
++)
2916 t
= TREE_CHAIN (t
) = gimple_asm_label_op (stmt
, i
);
2919 s
= gimple_asm_string (stmt
);
2920 str
= build_string (strlen (s
), s
);
2922 if (gimple_asm_input_p (stmt
))
2924 expand_asm_loc (str
, gimple_asm_volatile_p (stmt
), locus
);
2929 noutputs
= gimple_asm_noutputs (stmt
);
2930 /* o[I] is the place that output number I should be written. */
2931 o
= (tree
*) alloca (noutputs
* sizeof (tree
));
2933 /* Record the contents of OUTPUTS before it is modified. */
2934 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
2935 o
[i
] = TREE_VALUE (tail
);
2937 /* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of
2938 OUTPUTS some trees for where the values were actually stored. */
2939 expand_asm_operands (str
, outputs
, in
, cl
, labels
, fallthru_bb
,
2940 gimple_asm_volatile_p (stmt
), locus
);
2942 /* Copy all the intermediate outputs into the specified outputs. */
2943 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
2945 if (o
[i
] != TREE_VALUE (tail
))
2947 expand_assignment (o
[i
], TREE_VALUE (tail
), false);
2950 /* Restore the original value so that it's correct the next
2951 time we expand this function. */
2952 TREE_VALUE (tail
) = o
[i
];
2957 /* Emit code to jump to the address
2958 specified by the pointer expression EXP. */
2961 expand_computed_goto (tree exp
)
2963 rtx x
= expand_normal (exp
);
2965 x
= convert_memory_address (Pmode
, x
);
2967 do_pending_stack_adjust ();
2968 emit_indirect_jump (x
);
2971 /* Generate RTL code for a `goto' statement with target label LABEL.
2972 LABEL should be a LABEL_DECL tree node that was or will later be
2973 defined with `expand_label'. */
2976 expand_goto (tree label
)
2978 #ifdef ENABLE_CHECKING
2979 /* Check for a nonlocal goto to a containing function. Should have
2980 gotten translated to __builtin_nonlocal_goto. */
2981 tree context
= decl_function_context (label
);
2982 gcc_assert (!context
|| context
== current_function_decl
);
2985 emit_jump (label_rtx (label
));
2988 /* Output a return with no value. */
2991 expand_null_return_1 (void)
2993 clear_pending_stack_adjust ();
2994 do_pending_stack_adjust ();
2995 emit_jump (return_label
);
2998 /* Generate RTL to return from the current function, with no value.
2999 (That is, we do not do anything about returning any value.) */
3002 expand_null_return (void)
3004 /* If this function was declared to return a value, but we
3005 didn't, clobber the return registers so that they are not
3006 propagated live to the rest of the function. */
3007 clobber_return_register ();
3009 expand_null_return_1 ();
3012 /* Generate RTL to return from the current function, with value VAL. */
3015 expand_value_return (rtx val
)
3017 /* Copy the value to the return location unless it's already there. */
3019 tree decl
= DECL_RESULT (current_function_decl
);
3020 rtx return_reg
= DECL_RTL (decl
);
3021 if (return_reg
!= val
)
3023 tree funtype
= TREE_TYPE (current_function_decl
);
3024 tree type
= TREE_TYPE (decl
);
3025 int unsignedp
= TYPE_UNSIGNED (type
);
3026 enum machine_mode old_mode
= DECL_MODE (decl
);
3027 enum machine_mode mode
;
3028 if (DECL_BY_REFERENCE (decl
))
3029 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 2);
3031 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 1);
3033 if (mode
!= old_mode
)
3034 val
= convert_modes (mode
, old_mode
, val
, unsignedp
);
3036 if (GET_CODE (return_reg
) == PARALLEL
)
3037 emit_group_load (return_reg
, val
, type
, int_size_in_bytes (type
));
3039 emit_move_insn (return_reg
, val
);
3042 expand_null_return_1 ();
3045 /* Generate RTL to evaluate the expression RETVAL and return it
3046 from the current function. */
3049 expand_return (tree retval
)
3055 /* If function wants no value, give it none. */
3056 if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl
))) == VOID_TYPE
)
3058 expand_normal (retval
);
3059 expand_null_return ();
3063 if (retval
== error_mark_node
)
3065 /* Treat this like a return of no value from a function that
3067 expand_null_return ();
3070 else if ((TREE_CODE (retval
) == MODIFY_EXPR
3071 || TREE_CODE (retval
) == INIT_EXPR
)
3072 && TREE_CODE (TREE_OPERAND (retval
, 0)) == RESULT_DECL
)
3073 retval_rhs
= TREE_OPERAND (retval
, 1);
3075 retval_rhs
= retval
;
3077 result_rtl
= DECL_RTL (DECL_RESULT (current_function_decl
));
3079 /* If we are returning the RESULT_DECL, then the value has already
3080 been stored into it, so we don't have to do anything special. */
3081 if (TREE_CODE (retval_rhs
) == RESULT_DECL
)
3082 expand_value_return (result_rtl
);
3084 /* If the result is an aggregate that is being returned in one (or more)
3085 registers, load the registers here. */
3087 else if (retval_rhs
!= 0
3088 && TYPE_MODE (TREE_TYPE (retval_rhs
)) == BLKmode
3089 && REG_P (result_rtl
))
3091 val
= copy_blkmode_to_reg (GET_MODE (result_rtl
), retval_rhs
);
3094 /* Use the mode of the result value on the return register. */
3095 PUT_MODE (result_rtl
, GET_MODE (val
));
3096 expand_value_return (val
);
3099 expand_null_return ();
3101 else if (retval_rhs
!= 0
3102 && !VOID_TYPE_P (TREE_TYPE (retval_rhs
))
3103 && (REG_P (result_rtl
)
3104 || (GET_CODE (result_rtl
) == PARALLEL
)))
3106 /* Calculate the return value into a temporary (usually a pseudo
3108 tree ot
= TREE_TYPE (DECL_RESULT (current_function_decl
));
3109 tree nt
= build_qualified_type (ot
, TYPE_QUALS (ot
) | TYPE_QUAL_CONST
);
3111 val
= assign_temp (nt
, 0, 1);
3112 val
= expand_expr (retval_rhs
, val
, GET_MODE (val
), EXPAND_NORMAL
);
3113 val
= force_not_mem (val
);
3114 /* Return the calculated value. */
3115 expand_value_return (val
);
3119 /* No hard reg used; calculate value into hard return reg. */
3120 expand_expr (retval
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3121 expand_value_return (result_rtl
);
3125 /* A subroutine of expand_gimple_stmt, expanding one gimple statement
3126 STMT that doesn't require special handling for outgoing edges. That
3127 is no tailcalls and no GIMPLE_COND. */
3130 expand_gimple_stmt_1 (gimple stmt
)
3134 set_curr_insn_location (gimple_location (stmt
));
3136 switch (gimple_code (stmt
))
3139 op0
= gimple_goto_dest (stmt
);
3140 if (TREE_CODE (op0
) == LABEL_DECL
)
3143 expand_computed_goto (op0
);
3146 expand_label (gimple_label_label (stmt
));
3149 case GIMPLE_PREDICT
:
3155 expand_asm_stmt (stmt
);
3158 expand_call_stmt (stmt
);
3162 op0
= gimple_return_retval (stmt
);
3164 if (op0
&& op0
!= error_mark_node
)
3166 tree result
= DECL_RESULT (current_function_decl
);
3168 /* If we are not returning the current function's RESULT_DECL,
3169 build an assignment to it. */
3172 /* I believe that a function's RESULT_DECL is unique. */
3173 gcc_assert (TREE_CODE (op0
) != RESULT_DECL
);
3175 /* ??? We'd like to use simply expand_assignment here,
3176 but this fails if the value is of BLKmode but the return
3177 decl is a register. expand_return has special handling
3178 for this combination, which eventually should move
3179 to common code. See comments there. Until then, let's
3180 build a modify expression :-/ */
3181 op0
= build2 (MODIFY_EXPR
, TREE_TYPE (result
),
3186 expand_null_return ();
3188 expand_return (op0
);
3193 tree lhs
= gimple_assign_lhs (stmt
);
3195 /* Tree expand used to fiddle with |= and &= of two bitfield
3196 COMPONENT_REFs here. This can't happen with gimple, the LHS
3197 of binary assigns must be a gimple reg. */
3199 if (TREE_CODE (lhs
) != SSA_NAME
3200 || get_gimple_rhs_class (gimple_expr_code (stmt
))
3201 == GIMPLE_SINGLE_RHS
)
3203 tree rhs
= gimple_assign_rhs1 (stmt
);
3204 gcc_assert (get_gimple_rhs_class (gimple_expr_code (stmt
))
3205 == GIMPLE_SINGLE_RHS
);
3206 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (rhs
))
3207 SET_EXPR_LOCATION (rhs
, gimple_location (stmt
));
3208 if (TREE_CLOBBER_P (rhs
))
3209 /* This is a clobber to mark the going out of scope for
3213 expand_assignment (lhs
, rhs
,
3214 gimple_assign_nontemporal_move_p (stmt
));
3219 bool nontemporal
= gimple_assign_nontemporal_move_p (stmt
);
3220 struct separate_ops ops
;
3221 bool promoted
= false;
3223 target
= expand_expr (lhs
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
3224 if (GET_CODE (target
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (target
))
3227 ops
.code
= gimple_assign_rhs_code (stmt
);
3228 ops
.type
= TREE_TYPE (lhs
);
3229 switch (get_gimple_rhs_class (gimple_expr_code (stmt
)))
3231 case GIMPLE_TERNARY_RHS
:
3232 ops
.op2
= gimple_assign_rhs3 (stmt
);
3234 case GIMPLE_BINARY_RHS
:
3235 ops
.op1
= gimple_assign_rhs2 (stmt
);
3237 case GIMPLE_UNARY_RHS
:
3238 ops
.op0
= gimple_assign_rhs1 (stmt
);
3243 ops
.location
= gimple_location (stmt
);
3245 /* If we want to use a nontemporal store, force the value to
3246 register first. If we store into a promoted register,
3247 don't directly expand to target. */
3248 temp
= nontemporal
|| promoted
? NULL_RTX
: target
;
3249 temp
= expand_expr_real_2 (&ops
, temp
, GET_MODE (target
),
3256 int unsignedp
= SUBREG_PROMOTED_UNSIGNED_P (target
);
3257 /* If TEMP is a VOIDmode constant, use convert_modes to make
3258 sure that we properly convert it. */
3259 if (CONSTANT_P (temp
) && GET_MODE (temp
) == VOIDmode
)
3261 temp
= convert_modes (GET_MODE (target
),
3262 TYPE_MODE (ops
.type
),
3264 temp
= convert_modes (GET_MODE (SUBREG_REG (target
)),
3265 GET_MODE (target
), temp
, unsignedp
);
3268 convert_move (SUBREG_REG (target
), temp
, unsignedp
);
3270 else if (nontemporal
&& emit_storent_insn (target
, temp
))
3274 temp
= force_operand (temp
, target
);
3276 emit_move_insn (target
, temp
);
3287 /* Expand one gimple statement STMT and return the last RTL instruction
3288 before any of the newly generated ones.
3290 In addition to generating the necessary RTL instructions this also
3291 sets REG_EH_REGION notes if necessary and sets the current source
3292 location for diagnostics. */
3295 expand_gimple_stmt (gimple stmt
)
3297 location_t saved_location
= input_location
;
3298 rtx last
= get_last_insn ();
3303 /* We need to save and restore the current source location so that errors
3304 discovered during expansion are emitted with the right location. But
3305 it would be better if the diagnostic routines used the source location
3306 embedded in the tree nodes rather than globals. */
3307 if (gimple_has_location (stmt
))
3308 input_location
= gimple_location (stmt
);
3310 expand_gimple_stmt_1 (stmt
);
3312 /* Free any temporaries used to evaluate this statement. */
3315 input_location
= saved_location
;
3317 /* Mark all insns that may trap. */
3318 lp_nr
= lookup_stmt_eh_lp (stmt
);
3322 for (insn
= next_real_insn (last
); insn
;
3323 insn
= next_real_insn (insn
))
3325 if (! find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
3326 /* If we want exceptions for non-call insns, any
3327 may_trap_p instruction may throw. */
3328 && GET_CODE (PATTERN (insn
)) != CLOBBER
3329 && GET_CODE (PATTERN (insn
)) != USE
3330 && insn_could_throw_p (insn
))
3331 make_reg_eh_region_note (insn
, 0, lp_nr
);
3338 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_CALL
3339 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
3340 generated a tail call (something that might be denied by the ABI
3341 rules governing the call; see calls.c).
3343 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
3344 can still reach the rest of BB. The case here is __builtin_sqrt,
3345 where the NaN result goes through the external function (with a
3346 tailcall) and the normal result happens via a sqrt instruction. */
3349 expand_gimple_tailcall (basic_block bb
, gimple stmt
, bool *can_fallthru
)
3357 last2
= last
= expand_gimple_stmt (stmt
);
3359 for (last
= NEXT_INSN (last
); last
; last
= NEXT_INSN (last
))
3360 if (CALL_P (last
) && SIBLING_CALL_P (last
))
3363 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
3365 *can_fallthru
= true;
3369 /* ??? Wouldn't it be better to just reset any pending stack adjust?
3370 Any instructions emitted here are about to be deleted. */
3371 do_pending_stack_adjust ();
3373 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
3374 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
3375 EH or abnormal edges, we shouldn't have created a tail call in
3376 the first place. So it seems to me we should just be removing
3377 all edges here, or redirecting the existing fallthru edge to
3383 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
3385 if (!(e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
)))
3387 if (e
->dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
3389 e
->dest
->count
-= e
->count
;
3390 e
->dest
->frequency
-= EDGE_FREQUENCY (e
);
3391 if (e
->dest
->count
< 0)
3393 if (e
->dest
->frequency
< 0)
3394 e
->dest
->frequency
= 0;
3397 probability
+= e
->probability
;
3404 /* This is somewhat ugly: the call_expr expander often emits instructions
3405 after the sibcall (to perform the function return). These confuse the
3406 find_many_sub_basic_blocks code, so we need to get rid of these. */
3407 last
= NEXT_INSN (last
);
3408 gcc_assert (BARRIER_P (last
));
3410 *can_fallthru
= false;
3411 while (NEXT_INSN (last
))
3413 /* For instance an sqrt builtin expander expands if with
3414 sibcall in the then and label for `else`. */
3415 if (LABEL_P (NEXT_INSN (last
)))
3417 *can_fallthru
= true;
3420 delete_insn (NEXT_INSN (last
));
3423 e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_ABNORMAL
3425 e
->probability
+= probability
;
3428 update_bb_for_insn (bb
);
3430 if (NEXT_INSN (last
))
3432 bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
3435 if (BARRIER_P (last
))
3436 BB_END (bb
) = PREV_INSN (last
);
3439 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
3444 /* Return the difference between the floor and the truncated result of
3445 a signed division by OP1 with remainder MOD. */
3447 floor_sdiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1
)
3449 /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
3450 return gen_rtx_IF_THEN_ELSE
3451 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3452 gen_rtx_IF_THEN_ELSE
3453 (mode
, gen_rtx_LT (BImode
,
3454 gen_rtx_DIV (mode
, op1
, mod
),
3456 constm1_rtx
, const0_rtx
),
3460 /* Return the difference between the ceil and the truncated result of
3461 a signed division by OP1 with remainder MOD. */
3463 ceil_sdiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1
)
3465 /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
3466 return gen_rtx_IF_THEN_ELSE
3467 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3468 gen_rtx_IF_THEN_ELSE
3469 (mode
, gen_rtx_GT (BImode
,
3470 gen_rtx_DIV (mode
, op1
, mod
),
3472 const1_rtx
, const0_rtx
),
3476 /* Return the difference between the ceil and the truncated result of
3477 an unsigned division by OP1 with remainder MOD. */
3479 ceil_udiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1 ATTRIBUTE_UNUSED
)
3481 /* (mod != 0 ? 1 : 0) */
3482 return gen_rtx_IF_THEN_ELSE
3483 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3484 const1_rtx
, const0_rtx
);
3487 /* Return the difference between the rounded and the truncated result
3488 of a signed division by OP1 with remainder MOD. Halfway cases are
3489 rounded away from zero, rather than to the nearest even number. */
3491 round_sdiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1
)
3493 /* (abs (mod) >= abs (op1) - abs (mod)
3494 ? (op1 / mod > 0 ? 1 : -1)
3496 return gen_rtx_IF_THEN_ELSE
3497 (mode
, gen_rtx_GE (BImode
, gen_rtx_ABS (mode
, mod
),
3498 gen_rtx_MINUS (mode
,
3499 gen_rtx_ABS (mode
, op1
),
3500 gen_rtx_ABS (mode
, mod
))),
3501 gen_rtx_IF_THEN_ELSE
3502 (mode
, gen_rtx_GT (BImode
,
3503 gen_rtx_DIV (mode
, op1
, mod
),
3505 const1_rtx
, constm1_rtx
),
3509 /* Return the difference between the rounded and the truncated result
3510 of a unsigned division by OP1 with remainder MOD. Halfway cases
3511 are rounded away from zero, rather than to the nearest even
3514 round_udiv_adjust (enum machine_mode mode
, rtx mod
, rtx op1
)
3516 /* (mod >= op1 - mod ? 1 : 0) */
3517 return gen_rtx_IF_THEN_ELSE
3518 (mode
, gen_rtx_GE (BImode
, mod
,
3519 gen_rtx_MINUS (mode
, op1
, mod
)),
3520 const1_rtx
, const0_rtx
);
3523 /* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
3527 convert_debug_memory_address (enum machine_mode mode
, rtx x
,
3530 enum machine_mode xmode
= GET_MODE (x
);
3532 #ifndef POINTERS_EXTEND_UNSIGNED
3533 gcc_assert (mode
== Pmode
3534 || mode
== targetm
.addr_space
.address_mode (as
));
3535 gcc_assert (xmode
== mode
|| xmode
== VOIDmode
);
3539 gcc_assert (targetm
.addr_space
.valid_pointer_mode (mode
, as
));
3541 if (GET_MODE (x
) == mode
|| GET_MODE (x
) == VOIDmode
)
3544 if (GET_MODE_PRECISION (mode
) < GET_MODE_PRECISION (xmode
))
3545 x
= simplify_gen_subreg (mode
, x
, xmode
,
3546 subreg_lowpart_offset
3548 else if (POINTERS_EXTEND_UNSIGNED
> 0)
3549 x
= gen_rtx_ZERO_EXTEND (mode
, x
);
3550 else if (!POINTERS_EXTEND_UNSIGNED
)
3551 x
= gen_rtx_SIGN_EXTEND (mode
, x
);
3554 switch (GET_CODE (x
))
3557 if ((SUBREG_PROMOTED_VAR_P (x
)
3558 || (REG_P (SUBREG_REG (x
)) && REG_POINTER (SUBREG_REG (x
)))
3559 || (GET_CODE (SUBREG_REG (x
)) == PLUS
3560 && REG_P (XEXP (SUBREG_REG (x
), 0))
3561 && REG_POINTER (XEXP (SUBREG_REG (x
), 0))
3562 && CONST_INT_P (XEXP (SUBREG_REG (x
), 1))))
3563 && GET_MODE (SUBREG_REG (x
)) == mode
)
3564 return SUBREG_REG (x
);
3567 temp
= gen_rtx_LABEL_REF (mode
, XEXP (x
, 0));
3568 LABEL_REF_NONLOCAL_P (temp
) = LABEL_REF_NONLOCAL_P (x
);
3571 temp
= shallow_copy_rtx (x
);
3572 PUT_MODE (temp
, mode
);
3575 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
3577 temp
= gen_rtx_CONST (mode
, temp
);
3581 if (CONST_INT_P (XEXP (x
, 1)))
3583 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
3585 return gen_rtx_fmt_ee (GET_CODE (x
), mode
, temp
, XEXP (x
, 1));
3591 /* Don't know how to express ptr_extend as operation in debug info. */
3594 #endif /* POINTERS_EXTEND_UNSIGNED */
3599 /* Return an RTX equivalent to the value of the parameter DECL. */
3602 expand_debug_parm_decl (tree decl
)
3604 rtx incoming
= DECL_INCOMING_RTL (decl
);
3607 && GET_MODE (incoming
) != BLKmode
3608 && ((REG_P (incoming
) && HARD_REGISTER_P (incoming
))
3609 || (MEM_P (incoming
)
3610 && REG_P (XEXP (incoming
, 0))
3611 && HARD_REGISTER_P (XEXP (incoming
, 0)))))
3613 rtx rtl
= gen_rtx_ENTRY_VALUE (GET_MODE (incoming
));
3615 #ifdef HAVE_window_save
3616 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
3617 If the target machine has an explicit window save instruction, the
3618 actual entry value is the corresponding OUTGOING_REGNO instead. */
3619 if (REG_P (incoming
)
3620 && OUTGOING_REGNO (REGNO (incoming
)) != REGNO (incoming
))
3622 = gen_rtx_REG_offset (incoming
, GET_MODE (incoming
),
3623 OUTGOING_REGNO (REGNO (incoming
)), 0);
3624 else if (MEM_P (incoming
))
3626 rtx reg
= XEXP (incoming
, 0);
3627 if (OUTGOING_REGNO (REGNO (reg
)) != REGNO (reg
))
3629 reg
= gen_raw_REG (GET_MODE (reg
), OUTGOING_REGNO (REGNO (reg
)));
3630 incoming
= replace_equiv_address_nv (incoming
, reg
);
3633 incoming
= copy_rtx (incoming
);
3637 ENTRY_VALUE_EXP (rtl
) = incoming
;
3642 && GET_MODE (incoming
) != BLKmode
3643 && !TREE_ADDRESSABLE (decl
)
3645 && (XEXP (incoming
, 0) == virtual_incoming_args_rtx
3646 || (GET_CODE (XEXP (incoming
, 0)) == PLUS
3647 && XEXP (XEXP (incoming
, 0), 0) == virtual_incoming_args_rtx
3648 && CONST_INT_P (XEXP (XEXP (incoming
, 0), 1)))))
3649 return copy_rtx (incoming
);
3654 /* Return an RTX equivalent to the value of the tree expression EXP. */
3657 expand_debug_expr (tree exp
)
3659 rtx op0
= NULL_RTX
, op1
= NULL_RTX
, op2
= NULL_RTX
;
3660 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
3661 enum machine_mode inner_mode
= VOIDmode
;
3662 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (exp
));
3665 switch (TREE_CODE_CLASS (TREE_CODE (exp
)))
3667 case tcc_expression
:
3668 switch (TREE_CODE (exp
))
3672 case WIDEN_MULT_PLUS_EXPR
:
3673 case WIDEN_MULT_MINUS_EXPR
:
3677 case TRUTH_ANDIF_EXPR
:
3678 case TRUTH_ORIF_EXPR
:
3679 case TRUTH_AND_EXPR
:
3681 case TRUTH_XOR_EXPR
:
3684 case TRUTH_NOT_EXPR
:
3693 op2
= expand_debug_expr (TREE_OPERAND (exp
, 2));
3700 case tcc_comparison
:
3701 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
3708 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
3709 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
3719 case tcc_exceptional
:
3720 case tcc_declaration
:
3726 switch (TREE_CODE (exp
))
3729 if (!lookup_constant_def (exp
))
3731 if (strlen (TREE_STRING_POINTER (exp
)) + 1
3732 != (size_t) TREE_STRING_LENGTH (exp
))
3734 op0
= gen_rtx_CONST_STRING (Pmode
, TREE_STRING_POINTER (exp
));
3735 op0
= gen_rtx_MEM (BLKmode
, op0
);
3736 set_mem_attributes (op0
, exp
, 0);
3739 /* Fall through... */
3744 op0
= expand_expr (exp
, NULL_RTX
, mode
, EXPAND_INITIALIZER
);
3748 gcc_assert (COMPLEX_MODE_P (mode
));
3749 op0
= expand_debug_expr (TREE_REALPART (exp
));
3750 op1
= expand_debug_expr (TREE_IMAGPART (exp
));
3751 return gen_rtx_CONCAT (mode
, op0
, op1
);
3753 case DEBUG_EXPR_DECL
:
3754 op0
= DECL_RTL_IF_SET (exp
);
3759 op0
= gen_rtx_DEBUG_EXPR (mode
);
3760 DEBUG_EXPR_TREE_DECL (op0
) = exp
;
3761 SET_DECL_RTL (exp
, op0
);
3771 op0
= DECL_RTL_IF_SET (exp
);
3773 /* This decl was probably optimized away. */
3776 if (TREE_CODE (exp
) != VAR_DECL
3777 || DECL_EXTERNAL (exp
)
3778 || !TREE_STATIC (exp
)
3780 || DECL_HARD_REGISTER (exp
)
3781 || DECL_IN_CONSTANT_POOL (exp
)
3782 || mode
== VOIDmode
)
3785 op0
= make_decl_rtl_for_debug (exp
);
3787 || GET_CODE (XEXP (op0
, 0)) != SYMBOL_REF
3788 || SYMBOL_REF_DECL (XEXP (op0
, 0)) != exp
)
3792 op0
= copy_rtx (op0
);
3794 if (GET_MODE (op0
) == BLKmode
3795 /* If op0 is not BLKmode, but BLKmode is, adjust_mode
3796 below would ICE. While it is likely a FE bug,
3797 try to be robust here. See PR43166. */
3799 || (mode
== VOIDmode
&& GET_MODE (op0
) != VOIDmode
))
3801 gcc_assert (MEM_P (op0
));
3802 op0
= adjust_address_nv (op0
, mode
, 0);
3813 inner_mode
= GET_MODE (op0
);
3815 if (mode
== inner_mode
)
3818 if (inner_mode
== VOIDmode
)
3820 if (TREE_CODE (exp
) == SSA_NAME
)
3821 inner_mode
= TYPE_MODE (TREE_TYPE (exp
));
3823 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
3824 if (mode
== inner_mode
)
3828 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
3830 if (GET_MODE_BITSIZE (mode
) == GET_MODE_BITSIZE (inner_mode
))
3831 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
3832 else if (GET_MODE_BITSIZE (mode
) < GET_MODE_BITSIZE (inner_mode
))
3833 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
3835 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
3837 else if (FLOAT_MODE_P (mode
))
3839 gcc_assert (TREE_CODE (exp
) != SSA_NAME
);
3840 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
3841 op0
= simplify_gen_unary (UNSIGNED_FLOAT
, mode
, op0
, inner_mode
);
3843 op0
= simplify_gen_unary (FLOAT
, mode
, op0
, inner_mode
);
3845 else if (FLOAT_MODE_P (inner_mode
))
3848 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
3850 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
3852 else if (CONSTANT_P (op0
)
3853 || GET_MODE_PRECISION (mode
) <= GET_MODE_PRECISION (inner_mode
))
3854 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
,
3855 subreg_lowpart_offset (mode
,
3857 else if (TREE_CODE_CLASS (TREE_CODE (exp
)) == tcc_unary
3858 ? TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)))
3860 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
3862 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
3868 if (!is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
3870 tree newexp
= fold_binary (MEM_REF
, TREE_TYPE (exp
),
3871 TREE_OPERAND (exp
, 0),
3872 TREE_OPERAND (exp
, 1));
3874 return expand_debug_expr (newexp
);
3878 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
3879 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
3883 if (TREE_CODE (exp
) == MEM_REF
)
3885 if (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
3886 || (GET_CODE (op0
) == PLUS
3887 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
))
3888 /* (mem (debug_implicit_ptr)) might confuse aliasing.
3889 Instead just use get_inner_reference. */
3892 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
3893 if (!op1
|| !CONST_INT_P (op1
))
3896 op0
= plus_constant (inner_mode
, op0
, INTVAL (op1
));
3899 if (POINTER_TYPE_P (TREE_TYPE (exp
)))
3900 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)));
3902 as
= ADDR_SPACE_GENERIC
;
3904 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
3906 if (op0
== NULL_RTX
)
3909 op0
= gen_rtx_MEM (mode
, op0
);
3910 set_mem_attributes (op0
, exp
, 0);
3911 if (TREE_CODE (exp
) == MEM_REF
3912 && !is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
3913 set_mem_expr (op0
, NULL_TREE
);
3914 set_mem_addr_space (op0
, as
);
3918 case TARGET_MEM_REF
:
3919 if (TREE_CODE (TMR_BASE (exp
)) == ADDR_EXPR
3920 && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp
), 0)))
3923 op0
= expand_debug_expr
3924 (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp
)), exp
));
3928 if (POINTER_TYPE_P (TREE_TYPE (exp
)))
3929 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)));
3931 as
= ADDR_SPACE_GENERIC
;
3933 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
3935 if (op0
== NULL_RTX
)
3938 op0
= gen_rtx_MEM (mode
, op0
);
3940 set_mem_attributes (op0
, exp
, 0);
3941 set_mem_addr_space (op0
, as
);
3947 case ARRAY_RANGE_REF
:
3952 case VIEW_CONVERT_EXPR
:
3954 enum machine_mode mode1
;
3955 HOST_WIDE_INT bitsize
, bitpos
;
3958 tree tem
= get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
,
3959 &mode1
, &unsignedp
, &volatilep
, false);
3965 orig_op0
= op0
= expand_debug_expr (tem
);
3972 enum machine_mode addrmode
, offmode
;
3977 op0
= XEXP (op0
, 0);
3978 addrmode
= GET_MODE (op0
);
3979 if (addrmode
== VOIDmode
)
3982 op1
= expand_debug_expr (offset
);
3986 offmode
= GET_MODE (op1
);
3987 if (offmode
== VOIDmode
)
3988 offmode
= TYPE_MODE (TREE_TYPE (offset
));
3990 if (addrmode
!= offmode
)
3991 op1
= simplify_gen_subreg (addrmode
, op1
, offmode
,
3992 subreg_lowpart_offset (addrmode
,
3995 /* Don't use offset_address here, we don't need a
3996 recognizable address, and we don't want to generate
3998 op0
= gen_rtx_MEM (mode
, simplify_gen_binary (PLUS
, addrmode
,
4004 if (mode1
== VOIDmode
)
4006 mode1
= smallest_mode_for_size (bitsize
, MODE_INT
);
4007 if (bitpos
>= BITS_PER_UNIT
)
4009 op0
= adjust_address_nv (op0
, mode1
, bitpos
/ BITS_PER_UNIT
);
4010 bitpos
%= BITS_PER_UNIT
;
4012 else if (bitpos
< 0)
4015 = (-bitpos
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
4016 op0
= adjust_address_nv (op0
, mode1
, units
);
4017 bitpos
+= units
* BITS_PER_UNIT
;
4019 else if (bitpos
== 0 && bitsize
== GET_MODE_BITSIZE (mode
))
4020 op0
= adjust_address_nv (op0
, mode
, 0);
4021 else if (GET_MODE (op0
) != mode1
)
4022 op0
= adjust_address_nv (op0
, mode1
, 0);
4024 op0
= copy_rtx (op0
);
4025 if (op0
== orig_op0
)
4026 op0
= shallow_copy_rtx (op0
);
4027 set_mem_attributes (op0
, exp
, 0);
4030 if (bitpos
== 0 && mode
== GET_MODE (op0
))
4036 if (GET_MODE (op0
) == BLKmode
)
4039 if ((bitpos
% BITS_PER_UNIT
) == 0
4040 && bitsize
== GET_MODE_BITSIZE (mode1
))
4042 enum machine_mode opmode
= GET_MODE (op0
);
4044 if (opmode
== VOIDmode
)
4045 opmode
= TYPE_MODE (TREE_TYPE (tem
));
4047 /* This condition may hold if we're expanding the address
4048 right past the end of an array that turned out not to
4049 be addressable (i.e., the address was only computed in
4050 debug stmts). The gen_subreg below would rightfully
4051 crash, and the address doesn't really exist, so just
4053 if (bitpos
>= GET_MODE_BITSIZE (opmode
))
4056 if ((bitpos
% GET_MODE_BITSIZE (mode
)) == 0)
4057 return simplify_gen_subreg (mode
, op0
, opmode
,
4058 bitpos
/ BITS_PER_UNIT
);
4061 return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0
))
4062 && TYPE_UNSIGNED (TREE_TYPE (exp
))
4064 : ZERO_EXTRACT
, mode
,
4065 GET_MODE (op0
) != VOIDmode
4067 : TYPE_MODE (TREE_TYPE (tem
)),
4068 op0
, GEN_INT (bitsize
), GEN_INT (bitpos
));
4072 return simplify_gen_unary (ABS
, mode
, op0
, mode
);
4075 return simplify_gen_unary (NEG
, mode
, op0
, mode
);
4078 return simplify_gen_unary (NOT
, mode
, op0
, mode
);
4081 return simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4083 ? UNSIGNED_FLOAT
: FLOAT
, mode
, op0
,
4086 case FIX_TRUNC_EXPR
:
4087 return simplify_gen_unary (unsignedp
? UNSIGNED_FIX
: FIX
, mode
, op0
,
4090 case POINTER_PLUS_EXPR
:
4091 /* For the rare target where pointers are not the same size as
4092 size_t, we need to check for mis-matched modes and correct
4095 && GET_MODE (op0
) != VOIDmode
&& GET_MODE (op1
) != VOIDmode
4096 && GET_MODE (op0
) != GET_MODE (op1
))
4098 if (GET_MODE_BITSIZE (GET_MODE (op0
)) < GET_MODE_BITSIZE (GET_MODE (op1
))
4099 /* If OP0 is a partial mode, then we must truncate, even if it has
4100 the same bitsize as OP1 as GCC's representation of partial modes
4102 || (GET_MODE_CLASS (GET_MODE (op0
)) == MODE_PARTIAL_INT
4103 && GET_MODE_BITSIZE (GET_MODE (op0
)) == GET_MODE_BITSIZE (GET_MODE (op1
))))
4104 op1
= simplify_gen_unary (TRUNCATE
, GET_MODE (op0
), op1
,
4107 /* We always sign-extend, regardless of the signedness of
4108 the operand, because the operand is always unsigned
4109 here even if the original C expression is signed. */
4110 op1
= simplify_gen_unary (SIGN_EXTEND
, GET_MODE (op0
), op1
,
4115 return simplify_gen_binary (PLUS
, mode
, op0
, op1
);
4118 return simplify_gen_binary (MINUS
, mode
, op0
, op1
);
4121 return simplify_gen_binary (MULT
, mode
, op0
, op1
);
4124 case TRUNC_DIV_EXPR
:
4125 case EXACT_DIV_EXPR
:
4127 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4129 return simplify_gen_binary (DIV
, mode
, op0
, op1
);
4131 case TRUNC_MOD_EXPR
:
4132 return simplify_gen_binary (unsignedp
? UMOD
: MOD
, mode
, op0
, op1
);
4134 case FLOOR_DIV_EXPR
:
4136 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4139 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4140 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4141 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4142 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4145 case FLOOR_MOD_EXPR
:
4147 return simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4150 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4151 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4152 adj
= simplify_gen_unary (NEG
, mode
,
4153 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4155 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4161 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4162 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4163 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4164 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4168 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4169 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4170 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4171 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4177 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4178 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4179 adj
= simplify_gen_unary (NEG
, mode
,
4180 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4182 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4186 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4187 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4188 adj
= simplify_gen_unary (NEG
, mode
,
4189 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4191 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4194 case ROUND_DIV_EXPR
:
4197 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4198 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4199 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4200 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4204 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4205 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4206 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4207 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4210 case ROUND_MOD_EXPR
:
4213 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4214 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4215 adj
= simplify_gen_unary (NEG
, mode
,
4216 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4218 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4222 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4223 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4224 adj
= simplify_gen_unary (NEG
, mode
,
4225 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4227 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4231 return simplify_gen_binary (ASHIFT
, mode
, op0
, op1
);
4235 return simplify_gen_binary (LSHIFTRT
, mode
, op0
, op1
);
4237 return simplify_gen_binary (ASHIFTRT
, mode
, op0
, op1
);
4240 return simplify_gen_binary (ROTATE
, mode
, op0
, op1
);
4243 return simplify_gen_binary (ROTATERT
, mode
, op0
, op1
);
4246 return simplify_gen_binary (unsignedp
? UMIN
: SMIN
, mode
, op0
, op1
);
4249 return simplify_gen_binary (unsignedp
? UMAX
: SMAX
, mode
, op0
, op1
);
4252 case TRUTH_AND_EXPR
:
4253 return simplify_gen_binary (AND
, mode
, op0
, op1
);
4257 return simplify_gen_binary (IOR
, mode
, op0
, op1
);
4260 case TRUTH_XOR_EXPR
:
4261 return simplify_gen_binary (XOR
, mode
, op0
, op1
);
4263 case TRUTH_ANDIF_EXPR
:
4264 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, const0_rtx
);
4266 case TRUTH_ORIF_EXPR
:
4267 return gen_rtx_IF_THEN_ELSE (mode
, op0
, const_true_rtx
, op1
);
4269 case TRUTH_NOT_EXPR
:
4270 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, const0_rtx
);
4273 return simplify_gen_relational (unsignedp
? LTU
: LT
, mode
, inner_mode
,
4277 return simplify_gen_relational (unsignedp
? LEU
: LE
, mode
, inner_mode
,
4281 return simplify_gen_relational (unsignedp
? GTU
: GT
, mode
, inner_mode
,
4285 return simplify_gen_relational (unsignedp
? GEU
: GE
, mode
, inner_mode
,
4289 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, op1
);
4292 return simplify_gen_relational (NE
, mode
, inner_mode
, op0
, op1
);
4294 case UNORDERED_EXPR
:
4295 return simplify_gen_relational (UNORDERED
, mode
, inner_mode
, op0
, op1
);
4298 return simplify_gen_relational (ORDERED
, mode
, inner_mode
, op0
, op1
);
4301 return simplify_gen_relational (UNLT
, mode
, inner_mode
, op0
, op1
);
4304 return simplify_gen_relational (UNLE
, mode
, inner_mode
, op0
, op1
);
4307 return simplify_gen_relational (UNGT
, mode
, inner_mode
, op0
, op1
);
4310 return simplify_gen_relational (UNGE
, mode
, inner_mode
, op0
, op1
);
4313 return simplify_gen_relational (UNEQ
, mode
, inner_mode
, op0
, op1
);
4316 return simplify_gen_relational (LTGT
, mode
, inner_mode
, op0
, op1
);
4319 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, op2
);
4322 gcc_assert (COMPLEX_MODE_P (mode
));
4323 if (GET_MODE (op0
) == VOIDmode
)
4324 op0
= gen_rtx_CONST (GET_MODE_INNER (mode
), op0
);
4325 if (GET_MODE (op1
) == VOIDmode
)
4326 op1
= gen_rtx_CONST (GET_MODE_INNER (mode
), op1
);
4327 return gen_rtx_CONCAT (mode
, op0
, op1
);
4330 if (GET_CODE (op0
) == CONCAT
)
4331 return gen_rtx_CONCAT (mode
, XEXP (op0
, 0),
4332 simplify_gen_unary (NEG
, GET_MODE_INNER (mode
),
4334 GET_MODE_INNER (mode
)));
4337 enum machine_mode imode
= GET_MODE_INNER (mode
);
4342 re
= adjust_address_nv (op0
, imode
, 0);
4343 im
= adjust_address_nv (op0
, imode
, GET_MODE_SIZE (imode
));
4347 enum machine_mode ifmode
= int_mode_for_mode (mode
);
4348 enum machine_mode ihmode
= int_mode_for_mode (imode
);
4350 if (ifmode
== BLKmode
|| ihmode
== BLKmode
)
4352 halfsize
= GEN_INT (GET_MODE_BITSIZE (ihmode
));
4355 re
= gen_rtx_SUBREG (ifmode
, re
, 0);
4356 re
= gen_rtx_ZERO_EXTRACT (ihmode
, re
, halfsize
, const0_rtx
);
4357 if (imode
!= ihmode
)
4358 re
= gen_rtx_SUBREG (imode
, re
, 0);
4359 im
= copy_rtx (op0
);
4361 im
= gen_rtx_SUBREG (ifmode
, im
, 0);
4362 im
= gen_rtx_ZERO_EXTRACT (ihmode
, im
, halfsize
, halfsize
);
4363 if (imode
!= ihmode
)
4364 im
= gen_rtx_SUBREG (imode
, im
, 0);
4366 im
= gen_rtx_NEG (imode
, im
);
4367 return gen_rtx_CONCAT (mode
, re
, im
);
4371 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4372 if (!op0
|| !MEM_P (op0
))
4374 if ((TREE_CODE (TREE_OPERAND (exp
, 0)) == VAR_DECL
4375 || TREE_CODE (TREE_OPERAND (exp
, 0)) == PARM_DECL
4376 || TREE_CODE (TREE_OPERAND (exp
, 0)) == RESULT_DECL
)
4377 && (!TREE_ADDRESSABLE (TREE_OPERAND (exp
, 0))
4378 || target_for_debug_bind (TREE_OPERAND (exp
, 0))))
4379 return gen_rtx_DEBUG_IMPLICIT_PTR (mode
, TREE_OPERAND (exp
, 0));
4381 if (handled_component_p (TREE_OPERAND (exp
, 0)))
4383 HOST_WIDE_INT bitoffset
, bitsize
, maxsize
;
4385 = get_ref_base_and_extent (TREE_OPERAND (exp
, 0),
4386 &bitoffset
, &bitsize
, &maxsize
);
4387 if ((TREE_CODE (decl
) == VAR_DECL
4388 || TREE_CODE (decl
) == PARM_DECL
4389 || TREE_CODE (decl
) == RESULT_DECL
)
4390 && (!TREE_ADDRESSABLE (decl
)
4391 || target_for_debug_bind (decl
))
4392 && (bitoffset
% BITS_PER_UNIT
) == 0
4394 && bitsize
== maxsize
)
4396 rtx base
= gen_rtx_DEBUG_IMPLICIT_PTR (mode
, decl
);
4397 return plus_constant (mode
, base
, bitoffset
/ BITS_PER_UNIT
);
4401 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == MEM_REF
4402 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
4405 op0
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
4408 && (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
4409 || (GET_CODE (op0
) == PLUS
4410 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
4411 && CONST_INT_P (XEXP (op0
, 1)))))
4413 op1
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
4415 if (!op1
|| !CONST_INT_P (op1
))
4418 return plus_constant (mode
, op0
, INTVAL (op1
));
4425 as
= TYPE_ADDR_SPACE (TREE_TYPE (exp
));
4426 op0
= convert_debug_memory_address (mode
, XEXP (op0
, 0), as
);
4434 op0
= gen_rtx_CONCATN
4435 (mode
, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
))));
4437 for (i
= 0; i
< VECTOR_CST_NELTS (exp
); ++i
)
4439 op1
= expand_debug_expr (VECTOR_CST_ELT (exp
, i
));
4442 XVECEXP (op0
, 0, i
) = op1
;
4449 if (TREE_CLOBBER_P (exp
))
4451 else if (TREE_CODE (TREE_TYPE (exp
)) == VECTOR_TYPE
)
4456 op0
= gen_rtx_CONCATN
4457 (mode
, rtvec_alloc (TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
))));
4459 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), i
, val
)
4461 op1
= expand_debug_expr (val
);
4464 XVECEXP (op0
, 0, i
) = op1
;
4467 if (i
< TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)))
4469 op1
= expand_debug_expr
4470 (build_zero_cst (TREE_TYPE (TREE_TYPE (exp
))));
4475 for (; i
< TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)); i
++)
4476 XVECEXP (op0
, 0, i
) = op1
;
4482 goto flag_unsupported
;
4485 /* ??? Maybe handle some builtins? */
4490 gimple g
= get_gimple_for_ssa_name (exp
);
4493 op0
= expand_debug_expr (gimple_assign_rhs_to_tree (g
));
4499 int part
= var_to_partition (SA
.map
, exp
);
4501 if (part
== NO_PARTITION
)
4503 /* If this is a reference to an incoming value of parameter
4504 that is never used in the code or where the incoming
4505 value is never used in the code, use PARM_DECL's
4507 if (SSA_NAME_IS_DEFAULT_DEF (exp
)
4508 && TREE_CODE (SSA_NAME_VAR (exp
)) == PARM_DECL
)
4510 op0
= expand_debug_parm_decl (SSA_NAME_VAR (exp
));
4513 op0
= expand_debug_expr (SSA_NAME_VAR (exp
));
4520 gcc_assert (part
>= 0 && (unsigned)part
< SA
.map
->num_partitions
);
4522 op0
= copy_rtx (SA
.partition_to_pseudo
[part
]);
4530 /* Vector stuff. For most of the codes we don't have rtl codes. */
4531 case REALIGN_LOAD_EXPR
:
4532 case REDUC_MAX_EXPR
:
4533 case REDUC_MIN_EXPR
:
4534 case REDUC_PLUS_EXPR
:
4536 case VEC_LSHIFT_EXPR
:
4537 case VEC_PACK_FIX_TRUNC_EXPR
:
4538 case VEC_PACK_SAT_EXPR
:
4539 case VEC_PACK_TRUNC_EXPR
:
4540 case VEC_RSHIFT_EXPR
:
4541 case VEC_UNPACK_FLOAT_HI_EXPR
:
4542 case VEC_UNPACK_FLOAT_LO_EXPR
:
4543 case VEC_UNPACK_HI_EXPR
:
4544 case VEC_UNPACK_LO_EXPR
:
4545 case VEC_WIDEN_MULT_HI_EXPR
:
4546 case VEC_WIDEN_MULT_LO_EXPR
:
4547 case VEC_WIDEN_MULT_EVEN_EXPR
:
4548 case VEC_WIDEN_MULT_ODD_EXPR
:
4549 case VEC_WIDEN_LSHIFT_HI_EXPR
:
4550 case VEC_WIDEN_LSHIFT_LO_EXPR
:
4555 case ADDR_SPACE_CONVERT_EXPR
:
4556 case FIXED_CONVERT_EXPR
:
4558 case WITH_SIZE_EXPR
:
4562 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
4563 && SCALAR_INT_MODE_P (mode
))
4566 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4568 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
4571 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4573 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op1
,
4575 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
4576 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
4580 case WIDEN_MULT_EXPR
:
4581 case WIDEN_MULT_PLUS_EXPR
:
4582 case WIDEN_MULT_MINUS_EXPR
:
4583 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
4584 && SCALAR_INT_MODE_P (mode
))
4586 inner_mode
= GET_MODE (op0
);
4587 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
4588 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
4590 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
4591 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 1))))
4592 op1
= simplify_gen_unary (ZERO_EXTEND
, mode
, op1
, inner_mode
);
4594 op1
= simplify_gen_unary (SIGN_EXTEND
, mode
, op1
, inner_mode
);
4595 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
4596 if (TREE_CODE (exp
) == WIDEN_MULT_EXPR
)
4598 else if (TREE_CODE (exp
) == WIDEN_MULT_PLUS_EXPR
)
4599 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
4601 return simplify_gen_binary (MINUS
, mode
, op2
, op0
);
4605 case MULT_HIGHPART_EXPR
:
4606 /* ??? Similar to the above. */
4609 case WIDEN_SUM_EXPR
:
4610 case WIDEN_LSHIFT_EXPR
:
4611 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
4612 && SCALAR_INT_MODE_P (mode
))
4615 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4617 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
4619 return simplify_gen_binary (TREE_CODE (exp
) == WIDEN_LSHIFT_EXPR
4620 ? ASHIFT
: PLUS
, mode
, op0
, op1
);
4625 return simplify_gen_ternary (FMA
, mode
, inner_mode
, op0
, op1
, op2
);
4629 #ifdef ENABLE_CHECKING
4638 /* Return an RTX equivalent to the source bind value of the tree expression
4642 expand_debug_source_expr (tree exp
)
4645 enum machine_mode mode
= VOIDmode
, inner_mode
;
4647 switch (TREE_CODE (exp
))
4651 mode
= DECL_MODE (exp
);
4652 op0
= expand_debug_parm_decl (exp
);
4655 /* See if this isn't an argument that has been completely
4657 if (!DECL_RTL_SET_P (exp
)
4658 && !DECL_INCOMING_RTL (exp
)
4659 && DECL_ABSTRACT_ORIGIN (current_function_decl
))
4661 tree aexp
= DECL_ORIGIN (exp
);
4662 if (DECL_CONTEXT (aexp
)
4663 == DECL_ABSTRACT_ORIGIN (current_function_decl
))
4665 vec
<tree
, va_gc
> **debug_args
;
4668 debug_args
= decl_debug_args_lookup (current_function_decl
);
4669 if (debug_args
!= NULL
)
4671 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, &ddecl
);
4674 return gen_rtx_DEBUG_PARAMETER_REF (mode
, aexp
);
4684 if (op0
== NULL_RTX
)
4687 inner_mode
= GET_MODE (op0
);
4688 if (mode
== inner_mode
)
4691 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
4693 if (GET_MODE_BITSIZE (mode
) == GET_MODE_BITSIZE (inner_mode
))
4694 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
4695 else if (GET_MODE_BITSIZE (mode
) < GET_MODE_BITSIZE (inner_mode
))
4696 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
4698 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
4700 else if (FLOAT_MODE_P (mode
))
4702 else if (FLOAT_MODE_P (inner_mode
))
4704 if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
4705 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
4707 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
4709 else if (CONSTANT_P (op0
)
4710 || GET_MODE_BITSIZE (mode
) <= GET_MODE_BITSIZE (inner_mode
))
4711 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
,
4712 subreg_lowpart_offset (mode
, inner_mode
));
4713 else if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
4714 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
4716 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
4721 /* Ensure INSN_VAR_LOCATION_LOC (insn) doesn't have unbound complexity.
4722 Allow 4 levels of rtl nesting for most rtl codes, and if we see anything
4723 deeper than that, create DEBUG_EXPRs and emit DEBUG_INSNs before INSN. */
4726 avoid_complex_debug_insns (rtx insn
, rtx
*exp_p
, int depth
)
4730 if (exp
== NULL_RTX
)
4733 if ((OBJECT_P (exp
) && !MEM_P (exp
)) || GET_CODE (exp
) == CLOBBER
)
4738 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
4739 rtx dval
= make_debug_expr_from_rtl (exp
);
4741 /* Emit a debug bind insn before INSN. */
4742 rtx bind
= gen_rtx_VAR_LOCATION (GET_MODE (exp
),
4743 DEBUG_EXPR_TREE_DECL (dval
), exp
,
4744 VAR_INIT_STATUS_INITIALIZED
);
4746 emit_debug_insn_before (bind
, insn
);
4751 const char *format_ptr
= GET_RTX_FORMAT (GET_CODE (exp
));
4753 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
4754 switch (*format_ptr
++)
4757 avoid_complex_debug_insns (insn
, &XEXP (exp
, i
), depth
+ 1);
4762 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4763 avoid_complex_debug_insns (insn
, &XVECEXP (exp
, i
, j
), depth
+ 1);
4771 /* Expand the _LOCs in debug insns. We run this after expanding all
4772 regular insns, so that any variables referenced in the function
4773 will have their DECL_RTLs set. */
4776 expand_debug_locations (void)
4779 rtx last
= get_last_insn ();
4780 int save_strict_alias
= flag_strict_aliasing
;
4782 /* New alias sets while setting up memory attributes cause
4783 -fcompare-debug failures, even though it doesn't bring about any
4785 flag_strict_aliasing
= 0;
4787 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
4788 if (DEBUG_INSN_P (insn
))
4790 tree value
= (tree
)INSN_VAR_LOCATION_LOC (insn
);
4791 rtx val
, prev_insn
, insn2
;
4792 enum machine_mode mode
;
4794 if (value
== NULL_TREE
)
4798 if (INSN_VAR_LOCATION_STATUS (insn
)
4799 == VAR_INIT_STATUS_UNINITIALIZED
)
4800 val
= expand_debug_source_expr (value
);
4802 val
= expand_debug_expr (value
);
4803 gcc_assert (last
== get_last_insn ());
4807 val
= gen_rtx_UNKNOWN_VAR_LOC ();
4810 mode
= GET_MODE (INSN_VAR_LOCATION (insn
));
4812 gcc_assert (mode
== GET_MODE (val
)
4813 || (GET_MODE (val
) == VOIDmode
4814 && (CONST_SCALAR_INT_P (val
)
4815 || GET_CODE (val
) == CONST_FIXED
4816 || GET_CODE (val
) == LABEL_REF
)));
4819 INSN_VAR_LOCATION_LOC (insn
) = val
;
4820 prev_insn
= PREV_INSN (insn
);
4821 for (insn2
= insn
; insn2
!= prev_insn
; insn2
= PREV_INSN (insn2
))
4822 avoid_complex_debug_insns (insn2
, &INSN_VAR_LOCATION_LOC (insn2
), 0);
4825 flag_strict_aliasing
= save_strict_alias
;
4828 /* Expand basic block BB from GIMPLE trees to RTL. */
4831 expand_gimple_basic_block (basic_block bb
, bool disable_tail_calls
)
4833 gimple_stmt_iterator gsi
;
4842 fprintf (dump_file
, "\n;; Generating RTL for gimple basic block %d\n",
4845 /* Note that since we are now transitioning from GIMPLE to RTL, we
4846 cannot use the gsi_*_bb() routines because they expect the basic
4847 block to be in GIMPLE, instead of RTL. Therefore, we need to
4848 access the BB sequence directly. */
4849 stmts
= bb_seq (bb
);
4850 bb
->il
.gimple
.seq
= NULL
;
4851 bb
->il
.gimple
.phi_nodes
= NULL
;
4852 rtl_profile_for_bb (bb
);
4853 init_rtl_bb_info (bb
);
4854 bb
->flags
|= BB_RTL
;
4856 /* Remove the RETURN_EXPR if we may fall though to the exit
4858 gsi
= gsi_last (stmts
);
4859 if (!gsi_end_p (gsi
)
4860 && gimple_code (gsi_stmt (gsi
)) == GIMPLE_RETURN
)
4862 gimple ret_stmt
= gsi_stmt (gsi
);
4864 gcc_assert (single_succ_p (bb
));
4865 gcc_assert (single_succ (bb
) == EXIT_BLOCK_PTR_FOR_FN (cfun
));
4867 if (bb
->next_bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
)
4868 && !gimple_return_retval (ret_stmt
))
4870 gsi_remove (&gsi
, false);
4871 single_succ_edge (bb
)->flags
|= EDGE_FALLTHRU
;
4875 gsi
= gsi_start (stmts
);
4876 if (!gsi_end_p (gsi
))
4878 stmt
= gsi_stmt (gsi
);
4879 if (gimple_code (stmt
) != GIMPLE_LABEL
)
4883 elt
= pointer_map_contains (lab_rtx_for_bb
, bb
);
4887 last
= get_last_insn ();
4891 expand_gimple_stmt (stmt
);
4896 emit_label ((rtx
) *elt
);
4898 /* Java emits line number notes in the top of labels.
4899 ??? Make this go away once line number notes are obsoleted. */
4900 BB_HEAD (bb
) = NEXT_INSN (last
);
4901 if (NOTE_P (BB_HEAD (bb
)))
4902 BB_HEAD (bb
) = NEXT_INSN (BB_HEAD (bb
));
4903 note
= emit_note_after (NOTE_INSN_BASIC_BLOCK
, BB_HEAD (bb
));
4905 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
4908 note
= BB_HEAD (bb
) = emit_note (NOTE_INSN_BASIC_BLOCK
);
4910 NOTE_BASIC_BLOCK (note
) = bb
;
4912 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
4916 stmt
= gsi_stmt (gsi
);
4918 /* If this statement is a non-debug one, and we generate debug
4919 insns, then this one might be the last real use of a TERed
4920 SSA_NAME, but where there are still some debug uses further
4921 down. Expanding the current SSA name in such further debug
4922 uses by their RHS might lead to wrong debug info, as coalescing
4923 might make the operands of such RHS be placed into the same
4924 pseudo as something else. Like so:
4925 a_1 = a_0 + 1; // Assume a_1 is TERed and a_0 is dead
4929 As a_0 and a_2 don't overlap in lifetime, assume they are coalesced.
4930 If we now would expand a_1 by it's RHS (a_0 + 1) in the debug use,
4931 the write to a_2 would actually have clobbered the place which
4934 So, instead of that, we recognize the situation, and generate
4935 debug temporaries at the last real use of TERed SSA names:
4942 if (MAY_HAVE_DEBUG_INSNS
4944 && !is_gimple_debug (stmt
))
4950 location_t sloc
= curr_insn_location ();
4952 /* Look for SSA names that have their last use here (TERed
4953 names always have only one real use). */
4954 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
)
4955 if ((def
= get_gimple_for_ssa_name (op
)))
4957 imm_use_iterator imm_iter
;
4958 use_operand_p use_p
;
4959 bool have_debug_uses
= false;
4961 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, op
)
4963 if (gimple_debug_bind_p (USE_STMT (use_p
)))
4965 have_debug_uses
= true;
4970 if (have_debug_uses
)
4972 /* OP is a TERed SSA name, with DEF it's defining
4973 statement, and where OP is used in further debug
4974 instructions. Generate a debug temporary, and
4975 replace all uses of OP in debug insns with that
4978 tree value
= gimple_assign_rhs_to_tree (def
);
4979 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
4981 enum machine_mode mode
;
4983 set_curr_insn_location (gimple_location (def
));
4985 DECL_ARTIFICIAL (vexpr
) = 1;
4986 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
4988 mode
= DECL_MODE (value
);
4990 mode
= TYPE_MODE (TREE_TYPE (value
));
4991 DECL_MODE (vexpr
) = mode
;
4993 val
= gen_rtx_VAR_LOCATION
4994 (mode
, vexpr
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
4996 emit_debug_insn (val
);
4998 FOR_EACH_IMM_USE_STMT (debugstmt
, imm_iter
, op
)
5000 if (!gimple_debug_bind_p (debugstmt
))
5003 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
5004 SET_USE (use_p
, vexpr
);
5006 update_stmt (debugstmt
);
5010 set_curr_insn_location (sloc
);
5013 currently_expanding_gimple_stmt
= stmt
;
5015 /* Expand this statement, then evaluate the resulting RTL and
5016 fixup the CFG accordingly. */
5017 if (gimple_code (stmt
) == GIMPLE_COND
)
5019 new_bb
= expand_gimple_cond (bb
, stmt
);
5023 else if (gimple_debug_bind_p (stmt
))
5025 location_t sloc
= curr_insn_location ();
5026 gimple_stmt_iterator nsi
= gsi
;
5030 tree var
= gimple_debug_bind_get_var (stmt
);
5033 enum machine_mode mode
;
5035 if (TREE_CODE (var
) != DEBUG_EXPR_DECL
5036 && TREE_CODE (var
) != LABEL_DECL
5037 && !target_for_debug_bind (var
))
5038 goto delink_debug_stmt
;
5040 if (gimple_debug_bind_has_value_p (stmt
))
5041 value
= gimple_debug_bind_get_value (stmt
);
5045 last
= get_last_insn ();
5047 set_curr_insn_location (gimple_location (stmt
));
5050 mode
= DECL_MODE (var
);
5052 mode
= TYPE_MODE (TREE_TYPE (var
));
5054 val
= gen_rtx_VAR_LOCATION
5055 (mode
, var
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5057 emit_debug_insn (val
);
5059 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5061 /* We can't dump the insn with a TREE where an RTX
5063 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
5064 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5065 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
5069 /* In order not to generate too many debug temporaries,
5070 we delink all uses of debug statements we already expanded.
5071 Therefore debug statements between definition and real
5072 use of TERed SSA names will continue to use the SSA name,
5073 and not be replaced with debug temps. */
5074 delink_stmt_imm_use (stmt
);
5078 if (gsi_end_p (nsi
))
5080 stmt
= gsi_stmt (nsi
);
5081 if (!gimple_debug_bind_p (stmt
))
5085 set_curr_insn_location (sloc
);
5087 else if (gimple_debug_source_bind_p (stmt
))
5089 location_t sloc
= curr_insn_location ();
5090 tree var
= gimple_debug_source_bind_get_var (stmt
);
5091 tree value
= gimple_debug_source_bind_get_value (stmt
);
5093 enum machine_mode mode
;
5095 last
= get_last_insn ();
5097 set_curr_insn_location (gimple_location (stmt
));
5099 mode
= DECL_MODE (var
);
5101 val
= gen_rtx_VAR_LOCATION (mode
, var
, (rtx
)value
,
5102 VAR_INIT_STATUS_UNINITIALIZED
);
5104 emit_debug_insn (val
);
5106 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5108 /* We can't dump the insn with a TREE where an RTX
5110 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
5111 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5112 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
5115 set_curr_insn_location (sloc
);
5119 if (is_gimple_call (stmt
)
5120 && gimple_call_tail_p (stmt
)
5121 && disable_tail_calls
)
5122 gimple_call_set_tail (stmt
, false);
5124 if (is_gimple_call (stmt
) && gimple_call_tail_p (stmt
))
5127 new_bb
= expand_gimple_tailcall (bb
, stmt
, &can_fallthru
);
5138 def_operand_p def_p
;
5139 def_p
= SINGLE_SSA_DEF_OPERAND (stmt
, SSA_OP_DEF
);
5143 /* Ignore this stmt if it is in the list of
5144 replaceable expressions. */
5146 && bitmap_bit_p (SA
.values
,
5147 SSA_NAME_VERSION (DEF_FROM_PTR (def_p
))))
5150 last
= expand_gimple_stmt (stmt
);
5151 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5156 currently_expanding_gimple_stmt
= NULL
;
5158 /* Expand implicit goto and convert goto_locus. */
5159 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5161 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
5162 set_curr_insn_location (e
->goto_locus
);
5163 if ((e
->flags
& EDGE_FALLTHRU
) && e
->dest
!= bb
->next_bb
)
5165 emit_jump (label_rtx_for_bb (e
->dest
));
5166 e
->flags
&= ~EDGE_FALLTHRU
;
5170 /* Expanded RTL can create a jump in the last instruction of block.
5171 This later might be assumed to be a jump to successor and break edge insertion.
5172 We need to insert dummy move to prevent this. PR41440. */
5173 if (single_succ_p (bb
)
5174 && (single_succ_edge (bb
)->flags
& EDGE_FALLTHRU
)
5175 && (last
= get_last_insn ())
5178 rtx dummy
= gen_reg_rtx (SImode
);
5179 emit_insn_after_noloc (gen_move_insn (dummy
, dummy
), last
, NULL
);
5182 do_pending_stack_adjust ();
5184 /* Find the block tail. The last insn in the block is the insn
5185 before a barrier and/or table jump insn. */
5186 last
= get_last_insn ();
5187 if (BARRIER_P (last
))
5188 last
= PREV_INSN (last
);
5189 if (JUMP_TABLE_DATA_P (last
))
5190 last
= PREV_INSN (PREV_INSN (last
));
5193 update_bb_for_insn (bb
);
5199 /* Create a basic block for initialization code. */
5202 construct_init_block (void)
5204 basic_block init_block
, first_block
;
5208 /* Multiple entry points not supported yet. */
5209 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
) == 1);
5210 init_rtl_bb_info (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5211 init_rtl_bb_info (EXIT_BLOCK_PTR_FOR_FN (cfun
));
5212 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
5213 EXIT_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
5215 e
= EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun
), 0);
5217 /* When entry edge points to first basic block, we don't need jump,
5218 otherwise we have to jump into proper target. */
5219 if (e
&& e
->dest
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
)
5221 tree label
= gimple_block_label (e
->dest
);
5223 emit_jump (label_rtx (label
));
5227 flags
= EDGE_FALLTHRU
;
5229 init_block
= create_basic_block (NEXT_INSN (get_insns ()),
5231 ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5232 init_block
->frequency
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
;
5233 init_block
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
5234 if (current_loops
&& ENTRY_BLOCK_PTR_FOR_FN (cfun
)->loop_father
)
5235 add_bb_to_loop (init_block
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
5238 first_block
= e
->dest
;
5239 redirect_edge_succ (e
, init_block
);
5240 e
= make_edge (init_block
, first_block
, flags
);
5243 e
= make_edge (init_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_FALLTHRU
);
5244 e
->probability
= REG_BR_PROB_BASE
;
5245 e
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
5247 update_bb_for_insn (init_block
);
5251 /* For each lexical block, set BLOCK_NUMBER to the depth at which it is
5252 found in the block tree. */
5255 set_block_levels (tree block
, int level
)
5259 BLOCK_NUMBER (block
) = level
;
5260 set_block_levels (BLOCK_SUBBLOCKS (block
), level
+ 1);
5261 block
= BLOCK_CHAIN (block
);
5265 /* Create a block containing landing pads and similar stuff. */
5268 construct_exit_block (void)
5270 rtx head
= get_last_insn ();
5272 basic_block exit_block
;
5276 rtx orig_end
= BB_END (EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
);
5278 rtl_profile_for_bb (EXIT_BLOCK_PTR_FOR_FN (cfun
));
5280 /* Make sure the locus is set to the end of the function, so that
5281 epilogue line numbers and warnings are set properly. */
5282 if (LOCATION_LOCUS (cfun
->function_end_locus
) != UNKNOWN_LOCATION
)
5283 input_location
= cfun
->function_end_locus
;
5285 /* Generate rtl for function exit. */
5286 expand_function_end ();
5288 end
= get_last_insn ();
5291 /* While emitting the function end we could move end of the last basic block.
5293 BB_END (EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
) = orig_end
;
5294 while (NEXT_INSN (head
) && NOTE_P (NEXT_INSN (head
)))
5295 head
= NEXT_INSN (head
);
5296 exit_block
= create_basic_block (NEXT_INSN (head
), end
,
5297 EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
);
5298 exit_block
->frequency
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->frequency
;
5299 exit_block
->count
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
;
5300 if (current_loops
&& EXIT_BLOCK_PTR_FOR_FN (cfun
)->loop_father
)
5301 add_bb_to_loop (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
5304 while (ix
< EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
))
5306 e
= EDGE_PRED (EXIT_BLOCK_PTR_FOR_FN (cfun
), ix
);
5307 if (!(e
->flags
& EDGE_ABNORMAL
))
5308 redirect_edge_succ (e
, exit_block
);
5313 e
= make_edge (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_FALLTHRU
);
5314 e
->probability
= REG_BR_PROB_BASE
;
5315 e
->count
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
;
5316 FOR_EACH_EDGE (e2
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
5319 e
->count
-= e2
->count
;
5320 exit_block
->count
-= e2
->count
;
5321 exit_block
->frequency
-= EDGE_FREQUENCY (e2
);
5325 if (exit_block
->count
< 0)
5326 exit_block
->count
= 0;
5327 if (exit_block
->frequency
< 0)
5328 exit_block
->frequency
= 0;
5329 update_bb_for_insn (exit_block
);
5332 /* Helper function for discover_nonconstant_array_refs.
5333 Look for ARRAY_REF nodes with non-constant indexes and mark them
5337 discover_nonconstant_array_refs_r (tree
* tp
, int *walk_subtrees
,
5338 void *data ATTRIBUTE_UNUSED
)
5342 if (IS_TYPE_OR_DECL_P (t
))
5344 else if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5346 while (((TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5347 && is_gimple_min_invariant (TREE_OPERAND (t
, 1))
5348 && (!TREE_OPERAND (t
, 2)
5349 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
5350 || (TREE_CODE (t
) == COMPONENT_REF
5351 && (!TREE_OPERAND (t
,2)
5352 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
5353 || TREE_CODE (t
) == BIT_FIELD_REF
5354 || TREE_CODE (t
) == REALPART_EXPR
5355 || TREE_CODE (t
) == IMAGPART_EXPR
5356 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5357 || CONVERT_EXPR_P (t
))
5358 t
= TREE_OPERAND (t
, 0);
5360 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5362 t
= get_base_address (t
);
5364 && DECL_MODE (t
) != BLKmode
)
5365 TREE_ADDRESSABLE (t
) = 1;
5374 /* RTL expansion is not able to compile array references with variable
5375 offsets for arrays stored in single register. Discover such
5376 expressions and mark variables as addressable to avoid this
5380 discover_nonconstant_array_refs (void)
5383 gimple_stmt_iterator gsi
;
5385 FOR_EACH_BB_FN (bb
, cfun
)
5386 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5388 gimple stmt
= gsi_stmt (gsi
);
5389 if (!is_gimple_debug (stmt
))
5390 walk_gimple_op (stmt
, discover_nonconstant_array_refs_r
, NULL
);
5394 /* This function sets crtl->args.internal_arg_pointer to a virtual
5395 register if DRAP is needed. Local register allocator will replace
5396 virtual_incoming_args_rtx with the virtual register. */
5399 expand_stack_alignment (void)
5402 unsigned int preferred_stack_boundary
;
5404 if (! SUPPORTS_STACK_ALIGNMENT
)
5407 if (cfun
->calls_alloca
5408 || cfun
->has_nonlocal_label
5409 || crtl
->has_nonlocal_goto
)
5410 crtl
->need_drap
= true;
5412 /* Call update_stack_boundary here again to update incoming stack
5413 boundary. It may set incoming stack alignment to a different
5414 value after RTL expansion. TARGET_FUNCTION_OK_FOR_SIBCALL may
5415 use the minimum incoming stack alignment to check if it is OK
5416 to perform sibcall optimization since sibcall optimization will
5417 only align the outgoing stack to incoming stack boundary. */
5418 if (targetm
.calls
.update_stack_boundary
)
5419 targetm
.calls
.update_stack_boundary ();
5421 /* The incoming stack frame has to be aligned at least at
5422 parm_stack_boundary. */
5423 gcc_assert (crtl
->parm_stack_boundary
<= INCOMING_STACK_BOUNDARY
);
5425 /* Update crtl->stack_alignment_estimated and use it later to align
5426 stack. We check PREFERRED_STACK_BOUNDARY if there may be non-call
5427 exceptions since callgraph doesn't collect incoming stack alignment
5429 if (cfun
->can_throw_non_call_exceptions
5430 && PREFERRED_STACK_BOUNDARY
> crtl
->preferred_stack_boundary
)
5431 preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
5433 preferred_stack_boundary
= crtl
->preferred_stack_boundary
;
5434 if (preferred_stack_boundary
> crtl
->stack_alignment_estimated
)
5435 crtl
->stack_alignment_estimated
= preferred_stack_boundary
;
5436 if (preferred_stack_boundary
> crtl
->stack_alignment_needed
)
5437 crtl
->stack_alignment_needed
= preferred_stack_boundary
;
5439 gcc_assert (crtl
->stack_alignment_needed
5440 <= crtl
->stack_alignment_estimated
);
5442 crtl
->stack_realign_needed
5443 = INCOMING_STACK_BOUNDARY
< crtl
->stack_alignment_estimated
;
5444 crtl
->stack_realign_tried
= crtl
->stack_realign_needed
;
5446 crtl
->stack_realign_processed
= true;
5448 /* Target has to redefine TARGET_GET_DRAP_RTX to support stack
5450 gcc_assert (targetm
.calls
.get_drap_rtx
!= NULL
);
5451 drap_rtx
= targetm
.calls
.get_drap_rtx ();
5453 /* stack_realign_drap and drap_rtx must match. */
5454 gcc_assert ((stack_realign_drap
!= 0) == (drap_rtx
!= NULL
));
5456 /* Do nothing if NULL is returned, which means DRAP is not needed. */
5457 if (NULL
!= drap_rtx
)
5459 crtl
->args
.internal_arg_pointer
= drap_rtx
;
5461 /* Call fixup_tail_calls to clean up REG_EQUIV note if DRAP is
5463 fixup_tail_calls ();
5469 expand_main_function (void)
5471 #if (defined(INVOKE__main) \
5472 || (!defined(HAS_INIT_SECTION) \
5473 && !defined(INIT_SECTION_ASM_OP) \
5474 && !defined(INIT_ARRAY_SECTION_ASM_OP)))
5475 emit_library_call (init_one_libfunc (NAME__MAIN
), LCT_NORMAL
, VOIDmode
, 0);
5480 /* Expand code to initialize the stack_protect_guard. This is invoked at
5481 the beginning of a function to be protected. */
5483 #ifndef HAVE_stack_protect_set
5484 # define HAVE_stack_protect_set 0
5485 # define gen_stack_protect_set(x,y) (gcc_unreachable (), NULL_RTX)
5489 stack_protect_prologue (void)
5491 tree guard_decl
= targetm
.stack_protect_guard ();
5494 x
= expand_normal (crtl
->stack_protect_guard
);
5495 y
= expand_normal (guard_decl
);
5497 /* Allow the target to copy from Y to X without leaking Y into a
5499 if (HAVE_stack_protect_set
)
5501 rtx insn
= gen_stack_protect_set (x
, y
);
5509 /* Otherwise do a straight move. */
5510 emit_move_insn (x
, y
);
5513 /* Translate the intermediate representation contained in the CFG
5514 from GIMPLE trees to RTL.
5516 We do conversion per basic block and preserve/update the tree CFG.
5517 This implies we have to do some magic as the CFG can simultaneously
5518 consist of basic blocks containing RTL and GIMPLE trees. This can
5519 confuse the CFG hooks, so be careful to not manipulate CFG during
5523 gimple_expand_cfg (void)
5525 basic_block bb
, init_block
;
5529 rtx var_seq
, var_ret_seq
;
5532 timevar_push (TV_OUT_OF_SSA
);
5533 rewrite_out_of_ssa (&SA
);
5534 timevar_pop (TV_OUT_OF_SSA
);
5535 SA
.partition_to_pseudo
= XCNEWVEC (rtx
, SA
.map
->num_partitions
);
5537 /* Make sure all values used by the optimization passes have sane
5541 /* Some backends want to know that we are expanding to RTL. */
5542 currently_expanding_to_rtl
= 1;
5543 /* Dominators are not kept up-to-date as we may create new basic-blocks. */
5544 free_dominance_info (CDI_DOMINATORS
);
5546 rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5548 insn_locations_init ();
5549 if (!DECL_IS_BUILTIN (current_function_decl
))
5551 /* Eventually, all FEs should explicitly set function_start_locus. */
5552 if (LOCATION_LOCUS (cfun
->function_start_locus
) == UNKNOWN_LOCATION
)
5553 set_curr_insn_location
5554 (DECL_SOURCE_LOCATION (current_function_decl
));
5556 set_curr_insn_location (cfun
->function_start_locus
);
5559 set_curr_insn_location (UNKNOWN_LOCATION
);
5560 prologue_location
= curr_insn_location ();
5562 #ifdef INSN_SCHEDULING
5563 init_sched_attrs ();
5566 /* Make sure first insn is a note even if we don't want linenums.
5567 This makes sure the first insn will never be deleted.
5568 Also, final expects a note to appear there. */
5569 emit_note (NOTE_INSN_DELETED
);
5571 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
5572 discover_nonconstant_array_refs ();
5574 targetm
.expand_to_rtl_hook ();
5575 crtl
->stack_alignment_needed
= STACK_BOUNDARY
;
5576 crtl
->max_used_stack_slot_alignment
= STACK_BOUNDARY
;
5577 crtl
->stack_alignment_estimated
= 0;
5578 crtl
->preferred_stack_boundary
= STACK_BOUNDARY
;
5579 cfun
->cfg
->max_jumptable_ents
= 0;
5581 /* Resovle the function section. Some targets, like ARM EABI rely on knowledge
5582 of the function section at exapnsion time to predict distance of calls. */
5583 resolve_unique_section (current_function_decl
, 0, flag_function_sections
);
5585 /* Expand the variables recorded during gimple lowering. */
5586 timevar_push (TV_VAR_EXPAND
);
5589 var_ret_seq
= expand_used_vars ();
5591 var_seq
= get_insns ();
5593 timevar_pop (TV_VAR_EXPAND
);
5595 /* Honor stack protection warnings. */
5596 if (warn_stack_protect
)
5598 if (cfun
->calls_alloca
)
5599 warning (OPT_Wstack_protector
,
5600 "stack protector not protecting local variables: "
5601 "variable length buffer");
5602 if (has_short_buffer
&& !crtl
->stack_protect_guard
)
5603 warning (OPT_Wstack_protector
,
5604 "stack protector not protecting function: "
5605 "all local arrays are less than %d bytes long",
5606 (int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
));
5609 /* Set up parameters and prepare for return, for the function. */
5610 expand_function_start (current_function_decl
);
5612 /* If we emitted any instructions for setting up the variables,
5613 emit them before the FUNCTION_START note. */
5616 emit_insn_before (var_seq
, parm_birth_insn
);
5618 /* In expand_function_end we'll insert the alloca save/restore
5619 before parm_birth_insn. We've just insertted an alloca call.
5620 Adjust the pointer to match. */
5621 parm_birth_insn
= var_seq
;
5624 /* Now that we also have the parameter RTXs, copy them over to our
5626 for (i
= 0; i
< SA
.map
->num_partitions
; i
++)
5628 tree var
= SSA_NAME_VAR (partition_to_var (SA
.map
, i
));
5630 if (TREE_CODE (var
) != VAR_DECL
5631 && !SA
.partition_to_pseudo
[i
])
5632 SA
.partition_to_pseudo
[i
] = DECL_RTL_IF_SET (var
);
5633 gcc_assert (SA
.partition_to_pseudo
[i
]);
5635 /* If this decl was marked as living in multiple places, reset
5636 this now to NULL. */
5637 if (DECL_RTL_IF_SET (var
) == pc_rtx
)
5638 SET_DECL_RTL (var
, NULL
);
5640 /* Some RTL parts really want to look at DECL_RTL(x) when x
5641 was a decl marked in REG_ATTR or MEM_ATTR. We could use
5642 SET_DECL_RTL here making this available, but that would mean
5643 to select one of the potentially many RTLs for one DECL. Instead
5644 of doing that we simply reset the MEM_EXPR of the RTL in question,
5645 then nobody can get at it and hence nobody can call DECL_RTL on it. */
5646 if (!DECL_RTL_SET_P (var
))
5648 if (MEM_P (SA
.partition_to_pseudo
[i
]))
5649 set_mem_expr (SA
.partition_to_pseudo
[i
], NULL
);
5653 /* If we have a class containing differently aligned pointers
5654 we need to merge those into the corresponding RTL pointer
5656 for (i
= 1; i
< num_ssa_names
; i
++)
5658 tree name
= ssa_name (i
);
5663 /* We might have generated new SSA names in
5664 update_alias_info_with_stack_vars. They will have a NULL
5665 defining statements, and won't be part of the partitioning,
5667 || !SSA_NAME_DEF_STMT (name
))
5669 part
= var_to_partition (SA
.map
, name
);
5670 if (part
== NO_PARTITION
)
5673 /* Adjust all partition members to get the underlying decl of
5674 the representative which we might have created in expand_one_var. */
5675 if (SSA_NAME_VAR (name
) == NULL_TREE
)
5677 tree leader
= partition_to_var (SA
.map
, part
);
5678 gcc_assert (SSA_NAME_VAR (leader
) != NULL_TREE
);
5679 replace_ssa_name_symbol (name
, SSA_NAME_VAR (leader
));
5681 if (!POINTER_TYPE_P (TREE_TYPE (name
)))
5684 r
= SA
.partition_to_pseudo
[part
];
5686 mark_reg_pointer (r
, get_pointer_alignment (name
));
5689 /* If this function is `main', emit a call to `__main'
5690 to run global initializers, etc. */
5691 if (DECL_NAME (current_function_decl
)
5692 && MAIN_NAME_P (DECL_NAME (current_function_decl
))
5693 && DECL_FILE_SCOPE_P (current_function_decl
))
5694 expand_main_function ();
5696 /* Initialize the stack_protect_guard field. This must happen after the
5697 call to __main (if any) so that the external decl is initialized. */
5698 if (crtl
->stack_protect_guard
)
5699 stack_protect_prologue ();
5701 expand_phi_nodes (&SA
);
5703 /* Register rtl specific functions for cfg. */
5704 rtl_register_cfg_hooks ();
5706 init_block
= construct_init_block ();
5708 /* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
5709 remaining edges later. */
5710 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
)
5711 e
->flags
&= ~EDGE_EXECUTABLE
;
5713 lab_rtx_for_bb
= pointer_map_create ();
5714 FOR_BB_BETWEEN (bb
, init_block
->next_bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
),
5716 bb
= expand_gimple_basic_block (bb
, var_ret_seq
!= NULL_RTX
);
5718 if (MAY_HAVE_DEBUG_INSNS
)
5719 expand_debug_locations ();
5721 /* Free stuff we no longer need after GIMPLE optimizations. */
5722 free_dominance_info (CDI_DOMINATORS
);
5723 free_dominance_info (CDI_POST_DOMINATORS
);
5724 delete_tree_cfg_annotations ();
5726 timevar_push (TV_OUT_OF_SSA
);
5727 finish_out_of_ssa (&SA
);
5728 timevar_pop (TV_OUT_OF_SSA
);
5730 timevar_push (TV_POST_EXPAND
);
5731 /* We are no longer in SSA form. */
5732 cfun
->gimple_df
->in_ssa_p
= false;
5734 loops_state_clear (LOOP_CLOSED_SSA
);
5736 /* Expansion is used by optimization passes too, set maybe_hot_insn_p
5737 conservatively to true until they are all profile aware. */
5738 pointer_map_destroy (lab_rtx_for_bb
);
5741 construct_exit_block ();
5742 insn_locations_finalize ();
5746 rtx after
= return_label
;
5747 rtx next
= NEXT_INSN (after
);
5748 if (next
&& NOTE_INSN_BASIC_BLOCK_P (next
))
5750 emit_insn_after (var_ret_seq
, after
);
5753 /* Zap the tree EH table. */
5754 set_eh_throw_stmt_table (cfun
, NULL
);
5756 /* We need JUMP_LABEL be set in order to redirect jumps, and hence
5757 split edges which edge insertions might do. */
5758 rebuild_jump_labels (get_insns ());
5760 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (cfun
),
5761 EXIT_BLOCK_PTR_FOR_FN (cfun
), next_bb
)
5765 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
5769 rebuild_jump_labels_chain (e
->insns
.r
);
5770 /* Put insns after parm birth, but before
5771 NOTE_INSNS_FUNCTION_BEG. */
5772 if (e
->src
== ENTRY_BLOCK_PTR_FOR_FN (cfun
)
5773 && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (cfun
)))
5775 rtx insns
= e
->insns
.r
;
5776 e
->insns
.r
= NULL_RTX
;
5777 if (NOTE_P (parm_birth_insn
)
5778 && NOTE_KIND (parm_birth_insn
) == NOTE_INSN_FUNCTION_BEG
)
5779 emit_insn_before_noloc (insns
, parm_birth_insn
, e
->dest
);
5781 emit_insn_after_noloc (insns
, parm_birth_insn
, e
->dest
);
5784 commit_one_edge_insertion (e
);
5791 /* We're done expanding trees to RTL. */
5792 currently_expanding_to_rtl
= 0;
5794 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
,
5795 EXIT_BLOCK_PTR_FOR_FN (cfun
), next_bb
)
5799 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
5801 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
5802 e
->flags
&= ~EDGE_EXECUTABLE
;
5804 /* At the moment not all abnormal edges match the RTL
5805 representation. It is safe to remove them here as
5806 find_many_sub_basic_blocks will rediscover them.
5807 In the future we should get this fixed properly. */
5808 if ((e
->flags
& EDGE_ABNORMAL
)
5809 && !(e
->flags
& EDGE_SIBCALL
))
5816 blocks
= sbitmap_alloc (last_basic_block_for_fn (cfun
));
5817 bitmap_ones (blocks
);
5818 find_many_sub_basic_blocks (blocks
);
5819 sbitmap_free (blocks
);
5820 purge_all_dead_edges ();
5822 expand_stack_alignment ();
5824 /* Fixup REG_EQUIV notes in the prologue if there are tailcalls in this
5826 if (crtl
->tail_call_emit
)
5827 fixup_tail_calls ();
5829 /* After initial rtl generation, call back to finish generating
5830 exception support code. We need to do this before cleaning up
5831 the CFG as the code does not expect dead landing pads. */
5832 if (cfun
->eh
->region_tree
!= NULL
)
5833 finish_eh_generation ();
5835 /* Remove unreachable blocks, otherwise we cannot compute dominators
5836 which are needed for loop state verification. As a side-effect
5837 this also compacts blocks.
5838 ??? We cannot remove trivially dead insns here as for example
5839 the DRAP reg on i?86 is not magically live at this point.
5840 gcc.c-torture/execute/ipa-sra-2.c execution, -Os -m32 fails otherwise. */
5841 cleanup_cfg (CLEANUP_NO_INSN_DEL
);
5843 #ifdef ENABLE_CHECKING
5844 verify_flow_info ();
5847 /* Initialize pseudos allocated for hard registers. */
5848 emit_initial_value_sets ();
5850 /* And finally unshare all RTL. */
5853 /* There's no need to defer outputting this function any more; we
5854 know we want to output it. */
5855 DECL_DEFER_OUTPUT (current_function_decl
) = 0;
5857 /* Now that we're done expanding trees to RTL, we shouldn't have any
5858 more CONCATs anywhere. */
5859 generating_concat_p
= 0;
5864 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
5865 /* And the pass manager will dump RTL for us. */
5868 /* If we're emitting a nested function, make sure its parent gets
5869 emitted as well. Doing otherwise confuses debug info. */
5872 for (parent
= DECL_CONTEXT (current_function_decl
);
5873 parent
!= NULL_TREE
;
5874 parent
= get_containing_scope (parent
))
5875 if (TREE_CODE (parent
) == FUNCTION_DECL
)
5876 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent
)) = 1;
5879 /* We are now committed to emitting code for this function. Do any
5880 preparation, such as emitting abstract debug info for the inline
5881 before it gets mangled by optimization. */
5882 if (cgraph_function_possibly_inlined_p (current_function_decl
))
5883 (*debug_hooks
->outlining_inline_function
) (current_function_decl
);
5885 TREE_ASM_WRITTEN (current_function_decl
) = 1;
5887 /* After expanding, the return labels are no longer needed. */
5888 return_label
= NULL
;
5889 naked_return_label
= NULL
;
5891 /* After expanding, the tm_restart map is no longer needed. */
5892 if (cfun
->gimple_df
->tm_restart
)
5894 htab_delete (cfun
->gimple_df
->tm_restart
);
5895 cfun
->gimple_df
->tm_restart
= NULL
;
5898 /* Tag the blocks with a depth number so that change_scope can find
5899 the common parent easily. */
5900 set_block_levels (DECL_INITIAL (cfun
->decl
), 0);
5901 default_rtl_profile ();
5903 timevar_pop (TV_POST_EXPAND
);
5910 const pass_data pass_data_expand
=
5912 RTL_PASS
, /* type */
5913 "expand", /* name */
5914 OPTGROUP_NONE
, /* optinfo_flags */
5915 false, /* has_gate */
5916 true, /* has_execute */
5917 TV_EXPAND
, /* tv_id */
5918 ( PROP_ssa
| PROP_gimple_leh
| PROP_cfg
5920 | PROP_gimple_lvec
), /* properties_required */
5921 PROP_rtl
, /* properties_provided */
5922 ( PROP_ssa
| PROP_trees
), /* properties_destroyed */
5923 ( TODO_verify_ssa
| TODO_verify_flow
5924 | TODO_verify_stmts
), /* todo_flags_start */
5925 0, /* todo_flags_finish */
5928 class pass_expand
: public rtl_opt_pass
5931 pass_expand (gcc::context
*ctxt
)
5932 : rtl_opt_pass (pass_data_expand
, ctxt
)
5935 /* opt_pass methods: */
5936 unsigned int execute () { return gimple_expand_cfg (); }
5938 }; // class pass_expand
5943 make_pass_expand (gcc::context
*ctxt
)
5945 return new pass_expand (ctxt
);