1 /* A pass for lowering trees to RTL.
2 Copyright (C) 2004-2020 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"
29 #include "tree-pass.h"
34 #include "regs.h" /* For reg_renumber. */
38 #include "diagnostic.h"
39 #include "fold-const.h"
41 #include "stor-layout.h"
43 #include "print-tree.h"
47 #include "cfgcleanup.h"
52 #include "internal-fn.h"
54 #include "gimple-iterator.h"
55 #include "gimple-expr.h"
56 #include "gimple-walk.h"
61 #include "gimple-pretty-print.h"
64 #include "tree-inline.h"
65 #include "value-prof.h"
66 #include "tree-ssa-live.h"
67 #include "tree-outof-ssa.h"
69 #include "insn-attr.h" /* For INSN_SCHEDULING. */
70 #include "stringpool.h"
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 static bool defer_stack_allocation (tree
, bool);
97 static void record_alignment_for_reg_var (unsigned int);
99 /* Return an expression tree corresponding to the RHS of GIMPLE
103 gimple_assign_rhs_to_tree (gimple
*stmt
)
106 switch (gimple_assign_rhs_class (stmt
))
108 case GIMPLE_TERNARY_RHS
:
109 t
= build3 (gimple_assign_rhs_code (stmt
),
110 TREE_TYPE (gimple_assign_lhs (stmt
)),
111 gimple_assign_rhs1 (stmt
), gimple_assign_rhs2 (stmt
),
112 gimple_assign_rhs3 (stmt
));
114 case GIMPLE_BINARY_RHS
:
115 t
= build2 (gimple_assign_rhs_code (stmt
),
116 TREE_TYPE (gimple_assign_lhs (stmt
)),
117 gimple_assign_rhs1 (stmt
), gimple_assign_rhs2 (stmt
));
119 case GIMPLE_UNARY_RHS
:
120 t
= build1 (gimple_assign_rhs_code (stmt
),
121 TREE_TYPE (gimple_assign_lhs (stmt
)),
122 gimple_assign_rhs1 (stmt
));
124 case GIMPLE_SINGLE_RHS
:
126 t
= gimple_assign_rhs1 (stmt
);
127 /* Avoid modifying this tree in place below. */
128 if ((gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (t
)
129 && gimple_location (stmt
) != EXPR_LOCATION (t
))
130 || (gimple_block (stmt
) && currently_expanding_to_rtl
139 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (t
))
140 SET_EXPR_LOCATION (t
, gimple_location (stmt
));
146 #ifndef STACK_ALIGNMENT_NEEDED
147 #define STACK_ALIGNMENT_NEEDED 1
150 #define SSAVAR(x) (TREE_CODE (x) == SSA_NAME ? SSA_NAME_VAR (x) : x)
152 /* Choose either CUR or NEXT as the leader DECL for a partition.
153 Prefer ignored decls, to simplify debug dumps and reduce ambiguity
154 out of the same user variable being in multiple partitions (this is
155 less likely for compiler-introduced temps). */
158 leader_merge (tree cur
, tree next
)
160 if (cur
== NULL
|| cur
== next
)
163 if (DECL_P (cur
) && DECL_IGNORED_P (cur
))
166 if (DECL_P (next
) && DECL_IGNORED_P (next
))
172 /* Associate declaration T with storage space X. If T is no
173 SSA name this is exactly SET_DECL_RTL, otherwise make the
174 partition of T associated with X. */
176 set_rtl (tree t
, rtx x
)
178 gcc_checking_assert (!x
179 || !(TREE_CODE (t
) == SSA_NAME
|| is_gimple_reg (t
))
180 || (use_register_for_decl (t
)
182 || (GET_CODE (x
) == CONCAT
183 && (REG_P (XEXP (x
, 0))
184 || SUBREG_P (XEXP (x
, 0)))
185 && (REG_P (XEXP (x
, 1))
186 || SUBREG_P (XEXP (x
, 1))))
187 /* We need to accept PARALLELs for RESUT_DECLs
188 because of vector types with BLKmode returned
189 in multiple registers, but they are supposed
190 to be uncoalesced. */
191 || (GET_CODE (x
) == PARALLEL
193 && TREE_CODE (SSAVAR (t
)) == RESULT_DECL
194 && (GET_MODE (x
) == BLKmode
195 || !flag_tree_coalesce_vars
)))
196 : (MEM_P (x
) || x
== pc_rtx
197 || (GET_CODE (x
) == CONCAT
198 && MEM_P (XEXP (x
, 0))
199 && MEM_P (XEXP (x
, 1))))));
200 /* Check that the RTL for SSA_NAMEs and gimple-reg PARM_DECLs and
201 RESULT_DECLs has the expected mode. For memory, we accept
202 unpromoted modes, since that's what we're likely to get. For
203 PARM_DECLs and RESULT_DECLs, we'll have been called by
204 set_parm_rtl, which will give us the default def, so we don't
205 have to compute it ourselves. For RESULT_DECLs, we accept mode
206 mismatches too, as long as we have BLKmode or are not coalescing
207 across variables, so that we don't reject BLKmode PARALLELs or
209 gcc_checking_assert (!x
|| x
== pc_rtx
|| TREE_CODE (t
) != SSA_NAME
211 && TREE_CODE (SSAVAR (t
)) == RESULT_DECL
212 && (promote_ssa_mode (t
, NULL
) == BLKmode
213 || !flag_tree_coalesce_vars
))
214 || !use_register_for_decl (t
)
215 || GET_MODE (x
) == promote_ssa_mode (t
, NULL
));
220 tree cur
= NULL_TREE
;
228 else if (SUBREG_P (xm
))
230 gcc_assert (subreg_lowpart_p (xm
));
231 xm
= SUBREG_REG (xm
);
234 else if (GET_CODE (xm
) == CONCAT
)
239 else if (GET_CODE (xm
) == PARALLEL
)
241 xm
= XVECEXP (xm
, 0, 0);
242 gcc_assert (GET_CODE (xm
) == EXPR_LIST
);
246 else if (xm
== pc_rtx
)
251 tree next
= skip
? cur
: leader_merge (cur
, SSAVAR (t
) ? SSAVAR (t
) : t
);
256 set_mem_attributes (x
,
257 next
&& TREE_CODE (next
) == SSA_NAME
261 set_reg_attrs_for_decl_rtl (next
, x
);
265 if (TREE_CODE (t
) == SSA_NAME
)
267 int part
= var_to_partition (SA
.map
, t
);
268 if (part
!= NO_PARTITION
)
270 if (SA
.partition_to_pseudo
[part
])
271 gcc_assert (SA
.partition_to_pseudo
[part
] == x
);
272 else if (x
!= pc_rtx
)
273 SA
.partition_to_pseudo
[part
] = x
;
275 /* For the benefit of debug information at -O0 (where
276 vartracking doesn't run) record the place also in the base
277 DECL. For PARMs and RESULTs, do so only when setting the
279 if (x
&& x
!= pc_rtx
&& SSA_NAME_VAR (t
)
280 && (VAR_P (SSA_NAME_VAR (t
))
281 || SSA_NAME_IS_DEFAULT_DEF (t
)))
283 tree var
= SSA_NAME_VAR (t
);
284 /* If we don't yet have something recorded, just record it now. */
285 if (!DECL_RTL_SET_P (var
))
286 SET_DECL_RTL (var
, x
);
287 /* If we have it set already to "multiple places" don't
289 else if (DECL_RTL (var
) == pc_rtx
)
291 /* If we have something recorded and it's not the same place
292 as we want to record now, we have multiple partitions for the
293 same base variable, with different places. We can't just
294 randomly chose one, hence we have to say that we don't know.
295 This only happens with optimization, and there var-tracking
296 will figure out the right thing. */
297 else if (DECL_RTL (var
) != x
)
298 SET_DECL_RTL (var
, pc_rtx
);
305 /* This structure holds data relevant to one variable that will be
306 placed in a stack slot. */
313 /* Initially, the size of the variable. Later, the size of the partition,
314 if this variable becomes it's partition's representative. */
317 /* The *byte* alignment required for this variable. Or as, with the
318 size, the alignment for this partition. */
321 /* The partition representative. */
322 size_t representative
;
324 /* The next stack variable in the partition, or EOC. */
327 /* The numbers of conflicting stack variables. */
331 #define EOC ((size_t)-1)
333 /* We have an array of such objects while deciding allocation. */
334 static class stack_var
*stack_vars
;
335 static size_t stack_vars_alloc
;
336 static size_t stack_vars_num
;
337 static hash_map
<tree
, size_t> *decl_to_stack_part
;
339 /* Conflict bitmaps go on this obstack. This allows us to destroy
340 all of them in one big sweep. */
341 static bitmap_obstack stack_var_bitmap_obstack
;
343 /* An array of indices such that stack_vars[stack_vars_sorted[i]].size
344 is non-decreasing. */
345 static size_t *stack_vars_sorted
;
347 /* The phase of the stack frame. This is the known misalignment of
348 virtual_stack_vars_rtx from PREFERRED_STACK_BOUNDARY. That is,
349 (frame_offset+frame_phase) % PREFERRED_STACK_BOUNDARY == 0. */
350 static int frame_phase
;
352 /* Used during expand_used_vars to remember if we saw any decls for
353 which we'd like to enable stack smashing protection. */
354 static bool has_protected_decls
;
356 /* Used during expand_used_vars. Remember if we say a character buffer
357 smaller than our cutoff threshold. Used for -Wstack-protector. */
358 static bool has_short_buffer
;
360 /* Compute the byte alignment to use for DECL. Ignore alignment
361 we can't do with expected alignment of the stack boundary. */
364 align_local_variable (tree decl
, bool really_expand
)
368 if (TREE_CODE (decl
) == SSA_NAME
)
370 tree type
= TREE_TYPE (decl
);
371 machine_mode mode
= TYPE_MODE (type
);
373 align
= TYPE_ALIGN (type
);
375 && align
< GET_MODE_ALIGNMENT (mode
))
376 align
= GET_MODE_ALIGNMENT (mode
);
379 align
= LOCAL_DECL_ALIGNMENT (decl
);
381 if (hwasan_sanitize_stack_p ())
382 align
= MAX (align
, (unsigned) HWASAN_TAG_GRANULE_SIZE
* BITS_PER_UNIT
);
384 if (TREE_CODE (decl
) != SSA_NAME
&& really_expand
)
385 /* Don't change DECL_ALIGN when called from estimated_stack_frame_size.
386 That is done before IPA and could bump alignment based on host
387 backend even for offloaded code which wants different
388 LOCAL_DECL_ALIGNMENT. */
389 SET_DECL_ALIGN (decl
, align
);
391 return align
/ BITS_PER_UNIT
;
394 /* Align given offset BASE with ALIGN. Truncate up if ALIGN_UP is true,
395 down otherwise. Return truncated BASE value. */
397 static inline unsigned HOST_WIDE_INT
398 align_base (HOST_WIDE_INT base
, unsigned HOST_WIDE_INT align
, bool align_up
)
400 return align_up
? (base
+ align
- 1) & -align
: base
& -align
;
403 /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
404 Return the frame offset. */
407 alloc_stack_frame_space (poly_int64 size
, unsigned HOST_WIDE_INT align
)
409 poly_int64 offset
, new_frame_offset
;
411 if (FRAME_GROWS_DOWNWARD
)
414 = aligned_lower_bound (frame_offset
- frame_phase
- size
,
415 align
) + frame_phase
;
416 offset
= new_frame_offset
;
421 = aligned_upper_bound (frame_offset
- frame_phase
,
422 align
) + frame_phase
;
423 offset
= new_frame_offset
;
424 new_frame_offset
+= size
;
426 frame_offset
= new_frame_offset
;
428 if (frame_offset_overflow (frame_offset
, cfun
->decl
))
429 frame_offset
= offset
= 0;
434 /* Ensure that the stack is aligned to ALIGN bytes.
435 Return the new frame offset. */
437 align_frame_offset (unsigned HOST_WIDE_INT align
)
439 return alloc_stack_frame_space (0, align
);
442 /* Accumulate DECL into STACK_VARS. */
445 add_stack_var (tree decl
, bool really_expand
)
449 if (stack_vars_num
>= stack_vars_alloc
)
451 if (stack_vars_alloc
)
452 stack_vars_alloc
= stack_vars_alloc
* 3 / 2;
454 stack_vars_alloc
= 32;
456 = XRESIZEVEC (class stack_var
, stack_vars
, stack_vars_alloc
);
458 if (!decl_to_stack_part
)
459 decl_to_stack_part
= new hash_map
<tree
, size_t>;
461 v
= &stack_vars
[stack_vars_num
];
462 decl_to_stack_part
->put (decl
, stack_vars_num
);
465 tree size
= TREE_CODE (decl
) == SSA_NAME
466 ? TYPE_SIZE_UNIT (TREE_TYPE (decl
))
467 : DECL_SIZE_UNIT (decl
);
468 v
->size
= tree_to_poly_uint64 (size
);
469 /* Ensure that all variables have size, so that &a != &b for any two
470 variables that are simultaneously live. */
471 if (known_eq (v
->size
, 0U))
473 v
->alignb
= align_local_variable (decl
, really_expand
);
474 /* An alignment of zero can mightily confuse us later. */
475 gcc_assert (v
->alignb
!= 0);
477 /* All variables are initially in their own partition. */
478 v
->representative
= stack_vars_num
;
481 /* All variables initially conflict with no other. */
484 /* Ensure that this decl doesn't get put onto the list twice. */
485 set_rtl (decl
, pc_rtx
);
490 /* Make the decls associated with luid's X and Y conflict. */
493 add_stack_var_conflict (size_t x
, size_t y
)
495 class stack_var
*a
= &stack_vars
[x
];
496 class stack_var
*b
= &stack_vars
[y
];
500 a
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
502 b
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
503 bitmap_set_bit (a
->conflicts
, y
);
504 bitmap_set_bit (b
->conflicts
, x
);
507 /* Check whether the decls associated with luid's X and Y conflict. */
510 stack_var_conflict_p (size_t x
, size_t y
)
512 class stack_var
*a
= &stack_vars
[x
];
513 class stack_var
*b
= &stack_vars
[y
];
516 /* Partitions containing an SSA name result from gimple registers
517 with things like unsupported modes. They are top-level and
518 hence conflict with everything else. */
519 if (TREE_CODE (a
->decl
) == SSA_NAME
|| TREE_CODE (b
->decl
) == SSA_NAME
)
522 if (!a
->conflicts
|| !b
->conflicts
)
524 return bitmap_bit_p (a
->conflicts
, y
);
527 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
528 enter its partition number into bitmap DATA. */
531 visit_op (gimple
*, tree op
, tree
, void *data
)
533 bitmap active
= (bitmap
)data
;
534 op
= get_base_address (op
);
537 && DECL_RTL_IF_SET (op
) == pc_rtx
)
539 size_t *v
= decl_to_stack_part
->get (op
);
541 bitmap_set_bit (active
, *v
);
546 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
547 record conflicts between it and all currently active other partitions
551 visit_conflict (gimple
*, tree op
, tree
, void *data
)
553 bitmap active
= (bitmap
)data
;
554 op
= get_base_address (op
);
557 && DECL_RTL_IF_SET (op
) == pc_rtx
)
559 size_t *v
= decl_to_stack_part
->get (op
);
560 if (v
&& bitmap_set_bit (active
, *v
))
565 gcc_assert (num
< stack_vars_num
);
566 EXECUTE_IF_SET_IN_BITMAP (active
, 0, i
, bi
)
567 add_stack_var_conflict (num
, i
);
573 /* Helper routine for add_scope_conflicts, calculating the active partitions
574 at the end of BB, leaving the result in WORK. We're called to generate
575 conflicts when FOR_CONFLICT is true, otherwise we're just tracking
579 add_scope_conflicts_1 (basic_block bb
, bitmap work
, bool for_conflict
)
583 gimple_stmt_iterator gsi
;
584 walk_stmt_load_store_addr_fn visit
;
587 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
588 bitmap_ior_into (work
, (bitmap
)e
->src
->aux
);
592 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
594 gimple
*stmt
= gsi_stmt (gsi
);
595 walk_stmt_load_store_addr_ops (stmt
, work
, NULL
, NULL
, visit
);
597 for (gsi
= gsi_after_labels (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
599 gimple
*stmt
= gsi_stmt (gsi
);
601 if (gimple_clobber_p (stmt
))
603 tree lhs
= gimple_assign_lhs (stmt
);
605 /* Nested function lowering might introduce LHSs
606 that are COMPONENT_REFs. */
609 if (DECL_RTL_IF_SET (lhs
) == pc_rtx
610 && (v
= decl_to_stack_part
->get (lhs
)))
611 bitmap_clear_bit (work
, *v
);
613 else if (!is_gimple_debug (stmt
))
616 && visit
== visit_op
)
618 /* If this is the first real instruction in this BB we need
619 to add conflicts for everything live at this point now.
620 Unlike classical liveness for named objects we can't
621 rely on seeing a def/use of the names we're interested in.
622 There might merely be indirect loads/stores. We'd not add any
623 conflicts for such partitions. */
626 EXECUTE_IF_SET_IN_BITMAP (work
, 0, i
, bi
)
628 class stack_var
*a
= &stack_vars
[i
];
630 a
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
631 bitmap_ior_into (a
->conflicts
, work
);
633 visit
= visit_conflict
;
635 walk_stmt_load_store_addr_ops (stmt
, work
, visit
, visit
, visit
);
640 /* Generate stack partition conflicts between all partitions that are
641 simultaneously live. */
644 add_scope_conflicts (void)
648 bitmap work
= BITMAP_ALLOC (NULL
);
652 /* We approximate the live range of a stack variable by taking the first
653 mention of its name as starting point(s), and by the end-of-scope
654 death clobber added by gimplify as ending point(s) of the range.
655 This overapproximates in the case we for instance moved an address-taken
656 operation upward, without also moving a dereference to it upwards.
657 But it's conservatively correct as a variable never can hold values
658 before its name is mentioned at least once.
660 We then do a mostly classical bitmap liveness algorithm. */
662 FOR_ALL_BB_FN (bb
, cfun
)
663 bb
->aux
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
665 rpo
= XNEWVEC (int, last_basic_block_for_fn (cfun
));
666 n_bbs
= pre_and_rev_post_order_compute (NULL
, rpo
, false);
673 for (i
= 0; i
< n_bbs
; i
++)
676 bb
= BASIC_BLOCK_FOR_FN (cfun
, rpo
[i
]);
677 active
= (bitmap
)bb
->aux
;
678 add_scope_conflicts_1 (bb
, work
, false);
679 if (bitmap_ior_into (active
, work
))
684 FOR_EACH_BB_FN (bb
, cfun
)
685 add_scope_conflicts_1 (bb
, work
, true);
689 FOR_ALL_BB_FN (bb
, cfun
)
690 BITMAP_FREE (bb
->aux
);
693 /* A subroutine of partition_stack_vars. A comparison function for qsort,
694 sorting an array of indices by the properties of the object. */
697 stack_var_cmp (const void *a
, const void *b
)
699 size_t ia
= *(const size_t *)a
;
700 size_t ib
= *(const size_t *)b
;
701 unsigned int aligna
= stack_vars
[ia
].alignb
;
702 unsigned int alignb
= stack_vars
[ib
].alignb
;
703 poly_int64 sizea
= stack_vars
[ia
].size
;
704 poly_int64 sizeb
= stack_vars
[ib
].size
;
705 tree decla
= stack_vars
[ia
].decl
;
706 tree declb
= stack_vars
[ib
].decl
;
708 unsigned int uida
, uidb
;
710 /* Primary compare on "large" alignment. Large comes first. */
711 largea
= (aligna
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
712 largeb
= (alignb
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
713 if (largea
!= largeb
)
714 return (int)largeb
- (int)largea
;
716 /* Secondary compare on size, decreasing */
717 int diff
= compare_sizes_for_sort (sizeb
, sizea
);
721 /* Tertiary compare on true alignment, decreasing. */
727 /* Final compare on ID for sort stability, increasing.
728 Two SSA names are compared by their version, SSA names come before
729 non-SSA names, and two normal decls are compared by their DECL_UID. */
730 if (TREE_CODE (decla
) == SSA_NAME
)
732 if (TREE_CODE (declb
) == SSA_NAME
)
733 uida
= SSA_NAME_VERSION (decla
), uidb
= SSA_NAME_VERSION (declb
);
737 else if (TREE_CODE (declb
) == SSA_NAME
)
740 uida
= DECL_UID (decla
), uidb
= DECL_UID (declb
);
748 struct part_traits
: unbounded_int_hashmap_traits
<size_t, bitmap
> {};
749 typedef hash_map
<size_t, bitmap
, part_traits
> part_hashmap
;
751 /* If the points-to solution *PI points to variables that are in a partition
752 together with other variables add all partition members to the pointed-to
756 add_partitioned_vars_to_ptset (struct pt_solution
*pt
,
757 part_hashmap
*decls_to_partitions
,
758 hash_set
<bitmap
> *visited
, bitmap temp
)
766 /* The pointed-to vars bitmap is shared, it is enough to
768 || visited
->add (pt
->vars
))
773 /* By using a temporary bitmap to store all members of the partitions
774 we have to add we make sure to visit each of the partitions only
776 EXECUTE_IF_SET_IN_BITMAP (pt
->vars
, 0, i
, bi
)
778 || !bitmap_bit_p (temp
, i
))
779 && (part
= decls_to_partitions
->get (i
)))
780 bitmap_ior_into (temp
, *part
);
781 if (!bitmap_empty_p (temp
))
782 bitmap_ior_into (pt
->vars
, temp
);
785 /* Update points-to sets based on partition info, so we can use them on RTL.
786 The bitmaps representing stack partitions will be saved until expand,
787 where partitioned decls used as bases in memory expressions will be
791 update_alias_info_with_stack_vars (void)
793 part_hashmap
*decls_to_partitions
= NULL
;
795 tree var
= NULL_TREE
;
797 for (i
= 0; i
< stack_vars_num
; i
++)
801 struct ptr_info_def
*pi
;
803 /* Not interested in partitions with single variable. */
804 if (stack_vars
[i
].representative
!= i
805 || stack_vars
[i
].next
== EOC
)
808 if (!decls_to_partitions
)
810 decls_to_partitions
= new part_hashmap
;
811 cfun
->gimple_df
->decls_to_pointers
= new hash_map
<tree
, tree
>;
814 /* Create an SSA_NAME that points to the partition for use
815 as base during alias-oracle queries on RTL for bases that
816 have been partitioned. */
817 if (var
== NULL_TREE
)
818 var
= create_tmp_var (ptr_type_node
);
819 name
= make_ssa_name (var
);
821 /* Create bitmaps representing partitions. They will be used for
822 points-to sets later, so use GGC alloc. */
823 part
= BITMAP_GGC_ALLOC ();
824 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
826 tree decl
= stack_vars
[j
].decl
;
827 unsigned int uid
= DECL_PT_UID (decl
);
828 bitmap_set_bit (part
, uid
);
829 decls_to_partitions
->put (uid
, part
);
830 cfun
->gimple_df
->decls_to_pointers
->put (decl
, name
);
831 if (TREE_ADDRESSABLE (decl
))
832 TREE_ADDRESSABLE (name
) = 1;
835 /* Make the SSA name point to all partition members. */
836 pi
= get_ptr_info (name
);
837 pt_solution_set (&pi
->pt
, part
, false);
840 /* Make all points-to sets that contain one member of a partition
841 contain all members of the partition. */
842 if (decls_to_partitions
)
846 hash_set
<bitmap
> visited
;
847 bitmap temp
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
849 FOR_EACH_SSA_NAME (i
, name
, cfun
)
851 struct ptr_info_def
*pi
;
853 if (POINTER_TYPE_P (TREE_TYPE (name
))
854 && ((pi
= SSA_NAME_PTR_INFO (name
)) != NULL
))
855 add_partitioned_vars_to_ptset (&pi
->pt
, decls_to_partitions
,
859 add_partitioned_vars_to_ptset (&cfun
->gimple_df
->escaped
,
860 decls_to_partitions
, &visited
, temp
);
862 delete decls_to_partitions
;
867 /* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
868 partitioning algorithm. Partitions A and B are known to be non-conflicting.
869 Merge them into a single partition A. */
872 union_stack_vars (size_t a
, size_t b
)
874 class stack_var
*vb
= &stack_vars
[b
];
878 gcc_assert (stack_vars
[b
].next
== EOC
);
879 /* Add B to A's partition. */
880 stack_vars
[b
].next
= stack_vars
[a
].next
;
881 stack_vars
[b
].representative
= a
;
882 stack_vars
[a
].next
= b
;
884 /* Make sure A is big enough to hold B. */
885 stack_vars
[a
].size
= upper_bound (stack_vars
[a
].size
, stack_vars
[b
].size
);
887 /* Update the required alignment of partition A to account for B. */
888 if (stack_vars
[a
].alignb
< stack_vars
[b
].alignb
)
889 stack_vars
[a
].alignb
= stack_vars
[b
].alignb
;
891 /* Update the interference graph and merge the conflicts. */
894 EXECUTE_IF_SET_IN_BITMAP (vb
->conflicts
, 0, u
, bi
)
895 add_stack_var_conflict (a
, stack_vars
[u
].representative
);
896 BITMAP_FREE (vb
->conflicts
);
900 /* A subroutine of expand_used_vars. Binpack the variables into
901 partitions constrained by the interference graph. The overall
902 algorithm used is as follows:
904 Sort the objects by size in descending order.
909 Look for the largest non-conflicting object B with size <= S.
916 partition_stack_vars (void)
918 size_t si
, sj
, n
= stack_vars_num
;
920 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
921 for (si
= 0; si
< n
; ++si
)
922 stack_vars_sorted
[si
] = si
;
927 qsort (stack_vars_sorted
, n
, sizeof (size_t), stack_var_cmp
);
929 for (si
= 0; si
< n
; ++si
)
931 size_t i
= stack_vars_sorted
[si
];
932 unsigned int ialign
= stack_vars
[i
].alignb
;
933 poly_int64 isize
= stack_vars
[i
].size
;
935 /* Ignore objects that aren't partition representatives. If we
936 see a var that is not a partition representative, it must
937 have been merged earlier. */
938 if (stack_vars
[i
].representative
!= i
)
941 for (sj
= si
+ 1; sj
< n
; ++sj
)
943 size_t j
= stack_vars_sorted
[sj
];
944 unsigned int jalign
= stack_vars
[j
].alignb
;
945 poly_int64 jsize
= stack_vars
[j
].size
;
947 /* Ignore objects that aren't partition representatives. */
948 if (stack_vars
[j
].representative
!= j
)
951 /* Do not mix objects of "small" (supported) alignment
952 and "large" (unsupported) alignment. */
953 if ((ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
954 != (jalign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
))
957 /* For Address Sanitizer do not mix objects with different
958 sizes, as the shorter vars wouldn't be adequately protected.
959 Don't do that for "large" (unsupported) alignment objects,
960 those aren't protected anyway. */
961 if (asan_sanitize_stack_p ()
962 && maybe_ne (isize
, jsize
)
963 && ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
966 /* Ignore conflicting objects. */
967 if (stack_var_conflict_p (i
, j
))
970 /* UNION the objects, placing J at OFFSET. */
971 union_stack_vars (i
, j
);
975 update_alias_info_with_stack_vars ();
978 /* A debugging aid for expand_used_vars. Dump the generated partitions. */
981 dump_stack_var_partition (void)
983 size_t si
, i
, j
, n
= stack_vars_num
;
985 for (si
= 0; si
< n
; ++si
)
987 i
= stack_vars_sorted
[si
];
989 /* Skip variables that aren't partition representatives, for now. */
990 if (stack_vars
[i
].representative
!= i
)
993 fprintf (dump_file
, "Partition %lu: size ", (unsigned long) i
);
994 print_dec (stack_vars
[i
].size
, dump_file
);
995 fprintf (dump_file
, " align %u\n", stack_vars
[i
].alignb
);
997 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
999 fputc ('\t', dump_file
);
1000 print_generic_expr (dump_file
, stack_vars
[j
].decl
, dump_flags
);
1002 fputc ('\n', dump_file
);
1006 /* Assign rtl to DECL at BASE + OFFSET. */
1009 expand_one_stack_var_at (tree decl
, rtx base
, unsigned base_align
,
1015 /* If this fails, we've overflowed the stack frame. Error nicely? */
1016 gcc_assert (known_eq (offset
, trunc_int_for_mode (offset
, Pmode
)));
1018 if (hwasan_sanitize_stack_p ())
1019 x
= targetm
.memtag
.add_tag (base
, offset
,
1020 hwasan_current_frame_tag ());
1022 x
= plus_constant (Pmode
, base
, offset
);
1024 x
= gen_rtx_MEM (TREE_CODE (decl
) == SSA_NAME
1025 ? TYPE_MODE (TREE_TYPE (decl
))
1026 : DECL_MODE (decl
), x
);
1028 /* Set alignment we actually gave this decl if it isn't an SSA name.
1029 If it is we generate stack slots only accidentally so it isn't as
1030 important, we'll simply set the alignment directly on the MEM. */
1032 if (stack_vars_base_reg_p (base
))
1033 offset
-= frame_phase
;
1034 align
= known_alignment (offset
);
1035 align
*= BITS_PER_UNIT
;
1036 if (align
== 0 || align
> base_align
)
1039 if (TREE_CODE (decl
) != SSA_NAME
)
1041 /* One would think that we could assert that we're not decreasing
1042 alignment here, but (at least) the i386 port does exactly this
1043 via the MINIMUM_ALIGNMENT hook. */
1045 SET_DECL_ALIGN (decl
, align
);
1046 DECL_USER_ALIGN (decl
) = 0;
1051 set_mem_align (x
, align
);
1054 class stack_vars_data
1057 /* Vector of offset pairs, always end of some padding followed
1058 by start of the padding that needs Address Sanitizer protection.
1059 The vector is in reversed, highest offset pairs come first. */
1060 auto_vec
<HOST_WIDE_INT
> asan_vec
;
1062 /* Vector of partition representative decls in between the paddings. */
1063 auto_vec
<tree
> asan_decl_vec
;
1065 /* Base pseudo register for Address Sanitizer protected automatic vars. */
1068 /* Alignment needed for the Address Sanitizer protected automatic vars. */
1069 unsigned int asan_alignb
;
1072 /* A subroutine of expand_used_vars. Give each partition representative
1073 a unique location within the stack frame. Update each partition member
1074 with that location. */
1076 expand_stack_vars (bool (*pred
) (size_t), class stack_vars_data
*data
)
1078 size_t si
, i
, j
, n
= stack_vars_num
;
1079 poly_uint64 large_size
= 0, large_alloc
= 0;
1080 rtx large_base
= NULL
;
1081 rtx large_untagged_base
= NULL
;
1082 unsigned large_align
= 0;
1083 bool large_allocation_done
= false;
1086 /* Determine if there are any variables requiring "large" alignment.
1087 Since these are dynamically allocated, we only process these if
1088 no predicate involved. */
1089 large_align
= stack_vars
[stack_vars_sorted
[0]].alignb
* BITS_PER_UNIT
;
1090 if (pred
== NULL
&& large_align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1092 /* Find the total size of these variables. */
1093 for (si
= 0; si
< n
; ++si
)
1097 i
= stack_vars_sorted
[si
];
1098 alignb
= stack_vars
[i
].alignb
;
1100 /* All "large" alignment decls come before all "small" alignment
1101 decls, but "large" alignment decls are not sorted based on
1102 their alignment. Increase large_align to track the largest
1103 required alignment. */
1104 if ((alignb
* BITS_PER_UNIT
) > large_align
)
1105 large_align
= alignb
* BITS_PER_UNIT
;
1107 /* Stop when we get to the first decl with "small" alignment. */
1108 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
1111 /* Skip variables that aren't partition representatives. */
1112 if (stack_vars
[i
].representative
!= i
)
1115 /* Skip variables that have already had rtl assigned. See also
1116 add_stack_var where we perpetrate this pc_rtx hack. */
1117 decl
= stack_vars
[i
].decl
;
1118 if (TREE_CODE (decl
) == SSA_NAME
1119 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)] != NULL_RTX
1120 : DECL_RTL (decl
) != pc_rtx
)
1123 large_size
= aligned_upper_bound (large_size
, alignb
);
1124 large_size
+= stack_vars
[i
].size
;
1128 for (si
= 0; si
< n
; ++si
)
1131 unsigned base_align
, alignb
;
1132 poly_int64 offset
= 0;
1134 i
= stack_vars_sorted
[si
];
1136 /* Skip variables that aren't partition representatives, for now. */
1137 if (stack_vars
[i
].representative
!= i
)
1140 /* Skip variables that have already had rtl assigned. See also
1141 add_stack_var where we perpetrate this pc_rtx hack. */
1142 decl
= stack_vars
[i
].decl
;
1143 if (TREE_CODE (decl
) == SSA_NAME
1144 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)] != NULL_RTX
1145 : DECL_RTL (decl
) != pc_rtx
)
1148 /* Check the predicate to see whether this variable should be
1149 allocated in this pass. */
1150 if (pred
&& !pred (i
))
1153 base
= (hwasan_sanitize_stack_p ()
1154 ? hwasan_frame_base ()
1155 : virtual_stack_vars_rtx
);
1156 alignb
= stack_vars
[i
].alignb
;
1157 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
1159 poly_int64 hwasan_orig_offset
;
1160 if (hwasan_sanitize_stack_p ())
1162 /* There must be no tag granule "shared" between different
1163 objects. This means that no HWASAN_TAG_GRANULE_SIZE byte
1164 chunk can have more than one object in it.
1166 We ensure this by forcing the end of the last bit of data to
1167 be aligned to HWASAN_TAG_GRANULE_SIZE bytes here, and setting
1168 the start of each variable to be aligned to
1169 HWASAN_TAG_GRANULE_SIZE bytes in `align_local_variable`.
1171 We can't align just one of the start or end, since there are
1172 untagged things stored on the stack which we do not align to
1173 HWASAN_TAG_GRANULE_SIZE bytes. If we only aligned the start
1174 or the end of tagged objects then untagged objects could end
1175 up sharing the first granule of a tagged object or sharing the
1176 last granule of a tagged object respectively. */
1177 hwasan_orig_offset
= align_frame_offset (HWASAN_TAG_GRANULE_SIZE
);
1178 gcc_assert (stack_vars
[i
].alignb
>= HWASAN_TAG_GRANULE_SIZE
);
1180 /* ASAN description strings don't yet have a syntax for expressing
1181 polynomial offsets. */
1182 HOST_WIDE_INT prev_offset
;
1183 if (asan_sanitize_stack_p ()
1185 && frame_offset
.is_constant (&prev_offset
)
1186 && stack_vars
[i
].size
.is_constant ())
1188 if (data
->asan_vec
.is_empty ())
1190 align_frame_offset (ASAN_RED_ZONE_SIZE
);
1191 prev_offset
= frame_offset
.to_constant ();
1193 prev_offset
= align_base (prev_offset
,
1194 ASAN_MIN_RED_ZONE_SIZE
,
1195 !FRAME_GROWS_DOWNWARD
);
1196 tree repr_decl
= NULL_TREE
;
1197 unsigned HOST_WIDE_INT size
1198 = asan_var_and_redzone_size (stack_vars
[i
].size
.to_constant ());
1199 if (data
->asan_vec
.is_empty ())
1200 size
= MAX (size
, ASAN_RED_ZONE_SIZE
);
1202 unsigned HOST_WIDE_INT alignment
= MAX (alignb
,
1203 ASAN_MIN_RED_ZONE_SIZE
);
1204 offset
= alloc_stack_frame_space (size
, alignment
);
1206 data
->asan_vec
.safe_push (prev_offset
);
1207 /* Allocating a constant amount of space from a constant
1208 starting offset must give a constant result. */
1209 data
->asan_vec
.safe_push ((offset
+ stack_vars
[i
].size
)
1211 /* Find best representative of the partition.
1212 Prefer those with DECL_NAME, even better
1213 satisfying asan_protect_stack_decl predicate. */
1214 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1215 if (asan_protect_stack_decl (stack_vars
[j
].decl
)
1216 && DECL_NAME (stack_vars
[j
].decl
))
1218 repr_decl
= stack_vars
[j
].decl
;
1221 else if (repr_decl
== NULL_TREE
1222 && DECL_P (stack_vars
[j
].decl
)
1223 && DECL_NAME (stack_vars
[j
].decl
))
1224 repr_decl
= stack_vars
[j
].decl
;
1225 if (repr_decl
== NULL_TREE
)
1226 repr_decl
= stack_vars
[i
].decl
;
1227 data
->asan_decl_vec
.safe_push (repr_decl
);
1229 /* Make sure a representative is unpoison if another
1230 variable in the partition is handled by
1231 use-after-scope sanitization. */
1232 if (asan_handled_variables
!= NULL
1233 && !asan_handled_variables
->contains (repr_decl
))
1235 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1236 if (asan_handled_variables
->contains (stack_vars
[j
].decl
))
1239 asan_handled_variables
->add (repr_decl
);
1242 data
->asan_alignb
= MAX (data
->asan_alignb
, alignb
);
1243 if (data
->asan_base
== NULL
)
1244 data
->asan_base
= gen_reg_rtx (Pmode
);
1245 base
= data
->asan_base
;
1247 if (!STRICT_ALIGNMENT
)
1248 base_align
= crtl
->max_used_stack_slot_alignment
;
1250 base_align
= MAX (crtl
->max_used_stack_slot_alignment
,
1251 GET_MODE_ALIGNMENT (SImode
)
1252 << ASAN_SHADOW_SHIFT
);
1256 offset
= alloc_stack_frame_space (stack_vars
[i
].size
, alignb
);
1257 base_align
= crtl
->max_used_stack_slot_alignment
;
1259 if (hwasan_sanitize_stack_p ())
1261 /* Align again since the point of this alignment is to handle
1262 the "end" of the object (i.e. smallest address after the
1263 stack object). For FRAME_GROWS_DOWNWARD that requires
1264 aligning the stack before allocating, but for a frame that
1265 grows upwards that requires aligning the stack after
1268 Use `frame_offset` to record the offset value rather than
1269 `offset` since the `frame_offset` describes the extent
1270 allocated for this particular variable while `offset`
1271 describes the address that this variable starts at. */
1272 align_frame_offset (HWASAN_TAG_GRANULE_SIZE
);
1273 hwasan_record_stack_var (virtual_stack_vars_rtx
, base
,
1274 hwasan_orig_offset
, frame_offset
);
1280 /* Large alignment is only processed in the last pass. */
1284 /* If there were any variables requiring "large" alignment, allocate
1286 if (maybe_ne (large_size
, 0U) && ! large_allocation_done
)
1289 rtx large_allocsize
;
1291 large_allocsize
= gen_int_mode (large_size
, Pmode
);
1292 get_dynamic_stack_size (&large_allocsize
, 0, large_align
, NULL
);
1293 loffset
= alloc_stack_frame_space
1294 (rtx_to_poly_int64 (large_allocsize
),
1295 PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
);
1296 large_base
= get_dynamic_stack_base (loffset
, large_align
, base
);
1297 large_allocation_done
= true;
1300 gcc_assert (large_base
!= NULL
);
1301 large_alloc
= aligned_upper_bound (large_alloc
, alignb
);
1302 offset
= large_alloc
;
1303 large_alloc
+= stack_vars
[i
].size
;
1304 if (hwasan_sanitize_stack_p ())
1306 /* An object with a large alignment requirement means that the
1307 alignment requirement is greater than the required alignment
1309 if (!large_untagged_base
)
1311 = targetm
.memtag
.untagged_pointer (large_base
, NULL_RTX
);
1312 /* Ensure the end of the variable is also aligned correctly. */
1313 poly_int64 align_again
1314 = aligned_upper_bound (large_alloc
, HWASAN_TAG_GRANULE_SIZE
);
1315 /* For large allocations we always allocate a chunk of space
1316 (which is addressed by large_untagged_base/large_base) and
1317 then use positive offsets from that. Hence the farthest
1318 offset is `align_again` and the nearest offset from the base
1320 hwasan_record_stack_var (large_untagged_base
, large_base
,
1321 offset
, align_again
);
1325 base_align
= large_align
;
1328 /* Create rtl for each variable based on their location within the
1330 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1332 expand_one_stack_var_at (stack_vars
[j
].decl
,
1333 base
, base_align
, offset
);
1335 if (hwasan_sanitize_stack_p ())
1336 hwasan_increment_frame_tag ();
1339 gcc_assert (known_eq (large_alloc
, large_size
));
1342 /* Take into account all sizes of partitions and reset DECL_RTLs. */
1344 account_stack_vars (void)
1346 size_t si
, j
, i
, n
= stack_vars_num
;
1347 poly_uint64 size
= 0;
1349 for (si
= 0; si
< n
; ++si
)
1351 i
= stack_vars_sorted
[si
];
1353 /* Skip variables that aren't partition representatives, for now. */
1354 if (stack_vars
[i
].representative
!= i
)
1357 size
+= stack_vars
[i
].size
;
1358 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1359 set_rtl (stack_vars
[j
].decl
, NULL
);
1364 /* Record the RTL assignment X for the default def of PARM. */
1367 set_parm_rtl (tree parm
, rtx x
)
1369 gcc_assert (TREE_CODE (parm
) == PARM_DECL
1370 || TREE_CODE (parm
) == RESULT_DECL
);
1372 if (x
&& !MEM_P (x
))
1374 unsigned int align
= MINIMUM_ALIGNMENT (TREE_TYPE (parm
),
1375 TYPE_MODE (TREE_TYPE (parm
)),
1376 TYPE_ALIGN (TREE_TYPE (parm
)));
1378 /* If the variable alignment is very large we'll dynamicaly
1379 allocate it, which means that in-frame portion is just a
1380 pointer. ??? We've got a pseudo for sure here, do we
1381 actually dynamically allocate its spilling area if needed?
1382 ??? Isn't it a problem when Pmode alignment also exceeds
1383 MAX_SUPPORTED_STACK_ALIGNMENT, as can happen on cris and lm32? */
1384 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1385 align
= GET_MODE_ALIGNMENT (Pmode
);
1387 record_alignment_for_reg_var (align
);
1390 tree ssa
= ssa_default_def (cfun
, parm
);
1392 return set_rtl (parm
, x
);
1394 int part
= var_to_partition (SA
.map
, ssa
);
1395 gcc_assert (part
!= NO_PARTITION
);
1397 bool changed
= bitmap_bit_p (SA
.partitions_for_parm_default_defs
, part
);
1398 gcc_assert (changed
);
1401 gcc_assert (DECL_RTL (parm
) == x
);
1404 /* A subroutine of expand_one_var. Called to immediately assign rtl
1405 to a variable to be allocated in the stack frame. */
1408 expand_one_stack_var_1 (tree var
)
1412 unsigned byte_align
;
1414 if (TREE_CODE (var
) == SSA_NAME
)
1416 tree type
= TREE_TYPE (var
);
1417 size
= tree_to_poly_uint64 (TYPE_SIZE_UNIT (type
));
1420 size
= tree_to_poly_uint64 (DECL_SIZE_UNIT (var
));
1422 byte_align
= align_local_variable (var
, true);
1424 /* We handle highly aligned variables in expand_stack_vars. */
1425 gcc_assert (byte_align
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
);
1428 if (hwasan_sanitize_stack_p ())
1430 /* Allocate zero bytes to align the stack. */
1431 poly_int64 hwasan_orig_offset
1432 = align_frame_offset (HWASAN_TAG_GRANULE_SIZE
);
1433 offset
= alloc_stack_frame_space (size
, byte_align
);
1434 align_frame_offset (HWASAN_TAG_GRANULE_SIZE
);
1435 base
= hwasan_frame_base ();
1436 /* Use `frame_offset` to automatically account for machines where the
1437 frame grows upwards.
1439 `offset` will always point to the "start" of the stack object, which
1440 will be the smallest address, for ! FRAME_GROWS_DOWNWARD this is *not*
1441 the "furthest" offset from the base delimiting the current stack
1442 object. `frame_offset` will always delimit the extent that the frame.
1444 hwasan_record_stack_var (virtual_stack_vars_rtx
, base
,
1445 hwasan_orig_offset
, frame_offset
);
1449 offset
= alloc_stack_frame_space (size
, byte_align
);
1450 base
= virtual_stack_vars_rtx
;
1453 expand_one_stack_var_at (var
, base
,
1454 crtl
->max_used_stack_slot_alignment
, offset
);
1456 if (hwasan_sanitize_stack_p ())
1457 hwasan_increment_frame_tag ();
1460 /* Wrapper for expand_one_stack_var_1 that checks SSA_NAMEs are
1461 already assigned some MEM. */
1464 expand_one_stack_var (tree var
)
1466 if (TREE_CODE (var
) == SSA_NAME
)
1468 int part
= var_to_partition (SA
.map
, var
);
1469 if (part
!= NO_PARTITION
)
1471 rtx x
= SA
.partition_to_pseudo
[part
];
1473 gcc_assert (MEM_P (x
));
1478 return expand_one_stack_var_1 (var
);
1481 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1482 that will reside in a hard register. */
1485 expand_one_hard_reg_var (tree var
)
1487 rest_of_decl_compilation (var
, 0, 0);
1490 /* Record the alignment requirements of some variable assigned to a
1494 record_alignment_for_reg_var (unsigned int align
)
1496 if (SUPPORTS_STACK_ALIGNMENT
1497 && crtl
->stack_alignment_estimated
< align
)
1499 /* stack_alignment_estimated shouldn't change after stack
1500 realign decision made */
1501 gcc_assert (!crtl
->stack_realign_processed
);
1502 crtl
->stack_alignment_estimated
= align
;
1505 /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
1506 So here we only make sure stack_alignment_needed >= align. */
1507 if (crtl
->stack_alignment_needed
< align
)
1508 crtl
->stack_alignment_needed
= align
;
1509 if (crtl
->max_used_stack_slot_alignment
< align
)
1510 crtl
->max_used_stack_slot_alignment
= align
;
1513 /* Create RTL for an SSA partition. */
1516 expand_one_ssa_partition (tree var
)
1518 int part
= var_to_partition (SA
.map
, var
);
1519 gcc_assert (part
!= NO_PARTITION
);
1521 if (SA
.partition_to_pseudo
[part
])
1524 unsigned int align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1525 TYPE_MODE (TREE_TYPE (var
)),
1526 TYPE_ALIGN (TREE_TYPE (var
)));
1528 /* If the variable alignment is very large we'll dynamicaly allocate
1529 it, which means that in-frame portion is just a pointer. */
1530 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1531 align
= GET_MODE_ALIGNMENT (Pmode
);
1533 record_alignment_for_reg_var (align
);
1535 if (!use_register_for_decl (var
))
1537 if (defer_stack_allocation (var
, true))
1538 add_stack_var (var
, true);
1540 expand_one_stack_var_1 (var
);
1544 machine_mode reg_mode
= promote_ssa_mode (var
, NULL
);
1545 rtx x
= gen_reg_rtx (reg_mode
);
1549 /* For a promoted variable, X will not be used directly but wrapped in a
1550 SUBREG with SUBREG_PROMOTED_VAR_P set, which means that the RTL land
1551 will assume that its upper bits can be inferred from its lower bits.
1552 Therefore, if X isn't initialized on every path from the entry, then
1553 we must do it manually in order to fulfill the above assumption. */
1554 if (reg_mode
!= TYPE_MODE (TREE_TYPE (var
))
1555 && bitmap_bit_p (SA
.partitions_for_undefined_values
, part
))
1556 emit_move_insn (x
, CONST0_RTX (reg_mode
));
1559 /* Record the association between the RTL generated for partition PART
1560 and the underlying variable of the SSA_NAME VAR. */
1563 adjust_one_expanded_partition_var (tree var
)
1568 tree decl
= SSA_NAME_VAR (var
);
1570 int part
= var_to_partition (SA
.map
, var
);
1571 if (part
== NO_PARTITION
)
1574 rtx x
= SA
.partition_to_pseudo
[part
];
1583 /* Note if the object is a user variable. */
1584 if (decl
&& !DECL_ARTIFICIAL (decl
))
1587 if (POINTER_TYPE_P (decl
? TREE_TYPE (decl
) : TREE_TYPE (var
)))
1588 mark_reg_pointer (x
, get_pointer_alignment (var
));
1591 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1592 that will reside in a pseudo register. */
1595 expand_one_register_var (tree var
)
1597 if (TREE_CODE (var
) == SSA_NAME
)
1599 int part
= var_to_partition (SA
.map
, var
);
1600 if (part
!= NO_PARTITION
)
1602 rtx x
= SA
.partition_to_pseudo
[part
];
1604 gcc_assert (REG_P (x
));
1611 tree type
= TREE_TYPE (decl
);
1612 machine_mode reg_mode
= promote_decl_mode (decl
, NULL
);
1613 rtx x
= gen_reg_rtx (reg_mode
);
1617 /* Note if the object is a user variable. */
1618 if (!DECL_ARTIFICIAL (decl
))
1621 if (POINTER_TYPE_P (type
))
1622 mark_reg_pointer (x
, get_pointer_alignment (var
));
1625 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
1626 has some associated error, e.g. its type is error-mark. We just need
1627 to pick something that won't crash the rest of the compiler. */
1630 expand_one_error_var (tree var
)
1632 machine_mode mode
= DECL_MODE (var
);
1635 if (mode
== BLKmode
)
1636 x
= gen_rtx_MEM (BLKmode
, const0_rtx
);
1637 else if (mode
== VOIDmode
)
1640 x
= gen_reg_rtx (mode
);
1642 SET_DECL_RTL (var
, x
);
1645 /* A subroutine of expand_one_var. VAR is a variable that will be
1646 allocated to the local stack frame. Return true if we wish to
1647 add VAR to STACK_VARS so that it will be coalesced with other
1648 variables. Return false to allocate VAR immediately.
1650 This function is used to reduce the number of variables considered
1651 for coalescing, which reduces the size of the quadratic problem. */
1654 defer_stack_allocation (tree var
, bool toplevel
)
1656 tree size_unit
= TREE_CODE (var
) == SSA_NAME
1657 ? TYPE_SIZE_UNIT (TREE_TYPE (var
))
1658 : DECL_SIZE_UNIT (var
);
1661 /* Whether the variable is small enough for immediate allocation not to be
1662 a problem with regard to the frame size. */
1664 = (poly_int_tree_p (size_unit
, &size
)
1665 && (estimated_poly_value (size
)
1666 < param_min_size_for_stack_sharing
));
1668 /* If stack protection is enabled, *all* stack variables must be deferred,
1669 so that we can re-order the strings to the top of the frame.
1670 Similarly for Address Sanitizer. */
1671 if (flag_stack_protect
|| asan_sanitize_stack_p ())
1674 unsigned int align
= TREE_CODE (var
) == SSA_NAME
1675 ? TYPE_ALIGN (TREE_TYPE (var
))
1678 /* We handle "large" alignment via dynamic allocation. We want to handle
1679 this extra complication in only one place, so defer them. */
1680 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1683 bool ignored
= TREE_CODE (var
) == SSA_NAME
1684 ? !SSAVAR (var
) || DECL_IGNORED_P (SSA_NAME_VAR (var
))
1685 : DECL_IGNORED_P (var
);
1687 /* When optimization is enabled, DECL_IGNORED_P variables originally scoped
1688 might be detached from their block and appear at toplevel when we reach
1689 here. We want to coalesce them with variables from other blocks when
1690 the immediate contribution to the frame size would be noticeable. */
1691 if (toplevel
&& optimize
> 0 && ignored
&& !smallish
)
1694 /* Variables declared in the outermost scope automatically conflict
1695 with every other variable. The only reason to want to defer them
1696 at all is that, after sorting, we can more efficiently pack
1697 small variables in the stack frame. Continue to defer at -O2. */
1698 if (toplevel
&& optimize
< 2)
1701 /* Without optimization, *most* variables are allocated from the
1702 stack, which makes the quadratic problem large exactly when we
1703 want compilation to proceed as quickly as possible. On the
1704 other hand, we don't want the function's stack frame size to
1705 get completely out of hand. So we avoid adding scalars and
1706 "small" aggregates to the list at all. */
1707 if (optimize
== 0 && smallish
)
1713 /* A subroutine of expand_used_vars. Expand one variable according to
1714 its flavor. Variables to be placed on the stack are not actually
1715 expanded yet, merely recorded.
1716 When REALLY_EXPAND is false, only add stack values to be allocated.
1717 Return stack usage this variable is supposed to take.
1721 expand_one_var (tree var
, bool toplevel
, bool really_expand
)
1723 unsigned int align
= BITS_PER_UNIT
;
1728 if (TREE_TYPE (var
) != error_mark_node
&& VAR_P (var
))
1730 if (is_global_var (var
))
1733 /* Because we don't know if VAR will be in register or on stack,
1734 we conservatively assume it will be on stack even if VAR is
1735 eventually put into register after RA pass. For non-automatic
1736 variables, which won't be on stack, we collect alignment of
1737 type and ignore user specified alignment. Similarly for
1738 SSA_NAMEs for which use_register_for_decl returns true. */
1739 if (TREE_STATIC (var
)
1740 || DECL_EXTERNAL (var
)
1741 || (TREE_CODE (origvar
) == SSA_NAME
&& use_register_for_decl (var
)))
1742 align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1743 TYPE_MODE (TREE_TYPE (var
)),
1744 TYPE_ALIGN (TREE_TYPE (var
)));
1745 else if (DECL_HAS_VALUE_EXPR_P (var
)
1746 || (DECL_RTL_SET_P (var
) && MEM_P (DECL_RTL (var
))))
1747 /* Don't consider debug only variables with DECL_HAS_VALUE_EXPR_P set
1748 or variables which were assigned a stack slot already by
1749 expand_one_stack_var_at - in the latter case DECL_ALIGN has been
1750 changed from the offset chosen to it. */
1751 align
= crtl
->stack_alignment_estimated
;
1753 align
= MINIMUM_ALIGNMENT (var
, DECL_MODE (var
), DECL_ALIGN (var
));
1755 /* If the variable alignment is very large we'll dynamicaly allocate
1756 it, which means that in-frame portion is just a pointer. */
1757 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1758 align
= GET_MODE_ALIGNMENT (Pmode
);
1761 record_alignment_for_reg_var (align
);
1764 if (TREE_CODE (origvar
) == SSA_NAME
)
1766 gcc_assert (!VAR_P (var
)
1767 || (!DECL_EXTERNAL (var
)
1768 && !DECL_HAS_VALUE_EXPR_P (var
)
1769 && !TREE_STATIC (var
)
1770 && TREE_TYPE (var
) != error_mark_node
1771 && !DECL_HARD_REGISTER (var
)
1774 if (!VAR_P (var
) && TREE_CODE (origvar
) != SSA_NAME
)
1776 else if (DECL_EXTERNAL (var
))
1778 else if (DECL_HAS_VALUE_EXPR_P (var
))
1780 else if (TREE_STATIC (var
))
1782 else if (TREE_CODE (origvar
) != SSA_NAME
&& DECL_RTL_SET_P (var
))
1784 else if (TREE_TYPE (var
) == error_mark_node
)
1787 expand_one_error_var (var
);
1789 else if (VAR_P (var
) && DECL_HARD_REGISTER (var
))
1793 expand_one_hard_reg_var (var
);
1794 if (!DECL_HARD_REGISTER (var
))
1795 /* Invalid register specification. */
1796 expand_one_error_var (var
);
1799 else if (use_register_for_decl (var
))
1802 expand_one_register_var (origvar
);
1804 else if (!poly_int_tree_p (DECL_SIZE_UNIT (var
), &size
)
1805 || !valid_constant_size_p (DECL_SIZE_UNIT (var
)))
1807 /* Reject variables which cover more than half of the address-space. */
1810 if (DECL_NONLOCAL_FRAME (var
))
1811 error_at (DECL_SOURCE_LOCATION (current_function_decl
),
1812 "total size of local objects is too large");
1814 error_at (DECL_SOURCE_LOCATION (var
),
1815 "size of variable %q+D is too large", var
);
1816 expand_one_error_var (var
);
1819 else if (defer_stack_allocation (var
, toplevel
))
1820 add_stack_var (origvar
, really_expand
);
1825 if (lookup_attribute ("naked",
1826 DECL_ATTRIBUTES (current_function_decl
)))
1827 error ("cannot allocate stack for variable %q+D, naked function",
1830 expand_one_stack_var (origvar
);
1837 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1838 expanding variables. Those variables that can be put into registers
1839 are allocated pseudos; those that can't are put on the stack.
1841 TOPLEVEL is true if this is the outermost BLOCK. */
1844 expand_used_vars_for_block (tree block
, bool toplevel
)
1848 /* Expand all variables at this level. */
1849 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1851 && ((!VAR_P (t
) && TREE_CODE (t
) != RESULT_DECL
)
1852 || !DECL_NONSHAREABLE (t
)))
1853 expand_one_var (t
, toplevel
, true);
1855 /* Expand all variables at containing levels. */
1856 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1857 expand_used_vars_for_block (t
, false);
1860 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1861 and clear TREE_USED on all local variables. */
1864 clear_tree_used (tree block
)
1868 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1869 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
1870 if ((!VAR_P (t
) && TREE_CODE (t
) != RESULT_DECL
)
1871 || !DECL_NONSHAREABLE (t
))
1874 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1875 clear_tree_used (t
);
1878 /* Examine TYPE and determine a bit mask of the following features. */
1880 #define SPCT_HAS_LARGE_CHAR_ARRAY 1
1881 #define SPCT_HAS_SMALL_CHAR_ARRAY 2
1882 #define SPCT_HAS_ARRAY 4
1883 #define SPCT_HAS_AGGREGATE 8
1886 stack_protect_classify_type (tree type
)
1888 unsigned int ret
= 0;
1891 switch (TREE_CODE (type
))
1894 t
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1895 if (t
== char_type_node
1896 || t
== signed_char_type_node
1897 || t
== unsigned_char_type_node
)
1899 unsigned HOST_WIDE_INT max
= param_ssp_buffer_size
;
1900 unsigned HOST_WIDE_INT len
;
1902 if (!TYPE_SIZE_UNIT (type
)
1903 || !tree_fits_uhwi_p (TYPE_SIZE_UNIT (type
)))
1906 len
= tree_to_uhwi (TYPE_SIZE_UNIT (type
));
1909 ret
= SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1911 ret
= SPCT_HAS_LARGE_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1914 ret
= SPCT_HAS_ARRAY
;
1918 case QUAL_UNION_TYPE
:
1920 ret
= SPCT_HAS_AGGREGATE
;
1921 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
1922 if (TREE_CODE (t
) == FIELD_DECL
)
1923 ret
|= stack_protect_classify_type (TREE_TYPE (t
));
1933 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
1934 part of the local stack frame. Remember if we ever return nonzero for
1935 any variable in this function. The return value is the phase number in
1936 which the variable should be allocated. */
1939 stack_protect_decl_phase (tree decl
)
1941 unsigned int bits
= stack_protect_classify_type (TREE_TYPE (decl
));
1944 if (bits
& SPCT_HAS_SMALL_CHAR_ARRAY
)
1945 has_short_buffer
= true;
1947 tree attribs
= DECL_ATTRIBUTES (current_function_decl
);
1948 if (!lookup_attribute ("no_stack_protector", attribs
)
1949 && (flag_stack_protect
== SPCT_FLAG_ALL
1950 || flag_stack_protect
== SPCT_FLAG_STRONG
1951 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
1952 && lookup_attribute ("stack_protect", attribs
))))
1954 if ((bits
& (SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_LARGE_CHAR_ARRAY
))
1955 && !(bits
& SPCT_HAS_AGGREGATE
))
1957 else if (bits
& SPCT_HAS_ARRAY
)
1961 ret
= (bits
& SPCT_HAS_LARGE_CHAR_ARRAY
) != 0;
1964 has_protected_decls
= true;
1969 /* Two helper routines that check for phase 1 and phase 2. These are used
1970 as callbacks for expand_stack_vars. */
1973 stack_protect_decl_phase_1 (size_t i
)
1975 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 1;
1979 stack_protect_decl_phase_2 (size_t i
)
1981 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 2;
1984 /* And helper function that checks for asan phase (with stack protector
1985 it is phase 3). This is used as callback for expand_stack_vars.
1986 Returns true if any of the vars in the partition need to be protected. */
1989 asan_decl_phase_3 (size_t i
)
1993 if (asan_protect_stack_decl (stack_vars
[i
].decl
))
1995 i
= stack_vars
[i
].next
;
2000 /* Ensure that variables in different stack protection phases conflict
2001 so that they are not merged and share the same stack slot.
2002 Return true if there are any address taken variables. */
2005 add_stack_protection_conflicts (void)
2007 size_t i
, j
, n
= stack_vars_num
;
2008 unsigned char *phase
;
2011 phase
= XNEWVEC (unsigned char, n
);
2012 for (i
= 0; i
< n
; ++i
)
2014 phase
[i
] = stack_protect_decl_phase (stack_vars
[i
].decl
);
2015 if (TREE_ADDRESSABLE (stack_vars
[i
].decl
))
2019 for (i
= 0; i
< n
; ++i
)
2021 unsigned char ph_i
= phase
[i
];
2022 for (j
= i
+ 1; j
< n
; ++j
)
2023 if (ph_i
!= phase
[j
])
2024 add_stack_var_conflict (i
, j
);
2031 /* Create a decl for the guard at the top of the stack frame. */
2034 create_stack_guard (void)
2036 tree guard
= build_decl (DECL_SOURCE_LOCATION (current_function_decl
),
2037 VAR_DECL
, NULL
, ptr_type_node
);
2038 TREE_THIS_VOLATILE (guard
) = 1;
2039 TREE_USED (guard
) = 1;
2040 expand_one_stack_var (guard
);
2041 crtl
->stack_protect_guard
= guard
;
2044 /* Prepare for expanding variables. */
2046 init_vars_expansion (void)
2048 /* Conflict bitmaps, and a few related temporary bitmaps, go here. */
2049 bitmap_obstack_initialize (&stack_var_bitmap_obstack
);
2051 /* A map from decl to stack partition. */
2052 decl_to_stack_part
= new hash_map
<tree
, size_t>;
2054 /* Initialize local stack smashing state. */
2055 has_protected_decls
= false;
2056 has_short_buffer
= false;
2057 if (hwasan_sanitize_stack_p ())
2058 hwasan_record_frame_init ();
2061 /* Free up stack variable graph data. */
2063 fini_vars_expansion (void)
2065 bitmap_obstack_release (&stack_var_bitmap_obstack
);
2067 XDELETEVEC (stack_vars
);
2068 if (stack_vars_sorted
)
2069 XDELETEVEC (stack_vars_sorted
);
2071 stack_vars_sorted
= NULL
;
2072 stack_vars_alloc
= stack_vars_num
= 0;
2073 delete decl_to_stack_part
;
2074 decl_to_stack_part
= NULL
;
2077 /* Make a fair guess for the size of the stack frame of the function
2078 in NODE. This doesn't have to be exact, the result is only used in
2079 the inline heuristics. So we don't want to run the full stack var
2080 packing algorithm (which is quadratic in the number of stack vars).
2081 Instead, we calculate the total size of all stack vars. This turns
2082 out to be a pretty fair estimate -- packing of stack vars doesn't
2083 happen very often. */
2086 estimated_stack_frame_size (struct cgraph_node
*node
)
2088 poly_int64 size
= 0;
2091 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
2095 init_vars_expansion ();
2097 FOR_EACH_LOCAL_DECL (fn
, i
, var
)
2098 if (auto_var_in_fn_p (var
, fn
->decl
))
2099 size
+= expand_one_var (var
, true, false);
2101 if (stack_vars_num
> 0)
2103 /* Fake sorting the stack vars for account_stack_vars (). */
2104 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
2105 for (i
= 0; i
< stack_vars_num
; ++i
)
2106 stack_vars_sorted
[i
] = i
;
2107 size
+= account_stack_vars ();
2110 fini_vars_expansion ();
2112 return estimated_poly_value (size
);
2115 /* Check if the current function has calls that use a return slot. */
2118 stack_protect_return_slot_p ()
2122 FOR_ALL_BB_FN (bb
, cfun
)
2123 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
2124 !gsi_end_p (gsi
); gsi_next (&gsi
))
2126 gimple
*stmt
= gsi_stmt (gsi
);
2127 /* This assumes that calls to internal-only functions never
2128 use a return slot. */
2129 if (is_gimple_call (stmt
)
2130 && !gimple_call_internal_p (stmt
)
2131 && aggregate_value_p (TREE_TYPE (gimple_call_fntype (stmt
)),
2132 gimple_call_fndecl (stmt
)))
2138 /* Expand all variables used in the function. */
2141 expand_used_vars (void)
2143 tree var
, outer_block
= DECL_INITIAL (current_function_decl
);
2144 auto_vec
<tree
> maybe_local_decls
;
2145 rtx_insn
*var_end_seq
= NULL
;
2148 bool gen_stack_protect_signal
= false;
2150 /* Compute the phase of the stack frame for this function. */
2152 int align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
2153 int off
= targetm
.starting_frame_offset () % align
;
2154 frame_phase
= off
? align
- off
: 0;
2157 /* Set TREE_USED on all variables in the local_decls. */
2158 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
2159 TREE_USED (var
) = 1;
2160 /* Clear TREE_USED on all variables associated with a block scope. */
2161 clear_tree_used (DECL_INITIAL (current_function_decl
));
2163 init_vars_expansion ();
2165 if (targetm
.use_pseudo_pic_reg ())
2166 pic_offset_table_rtx
= gen_reg_rtx (Pmode
);
2168 for (i
= 0; i
< SA
.map
->num_partitions
; i
++)
2170 if (bitmap_bit_p (SA
.partitions_for_parm_default_defs
, i
))
2173 tree var
= partition_to_var (SA
.map
, i
);
2175 gcc_assert (!virtual_operand_p (var
));
2177 expand_one_ssa_partition (var
);
2180 if (flag_stack_protect
== SPCT_FLAG_STRONG
)
2181 gen_stack_protect_signal
= stack_protect_return_slot_p ();
2183 /* At this point all variables on the local_decls with TREE_USED
2184 set are not associated with any block scope. Lay them out. */
2186 len
= vec_safe_length (cfun
->local_decls
);
2187 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
2189 bool expand_now
= false;
2191 /* Expanded above already. */
2192 if (is_gimple_reg (var
))
2194 TREE_USED (var
) = 0;
2197 /* We didn't set a block for static or extern because it's hard
2198 to tell the difference between a global variable (re)declared
2199 in a local scope, and one that's really declared there to
2200 begin with. And it doesn't really matter much, since we're
2201 not giving them stack space. Expand them now. */
2202 else if (TREE_STATIC (var
) || DECL_EXTERNAL (var
))
2205 /* Expand variables not associated with any block now. Those created by
2206 the optimizers could be live anywhere in the function. Those that
2207 could possibly have been scoped originally and detached from their
2208 block will have their allocation deferred so we coalesce them with
2209 others when optimization is enabled. */
2210 else if (TREE_USED (var
))
2213 /* Finally, mark all variables on the list as used. We'll use
2214 this in a moment when we expand those associated with scopes. */
2215 TREE_USED (var
) = 1;
2218 expand_one_var (var
, true, true);
2221 if (DECL_ARTIFICIAL (var
) && !DECL_IGNORED_P (var
))
2223 rtx rtl
= DECL_RTL_IF_SET (var
);
2225 /* Keep artificial non-ignored vars in cfun->local_decls
2226 chain until instantiate_decls. */
2227 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
2228 add_local_decl (cfun
, var
);
2229 else if (rtl
== NULL_RTX
)
2230 /* If rtl isn't set yet, which can happen e.g. with
2231 -fstack-protector, retry before returning from this
2233 maybe_local_decls
.safe_push (var
);
2237 /* We duplicated some of the decls in CFUN->LOCAL_DECLS.
2239 +-----------------+-----------------+
2240 | ...processed... | ...duplicates...|
2241 +-----------------+-----------------+
2243 +-- LEN points here.
2245 We just want the duplicates, as those are the artificial
2246 non-ignored vars that we want to keep until instantiate_decls.
2247 Move them down and truncate the array. */
2248 if (!vec_safe_is_empty (cfun
->local_decls
))
2249 cfun
->local_decls
->block_remove (0, len
);
2251 /* At this point, all variables within the block tree with TREE_USED
2252 set are actually used by the optimized function. Lay them out. */
2253 expand_used_vars_for_block (outer_block
, true);
2255 tree attribs
= DECL_ATTRIBUTES (current_function_decl
);
2256 if (stack_vars_num
> 0)
2258 bool has_addressable_vars
= false;
2260 add_scope_conflicts ();
2262 /* If stack protection is enabled, we don't share space between
2263 vulnerable data and non-vulnerable data. */
2264 if (flag_stack_protect
!= 0
2265 && !lookup_attribute ("no_stack_protector", attribs
)
2266 && (flag_stack_protect
!= SPCT_FLAG_EXPLICIT
2267 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
2268 && lookup_attribute ("stack_protect", attribs
))))
2269 has_addressable_vars
= add_stack_protection_conflicts ();
2271 if (flag_stack_protect
== SPCT_FLAG_STRONG
&& has_addressable_vars
)
2272 gen_stack_protect_signal
= true;
2274 /* Now that we have collected all stack variables, and have computed a
2275 minimal interference graph, attempt to save some stack space. */
2276 partition_stack_vars ();
2278 dump_stack_var_partition ();
2282 if (!lookup_attribute ("no_stack_protector", attribs
))
2283 switch (flag_stack_protect
)
2286 create_stack_guard ();
2289 case SPCT_FLAG_STRONG
:
2290 if (gen_stack_protect_signal
2291 || cfun
->calls_alloca
2292 || has_protected_decls
2293 || lookup_attribute ("stack_protect",
2294 DECL_ATTRIBUTES (current_function_decl
)))
2295 create_stack_guard ();
2298 case SPCT_FLAG_DEFAULT
:
2299 if (cfun
->calls_alloca
2300 || has_protected_decls
2301 || lookup_attribute ("stack_protect",
2302 DECL_ATTRIBUTES (current_function_decl
)))
2303 create_stack_guard ();
2306 case SPCT_FLAG_EXPLICIT
:
2307 if (lookup_attribute ("stack_protect",
2308 DECL_ATTRIBUTES (current_function_decl
)))
2309 create_stack_guard ();
2316 /* Assign rtl to each variable based on these partitions. */
2317 if (stack_vars_num
> 0)
2319 class stack_vars_data data
;
2321 data
.asan_base
= NULL_RTX
;
2322 data
.asan_alignb
= 0;
2324 /* Reorder decls to be protected by iterating over the variables
2325 array multiple times, and allocating out of each phase in turn. */
2326 /* ??? We could probably integrate this into the qsort we did
2327 earlier, such that we naturally see these variables first,
2328 and thus naturally allocate things in the right order. */
2329 if (has_protected_decls
)
2331 /* Phase 1 contains only character arrays. */
2332 expand_stack_vars (stack_protect_decl_phase_1
, &data
);
2334 /* Phase 2 contains other kinds of arrays. */
2335 if (!lookup_attribute ("no_stack_protector", attribs
)
2336 && (flag_stack_protect
== SPCT_FLAG_ALL
2337 || flag_stack_protect
== SPCT_FLAG_STRONG
2338 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
2339 && lookup_attribute ("stack_protect", attribs
))))
2340 expand_stack_vars (stack_protect_decl_phase_2
, &data
);
2343 if (asan_sanitize_stack_p ())
2344 /* Phase 3, any partitions that need asan protection
2345 in addition to phase 1 and 2. */
2346 expand_stack_vars (asan_decl_phase_3
, &data
);
2348 /* ASAN description strings don't yet have a syntax for expressing
2349 polynomial offsets. */
2350 HOST_WIDE_INT prev_offset
;
2351 if (!data
.asan_vec
.is_empty ()
2352 && frame_offset
.is_constant (&prev_offset
))
2354 HOST_WIDE_INT offset
, sz
, redzonesz
;
2355 redzonesz
= ASAN_RED_ZONE_SIZE
;
2356 sz
= data
.asan_vec
[0] - prev_offset
;
2357 if (data
.asan_alignb
> ASAN_RED_ZONE_SIZE
2358 && data
.asan_alignb
<= 4096
2359 && sz
+ ASAN_RED_ZONE_SIZE
>= (int) data
.asan_alignb
)
2360 redzonesz
= ((sz
+ ASAN_RED_ZONE_SIZE
+ data
.asan_alignb
- 1)
2361 & ~(data
.asan_alignb
- HOST_WIDE_INT_1
)) - sz
;
2362 /* Allocating a constant amount of space from a constant
2363 starting offset must give a constant result. */
2364 offset
= (alloc_stack_frame_space (redzonesz
, ASAN_RED_ZONE_SIZE
)
2366 data
.asan_vec
.safe_push (prev_offset
);
2367 data
.asan_vec
.safe_push (offset
);
2368 /* Leave space for alignment if STRICT_ALIGNMENT. */
2369 if (STRICT_ALIGNMENT
)
2370 alloc_stack_frame_space ((GET_MODE_ALIGNMENT (SImode
)
2371 << ASAN_SHADOW_SHIFT
)
2372 / BITS_PER_UNIT
, 1);
2375 = asan_emit_stack_protection (virtual_stack_vars_rtx
,
2378 data
.asan_vec
.address (),
2379 data
.asan_decl_vec
.address (),
2380 data
.asan_vec
.length ());
2383 expand_stack_vars (NULL
, &data
);
2386 if (hwasan_sanitize_stack_p ())
2387 hwasan_emit_prologue ();
2388 if (asan_sanitize_allocas_p () && cfun
->calls_alloca
)
2389 var_end_seq
= asan_emit_allocas_unpoison (virtual_stack_dynamic_rtx
,
2390 virtual_stack_vars_rtx
,
2392 else if (hwasan_sanitize_allocas_p () && cfun
->calls_alloca
)
2393 /* When using out-of-line instrumentation we only want to emit one function
2394 call for clearing the tags in a region of shadow stack. When there are
2395 alloca calls in this frame we want to emit a call using the
2396 virtual_stack_dynamic_rtx, but when not we use the hwasan_frame_extent
2397 rtx we created in expand_stack_vars. */
2398 var_end_seq
= hwasan_emit_untag_frame (virtual_stack_dynamic_rtx
,
2399 virtual_stack_vars_rtx
);
2400 else if (hwasan_sanitize_stack_p ())
2401 /* If no variables were stored on the stack, `hwasan_get_frame_extent`
2402 will return NULL_RTX and hence `hwasan_emit_untag_frame` will return
2403 NULL (i.e. an empty sequence). */
2404 var_end_seq
= hwasan_emit_untag_frame (hwasan_get_frame_extent (),
2405 virtual_stack_vars_rtx
);
2407 fini_vars_expansion ();
2409 /* If there were any artificial non-ignored vars without rtl
2410 found earlier, see if deferred stack allocation hasn't assigned
2412 FOR_EACH_VEC_ELT_REVERSE (maybe_local_decls
, i
, var
)
2414 rtx rtl
= DECL_RTL_IF_SET (var
);
2416 /* Keep artificial non-ignored vars in cfun->local_decls
2417 chain until instantiate_decls. */
2418 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
2419 add_local_decl (cfun
, var
);
2422 /* If the target requires that FRAME_OFFSET be aligned, do it. */
2423 if (STACK_ALIGNMENT_NEEDED
)
2425 HOST_WIDE_INT align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
2426 if (FRAME_GROWS_DOWNWARD
)
2427 frame_offset
= aligned_lower_bound (frame_offset
, align
);
2429 frame_offset
= aligned_upper_bound (frame_offset
, align
);
2436 /* If we need to produce a detailed dump, print the tree representation
2437 for STMT to the dump file. SINCE is the last RTX after which the RTL
2438 generated for STMT should have been appended. */
2441 maybe_dump_rtl_for_gimple_stmt (gimple
*stmt
, rtx_insn
*since
)
2443 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2445 fprintf (dump_file
, "\n;; ");
2446 print_gimple_stmt (dump_file
, stmt
, 0,
2447 TDF_SLIM
| (dump_flags
& TDF_LINENO
));
2448 fprintf (dump_file
, "\n");
2450 print_rtl (dump_file
, since
? NEXT_INSN (since
) : since
);
2454 /* Maps the blocks that do not contain tree labels to rtx labels. */
2456 static hash_map
<basic_block
, rtx_code_label
*> *lab_rtx_for_bb
;
2458 /* Returns the label_rtx expression for a label starting basic block BB. */
2460 static rtx_code_label
*
2461 label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED
)
2463 gimple_stmt_iterator gsi
;
2466 if (bb
->flags
& BB_RTL
)
2467 return block_label (bb
);
2469 rtx_code_label
**elt
= lab_rtx_for_bb
->get (bb
);
2473 /* Find the tree label if it is present. */
2475 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2479 lab_stmt
= dyn_cast
<glabel
*> (gsi_stmt (gsi
));
2483 lab
= gimple_label_label (lab_stmt
);
2484 if (DECL_NONLOCAL (lab
))
2487 return jump_target_rtx (lab
);
2490 rtx_code_label
*l
= gen_label_rtx ();
2491 lab_rtx_for_bb
->put (bb
, l
);
2496 /* A subroutine of expand_gimple_cond. Given E, a fallthrough edge
2497 of a basic block where we just expanded the conditional at the end,
2498 possibly clean up the CFG and instruction sequence. LAST is the
2499 last instruction before the just emitted jump sequence. */
2502 maybe_cleanup_end_of_block (edge e
, rtx_insn
*last
)
2504 /* Special case: when jumpif decides that the condition is
2505 trivial it emits an unconditional jump (and the necessary
2506 barrier). But we still have two edges, the fallthru one is
2507 wrong. purge_dead_edges would clean this up later. Unfortunately
2508 we have to insert insns (and split edges) before
2509 find_many_sub_basic_blocks and hence before purge_dead_edges.
2510 But splitting edges might create new blocks which depend on the
2511 fact that if there are two edges there's no barrier. So the
2512 barrier would get lost and verify_flow_info would ICE. Instead
2513 of auditing all edge splitters to care for the barrier (which
2514 normally isn't there in a cleaned CFG), fix it here. */
2515 if (BARRIER_P (get_last_insn ()))
2519 /* Now, we have a single successor block, if we have insns to
2520 insert on the remaining edge we potentially will insert
2521 it at the end of this block (if the dest block isn't feasible)
2522 in order to avoid splitting the edge. This insertion will take
2523 place in front of the last jump. But we might have emitted
2524 multiple jumps (conditional and one unconditional) to the
2525 same destination. Inserting in front of the last one then
2526 is a problem. See PR 40021. We fix this by deleting all
2527 jumps except the last unconditional one. */
2528 insn
= PREV_INSN (get_last_insn ());
2529 /* Make sure we have an unconditional jump. Otherwise we're
2531 gcc_assert (JUMP_P (insn
) && !any_condjump_p (insn
));
2532 for (insn
= PREV_INSN (insn
); insn
!= last
;)
2534 insn
= PREV_INSN (insn
);
2535 if (JUMP_P (NEXT_INSN (insn
)))
2537 if (!any_condjump_p (NEXT_INSN (insn
)))
2539 gcc_assert (BARRIER_P (NEXT_INSN (NEXT_INSN (insn
))));
2540 delete_insn (NEXT_INSN (NEXT_INSN (insn
)));
2542 delete_insn (NEXT_INSN (insn
));
2548 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_COND.
2549 Returns a new basic block if we've terminated the current basic
2550 block and created a new one. */
2553 expand_gimple_cond (basic_block bb
, gcond
*stmt
)
2555 basic_block new_bb
, dest
;
2558 rtx_insn
*last2
, *last
;
2559 enum tree_code code
;
2562 code
= gimple_cond_code (stmt
);
2563 op0
= gimple_cond_lhs (stmt
);
2564 op1
= gimple_cond_rhs (stmt
);
2565 /* We're sometimes presented with such code:
2569 This would expand to two comparisons which then later might
2570 be cleaned up by combine. But some pattern matchers like if-conversion
2571 work better when there's only one compare, so make up for this
2572 here as special exception if TER would have made the same change. */
2574 && TREE_CODE (op0
) == SSA_NAME
2575 && TREE_CODE (TREE_TYPE (op0
)) == BOOLEAN_TYPE
2576 && TREE_CODE (op1
) == INTEGER_CST
2577 && ((gimple_cond_code (stmt
) == NE_EXPR
2578 && integer_zerop (op1
))
2579 || (gimple_cond_code (stmt
) == EQ_EXPR
2580 && integer_onep (op1
)))
2581 && bitmap_bit_p (SA
.values
, SSA_NAME_VERSION (op0
)))
2583 gimple
*second
= SSA_NAME_DEF_STMT (op0
);
2584 if (gimple_code (second
) == GIMPLE_ASSIGN
)
2586 enum tree_code code2
= gimple_assign_rhs_code (second
);
2587 if (TREE_CODE_CLASS (code2
) == tcc_comparison
)
2590 op0
= gimple_assign_rhs1 (second
);
2591 op1
= gimple_assign_rhs2 (second
);
2593 /* If jumps are cheap and the target does not support conditional
2594 compare, turn some more codes into jumpy sequences. */
2595 else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4
2596 && targetm
.gen_ccmp_first
== NULL
)
2598 if ((code2
== BIT_AND_EXPR
2599 && TYPE_PRECISION (TREE_TYPE (op0
)) == 1
2600 && TREE_CODE (gimple_assign_rhs2 (second
)) != INTEGER_CST
)
2601 || code2
== TRUTH_AND_EXPR
)
2603 code
= TRUTH_ANDIF_EXPR
;
2604 op0
= gimple_assign_rhs1 (second
);
2605 op1
= gimple_assign_rhs2 (second
);
2607 else if (code2
== BIT_IOR_EXPR
|| code2
== TRUTH_OR_EXPR
)
2609 code
= TRUTH_ORIF_EXPR
;
2610 op0
= gimple_assign_rhs1 (second
);
2611 op1
= gimple_assign_rhs2 (second
);
2617 /* Optimize (x % C1) == C2 or (x % C1) != C2 if it is beneficial
2618 into (x - C2) * C3 < C4. */
2619 if ((code
== EQ_EXPR
|| code
== NE_EXPR
)
2620 && TREE_CODE (op0
) == SSA_NAME
2621 && TREE_CODE (op1
) == INTEGER_CST
)
2622 code
= maybe_optimize_mod_cmp (code
, &op0
, &op1
);
2624 last2
= last
= get_last_insn ();
2626 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
2627 set_curr_insn_location (gimple_location (stmt
));
2629 /* These flags have no purpose in RTL land. */
2630 true_edge
->flags
&= ~EDGE_TRUE_VALUE
;
2631 false_edge
->flags
&= ~EDGE_FALSE_VALUE
;
2633 /* We can either have a pure conditional jump with one fallthru edge or
2634 two-way jump that needs to be decomposed into two basic blocks. */
2635 if (false_edge
->dest
== bb
->next_bb
)
2637 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2638 true_edge
->probability
);
2639 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2640 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2641 set_curr_insn_location (true_edge
->goto_locus
);
2642 false_edge
->flags
|= EDGE_FALLTHRU
;
2643 maybe_cleanup_end_of_block (false_edge
, last
);
2646 if (true_edge
->dest
== bb
->next_bb
)
2648 jumpifnot_1 (code
, op0
, op1
, label_rtx_for_bb (false_edge
->dest
),
2649 false_edge
->probability
);
2650 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2651 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2652 set_curr_insn_location (false_edge
->goto_locus
);
2653 true_edge
->flags
|= EDGE_FALLTHRU
;
2654 maybe_cleanup_end_of_block (true_edge
, last
);
2658 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2659 true_edge
->probability
);
2660 last
= get_last_insn ();
2661 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2662 set_curr_insn_location (false_edge
->goto_locus
);
2663 emit_jump (label_rtx_for_bb (false_edge
->dest
));
2666 if (BARRIER_P (BB_END (bb
)))
2667 BB_END (bb
) = PREV_INSN (BB_END (bb
));
2668 update_bb_for_insn (bb
);
2670 new_bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
2671 dest
= false_edge
->dest
;
2672 redirect_edge_succ (false_edge
, new_bb
);
2673 false_edge
->flags
|= EDGE_FALLTHRU
;
2674 new_bb
->count
= false_edge
->count ();
2675 loop_p loop
= find_common_loop (bb
->loop_father
, dest
->loop_father
);
2676 add_bb_to_loop (new_bb
, loop
);
2677 if (loop
->latch
== bb
2678 && loop
->header
== dest
)
2679 loop
->latch
= new_bb
;
2680 make_single_succ_edge (new_bb
, dest
, 0);
2681 if (BARRIER_P (BB_END (new_bb
)))
2682 BB_END (new_bb
) = PREV_INSN (BB_END (new_bb
));
2683 update_bb_for_insn (new_bb
);
2685 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
2687 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2689 set_curr_insn_location (true_edge
->goto_locus
);
2690 true_edge
->goto_locus
= curr_insn_location ();
2696 /* Mark all calls that can have a transaction restart. */
2699 mark_transaction_restart_calls (gimple
*stmt
)
2701 struct tm_restart_node dummy
;
2702 tm_restart_node
**slot
;
2704 if (!cfun
->gimple_df
->tm_restart
)
2708 slot
= cfun
->gimple_df
->tm_restart
->find_slot (&dummy
, NO_INSERT
);
2711 struct tm_restart_node
*n
= *slot
;
2712 tree list
= n
->label_or_list
;
2715 for (insn
= next_real_insn (get_last_insn ());
2717 insn
= next_real_insn (insn
))
2720 if (TREE_CODE (list
) == LABEL_DECL
)
2721 add_reg_note (insn
, REG_TM
, label_rtx (list
));
2723 for (; list
; list
= TREE_CHAIN (list
))
2724 add_reg_note (insn
, REG_TM
, label_rtx (TREE_VALUE (list
)));
2728 /* A subroutine of expand_gimple_stmt_1, expanding one GIMPLE_CALL
2732 expand_call_stmt (gcall
*stmt
)
2734 tree exp
, decl
, lhs
;
2738 if (gimple_call_internal_p (stmt
))
2740 expand_internal_call (stmt
);
2744 /* If this is a call to a built-in function and it has no effect other
2745 than setting the lhs, try to implement it using an internal function
2747 decl
= gimple_call_fndecl (stmt
);
2748 if (gimple_call_lhs (stmt
)
2749 && !gimple_has_side_effects (stmt
)
2750 && (optimize
|| (decl
&& called_as_built_in (decl
))))
2752 internal_fn ifn
= replacement_internal_fn (stmt
);
2753 if (ifn
!= IFN_LAST
)
2755 expand_internal_call (ifn
, stmt
);
2760 exp
= build_vl_exp (CALL_EXPR
, gimple_call_num_args (stmt
) + 3);
2762 CALL_EXPR_FN (exp
) = gimple_call_fn (stmt
);
2763 builtin_p
= decl
&& fndecl_built_in_p (decl
);
2765 /* If this is not a builtin function, the function type through which the
2766 call is made may be different from the type of the function. */
2769 = fold_convert (build_pointer_type (gimple_call_fntype (stmt
)),
2770 CALL_EXPR_FN (exp
));
2772 TREE_TYPE (exp
) = gimple_call_return_type (stmt
);
2773 CALL_EXPR_STATIC_CHAIN (exp
) = gimple_call_chain (stmt
);
2775 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2777 tree arg
= gimple_call_arg (stmt
, i
);
2779 /* TER addresses into arguments of builtin functions so we have a
2780 chance to infer more correct alignment information. See PR39954. */
2782 && TREE_CODE (arg
) == SSA_NAME
2783 && (def
= get_gimple_for_ssa_name (arg
))
2784 && gimple_assign_rhs_code (def
) == ADDR_EXPR
)
2785 arg
= gimple_assign_rhs1 (def
);
2786 CALL_EXPR_ARG (exp
, i
) = arg
;
2789 if (gimple_has_side_effects (stmt
))
2790 TREE_SIDE_EFFECTS (exp
) = 1;
2792 if (gimple_call_nothrow_p (stmt
))
2793 TREE_NOTHROW (exp
) = 1;
2795 if (gimple_no_warning_p (stmt
))
2796 TREE_NO_WARNING (exp
) = 1;
2798 CALL_EXPR_TAILCALL (exp
) = gimple_call_tail_p (stmt
);
2799 CALL_EXPR_MUST_TAIL_CALL (exp
) = gimple_call_must_tail_p (stmt
);
2800 CALL_EXPR_RETURN_SLOT_OPT (exp
) = gimple_call_return_slot_opt_p (stmt
);
2802 && fndecl_built_in_p (decl
, BUILT_IN_NORMAL
)
2803 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (decl
)))
2804 CALL_ALLOCA_FOR_VAR_P (exp
) = gimple_call_alloca_for_var_p (stmt
);
2806 CALL_FROM_THUNK_P (exp
) = gimple_call_from_thunk_p (stmt
);
2807 CALL_EXPR_VA_ARG_PACK (exp
) = gimple_call_va_arg_pack_p (stmt
);
2808 CALL_EXPR_BY_DESCRIPTOR (exp
) = gimple_call_by_descriptor_p (stmt
);
2809 SET_EXPR_LOCATION (exp
, gimple_location (stmt
));
2811 /* Ensure RTL is created for debug args. */
2812 if (decl
&& DECL_HAS_DEBUG_ARGS_P (decl
))
2814 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (decl
);
2819 for (ix
= 1; (*debug_args
)->iterate (ix
, &dtemp
); ix
+= 2)
2821 gcc_assert (TREE_CODE (dtemp
) == DEBUG_EXPR_DECL
);
2822 expand_debug_expr (dtemp
);
2826 rtx_insn
*before_call
= get_last_insn ();
2827 lhs
= gimple_call_lhs (stmt
);
2829 expand_assignment (lhs
, exp
, false);
2831 expand_expr (exp
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2833 /* If the gimple call is an indirect call and has 'nocf_check'
2834 attribute find a generated CALL insn to mark it as no
2835 control-flow verification is needed. */
2836 if (gimple_call_nocf_check_p (stmt
)
2837 && !gimple_call_fndecl (stmt
))
2839 rtx_insn
*last
= get_last_insn ();
2840 while (!CALL_P (last
)
2841 && last
!= before_call
)
2842 last
= PREV_INSN (last
);
2844 if (last
!= before_call
)
2845 add_reg_note (last
, REG_CALL_NOCF_CHECK
, const0_rtx
);
2848 mark_transaction_restart_calls (stmt
);
2852 /* Generate RTL for an asm statement (explicit assembler code).
2853 STRING is a STRING_CST node containing the assembler code text,
2854 or an ADDR_EXPR containing a STRING_CST. VOL nonzero means the
2855 insn is volatile; don't optimize it. */
2858 expand_asm_loc (tree string
, int vol
, location_t locus
)
2862 body
= gen_rtx_ASM_INPUT_loc (VOIDmode
,
2863 ggc_strdup (TREE_STRING_POINTER (string
)),
2866 MEM_VOLATILE_P (body
) = vol
;
2868 /* Non-empty basic ASM implicitly clobbers memory. */
2869 if (TREE_STRING_LENGTH (string
) != 0)
2872 unsigned i
, nclobbers
;
2873 auto_vec
<rtx
> input_rvec
, output_rvec
;
2874 auto_vec
<const char *> constraints
;
2875 auto_vec
<rtx
> clobber_rvec
;
2876 HARD_REG_SET clobbered_regs
;
2877 CLEAR_HARD_REG_SET (clobbered_regs
);
2879 clob
= gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
));
2880 clobber_rvec
.safe_push (clob
);
2882 if (targetm
.md_asm_adjust
)
2883 targetm
.md_asm_adjust (output_rvec
, input_rvec
,
2884 constraints
, clobber_rvec
,
2888 nclobbers
= clobber_rvec
.length ();
2889 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (1 + nclobbers
));
2891 XVECEXP (body
, 0, 0) = asm_op
;
2892 for (i
= 0; i
< nclobbers
; i
++)
2893 XVECEXP (body
, 0, i
+ 1) = gen_rtx_CLOBBER (VOIDmode
, clobber_rvec
[i
]);
2899 /* Return the number of times character C occurs in string S. */
2901 n_occurrences (int c
, const char *s
)
2909 /* A subroutine of expand_asm_operands. Check that all operands have
2910 the same number of alternatives. Return true if so. */
2913 check_operand_nalternatives (const vec
<const char *> &constraints
)
2915 unsigned len
= constraints
.length();
2918 int nalternatives
= n_occurrences (',', constraints
[0]);
2920 if (nalternatives
+ 1 > MAX_RECOG_ALTERNATIVES
)
2922 error ("too many alternatives in %<asm%>");
2926 for (unsigned i
= 1; i
< len
; ++i
)
2927 if (n_occurrences (',', constraints
[i
]) != nalternatives
)
2929 error ("operand constraints for %<asm%> differ "
2930 "in number of alternatives");
2937 /* Check for overlap between registers marked in CLOBBERED_REGS and
2938 anything inappropriate in T. Emit error and return the register
2939 variable definition for error, NULL_TREE for ok. */
2942 tree_conflicts_with_clobbers_p (tree t
, HARD_REG_SET
*clobbered_regs
)
2944 /* Conflicts between asm-declared register variables and the clobber
2945 list are not allowed. */
2946 tree overlap
= tree_overlaps_hard_reg_set (t
, clobbered_regs
);
2950 error ("%<asm%> specifier for variable %qE conflicts with "
2951 "%<asm%> clobber list",
2952 DECL_NAME (overlap
));
2954 /* Reset registerness to stop multiple errors emitted for a single
2956 DECL_REGISTER (overlap
) = 0;
2963 /* Check that the given REGNO spanning NREGS is a valid
2964 asm clobber operand. Some HW registers cannot be
2965 saved/restored, hence they should not be clobbered by
2968 asm_clobber_reg_is_valid (int regno
, int nregs
, const char *regname
)
2970 bool is_valid
= true;
2971 HARD_REG_SET regset
;
2973 CLEAR_HARD_REG_SET (regset
);
2975 add_range_to_hard_reg_set (®set
, regno
, nregs
);
2977 /* Clobbering the PIC register is an error. */
2978 if (PIC_OFFSET_TABLE_REGNUM
!= INVALID_REGNUM
2979 && overlaps_hard_reg_set_p (regset
, Pmode
, PIC_OFFSET_TABLE_REGNUM
))
2981 /* ??? Diagnose during gimplification? */
2982 error ("PIC register clobbered by %qs in %<asm%>", regname
);
2985 else if (!in_hard_reg_set_p
2986 (accessible_reg_set
, reg_raw_mode
[regno
], regno
))
2988 /* ??? Diagnose during gimplification? */
2989 error ("the register %qs cannot be clobbered in %<asm%>"
2990 " for the current target", regname
);
2994 /* Clobbering the stack pointer register is deprecated. GCC expects
2995 the value of the stack pointer after an asm statement to be the same
2996 as it was before, so no asm can validly clobber the stack pointer in
2997 the usual sense. Adding the stack pointer to the clobber list has
2998 traditionally had some undocumented and somewhat obscure side-effects. */
2999 if (overlaps_hard_reg_set_p (regset
, Pmode
, STACK_POINTER_REGNUM
))
3001 crtl
->sp_is_clobbered_by_asm
= true;
3002 if (warning (OPT_Wdeprecated
, "listing the stack pointer register"
3003 " %qs in a clobber list is deprecated", regname
))
3004 inform (input_location
, "the value of the stack pointer after"
3005 " an %<asm%> statement must be the same as it was before"
3012 /* Generate RTL for an asm statement with arguments.
3013 STRING is the instruction template.
3014 OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
3015 Each output or input has an expression in the TREE_VALUE and
3016 a tree list in TREE_PURPOSE which in turn contains a constraint
3017 name in TREE_VALUE (or NULL_TREE) and a constraint string
3019 CLOBBERS is a list of STRING_CST nodes each naming a hard register
3020 that is clobbered by this insn.
3022 LABELS is a list of labels, and if LABELS is non-NULL, FALLTHRU_BB
3023 should be the fallthru basic block of the asm goto.
3025 Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
3026 Some elements of OUTPUTS may be replaced with trees representing temporary
3027 values. The caller should copy those temporary values to the originally
3030 VOL nonzero means the insn is volatile; don't optimize it. */
3033 expand_asm_stmt (gasm
*stmt
)
3035 class save_input_location
3040 explicit save_input_location(location_t where
)
3042 old
= input_location
;
3043 input_location
= where
;
3046 ~save_input_location()
3048 input_location
= old
;
3052 location_t locus
= gimple_location (stmt
);
3054 if (gimple_asm_input_p (stmt
))
3056 const char *s
= gimple_asm_string (stmt
);
3057 tree string
= build_string (strlen (s
), s
);
3058 expand_asm_loc (string
, gimple_asm_volatile_p (stmt
), locus
);
3062 /* There are some legacy diagnostics in here, and also avoids a
3063 sixth parameger to targetm.md_asm_adjust. */
3064 save_input_location
s_i_l(locus
);
3066 unsigned noutputs
= gimple_asm_noutputs (stmt
);
3067 unsigned ninputs
= gimple_asm_ninputs (stmt
);
3068 unsigned nlabels
= gimple_asm_nlabels (stmt
);
3071 /* ??? Diagnose during gimplification? */
3072 if (ninputs
+ noutputs
+ nlabels
> MAX_RECOG_OPERANDS
)
3074 error ("more than %d operands in %<asm%>", MAX_RECOG_OPERANDS
);
3078 auto_vec
<tree
, MAX_RECOG_OPERANDS
> output_tvec
;
3079 auto_vec
<tree
, MAX_RECOG_OPERANDS
> input_tvec
;
3080 auto_vec
<const char *, MAX_RECOG_OPERANDS
> constraints
;
3082 /* Copy the gimple vectors into new vectors that we can manipulate. */
3084 output_tvec
.safe_grow (noutputs
, true);
3085 input_tvec
.safe_grow (ninputs
, true);
3086 constraints
.safe_grow (noutputs
+ ninputs
, true);
3088 for (i
= 0; i
< noutputs
; ++i
)
3090 tree t
= gimple_asm_output_op (stmt
, i
);
3091 output_tvec
[i
] = TREE_VALUE (t
);
3092 constraints
[i
] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
3094 for (i
= 0; i
< ninputs
; i
++)
3096 tree t
= gimple_asm_input_op (stmt
, i
);
3097 input_tvec
[i
] = TREE_VALUE (t
);
3098 constraints
[i
+ noutputs
]
3099 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
3102 /* ??? Diagnose during gimplification? */
3103 if (! check_operand_nalternatives (constraints
))
3106 /* Count the number of meaningful clobbered registers, ignoring what
3107 we would ignore later. */
3108 auto_vec
<rtx
> clobber_rvec
;
3109 HARD_REG_SET clobbered_regs
;
3110 CLEAR_HARD_REG_SET (clobbered_regs
);
3112 if (unsigned n
= gimple_asm_nclobbers (stmt
))
3114 clobber_rvec
.reserve (n
);
3115 for (i
= 0; i
< n
; i
++)
3117 tree t
= gimple_asm_clobber_op (stmt
, i
);
3118 const char *regname
= TREE_STRING_POINTER (TREE_VALUE (t
));
3121 j
= decode_reg_name_and_count (regname
, &nregs
);
3126 /* ??? Diagnose during gimplification? */
3127 error ("unknown register name %qs in %<asm%>", regname
);
3131 rtx x
= gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
));
3132 clobber_rvec
.safe_push (x
);
3136 /* Otherwise we should have -1 == empty string
3137 or -3 == cc, which is not a register. */
3138 gcc_assert (j
== -1 || j
== -3);
3142 for (int reg
= j
; reg
< j
+ nregs
; reg
++)
3144 if (!asm_clobber_reg_is_valid (reg
, nregs
, regname
))
3147 SET_HARD_REG_BIT (clobbered_regs
, reg
);
3148 rtx x
= gen_rtx_REG (reg_raw_mode
[reg
], reg
);
3149 clobber_rvec
.safe_push (x
);
3154 /* First pass over inputs and outputs checks validity and sets
3155 mark_addressable if needed. */
3156 /* ??? Diagnose during gimplification? */
3158 for (i
= 0; i
< noutputs
; ++i
)
3160 tree val
= output_tvec
[i
];
3161 tree type
= TREE_TYPE (val
);
3162 const char *constraint
;
3167 /* Try to parse the output constraint. If that fails, there's
3168 no point in going further. */
3169 constraint
= constraints
[i
];
3170 if (!parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
3171 &allows_mem
, &allows_reg
, &is_inout
))
3174 /* If the output is a hard register, verify it doesn't conflict with
3175 any other operand's possible hard register use. */
3177 && REG_P (DECL_RTL (val
))
3178 && HARD_REGISTER_P (DECL_RTL (val
)))
3180 unsigned j
, output_hregno
= REGNO (DECL_RTL (val
));
3181 bool early_clobber_p
= strchr (constraints
[i
], '&') != NULL
;
3182 unsigned long match
;
3184 /* Verify the other outputs do not use the same hard register. */
3185 for (j
= i
+ 1; j
< noutputs
; ++j
)
3186 if (DECL_P (output_tvec
[j
])
3187 && REG_P (DECL_RTL (output_tvec
[j
]))
3188 && HARD_REGISTER_P (DECL_RTL (output_tvec
[j
]))
3189 && output_hregno
== REGNO (DECL_RTL (output_tvec
[j
])))
3190 error ("invalid hard register usage between output operands");
3192 /* Verify matching constraint operands use the same hard register
3193 and that the non-matching constraint operands do not use the same
3194 hard register if the output is an early clobber operand. */
3195 for (j
= 0; j
< ninputs
; ++j
)
3196 if (DECL_P (input_tvec
[j
])
3197 && REG_P (DECL_RTL (input_tvec
[j
]))
3198 && HARD_REGISTER_P (DECL_RTL (input_tvec
[j
])))
3200 unsigned input_hregno
= REGNO (DECL_RTL (input_tvec
[j
]));
3201 switch (*constraints
[j
+ noutputs
])
3203 case '0': case '1': case '2': case '3': case '4':
3204 case '5': case '6': case '7': case '8': case '9':
3205 match
= strtoul (constraints
[j
+ noutputs
], NULL
, 10);
3212 && output_hregno
!= input_hregno
)
3213 error ("invalid hard register usage between output operand "
3214 "and matching constraint operand");
3215 else if (early_clobber_p
3217 && output_hregno
== input_hregno
)
3218 error ("invalid hard register usage between earlyclobber "
3219 "operand and input operand");
3227 && REG_P (DECL_RTL (val
))
3228 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
))))
3229 mark_addressable (val
);
3232 for (i
= 0; i
< ninputs
; ++i
)
3234 bool allows_reg
, allows_mem
;
3235 const char *constraint
;
3237 constraint
= constraints
[i
+ noutputs
];
3238 if (! parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
3239 constraints
.address (),
3240 &allows_mem
, &allows_reg
))
3243 if (! allows_reg
&& allows_mem
)
3244 mark_addressable (input_tvec
[i
]);
3247 /* Second pass evaluates arguments. */
3249 /* Make sure stack is consistent for asm goto. */
3251 do_pending_stack_adjust ();
3252 int old_generating_concat_p
= generating_concat_p
;
3254 /* Vector of RTX's of evaluated output operands. */
3255 auto_vec
<rtx
, MAX_RECOG_OPERANDS
> output_rvec
;
3256 auto_vec
<int, MAX_RECOG_OPERANDS
> inout_opnum
;
3257 rtx_insn
*after_rtl_seq
= NULL
, *after_rtl_end
= NULL
;
3259 output_rvec
.safe_grow (noutputs
, true);
3261 for (i
= 0; i
< noutputs
; ++i
)
3263 tree val
= output_tvec
[i
];
3264 tree type
= TREE_TYPE (val
);
3265 bool is_inout
, allows_reg
, allows_mem
, ok
;
3268 ok
= parse_output_constraint (&constraints
[i
], i
, ninputs
,
3269 noutputs
, &allows_mem
, &allows_reg
,
3273 /* If an output operand is not a decl or indirect ref and our constraint
3274 allows a register, make a temporary to act as an intermediate.
3275 Make the asm insn write into that, then we will copy it to
3276 the real output operand. Likewise for promoted variables. */
3278 generating_concat_p
= 0;
3280 if ((TREE_CODE (val
) == INDIRECT_REF
&& allows_mem
)
3282 && (allows_mem
|| REG_P (DECL_RTL (val
)))
3283 && ! (REG_P (DECL_RTL (val
))
3284 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
)))
3287 || TREE_ADDRESSABLE (type
))
3289 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
3290 !allows_reg
? EXPAND_MEMORY
: EXPAND_WRITE
);
3292 op
= validize_mem (op
);
3294 if (! allows_reg
&& !MEM_P (op
))
3295 error ("output number %d not directly addressable", i
);
3296 if ((! allows_mem
&& MEM_P (op
) && GET_MODE (op
) != BLKmode
)
3297 || GET_CODE (op
) == CONCAT
)
3300 op
= gen_reg_rtx (GET_MODE (op
));
3302 generating_concat_p
= old_generating_concat_p
;
3305 emit_move_insn (op
, old_op
);
3307 push_to_sequence2 (after_rtl_seq
, after_rtl_end
);
3308 emit_move_insn (old_op
, op
);
3309 after_rtl_seq
= get_insns ();
3310 after_rtl_end
= get_last_insn ();
3316 op
= assign_temp (type
, 0, 1);
3317 op
= validize_mem (op
);
3318 if (!MEM_P (op
) && TREE_CODE (val
) == SSA_NAME
)
3319 set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (val
), op
);
3321 generating_concat_p
= old_generating_concat_p
;
3323 push_to_sequence2 (after_rtl_seq
, after_rtl_end
);
3324 expand_assignment (val
, make_tree (type
, op
), false);
3325 after_rtl_seq
= get_insns ();
3326 after_rtl_end
= get_last_insn ();
3329 output_rvec
[i
] = op
;
3332 inout_opnum
.safe_push (i
);
3335 auto_vec
<rtx
, MAX_RECOG_OPERANDS
> input_rvec
;
3336 auto_vec
<machine_mode
, MAX_RECOG_OPERANDS
> input_mode
;
3338 input_rvec
.safe_grow (ninputs
, true);
3339 input_mode
.safe_grow (ninputs
, true);
3341 generating_concat_p
= 0;
3343 for (i
= 0; i
< ninputs
; ++i
)
3345 tree val
= input_tvec
[i
];
3346 tree type
= TREE_TYPE (val
);
3347 bool allows_reg
, allows_mem
, ok
;
3348 const char *constraint
;
3351 constraint
= constraints
[i
+ noutputs
];
3352 ok
= parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
3353 constraints
.address (),
3354 &allows_mem
, &allows_reg
);
3357 /* EXPAND_INITIALIZER will not generate code for valid initializer
3358 constants, but will still generate code for other types of operand.
3359 This is the behavior we want for constant constraints. */
3360 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
3361 allows_reg
? EXPAND_NORMAL
3362 : allows_mem
? EXPAND_MEMORY
3363 : EXPAND_INITIALIZER
);
3365 /* Never pass a CONCAT to an ASM. */
3366 if (GET_CODE (op
) == CONCAT
)
3367 op
= force_reg (GET_MODE (op
), op
);
3368 else if (MEM_P (op
))
3369 op
= validize_mem (op
);
3371 if (asm_operand_ok (op
, constraint
, NULL
) <= 0)
3373 if (allows_reg
&& TYPE_MODE (type
) != BLKmode
)
3374 op
= force_reg (TYPE_MODE (type
), op
);
3375 else if (!allows_mem
)
3376 warning (0, "%<asm%> operand %d probably does not match "
3379 else if (MEM_P (op
))
3381 /* We won't recognize either volatile memory or memory
3382 with a queued address as available a memory_operand
3383 at this point. Ignore it: clearly this *is* a memory. */
3389 input_mode
[i
] = TYPE_MODE (type
);
3392 /* For in-out operands, copy output rtx to input rtx. */
3393 unsigned ninout
= inout_opnum
.length();
3394 for (i
= 0; i
< ninout
; i
++)
3396 int j
= inout_opnum
[i
];
3397 rtx o
= output_rvec
[j
];
3399 input_rvec
.safe_push (o
);
3400 input_mode
.safe_push (GET_MODE (o
));
3403 sprintf (buffer
, "%d", j
);
3404 constraints
.safe_push (ggc_strdup (buffer
));
3408 /* Sometimes we wish to automatically clobber registers across an asm.
3409 Case in point is when the i386 backend moved from cc0 to a hard reg --
3410 maintaining source-level compatibility means automatically clobbering
3411 the flags register. */
3412 rtx_insn
*after_md_seq
= NULL
;
3413 if (targetm
.md_asm_adjust
)
3414 after_md_seq
= targetm
.md_asm_adjust (output_rvec
, input_rvec
,
3415 constraints
, clobber_rvec
,
3418 /* Do not allow the hook to change the output and input count,
3419 lest it mess up the operand numbering. */
3420 gcc_assert (output_rvec
.length() == noutputs
);
3421 gcc_assert (input_rvec
.length() == ninputs
);
3422 gcc_assert (constraints
.length() == noutputs
+ ninputs
);
3424 /* But it certainly can adjust the clobbers. */
3425 unsigned nclobbers
= clobber_rvec
.length ();
3427 /* Third pass checks for easy conflicts. */
3428 /* ??? Why are we doing this on trees instead of rtx. */
3430 bool clobber_conflict_found
= 0;
3431 for (i
= 0; i
< noutputs
; ++i
)
3432 if (tree_conflicts_with_clobbers_p (output_tvec
[i
], &clobbered_regs
))
3433 clobber_conflict_found
= 1;
3434 for (i
= 0; i
< ninputs
- ninout
; ++i
)
3435 if (tree_conflicts_with_clobbers_p (input_tvec
[i
], &clobbered_regs
))
3436 clobber_conflict_found
= 1;
3438 /* Make vectors for the expression-rtx, constraint strings,
3439 and named operands. */
3441 rtvec argvec
= rtvec_alloc (ninputs
);
3442 rtvec constraintvec
= rtvec_alloc (ninputs
);
3443 rtvec labelvec
= rtvec_alloc (nlabels
);
3445 rtx body
= gen_rtx_ASM_OPERANDS ((noutputs
== 0 ? VOIDmode
3446 : GET_MODE (output_rvec
[0])),
3447 ggc_strdup (gimple_asm_string (stmt
)),
3448 "", 0, argvec
, constraintvec
,
3450 MEM_VOLATILE_P (body
) = gimple_asm_volatile_p (stmt
);
3452 for (i
= 0; i
< ninputs
; ++i
)
3454 ASM_OPERANDS_INPUT (body
, i
) = input_rvec
[i
];
3455 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body
, i
)
3456 = gen_rtx_ASM_INPUT_loc (input_mode
[i
],
3457 constraints
[i
+ noutputs
],
3461 /* Copy labels to the vector. */
3462 rtx_code_label
*fallthru_label
= NULL
;
3465 basic_block fallthru_bb
= NULL
;
3466 edge fallthru
= find_fallthru_edge (gimple_bb (stmt
)->succs
);
3468 fallthru_bb
= fallthru
->dest
;
3470 for (i
= 0; i
< nlabels
; ++i
)
3472 tree label
= TREE_VALUE (gimple_asm_label_op (stmt
, i
));
3474 /* If asm goto has any labels in the fallthru basic block, use
3475 a label that we emit immediately after the asm goto. Expansion
3476 may insert further instructions into the same basic block after
3477 asm goto and if we don't do this, insertion of instructions on
3478 the fallthru edge might misbehave. See PR58670. */
3479 if (fallthru_bb
&& label_to_block (cfun
, label
) == fallthru_bb
)
3481 if (fallthru_label
== NULL_RTX
)
3482 fallthru_label
= gen_label_rtx ();
3486 r
= label_rtx (label
);
3487 ASM_OPERANDS_LABEL (body
, i
) = gen_rtx_LABEL_REF (Pmode
, r
);
3491 /* Now, for each output, construct an rtx
3492 (set OUTPUT (asm_operands INSN OUTPUTCONSTRAINT OUTPUTNUMBER
3493 ARGVEC CONSTRAINTS OPNAMES))
3494 If there is more than one, put them inside a PARALLEL. */
3496 if (noutputs
== 0 && nclobbers
== 0)
3498 /* No output operands: put in a raw ASM_OPERANDS rtx. */
3500 emit_jump_insn (body
);
3504 else if (noutputs
== 1 && nclobbers
== 0)
3506 ASM_OPERANDS_OUTPUT_CONSTRAINT (body
) = constraints
[0];
3508 emit_jump_insn (gen_rtx_SET (output_rvec
[0], body
));
3510 emit_insn (gen_rtx_SET (output_rvec
[0], body
));
3520 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (num
+ nclobbers
));
3522 /* For each output operand, store a SET. */
3523 for (i
= 0; i
< noutputs
; ++i
)
3525 rtx src
, o
= output_rvec
[i
];
3528 ASM_OPERANDS_OUTPUT_CONSTRAINT (obody
) = constraints
[0];
3533 src
= gen_rtx_ASM_OPERANDS (GET_MODE (o
),
3534 ASM_OPERANDS_TEMPLATE (obody
),
3535 constraints
[i
], i
, argvec
,
3536 constraintvec
, labelvec
, locus
);
3537 MEM_VOLATILE_P (src
) = gimple_asm_volatile_p (stmt
);
3539 XVECEXP (body
, 0, i
) = gen_rtx_SET (o
, src
);
3542 /* If there are no outputs (but there are some clobbers)
3543 store the bare ASM_OPERANDS into the PARALLEL. */
3545 XVECEXP (body
, 0, i
++) = obody
;
3547 /* Store (clobber REG) for each clobbered register specified. */
3548 for (unsigned j
= 0; j
< nclobbers
; ++j
)
3550 rtx clobbered_reg
= clobber_rvec
[j
];
3552 /* Do sanity check for overlap between clobbers and respectively
3553 input and outputs that hasn't been handled. Such overlap
3554 should have been detected and reported above. */
3555 if (!clobber_conflict_found
&& REG_P (clobbered_reg
))
3557 /* We test the old body (obody) contents to avoid
3558 tripping over the under-construction body. */
3559 for (unsigned k
= 0; k
< noutputs
; ++k
)
3560 if (reg_overlap_mentioned_p (clobbered_reg
, output_rvec
[k
]))
3561 internal_error ("%<asm%> clobber conflict with "
3564 for (unsigned k
= 0; k
< ninputs
- ninout
; ++k
)
3565 if (reg_overlap_mentioned_p (clobbered_reg
, input_rvec
[k
]))
3566 internal_error ("%<asm%> clobber conflict with "
3570 XVECEXP (body
, 0, i
++) = gen_rtx_CLOBBER (VOIDmode
, clobbered_reg
);
3574 emit_jump_insn (body
);
3579 generating_concat_p
= old_generating_concat_p
;
3582 emit_label (fallthru_label
);
3585 emit_insn (after_md_seq
);
3589 emit_insn (after_rtl_seq
);
3595 FOR_EACH_EDGE (e
, ei
, gimple_bb (stmt
)->succs
)
3598 for (rtx_insn
*curr
= after_rtl_seq
;
3600 curr
= NEXT_INSN (curr
))
3601 emit_insn (copy_insn (PATTERN (curr
)));
3602 rtx_insn
*copy
= get_insns ();
3604 insert_insn_on_edge (copy
, e
);
3610 crtl
->has_asm_statement
= 1;
3613 /* Emit code to jump to the address
3614 specified by the pointer expression EXP. */
3617 expand_computed_goto (tree exp
)
3619 rtx x
= expand_normal (exp
);
3621 do_pending_stack_adjust ();
3622 emit_indirect_jump (x
);
3625 /* Generate RTL code for a `goto' statement with target label LABEL.
3626 LABEL should be a LABEL_DECL tree node that was or will later be
3627 defined with `expand_label'. */
3630 expand_goto (tree label
)
3634 /* Check for a nonlocal goto to a containing function. Should have
3635 gotten translated to __builtin_nonlocal_goto. */
3636 tree context
= decl_function_context (label
);
3637 gcc_assert (!context
|| context
== current_function_decl
);
3640 emit_jump (jump_target_rtx (label
));
3643 /* Output a return with no value. */
3646 expand_null_return_1 (void)
3648 clear_pending_stack_adjust ();
3649 do_pending_stack_adjust ();
3650 emit_jump (return_label
);
3653 /* Generate RTL to return from the current function, with no value.
3654 (That is, we do not do anything about returning any value.) */
3657 expand_null_return (void)
3659 /* If this function was declared to return a value, but we
3660 didn't, clobber the return registers so that they are not
3661 propagated live to the rest of the function. */
3662 clobber_return_register ();
3664 expand_null_return_1 ();
3667 /* Generate RTL to return from the current function, with value VAL. */
3670 expand_value_return (rtx val
)
3672 /* Copy the value to the return location unless it's already there. */
3674 tree decl
= DECL_RESULT (current_function_decl
);
3675 rtx return_reg
= DECL_RTL (decl
);
3676 if (return_reg
!= val
)
3678 tree funtype
= TREE_TYPE (current_function_decl
);
3679 tree type
= TREE_TYPE (decl
);
3680 int unsignedp
= TYPE_UNSIGNED (type
);
3681 machine_mode old_mode
= DECL_MODE (decl
);
3683 if (DECL_BY_REFERENCE (decl
))
3684 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 2);
3686 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 1);
3688 if (mode
!= old_mode
)
3689 val
= convert_modes (mode
, old_mode
, val
, unsignedp
);
3691 if (GET_CODE (return_reg
) == PARALLEL
)
3692 emit_group_load (return_reg
, val
, type
, int_size_in_bytes (type
));
3694 emit_move_insn (return_reg
, val
);
3697 expand_null_return_1 ();
3700 /* Generate RTL to evaluate the expression RETVAL and return it
3701 from the current function. */
3704 expand_return (tree retval
)
3710 /* If function wants no value, give it none. */
3711 if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl
))) == VOID_TYPE
)
3713 expand_normal (retval
);
3714 expand_null_return ();
3718 if (retval
== error_mark_node
)
3720 /* Treat this like a return of no value from a function that
3722 expand_null_return ();
3725 else if ((TREE_CODE (retval
) == MODIFY_EXPR
3726 || TREE_CODE (retval
) == INIT_EXPR
)
3727 && TREE_CODE (TREE_OPERAND (retval
, 0)) == RESULT_DECL
)
3728 retval_rhs
= TREE_OPERAND (retval
, 1);
3730 retval_rhs
= retval
;
3732 result_rtl
= DECL_RTL (DECL_RESULT (current_function_decl
));
3734 /* If we are returning the RESULT_DECL, then the value has already
3735 been stored into it, so we don't have to do anything special. */
3736 if (TREE_CODE (retval_rhs
) == RESULT_DECL
)
3737 expand_value_return (result_rtl
);
3739 /* If the result is an aggregate that is being returned in one (or more)
3740 registers, load the registers here. */
3742 else if (retval_rhs
!= 0
3743 && TYPE_MODE (TREE_TYPE (retval_rhs
)) == BLKmode
3744 && REG_P (result_rtl
))
3746 val
= copy_blkmode_to_reg (GET_MODE (result_rtl
), retval_rhs
);
3749 /* Use the mode of the result value on the return register. */
3750 PUT_MODE (result_rtl
, GET_MODE (val
));
3751 expand_value_return (val
);
3754 expand_null_return ();
3756 else if (retval_rhs
!= 0
3757 && !VOID_TYPE_P (TREE_TYPE (retval_rhs
))
3758 && (REG_P (result_rtl
)
3759 || (GET_CODE (result_rtl
) == PARALLEL
)))
3761 /* Compute the return value into a temporary (usually a pseudo reg). */
3763 = assign_temp (TREE_TYPE (DECL_RESULT (current_function_decl
)), 0, 1);
3764 val
= expand_expr (retval_rhs
, val
, GET_MODE (val
), EXPAND_NORMAL
);
3765 val
= force_not_mem (val
);
3766 expand_value_return (val
);
3770 /* No hard reg used; calculate value into hard return reg. */
3771 expand_expr (retval
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3772 expand_value_return (result_rtl
);
3776 /* Expand a clobber of LHS. If LHS is stored it in a multi-part
3777 register, tell the rtl optimizers that its value is no longer
3781 expand_clobber (tree lhs
)
3785 rtx decl_rtl
= DECL_RTL_IF_SET (lhs
);
3786 if (decl_rtl
&& REG_P (decl_rtl
))
3788 machine_mode decl_mode
= GET_MODE (decl_rtl
);
3789 if (maybe_gt (GET_MODE_SIZE (decl_mode
),
3790 REGMODE_NATURAL_SIZE (decl_mode
)))
3791 emit_clobber (decl_rtl
);
3796 /* A subroutine of expand_gimple_stmt, expanding one gimple statement
3797 STMT that doesn't require special handling for outgoing edges. That
3798 is no tailcalls and no GIMPLE_COND. */
3801 expand_gimple_stmt_1 (gimple
*stmt
)
3805 set_curr_insn_location (gimple_location (stmt
));
3807 switch (gimple_code (stmt
))
3810 op0
= gimple_goto_dest (stmt
);
3811 if (TREE_CODE (op0
) == LABEL_DECL
)
3814 expand_computed_goto (op0
);
3817 expand_label (gimple_label_label (as_a
<glabel
*> (stmt
)));
3820 case GIMPLE_PREDICT
:
3824 gswitch
*swtch
= as_a
<gswitch
*> (stmt
);
3825 if (gimple_switch_num_labels (swtch
) == 1)
3826 expand_goto (CASE_LABEL (gimple_switch_default_label (swtch
)));
3828 expand_case (swtch
);
3832 expand_asm_stmt (as_a
<gasm
*> (stmt
));
3835 expand_call_stmt (as_a
<gcall
*> (stmt
));
3840 op0
= gimple_return_retval (as_a
<greturn
*> (stmt
));
3842 /* If a return doesn't have a location, it very likely represents
3843 multiple user returns so we cannot let it inherit the location
3844 of the last statement of the previous basic block in RTL. */
3845 if (!gimple_has_location (stmt
))
3846 set_curr_insn_location (cfun
->function_end_locus
);
3848 if (op0
&& op0
!= error_mark_node
)
3850 tree result
= DECL_RESULT (current_function_decl
);
3852 /* If we are not returning the current function's RESULT_DECL,
3853 build an assignment to it. */
3856 /* I believe that a function's RESULT_DECL is unique. */
3857 gcc_assert (TREE_CODE (op0
) != RESULT_DECL
);
3859 /* ??? We'd like to use simply expand_assignment here,
3860 but this fails if the value is of BLKmode but the return
3861 decl is a register. expand_return has special handling
3862 for this combination, which eventually should move
3863 to common code. See comments there. Until then, let's
3864 build a modify expression :-/ */
3865 op0
= build2 (MODIFY_EXPR
, TREE_TYPE (result
),
3871 expand_null_return ();
3873 expand_return (op0
);
3879 gassign
*assign_stmt
= as_a
<gassign
*> (stmt
);
3880 tree lhs
= gimple_assign_lhs (assign_stmt
);
3882 /* Tree expand used to fiddle with |= and &= of two bitfield
3883 COMPONENT_REFs here. This can't happen with gimple, the LHS
3884 of binary assigns must be a gimple reg. */
3886 if (TREE_CODE (lhs
) != SSA_NAME
3887 || gimple_assign_rhs_class (assign_stmt
) == GIMPLE_SINGLE_RHS
)
3889 tree rhs
= gimple_assign_rhs1 (assign_stmt
);
3890 gcc_assert (gimple_assign_rhs_class (assign_stmt
)
3891 == GIMPLE_SINGLE_RHS
);
3892 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (rhs
)
3893 /* Do not put locations on possibly shared trees. */
3894 && !is_gimple_min_invariant (rhs
))
3895 SET_EXPR_LOCATION (rhs
, gimple_location (stmt
));
3896 if (TREE_CLOBBER_P (rhs
))
3897 /* This is a clobber to mark the going out of scope for
3899 expand_clobber (lhs
);
3901 expand_assignment (lhs
, rhs
,
3902 gimple_assign_nontemporal_move_p (
3908 bool nontemporal
= gimple_assign_nontemporal_move_p (assign_stmt
);
3909 struct separate_ops ops
;
3910 bool promoted
= false;
3912 target
= expand_expr (lhs
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
3913 if (GET_CODE (target
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (target
))
3916 ops
.code
= gimple_assign_rhs_code (assign_stmt
);
3917 ops
.type
= TREE_TYPE (lhs
);
3918 switch (get_gimple_rhs_class (ops
.code
))
3920 case GIMPLE_TERNARY_RHS
:
3921 ops
.op2
= gimple_assign_rhs3 (assign_stmt
);
3923 case GIMPLE_BINARY_RHS
:
3924 ops
.op1
= gimple_assign_rhs2 (assign_stmt
);
3926 case GIMPLE_UNARY_RHS
:
3927 ops
.op0
= gimple_assign_rhs1 (assign_stmt
);
3932 ops
.location
= gimple_location (stmt
);
3934 /* If we want to use a nontemporal store, force the value to
3935 register first. If we store into a promoted register,
3936 don't directly expand to target. */
3937 temp
= nontemporal
|| promoted
? NULL_RTX
: target
;
3938 temp
= expand_expr_real_2 (&ops
, temp
, GET_MODE (target
),
3945 int unsignedp
= SUBREG_PROMOTED_SIGN (target
);
3946 /* If TEMP is a VOIDmode constant, use convert_modes to make
3947 sure that we properly convert it. */
3948 if (CONSTANT_P (temp
) && GET_MODE (temp
) == VOIDmode
)
3950 temp
= convert_modes (GET_MODE (target
),
3951 TYPE_MODE (ops
.type
),
3953 temp
= convert_modes (GET_MODE (SUBREG_REG (target
)),
3954 GET_MODE (target
), temp
, unsignedp
);
3957 convert_move (SUBREG_REG (target
), temp
, unsignedp
);
3959 else if (nontemporal
&& emit_storent_insn (target
, temp
))
3963 temp
= force_operand (temp
, target
);
3965 emit_move_insn (target
, temp
);
3976 /* Expand one gimple statement STMT and return the last RTL instruction
3977 before any of the newly generated ones.
3979 In addition to generating the necessary RTL instructions this also
3980 sets REG_EH_REGION notes if necessary and sets the current source
3981 location for diagnostics. */
3984 expand_gimple_stmt (gimple
*stmt
)
3986 location_t saved_location
= input_location
;
3987 rtx_insn
*last
= get_last_insn ();
3992 /* We need to save and restore the current source location so that errors
3993 discovered during expansion are emitted with the right location. But
3994 it would be better if the diagnostic routines used the source location
3995 embedded in the tree nodes rather than globals. */
3996 if (gimple_has_location (stmt
))
3997 input_location
= gimple_location (stmt
);
3999 expand_gimple_stmt_1 (stmt
);
4001 /* Free any temporaries used to evaluate this statement. */
4004 input_location
= saved_location
;
4006 /* Mark all insns that may trap. */
4007 lp_nr
= lookup_stmt_eh_lp (stmt
);
4011 for (insn
= next_real_insn (last
); insn
;
4012 insn
= next_real_insn (insn
))
4014 if (! find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
4015 /* If we want exceptions for non-call insns, any
4016 may_trap_p instruction may throw. */
4017 && GET_CODE (PATTERN (insn
)) != CLOBBER
4018 && GET_CODE (PATTERN (insn
)) != USE
4019 && insn_could_throw_p (insn
))
4020 make_reg_eh_region_note (insn
, 0, lp_nr
);
4027 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_CALL
4028 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
4029 generated a tail call (something that might be denied by the ABI
4030 rules governing the call; see calls.c).
4032 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
4033 can still reach the rest of BB. The case here is __builtin_sqrt,
4034 where the NaN result goes through the external function (with a
4035 tailcall) and the normal result happens via a sqrt instruction. */
4038 expand_gimple_tailcall (basic_block bb
, gcall
*stmt
, bool *can_fallthru
)
4040 rtx_insn
*last2
, *last
;
4043 profile_probability probability
;
4045 last2
= last
= expand_gimple_stmt (stmt
);
4047 for (last
= NEXT_INSN (last
); last
; last
= NEXT_INSN (last
))
4048 if (CALL_P (last
) && SIBLING_CALL_P (last
))
4051 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
4053 *can_fallthru
= true;
4057 /* ??? Wouldn't it be better to just reset any pending stack adjust?
4058 Any instructions emitted here are about to be deleted. */
4059 do_pending_stack_adjust ();
4061 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
4062 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
4063 EH or abnormal edges, we shouldn't have created a tail call in
4064 the first place. So it seems to me we should just be removing
4065 all edges here, or redirecting the existing fallthru edge to
4068 probability
= profile_probability::never ();
4070 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
4072 if (!(e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
)))
4074 if (e
->dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
4075 e
->dest
->count
-= e
->count ();
4076 probability
+= e
->probability
;
4083 /* This is somewhat ugly: the call_expr expander often emits instructions
4084 after the sibcall (to perform the function return). These confuse the
4085 find_many_sub_basic_blocks code, so we need to get rid of these. */
4086 last
= NEXT_INSN (last
);
4087 gcc_assert (BARRIER_P (last
));
4089 *can_fallthru
= false;
4090 while (NEXT_INSN (last
))
4092 /* For instance an sqrt builtin expander expands if with
4093 sibcall in the then and label for `else`. */
4094 if (LABEL_P (NEXT_INSN (last
)))
4096 *can_fallthru
= true;
4099 delete_insn (NEXT_INSN (last
));
4102 e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_ABNORMAL
4104 e
->probability
= probability
;
4106 update_bb_for_insn (bb
);
4108 if (NEXT_INSN (last
))
4110 bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
4113 if (BARRIER_P (last
))
4114 BB_END (bb
) = PREV_INSN (last
);
4117 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
4122 /* Return the difference between the floor and the truncated result of
4123 a signed division by OP1 with remainder MOD. */
4125 floor_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
4127 /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
4128 return gen_rtx_IF_THEN_ELSE
4129 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
4130 gen_rtx_IF_THEN_ELSE
4131 (mode
, gen_rtx_LT (BImode
,
4132 gen_rtx_DIV (mode
, op1
, mod
),
4134 constm1_rtx
, const0_rtx
),
4138 /* Return the difference between the ceil and the truncated result of
4139 a signed division by OP1 with remainder MOD. */
4141 ceil_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
4143 /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
4144 return gen_rtx_IF_THEN_ELSE
4145 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
4146 gen_rtx_IF_THEN_ELSE
4147 (mode
, gen_rtx_GT (BImode
,
4148 gen_rtx_DIV (mode
, op1
, mod
),
4150 const1_rtx
, const0_rtx
),
4154 /* Return the difference between the ceil and the truncated result of
4155 an unsigned division by OP1 with remainder MOD. */
4157 ceil_udiv_adjust (machine_mode mode
, rtx mod
, rtx op1 ATTRIBUTE_UNUSED
)
4159 /* (mod != 0 ? 1 : 0) */
4160 return gen_rtx_IF_THEN_ELSE
4161 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
4162 const1_rtx
, const0_rtx
);
4165 /* Return the difference between the rounded and the truncated result
4166 of a signed division by OP1 with remainder MOD. Halfway cases are
4167 rounded away from zero, rather than to the nearest even number. */
4169 round_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
4171 /* (abs (mod) >= abs (op1) - abs (mod)
4172 ? (op1 / mod > 0 ? 1 : -1)
4174 return gen_rtx_IF_THEN_ELSE
4175 (mode
, gen_rtx_GE (BImode
, gen_rtx_ABS (mode
, mod
),
4176 gen_rtx_MINUS (mode
,
4177 gen_rtx_ABS (mode
, op1
),
4178 gen_rtx_ABS (mode
, mod
))),
4179 gen_rtx_IF_THEN_ELSE
4180 (mode
, gen_rtx_GT (BImode
,
4181 gen_rtx_DIV (mode
, op1
, mod
),
4183 const1_rtx
, constm1_rtx
),
4187 /* Return the difference between the rounded and the truncated result
4188 of a unsigned division by OP1 with remainder MOD. Halfway cases
4189 are rounded away from zero, rather than to the nearest even
4192 round_udiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
4194 /* (mod >= op1 - mod ? 1 : 0) */
4195 return gen_rtx_IF_THEN_ELSE
4196 (mode
, gen_rtx_GE (BImode
, mod
,
4197 gen_rtx_MINUS (mode
, op1
, mod
)),
4198 const1_rtx
, const0_rtx
);
4201 /* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
4205 convert_debug_memory_address (scalar_int_mode mode
, rtx x
,
4208 #ifndef POINTERS_EXTEND_UNSIGNED
4209 gcc_assert (mode
== Pmode
4210 || mode
== targetm
.addr_space
.address_mode (as
));
4211 gcc_assert (GET_MODE (x
) == mode
|| GET_MODE (x
) == VOIDmode
);
4215 gcc_assert (targetm
.addr_space
.valid_pointer_mode (mode
, as
));
4217 if (GET_MODE (x
) == mode
|| GET_MODE (x
) == VOIDmode
)
4220 /* X must have some form of address mode already. */
4221 scalar_int_mode xmode
= as_a
<scalar_int_mode
> (GET_MODE (x
));
4222 if (GET_MODE_PRECISION (mode
) < GET_MODE_PRECISION (xmode
))
4223 x
= lowpart_subreg (mode
, x
, xmode
);
4224 else if (POINTERS_EXTEND_UNSIGNED
> 0)
4225 x
= gen_rtx_ZERO_EXTEND (mode
, x
);
4226 else if (!POINTERS_EXTEND_UNSIGNED
)
4227 x
= gen_rtx_SIGN_EXTEND (mode
, x
);
4230 switch (GET_CODE (x
))
4233 if ((SUBREG_PROMOTED_VAR_P (x
)
4234 || (REG_P (SUBREG_REG (x
)) && REG_POINTER (SUBREG_REG (x
)))
4235 || (GET_CODE (SUBREG_REG (x
)) == PLUS
4236 && REG_P (XEXP (SUBREG_REG (x
), 0))
4237 && REG_POINTER (XEXP (SUBREG_REG (x
), 0))
4238 && CONST_INT_P (XEXP (SUBREG_REG (x
), 1))))
4239 && GET_MODE (SUBREG_REG (x
)) == mode
)
4240 return SUBREG_REG (x
);
4243 temp
= gen_rtx_LABEL_REF (mode
, label_ref_label (x
));
4244 LABEL_REF_NONLOCAL_P (temp
) = LABEL_REF_NONLOCAL_P (x
);
4247 temp
= shallow_copy_rtx (x
);
4248 PUT_MODE (temp
, mode
);
4251 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
4253 temp
= gen_rtx_CONST (mode
, temp
);
4257 if (CONST_INT_P (XEXP (x
, 1)))
4259 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
4261 return gen_rtx_fmt_ee (GET_CODE (x
), mode
, temp
, XEXP (x
, 1));
4267 /* Don't know how to express ptr_extend as operation in debug info. */
4270 #endif /* POINTERS_EXTEND_UNSIGNED */
4275 /* Map from SSA_NAMEs to corresponding DEBUG_EXPR_DECLs created
4276 by avoid_deep_ter_for_debug. */
4278 static hash_map
<tree
, tree
> *deep_ter_debug_map
;
4280 /* Split too deep TER chains for debug stmts using debug temporaries. */
4283 avoid_deep_ter_for_debug (gimple
*stmt
, int depth
)
4285 use_operand_p use_p
;
4287 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
4289 tree use
= USE_FROM_PTR (use_p
);
4290 if (TREE_CODE (use
) != SSA_NAME
|| SSA_NAME_IS_DEFAULT_DEF (use
))
4292 gimple
*g
= get_gimple_for_ssa_name (use
);
4295 if (depth
> 6 && !stmt_ends_bb_p (g
))
4297 if (deep_ter_debug_map
== NULL
)
4298 deep_ter_debug_map
= new hash_map
<tree
, tree
>;
4300 tree
&vexpr
= deep_ter_debug_map
->get_or_insert (use
);
4303 vexpr
= make_node (DEBUG_EXPR_DECL
);
4304 gimple
*def_temp
= gimple_build_debug_bind (vexpr
, use
, g
);
4305 DECL_ARTIFICIAL (vexpr
) = 1;
4306 TREE_TYPE (vexpr
) = TREE_TYPE (use
);
4307 SET_DECL_MODE (vexpr
, TYPE_MODE (TREE_TYPE (use
)));
4308 gimple_stmt_iterator gsi
= gsi_for_stmt (g
);
4309 gsi_insert_after (&gsi
, def_temp
, GSI_NEW_STMT
);
4310 avoid_deep_ter_for_debug (def_temp
, 0);
4313 avoid_deep_ter_for_debug (g
, depth
+ 1);
4317 /* Return an RTX equivalent to the value of the parameter DECL. */
4320 expand_debug_parm_decl (tree decl
)
4322 rtx incoming
= DECL_INCOMING_RTL (decl
);
4325 && GET_MODE (incoming
) != BLKmode
4326 && ((REG_P (incoming
) && HARD_REGISTER_P (incoming
))
4327 || (MEM_P (incoming
)
4328 && REG_P (XEXP (incoming
, 0))
4329 && HARD_REGISTER_P (XEXP (incoming
, 0)))))
4331 rtx rtl
= gen_rtx_ENTRY_VALUE (GET_MODE (incoming
));
4333 #ifdef HAVE_window_save
4334 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
4335 If the target machine has an explicit window save instruction, the
4336 actual entry value is the corresponding OUTGOING_REGNO instead. */
4337 if (REG_P (incoming
)
4338 && OUTGOING_REGNO (REGNO (incoming
)) != REGNO (incoming
))
4340 = gen_rtx_REG_offset (incoming
, GET_MODE (incoming
),
4341 OUTGOING_REGNO (REGNO (incoming
)), 0);
4342 else if (MEM_P (incoming
))
4344 rtx reg
= XEXP (incoming
, 0);
4345 if (OUTGOING_REGNO (REGNO (reg
)) != REGNO (reg
))
4347 reg
= gen_raw_REG (GET_MODE (reg
), OUTGOING_REGNO (REGNO (reg
)));
4348 incoming
= replace_equiv_address_nv (incoming
, reg
);
4351 incoming
= copy_rtx (incoming
);
4355 ENTRY_VALUE_EXP (rtl
) = incoming
;
4360 && GET_MODE (incoming
) != BLKmode
4361 && !TREE_ADDRESSABLE (decl
)
4363 && (XEXP (incoming
, 0) == virtual_incoming_args_rtx
4364 || (GET_CODE (XEXP (incoming
, 0)) == PLUS
4365 && XEXP (XEXP (incoming
, 0), 0) == virtual_incoming_args_rtx
4366 && CONST_INT_P (XEXP (XEXP (incoming
, 0), 1)))))
4367 return copy_rtx (incoming
);
4372 /* Return an RTX equivalent to the value of the tree expression EXP. */
4375 expand_debug_expr (tree exp
)
4377 rtx op0
= NULL_RTX
, op1
= NULL_RTX
, op2
= NULL_RTX
;
4378 machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
4379 machine_mode inner_mode
= VOIDmode
;
4380 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (exp
));
4382 scalar_int_mode op0_mode
, op1_mode
, addr_mode
;
4384 switch (TREE_CODE_CLASS (TREE_CODE (exp
)))
4386 case tcc_expression
:
4387 switch (TREE_CODE (exp
))
4392 case WIDEN_MULT_PLUS_EXPR
:
4393 case WIDEN_MULT_MINUS_EXPR
:
4396 case TRUTH_ANDIF_EXPR
:
4397 case TRUTH_ORIF_EXPR
:
4398 case TRUTH_AND_EXPR
:
4400 case TRUTH_XOR_EXPR
:
4403 case TRUTH_NOT_EXPR
:
4412 op2
= expand_debug_expr (TREE_OPERAND (exp
, 2));
4419 if (mode
== BLKmode
)
4421 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
4424 switch (TREE_CODE (exp
))
4430 case WIDEN_LSHIFT_EXPR
:
4431 /* Ensure second operand isn't wider than the first one. */
4432 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 1)));
4433 if (is_a
<scalar_int_mode
> (inner_mode
, &op1_mode
)
4434 && (GET_MODE_UNIT_PRECISION (mode
)
4435 < GET_MODE_PRECISION (op1_mode
)))
4436 op1
= lowpart_subreg (GET_MODE_INNER (mode
), op1
, op1_mode
);
4445 if (mode
== BLKmode
)
4447 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4448 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4453 case tcc_comparison
:
4454 unsignedp
= TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4462 case tcc_exceptional
:
4463 case tcc_declaration
:
4469 switch (TREE_CODE (exp
))
4472 if (!lookup_constant_def (exp
))
4474 if (strlen (TREE_STRING_POINTER (exp
)) + 1
4475 != (size_t) TREE_STRING_LENGTH (exp
))
4477 op0
= gen_rtx_CONST_STRING (Pmode
, TREE_STRING_POINTER (exp
));
4478 op0
= gen_rtx_MEM (BLKmode
, op0
);
4479 set_mem_attributes (op0
, exp
, 0);
4487 op0
= expand_expr (exp
, NULL_RTX
, mode
, EXPAND_INITIALIZER
);
4491 return immed_wide_int_const (poly_int_cst_value (exp
), mode
);
4494 gcc_assert (COMPLEX_MODE_P (mode
));
4495 op0
= expand_debug_expr (TREE_REALPART (exp
));
4496 op1
= expand_debug_expr (TREE_IMAGPART (exp
));
4497 return gen_rtx_CONCAT (mode
, op0
, op1
);
4499 case DEBUG_EXPR_DECL
:
4500 op0
= DECL_RTL_IF_SET (exp
);
4505 op0
= gen_rtx_DEBUG_EXPR (mode
);
4506 DEBUG_EXPR_TREE_DECL (op0
) = exp
;
4507 SET_DECL_RTL (exp
, op0
);
4517 op0
= DECL_RTL_IF_SET (exp
);
4519 /* This decl was probably optimized away. */
4521 /* At least label RTXen are sometimes replaced by
4522 NOTE_INSN_DELETED_LABEL. Any notes here are not
4523 handled by copy_rtx. */
4527 || DECL_EXTERNAL (exp
)
4528 || !TREE_STATIC (exp
)
4530 || DECL_HARD_REGISTER (exp
)
4531 || DECL_IN_CONSTANT_POOL (exp
)
4532 || mode
== VOIDmode
)
4535 op0
= make_decl_rtl_for_debug (exp
);
4537 || GET_CODE (XEXP (op0
, 0)) != SYMBOL_REF
4538 || SYMBOL_REF_DECL (XEXP (op0
, 0)) != exp
)
4542 op0
= copy_rtx (op0
);
4544 if (GET_MODE (op0
) == BLKmode
4545 /* If op0 is not BLKmode, but mode is, adjust_mode
4546 below would ICE. While it is likely a FE bug,
4547 try to be robust here. See PR43166. */
4549 || (mode
== VOIDmode
&& GET_MODE (op0
) != VOIDmode
))
4551 gcc_assert (MEM_P (op0
));
4552 op0
= adjust_address_nv (op0
, mode
, 0);
4562 inner_mode
= GET_MODE (op0
);
4564 if (mode
== inner_mode
)
4567 if (inner_mode
== VOIDmode
)
4569 if (TREE_CODE (exp
) == SSA_NAME
)
4570 inner_mode
= TYPE_MODE (TREE_TYPE (exp
));
4572 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4573 if (mode
== inner_mode
)
4577 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
4579 if (GET_MODE_UNIT_BITSIZE (mode
)
4580 == GET_MODE_UNIT_BITSIZE (inner_mode
))
4581 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
4582 else if (GET_MODE_UNIT_BITSIZE (mode
)
4583 < GET_MODE_UNIT_BITSIZE (inner_mode
))
4584 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
4586 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
4588 else if (FLOAT_MODE_P (mode
))
4590 gcc_assert (TREE_CODE (exp
) != SSA_NAME
);
4591 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
4592 op0
= simplify_gen_unary (UNSIGNED_FLOAT
, mode
, op0
, inner_mode
);
4594 op0
= simplify_gen_unary (FLOAT
, mode
, op0
, inner_mode
);
4596 else if (FLOAT_MODE_P (inner_mode
))
4599 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
4601 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
4603 else if (GET_MODE_UNIT_PRECISION (mode
)
4604 == GET_MODE_UNIT_PRECISION (inner_mode
))
4605 op0
= lowpart_subreg (mode
, op0
, inner_mode
);
4606 else if (GET_MODE_UNIT_PRECISION (mode
)
4607 < GET_MODE_UNIT_PRECISION (inner_mode
))
4608 op0
= simplify_gen_unary (TRUNCATE
, mode
, op0
, inner_mode
);
4609 else if (UNARY_CLASS_P (exp
)
4610 ? TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)))
4612 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
4614 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
4620 if (!is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
4622 tree newexp
= fold_binary (MEM_REF
, TREE_TYPE (exp
),
4623 TREE_OPERAND (exp
, 0),
4624 TREE_OPERAND (exp
, 1));
4626 return expand_debug_expr (newexp
);
4630 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4631 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4635 if (TREE_CODE (exp
) == MEM_REF
)
4637 if (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
4638 || (GET_CODE (op0
) == PLUS
4639 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
))
4640 /* (mem (debug_implicit_ptr)) might confuse aliasing.
4641 Instead just use get_inner_reference. */
4644 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
4646 if (!op1
|| !poly_int_rtx_p (op1
, &offset
))
4649 op0
= plus_constant (inner_mode
, op0
, offset
);
4652 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))));
4654 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
4656 if (op0
== NULL_RTX
)
4659 op0
= gen_rtx_MEM (mode
, op0
);
4660 set_mem_attributes (op0
, exp
, 0);
4661 if (TREE_CODE (exp
) == MEM_REF
4662 && !is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
4663 set_mem_expr (op0
, NULL_TREE
);
4664 set_mem_addr_space (op0
, as
);
4668 case TARGET_MEM_REF
:
4669 if (TREE_CODE (TMR_BASE (exp
)) == ADDR_EXPR
4670 && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp
), 0)))
4673 op0
= expand_debug_expr
4674 (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp
)), exp
));
4678 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))));
4679 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
4681 if (op0
== NULL_RTX
)
4684 op0
= gen_rtx_MEM (mode
, op0
);
4686 set_mem_attributes (op0
, exp
, 0);
4687 set_mem_addr_space (op0
, as
);
4693 case ARRAY_RANGE_REF
:
4698 case VIEW_CONVERT_EXPR
:
4701 poly_int64 bitsize
, bitpos
;
4703 int reversep
, volatilep
= 0;
4705 = get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
, &mode1
,
4706 &unsignedp
, &reversep
, &volatilep
);
4709 if (known_eq (bitsize
, 0))
4712 orig_op0
= op0
= expand_debug_expr (tem
);
4719 machine_mode addrmode
, offmode
;
4724 op0
= XEXP (op0
, 0);
4725 addrmode
= GET_MODE (op0
);
4726 if (addrmode
== VOIDmode
)
4729 op1
= expand_debug_expr (offset
);
4733 offmode
= GET_MODE (op1
);
4734 if (offmode
== VOIDmode
)
4735 offmode
= TYPE_MODE (TREE_TYPE (offset
));
4737 if (addrmode
!= offmode
)
4738 op1
= lowpart_subreg (addrmode
, op1
, offmode
);
4740 /* Don't use offset_address here, we don't need a
4741 recognizable address, and we don't want to generate
4743 op0
= gen_rtx_MEM (mode
, simplify_gen_binary (PLUS
, addrmode
,
4749 if (mode1
== VOIDmode
)
4751 if (maybe_gt (bitsize
, MAX_BITSIZE_MODE_ANY_INT
))
4754 mode1
= smallest_int_mode_for_size (bitsize
);
4756 poly_int64 bytepos
= bits_to_bytes_round_down (bitpos
);
4757 if (maybe_ne (bytepos
, 0))
4759 op0
= adjust_address_nv (op0
, mode1
, bytepos
);
4760 bitpos
= num_trailing_bits (bitpos
);
4762 else if (known_eq (bitpos
, 0)
4763 && known_eq (bitsize
, GET_MODE_BITSIZE (mode
)))
4764 op0
= adjust_address_nv (op0
, mode
, 0);
4765 else if (GET_MODE (op0
) != mode1
)
4766 op0
= adjust_address_nv (op0
, mode1
, 0);
4768 op0
= copy_rtx (op0
);
4769 if (op0
== orig_op0
)
4770 op0
= shallow_copy_rtx (op0
);
4771 if (TREE_CODE (tem
) != SSA_NAME
)
4772 set_mem_attributes (op0
, exp
, 0);
4775 if (known_eq (bitpos
, 0) && mode
== GET_MODE (op0
))
4778 if (maybe_lt (bitpos
, 0))
4781 if (GET_MODE (op0
) == BLKmode
|| mode
== BLKmode
)
4785 if (multiple_p (bitpos
, BITS_PER_UNIT
, &bytepos
)
4786 && known_eq (bitsize
, GET_MODE_BITSIZE (mode1
)))
4788 machine_mode opmode
= GET_MODE (op0
);
4790 if (opmode
== VOIDmode
)
4791 opmode
= TYPE_MODE (TREE_TYPE (tem
));
4793 /* This condition may hold if we're expanding the address
4794 right past the end of an array that turned out not to
4795 be addressable (i.e., the address was only computed in
4796 debug stmts). The gen_subreg below would rightfully
4797 crash, and the address doesn't really exist, so just
4799 if (known_ge (bitpos
, GET_MODE_BITSIZE (opmode
)))
4802 if (multiple_p (bitpos
, GET_MODE_BITSIZE (mode
)))
4803 return simplify_gen_subreg (mode
, op0
, opmode
, bytepos
);
4806 return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0
))
4807 && TYPE_UNSIGNED (TREE_TYPE (exp
))
4809 : ZERO_EXTRACT
, mode
,
4810 GET_MODE (op0
) != VOIDmode
4812 : TYPE_MODE (TREE_TYPE (tem
)),
4813 op0
, gen_int_mode (bitsize
, word_mode
),
4814 gen_int_mode (bitpos
, word_mode
));
4819 return simplify_gen_unary (ABS
, mode
, op0
, mode
);
4822 return simplify_gen_unary (NEG
, mode
, op0
, mode
);
4825 return simplify_gen_unary (NOT
, mode
, op0
, mode
);
4828 return simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4830 ? UNSIGNED_FLOAT
: FLOAT
, mode
, op0
,
4833 case FIX_TRUNC_EXPR
:
4834 return simplify_gen_unary (unsignedp
? UNSIGNED_FIX
: FIX
, mode
, op0
,
4837 case POINTER_PLUS_EXPR
:
4838 /* For the rare target where pointers are not the same size as
4839 size_t, we need to check for mis-matched modes and correct
4842 && is_a
<scalar_int_mode
> (GET_MODE (op0
), &op0_mode
)
4843 && is_a
<scalar_int_mode
> (GET_MODE (op1
), &op1_mode
)
4844 && op0_mode
!= op1_mode
)
4846 if (GET_MODE_BITSIZE (op0_mode
) < GET_MODE_BITSIZE (op1_mode
)
4847 /* If OP0 is a partial mode, then we must truncate, even
4848 if it has the same bitsize as OP1 as GCC's
4849 representation of partial modes is opaque. */
4850 || (GET_MODE_CLASS (op0_mode
) == MODE_PARTIAL_INT
4851 && (GET_MODE_BITSIZE (op0_mode
)
4852 == GET_MODE_BITSIZE (op1_mode
))))
4853 op1
= simplify_gen_unary (TRUNCATE
, op0_mode
, op1
, op1_mode
);
4855 /* We always sign-extend, regardless of the signedness of
4856 the operand, because the operand is always unsigned
4857 here even if the original C expression is signed. */
4858 op1
= simplify_gen_unary (SIGN_EXTEND
, op0_mode
, op1
, op1_mode
);
4862 return simplify_gen_binary (PLUS
, mode
, op0
, op1
);
4865 case POINTER_DIFF_EXPR
:
4866 return simplify_gen_binary (MINUS
, mode
, op0
, op1
);
4869 return simplify_gen_binary (MULT
, mode
, op0
, op1
);
4872 case TRUNC_DIV_EXPR
:
4873 case EXACT_DIV_EXPR
:
4875 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4877 return simplify_gen_binary (DIV
, mode
, op0
, op1
);
4879 case TRUNC_MOD_EXPR
:
4880 return simplify_gen_binary (unsignedp
? UMOD
: MOD
, mode
, op0
, op1
);
4882 case FLOOR_DIV_EXPR
:
4884 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4887 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4888 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4889 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4890 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4893 case FLOOR_MOD_EXPR
:
4895 return simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4898 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4899 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4900 adj
= simplify_gen_unary (NEG
, mode
,
4901 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4903 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4909 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4910 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4911 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4912 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4916 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4917 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4918 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4919 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4925 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4926 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4927 adj
= simplify_gen_unary (NEG
, mode
,
4928 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4930 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4934 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4935 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4936 adj
= simplify_gen_unary (NEG
, mode
,
4937 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4939 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4942 case ROUND_DIV_EXPR
:
4945 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4946 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4947 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4948 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4952 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4953 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4954 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4955 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4958 case ROUND_MOD_EXPR
:
4961 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4962 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4963 adj
= simplify_gen_unary (NEG
, mode
,
4964 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4966 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4970 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4971 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4972 adj
= simplify_gen_unary (NEG
, mode
,
4973 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4975 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4979 return simplify_gen_binary (ASHIFT
, mode
, op0
, op1
);
4983 return simplify_gen_binary (LSHIFTRT
, mode
, op0
, op1
);
4985 return simplify_gen_binary (ASHIFTRT
, mode
, op0
, op1
);
4988 return simplify_gen_binary (ROTATE
, mode
, op0
, op1
);
4991 return simplify_gen_binary (ROTATERT
, mode
, op0
, op1
);
4994 return simplify_gen_binary (unsignedp
? UMIN
: SMIN
, mode
, op0
, op1
);
4997 return simplify_gen_binary (unsignedp
? UMAX
: SMAX
, mode
, op0
, op1
);
5000 case TRUTH_AND_EXPR
:
5001 return simplify_gen_binary (AND
, mode
, op0
, op1
);
5005 return simplify_gen_binary (IOR
, mode
, op0
, op1
);
5008 case TRUTH_XOR_EXPR
:
5009 return simplify_gen_binary (XOR
, mode
, op0
, op1
);
5011 case TRUTH_ANDIF_EXPR
:
5012 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, const0_rtx
);
5014 case TRUTH_ORIF_EXPR
:
5015 return gen_rtx_IF_THEN_ELSE (mode
, op0
, const_true_rtx
, op1
);
5017 case TRUTH_NOT_EXPR
:
5018 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, const0_rtx
);
5021 return simplify_gen_relational (unsignedp
? LTU
: LT
, mode
, inner_mode
,
5025 return simplify_gen_relational (unsignedp
? LEU
: LE
, mode
, inner_mode
,
5029 return simplify_gen_relational (unsignedp
? GTU
: GT
, mode
, inner_mode
,
5033 return simplify_gen_relational (unsignedp
? GEU
: GE
, mode
, inner_mode
,
5037 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, op1
);
5040 return simplify_gen_relational (NE
, mode
, inner_mode
, op0
, op1
);
5042 case UNORDERED_EXPR
:
5043 return simplify_gen_relational (UNORDERED
, mode
, inner_mode
, op0
, op1
);
5046 return simplify_gen_relational (ORDERED
, mode
, inner_mode
, op0
, op1
);
5049 return simplify_gen_relational (UNLT
, mode
, inner_mode
, op0
, op1
);
5052 return simplify_gen_relational (UNLE
, mode
, inner_mode
, op0
, op1
);
5055 return simplify_gen_relational (UNGT
, mode
, inner_mode
, op0
, op1
);
5058 return simplify_gen_relational (UNGE
, mode
, inner_mode
, op0
, op1
);
5061 return simplify_gen_relational (UNEQ
, mode
, inner_mode
, op0
, op1
);
5064 return simplify_gen_relational (LTGT
, mode
, inner_mode
, op0
, op1
);
5067 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, op2
);
5070 gcc_assert (COMPLEX_MODE_P (mode
));
5071 if (GET_MODE (op0
) == VOIDmode
)
5072 op0
= gen_rtx_CONST (GET_MODE_INNER (mode
), op0
);
5073 if (GET_MODE (op1
) == VOIDmode
)
5074 op1
= gen_rtx_CONST (GET_MODE_INNER (mode
), op1
);
5075 return gen_rtx_CONCAT (mode
, op0
, op1
);
5078 if (GET_CODE (op0
) == CONCAT
)
5079 return gen_rtx_CONCAT (mode
, XEXP (op0
, 0),
5080 simplify_gen_unary (NEG
, GET_MODE_INNER (mode
),
5082 GET_MODE_INNER (mode
)));
5085 scalar_mode imode
= GET_MODE_INNER (mode
);
5090 re
= adjust_address_nv (op0
, imode
, 0);
5091 im
= adjust_address_nv (op0
, imode
, GET_MODE_SIZE (imode
));
5095 scalar_int_mode ifmode
;
5096 scalar_int_mode ihmode
;
5098 if (!int_mode_for_mode (mode
).exists (&ifmode
)
5099 || !int_mode_for_mode (imode
).exists (&ihmode
))
5101 halfsize
= GEN_INT (GET_MODE_BITSIZE (ihmode
));
5104 re
= gen_rtx_SUBREG (ifmode
, re
, 0);
5105 re
= gen_rtx_ZERO_EXTRACT (ihmode
, re
, halfsize
, const0_rtx
);
5106 if (imode
!= ihmode
)
5107 re
= gen_rtx_SUBREG (imode
, re
, 0);
5108 im
= copy_rtx (op0
);
5110 im
= gen_rtx_SUBREG (ifmode
, im
, 0);
5111 im
= gen_rtx_ZERO_EXTRACT (ihmode
, im
, halfsize
, halfsize
);
5112 if (imode
!= ihmode
)
5113 im
= gen_rtx_SUBREG (imode
, im
, 0);
5115 im
= gen_rtx_NEG (imode
, im
);
5116 return gen_rtx_CONCAT (mode
, re
, im
);
5120 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
5121 if (!op0
|| !MEM_P (op0
))
5123 if ((TREE_CODE (TREE_OPERAND (exp
, 0)) == VAR_DECL
5124 || TREE_CODE (TREE_OPERAND (exp
, 0)) == PARM_DECL
5125 || TREE_CODE (TREE_OPERAND (exp
, 0)) == RESULT_DECL
)
5126 && (!TREE_ADDRESSABLE (TREE_OPERAND (exp
, 0))
5127 || target_for_debug_bind (TREE_OPERAND (exp
, 0))))
5128 return gen_rtx_DEBUG_IMPLICIT_PTR (mode
, TREE_OPERAND (exp
, 0));
5130 if (handled_component_p (TREE_OPERAND (exp
, 0)))
5132 poly_int64 bitoffset
, bitsize
, maxsize
, byteoffset
;
5135 = get_ref_base_and_extent (TREE_OPERAND (exp
, 0), &bitoffset
,
5136 &bitsize
, &maxsize
, &reverse
);
5138 || TREE_CODE (decl
) == PARM_DECL
5139 || TREE_CODE (decl
) == RESULT_DECL
)
5140 && (!TREE_ADDRESSABLE (decl
)
5141 || target_for_debug_bind (decl
))
5142 && multiple_p (bitoffset
, BITS_PER_UNIT
, &byteoffset
)
5143 && known_gt (bitsize
, 0)
5144 && known_eq (bitsize
, maxsize
))
5146 rtx base
= gen_rtx_DEBUG_IMPLICIT_PTR (mode
, decl
);
5147 return plus_constant (mode
, base
, byteoffset
);
5151 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == MEM_REF
5152 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
5155 op0
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
5158 && (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
5159 || (GET_CODE (op0
) == PLUS
5160 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
5161 && CONST_INT_P (XEXP (op0
, 1)))))
5163 op1
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
5166 if (!op1
|| !poly_int_rtx_p (op1
, &offset
))
5169 return plus_constant (mode
, op0
, offset
);
5176 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)));
5177 addr_mode
= SCALAR_INT_TYPE_MODE (TREE_TYPE (exp
));
5178 op0
= convert_debug_memory_address (addr_mode
, XEXP (op0
, 0), as
);
5184 unsigned HOST_WIDE_INT i
, nelts
;
5186 if (!VECTOR_CST_NELTS (exp
).is_constant (&nelts
))
5189 op0
= gen_rtx_CONCATN (mode
, rtvec_alloc (nelts
));
5191 for (i
= 0; i
< nelts
; ++i
)
5193 op1
= expand_debug_expr (VECTOR_CST_ELT (exp
, i
));
5196 XVECEXP (op0
, 0, i
) = op1
;
5203 if (TREE_CLOBBER_P (exp
))
5205 else if (TREE_CODE (TREE_TYPE (exp
)) == VECTOR_TYPE
)
5208 unsigned HOST_WIDE_INT nelts
;
5211 if (!TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)).is_constant (&nelts
))
5212 goto flag_unsupported
;
5214 op0
= gen_rtx_CONCATN (mode
, rtvec_alloc (nelts
));
5216 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), i
, val
)
5218 op1
= expand_debug_expr (val
);
5221 XVECEXP (op0
, 0, i
) = op1
;
5226 op1
= expand_debug_expr
5227 (build_zero_cst (TREE_TYPE (TREE_TYPE (exp
))));
5232 for (; i
< nelts
; i
++)
5233 XVECEXP (op0
, 0, i
) = op1
;
5239 goto flag_unsupported
;
5242 /* ??? Maybe handle some builtins? */
5247 gimple
*g
= get_gimple_for_ssa_name (exp
);
5251 if (deep_ter_debug_map
)
5253 tree
*slot
= deep_ter_debug_map
->get (exp
);
5258 t
= gimple_assign_rhs_to_tree (g
);
5259 op0
= expand_debug_expr (t
);
5265 /* If this is a reference to an incoming value of
5266 parameter that is never used in the code or where the
5267 incoming value is never used in the code, use
5268 PARM_DECL's DECL_RTL if set. */
5269 if (SSA_NAME_IS_DEFAULT_DEF (exp
)
5270 && SSA_NAME_VAR (exp
)
5271 && TREE_CODE (SSA_NAME_VAR (exp
)) == PARM_DECL
5272 && has_zero_uses (exp
))
5274 op0
= expand_debug_parm_decl (SSA_NAME_VAR (exp
));
5277 op0
= expand_debug_expr (SSA_NAME_VAR (exp
));
5282 int part
= var_to_partition (SA
.map
, exp
);
5284 if (part
== NO_PARTITION
)
5287 gcc_assert (part
>= 0 && (unsigned)part
< SA
.map
->num_partitions
);
5289 op0
= copy_rtx (SA
.partition_to_pseudo
[part
]);
5297 /* Vector stuff. For most of the codes we don't have rtl codes. */
5298 case REALIGN_LOAD_EXPR
:
5300 case VEC_PACK_FIX_TRUNC_EXPR
:
5301 case VEC_PACK_FLOAT_EXPR
:
5302 case VEC_PACK_SAT_EXPR
:
5303 case VEC_PACK_TRUNC_EXPR
:
5304 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
5305 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
5306 case VEC_UNPACK_FLOAT_HI_EXPR
:
5307 case VEC_UNPACK_FLOAT_LO_EXPR
:
5308 case VEC_UNPACK_HI_EXPR
:
5309 case VEC_UNPACK_LO_EXPR
:
5310 case VEC_WIDEN_MULT_HI_EXPR
:
5311 case VEC_WIDEN_MULT_LO_EXPR
:
5312 case VEC_WIDEN_MULT_EVEN_EXPR
:
5313 case VEC_WIDEN_MULT_ODD_EXPR
:
5314 case VEC_WIDEN_LSHIFT_HI_EXPR
:
5315 case VEC_WIDEN_LSHIFT_LO_EXPR
:
5317 case VEC_DUPLICATE_EXPR
:
5318 case VEC_SERIES_EXPR
:
5323 case ADDR_SPACE_CONVERT_EXPR
:
5324 case FIXED_CONVERT_EXPR
:
5326 case WITH_SIZE_EXPR
:
5327 case BIT_INSERT_EXPR
:
5331 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5332 && SCALAR_INT_MODE_P (mode
))
5335 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5337 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
5340 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5342 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op1
,
5344 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
5345 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
5349 case WIDEN_MULT_EXPR
:
5350 case WIDEN_MULT_PLUS_EXPR
:
5351 case WIDEN_MULT_MINUS_EXPR
:
5352 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5353 && SCALAR_INT_MODE_P (mode
))
5355 inner_mode
= GET_MODE (op0
);
5356 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
5357 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
5359 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
5360 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 1))))
5361 op1
= simplify_gen_unary (ZERO_EXTEND
, mode
, op1
, inner_mode
);
5363 op1
= simplify_gen_unary (SIGN_EXTEND
, mode
, op1
, inner_mode
);
5364 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
5365 if (TREE_CODE (exp
) == WIDEN_MULT_EXPR
)
5367 else if (TREE_CODE (exp
) == WIDEN_MULT_PLUS_EXPR
)
5368 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
5370 return simplify_gen_binary (MINUS
, mode
, op2
, op0
);
5374 case MULT_HIGHPART_EXPR
:
5375 /* ??? Similar to the above. */
5378 case WIDEN_SUM_EXPR
:
5379 case WIDEN_LSHIFT_EXPR
:
5380 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5381 && SCALAR_INT_MODE_P (mode
))
5384 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5386 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
5388 return simplify_gen_binary (TREE_CODE (exp
) == WIDEN_LSHIFT_EXPR
5389 ? ASHIFT
: PLUS
, mode
, op0
, op1
);
5404 /* Return an RTX equivalent to the source bind value of the tree expression
5408 expand_debug_source_expr (tree exp
)
5411 machine_mode mode
= VOIDmode
, inner_mode
;
5413 switch (TREE_CODE (exp
))
5416 if (DECL_ABSTRACT_ORIGIN (exp
))
5417 return expand_debug_source_expr (DECL_ABSTRACT_ORIGIN (exp
));
5421 mode
= DECL_MODE (exp
);
5422 op0
= expand_debug_parm_decl (exp
);
5425 /* See if this isn't an argument that has been completely
5427 if (!DECL_RTL_SET_P (exp
)
5428 && !DECL_INCOMING_RTL (exp
)
5429 && DECL_ABSTRACT_ORIGIN (current_function_decl
))
5431 tree aexp
= DECL_ORIGIN (exp
);
5432 if (DECL_CONTEXT (aexp
)
5433 == DECL_ABSTRACT_ORIGIN (current_function_decl
))
5435 vec
<tree
, va_gc
> **debug_args
;
5438 debug_args
= decl_debug_args_lookup (current_function_decl
);
5439 if (debug_args
!= NULL
)
5441 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, &ddecl
);
5444 return gen_rtx_DEBUG_PARAMETER_REF (mode
, aexp
);
5454 if (op0
== NULL_RTX
)
5457 inner_mode
= GET_MODE (op0
);
5458 if (mode
== inner_mode
)
5461 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
5463 if (GET_MODE_UNIT_BITSIZE (mode
)
5464 == GET_MODE_UNIT_BITSIZE (inner_mode
))
5465 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
5466 else if (GET_MODE_UNIT_BITSIZE (mode
)
5467 < GET_MODE_UNIT_BITSIZE (inner_mode
))
5468 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
5470 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
5472 else if (FLOAT_MODE_P (mode
))
5474 else if (FLOAT_MODE_P (inner_mode
))
5476 if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
5477 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
5479 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
5481 else if (GET_MODE_UNIT_PRECISION (mode
)
5482 == GET_MODE_UNIT_PRECISION (inner_mode
))
5483 op0
= lowpart_subreg (mode
, op0
, inner_mode
);
5484 else if (GET_MODE_UNIT_PRECISION (mode
)
5485 < GET_MODE_UNIT_PRECISION (inner_mode
))
5486 op0
= simplify_gen_unary (TRUNCATE
, mode
, op0
, inner_mode
);
5487 else if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
5488 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
5490 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
5495 /* Ensure INSN_VAR_LOCATION_LOC (insn) doesn't have unbound complexity.
5496 Allow 4 levels of rtl nesting for most rtl codes, and if we see anything
5497 deeper than that, create DEBUG_EXPRs and emit DEBUG_INSNs before INSN. */
5500 avoid_complex_debug_insns (rtx_insn
*insn
, rtx
*exp_p
, int depth
)
5504 if (exp
== NULL_RTX
)
5507 if ((OBJECT_P (exp
) && !MEM_P (exp
)) || GET_CODE (exp
) == CLOBBER
)
5512 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
5513 rtx dval
= make_debug_expr_from_rtl (exp
);
5515 /* Emit a debug bind insn before INSN. */
5516 rtx bind
= gen_rtx_VAR_LOCATION (GET_MODE (exp
),
5517 DEBUG_EXPR_TREE_DECL (dval
), exp
,
5518 VAR_INIT_STATUS_INITIALIZED
);
5520 emit_debug_insn_before (bind
, insn
);
5525 const char *format_ptr
= GET_RTX_FORMAT (GET_CODE (exp
));
5527 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
5528 switch (*format_ptr
++)
5531 avoid_complex_debug_insns (insn
, &XEXP (exp
, i
), depth
+ 1);
5536 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
5537 avoid_complex_debug_insns (insn
, &XVECEXP (exp
, i
, j
), depth
+ 1);
5545 /* Expand the _LOCs in debug insns. We run this after expanding all
5546 regular insns, so that any variables referenced in the function
5547 will have their DECL_RTLs set. */
5550 expand_debug_locations (void)
5553 rtx_insn
*last
= get_last_insn ();
5554 int save_strict_alias
= flag_strict_aliasing
;
5556 /* New alias sets while setting up memory attributes cause
5557 -fcompare-debug failures, even though it doesn't bring about any
5559 flag_strict_aliasing
= 0;
5561 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
5562 if (DEBUG_BIND_INSN_P (insn
))
5564 tree value
= (tree
)INSN_VAR_LOCATION_LOC (insn
);
5566 rtx_insn
*prev_insn
, *insn2
;
5569 if (value
== NULL_TREE
)
5573 if (INSN_VAR_LOCATION_STATUS (insn
)
5574 == VAR_INIT_STATUS_UNINITIALIZED
)
5575 val
= expand_debug_source_expr (value
);
5576 /* The avoid_deep_ter_for_debug function inserts
5577 debug bind stmts after SSA_NAME definition, with the
5578 SSA_NAME as the whole bind location. Disable temporarily
5579 expansion of that SSA_NAME into the DEBUG_EXPR_DECL
5580 being defined in this DEBUG_INSN. */
5581 else if (deep_ter_debug_map
&& TREE_CODE (value
) == SSA_NAME
)
5583 tree
*slot
= deep_ter_debug_map
->get (value
);
5586 if (*slot
== INSN_VAR_LOCATION_DECL (insn
))
5591 val
= expand_debug_expr (value
);
5593 *slot
= INSN_VAR_LOCATION_DECL (insn
);
5596 val
= expand_debug_expr (value
);
5597 gcc_assert (last
== get_last_insn ());
5601 val
= gen_rtx_UNKNOWN_VAR_LOC ();
5604 mode
= GET_MODE (INSN_VAR_LOCATION (insn
));
5606 gcc_assert (mode
== GET_MODE (val
)
5607 || (GET_MODE (val
) == VOIDmode
5608 && (CONST_SCALAR_INT_P (val
)
5609 || GET_CODE (val
) == CONST_FIXED
5610 || GET_CODE (val
) == LABEL_REF
)));
5613 INSN_VAR_LOCATION_LOC (insn
) = val
;
5614 prev_insn
= PREV_INSN (insn
);
5615 for (insn2
= insn
; insn2
!= prev_insn
; insn2
= PREV_INSN (insn2
))
5616 avoid_complex_debug_insns (insn2
, &INSN_VAR_LOCATION_LOC (insn2
), 0);
5619 flag_strict_aliasing
= save_strict_alias
;
5622 /* Performs swapping operands of commutative operations to expand
5623 the expensive one first. */
5626 reorder_operands (basic_block bb
)
5628 unsigned int *lattice
; /* Hold cost of each statement. */
5629 unsigned int i
= 0, n
= 0;
5630 gimple_stmt_iterator gsi
;
5636 use_operand_p use_p
;
5637 gimple
*def0
, *def1
;
5639 /* Compute cost of each statement using estimate_num_insns. */
5640 stmts
= bb_seq (bb
);
5641 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5643 stmt
= gsi_stmt (gsi
);
5644 if (!is_gimple_debug (stmt
))
5645 gimple_set_uid (stmt
, n
++);
5647 lattice
= XNEWVEC (unsigned int, n
);
5648 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5651 stmt
= gsi_stmt (gsi
);
5652 if (is_gimple_debug (stmt
))
5654 cost
= estimate_num_insns (stmt
, &eni_size_weights
);
5656 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
5658 tree use
= USE_FROM_PTR (use_p
);
5660 if (TREE_CODE (use
) != SSA_NAME
)
5662 def_stmt
= get_gimple_for_ssa_name (use
);
5665 lattice
[i
] += lattice
[gimple_uid (def_stmt
)];
5668 if (!is_gimple_assign (stmt
)
5669 || !commutative_tree_code (gimple_assign_rhs_code (stmt
)))
5671 op0
= gimple_op (stmt
, 1);
5672 op1
= gimple_op (stmt
, 2);
5673 if (TREE_CODE (op0
) != SSA_NAME
5674 || TREE_CODE (op1
) != SSA_NAME
)
5676 /* Swap operands if the second one is more expensive. */
5677 def0
= get_gimple_for_ssa_name (op0
);
5678 def1
= get_gimple_for_ssa_name (op1
);
5682 if (!def0
|| lattice
[gimple_uid (def1
)] > lattice
[gimple_uid (def0
)])
5686 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5688 fprintf (dump_file
, "Swap operands in stmt:\n");
5689 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
5690 fprintf (dump_file
, "Cost left opnd=%d, right opnd=%d\n",
5691 def0
? lattice
[gimple_uid (def0
)] : 0,
5692 lattice
[gimple_uid (def1
)]);
5694 swap_ssa_operands (stmt
, gimple_assign_rhs1_ptr (stmt
),
5695 gimple_assign_rhs2_ptr (stmt
));
5701 /* Expand basic block BB from GIMPLE trees to RTL. */
5704 expand_gimple_basic_block (basic_block bb
, bool disable_tail_calls
)
5706 gimple_stmt_iterator gsi
;
5708 gimple
*stmt
= NULL
;
5709 rtx_note
*note
= NULL
;
5715 fprintf (dump_file
, "\n;; Generating RTL for gimple basic block %d\n",
5718 /* Note that since we are now transitioning from GIMPLE to RTL, we
5719 cannot use the gsi_*_bb() routines because they expect the basic
5720 block to be in GIMPLE, instead of RTL. Therefore, we need to
5721 access the BB sequence directly. */
5723 reorder_operands (bb
);
5724 stmts
= bb_seq (bb
);
5725 bb
->il
.gimple
.seq
= NULL
;
5726 bb
->il
.gimple
.phi_nodes
= NULL
;
5727 rtl_profile_for_bb (bb
);
5728 init_rtl_bb_info (bb
);
5729 bb
->flags
|= BB_RTL
;
5731 /* Remove the RETURN_EXPR if we may fall though to the exit
5733 gsi
= gsi_last (stmts
);
5734 if (!gsi_end_p (gsi
)
5735 && gimple_code (gsi_stmt (gsi
)) == GIMPLE_RETURN
)
5737 greturn
*ret_stmt
= as_a
<greturn
*> (gsi_stmt (gsi
));
5739 gcc_assert (single_succ_p (bb
));
5740 gcc_assert (single_succ (bb
) == EXIT_BLOCK_PTR_FOR_FN (cfun
));
5742 if (bb
->next_bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
)
5743 && !gimple_return_retval (ret_stmt
))
5745 gsi_remove (&gsi
, false);
5746 single_succ_edge (bb
)->flags
|= EDGE_FALLTHRU
;
5750 gsi
= gsi_start (stmts
);
5751 if (!gsi_end_p (gsi
))
5753 stmt
= gsi_stmt (gsi
);
5754 if (gimple_code (stmt
) != GIMPLE_LABEL
)
5758 rtx_code_label
**elt
= lab_rtx_for_bb
->get (bb
);
5762 gcc_checking_assert (!note
);
5763 last
= get_last_insn ();
5767 expand_gimple_stmt (stmt
);
5774 BB_HEAD (bb
) = NEXT_INSN (last
);
5775 if (NOTE_P (BB_HEAD (bb
)))
5776 BB_HEAD (bb
) = NEXT_INSN (BB_HEAD (bb
));
5777 gcc_assert (LABEL_P (BB_HEAD (bb
)));
5778 note
= emit_note_after (NOTE_INSN_BASIC_BLOCK
, BB_HEAD (bb
));
5780 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5783 BB_HEAD (bb
) = note
= emit_note (NOTE_INSN_BASIC_BLOCK
);
5786 NOTE_BASIC_BLOCK (note
) = bb
;
5788 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
5792 stmt
= gsi_stmt (gsi
);
5794 /* If this statement is a non-debug one, and we generate debug
5795 insns, then this one might be the last real use of a TERed
5796 SSA_NAME, but where there are still some debug uses further
5797 down. Expanding the current SSA name in such further debug
5798 uses by their RHS might lead to wrong debug info, as coalescing
5799 might make the operands of such RHS be placed into the same
5800 pseudo as something else. Like so:
5801 a_1 = a_0 + 1; // Assume a_1 is TERed and a_0 is dead
5805 As a_0 and a_2 don't overlap in lifetime, assume they are coalesced.
5806 If we now would expand a_1 by it's RHS (a_0 + 1) in the debug use,
5807 the write to a_2 would actually have clobbered the place which
5810 So, instead of that, we recognize the situation, and generate
5811 debug temporaries at the last real use of TERed SSA names:
5818 if (MAY_HAVE_DEBUG_BIND_INSNS
5820 && !is_gimple_debug (stmt
))
5826 location_t sloc
= curr_insn_location ();
5828 /* Look for SSA names that have their last use here (TERed
5829 names always have only one real use). */
5830 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
)
5831 if ((def
= get_gimple_for_ssa_name (op
)))
5833 imm_use_iterator imm_iter
;
5834 use_operand_p use_p
;
5835 bool have_debug_uses
= false;
5837 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, op
)
5839 if (gimple_debug_bind_p (USE_STMT (use_p
)))
5841 have_debug_uses
= true;
5846 if (have_debug_uses
)
5848 /* OP is a TERed SSA name, with DEF its defining
5849 statement, and where OP is used in further debug
5850 instructions. Generate a debug temporary, and
5851 replace all uses of OP in debug insns with that
5854 tree value
= gimple_assign_rhs_to_tree (def
);
5855 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
5859 set_curr_insn_location (gimple_location (def
));
5861 DECL_ARTIFICIAL (vexpr
) = 1;
5862 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
5864 mode
= DECL_MODE (value
);
5866 mode
= TYPE_MODE (TREE_TYPE (value
));
5867 SET_DECL_MODE (vexpr
, mode
);
5869 val
= gen_rtx_VAR_LOCATION
5870 (mode
, vexpr
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5872 emit_debug_insn (val
);
5874 FOR_EACH_IMM_USE_STMT (debugstmt
, imm_iter
, op
)
5876 if (!gimple_debug_bind_p (debugstmt
))
5879 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
5880 SET_USE (use_p
, vexpr
);
5882 update_stmt (debugstmt
);
5886 set_curr_insn_location (sloc
);
5889 currently_expanding_gimple_stmt
= stmt
;
5891 /* Expand this statement, then evaluate the resulting RTL and
5892 fixup the CFG accordingly. */
5893 if (gimple_code (stmt
) == GIMPLE_COND
)
5895 new_bb
= expand_gimple_cond (bb
, as_a
<gcond
*> (stmt
));
5899 else if (is_gimple_debug (stmt
))
5901 location_t sloc
= curr_insn_location ();
5902 gimple_stmt_iterator nsi
= gsi
;
5907 tree value
= NULL_TREE
;
5911 if (!gimple_debug_nonbind_marker_p (stmt
))
5913 if (gimple_debug_bind_p (stmt
))
5915 var
= gimple_debug_bind_get_var (stmt
);
5917 if (TREE_CODE (var
) != DEBUG_EXPR_DECL
5918 && TREE_CODE (var
) != LABEL_DECL
5919 && !target_for_debug_bind (var
))
5920 goto delink_debug_stmt
;
5923 mode
= DECL_MODE (var
);
5925 mode
= TYPE_MODE (TREE_TYPE (var
));
5927 if (gimple_debug_bind_has_value_p (stmt
))
5928 value
= gimple_debug_bind_get_value (stmt
);
5930 val
= gen_rtx_VAR_LOCATION
5931 (mode
, var
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5933 else if (gimple_debug_source_bind_p (stmt
))
5935 var
= gimple_debug_source_bind_get_var (stmt
);
5937 value
= gimple_debug_source_bind_get_value (stmt
);
5939 mode
= DECL_MODE (var
);
5941 val
= gen_rtx_VAR_LOCATION (mode
, var
, (rtx
)value
,
5942 VAR_INIT_STATUS_UNINITIALIZED
);
5947 /* If this function was first compiled with markers
5948 enabled, but they're now disable (e.g. LTO), drop
5949 them on the floor. */
5950 else if (gimple_debug_nonbind_marker_p (stmt
)
5951 && !MAY_HAVE_DEBUG_MARKER_INSNS
)
5952 goto delink_debug_stmt
;
5953 else if (gimple_debug_begin_stmt_p (stmt
))
5954 val
= GEN_RTX_DEBUG_MARKER_BEGIN_STMT_PAT ();
5955 else if (gimple_debug_inline_entry_p (stmt
))
5957 tree block
= gimple_block (stmt
);
5960 val
= GEN_RTX_DEBUG_MARKER_INLINE_ENTRY_PAT ();
5962 goto delink_debug_stmt
;
5967 last
= get_last_insn ();
5969 set_curr_insn_location (gimple_location (stmt
));
5971 emit_debug_insn (val
);
5973 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5975 /* We can't dump the insn with a TREE where an RTX
5977 if (GET_CODE (val
) == VAR_LOCATION
)
5979 gcc_checking_assert (PAT_VAR_LOCATION_LOC (val
) == (rtx
)value
);
5980 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
5982 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5983 if (GET_CODE (val
) == VAR_LOCATION
)
5984 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
5988 /* In order not to generate too many debug temporaries,
5989 we delink all uses of debug statements we already expanded.
5990 Therefore debug statements between definition and real
5991 use of TERed SSA names will continue to use the SSA name,
5992 and not be replaced with debug temps. */
5993 delink_stmt_imm_use (stmt
);
5997 if (gsi_end_p (nsi
))
5999 stmt
= gsi_stmt (nsi
);
6000 if (!is_gimple_debug (stmt
))
6004 set_curr_insn_location (sloc
);
6008 gcall
*call_stmt
= dyn_cast
<gcall
*> (stmt
);
6010 && gimple_call_tail_p (call_stmt
)
6011 && disable_tail_calls
)
6012 gimple_call_set_tail (call_stmt
, false);
6014 if (call_stmt
&& gimple_call_tail_p (call_stmt
))
6017 new_bb
= expand_gimple_tailcall (bb
, call_stmt
, &can_fallthru
);
6028 def_operand_p def_p
;
6029 def_p
= SINGLE_SSA_DEF_OPERAND (stmt
, SSA_OP_DEF
);
6033 /* Ignore this stmt if it is in the list of
6034 replaceable expressions. */
6036 && bitmap_bit_p (SA
.values
,
6037 SSA_NAME_VERSION (DEF_FROM_PTR (def_p
))))
6040 last
= expand_gimple_stmt (stmt
);
6041 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
6046 currently_expanding_gimple_stmt
= NULL
;
6048 /* Expand implicit goto and convert goto_locus. */
6049 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6051 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
6052 set_curr_insn_location (e
->goto_locus
);
6053 if ((e
->flags
& EDGE_FALLTHRU
) && e
->dest
!= bb
->next_bb
)
6055 emit_jump (label_rtx_for_bb (e
->dest
));
6056 e
->flags
&= ~EDGE_FALLTHRU
;
6060 /* Expanded RTL can create a jump in the last instruction of block.
6061 This later might be assumed to be a jump to successor and break edge insertion.
6062 We need to insert dummy move to prevent this. PR41440. */
6063 if (single_succ_p (bb
)
6064 && (single_succ_edge (bb
)->flags
& EDGE_FALLTHRU
)
6065 && (last
= get_last_insn ())
6067 || (DEBUG_INSN_P (last
)
6068 && JUMP_P (prev_nondebug_insn (last
)))))
6070 rtx dummy
= gen_reg_rtx (SImode
);
6071 emit_insn_after_noloc (gen_move_insn (dummy
, dummy
), last
, NULL
);
6074 do_pending_stack_adjust ();
6076 /* Find the block tail. The last insn in the block is the insn
6077 before a barrier and/or table jump insn. */
6078 last
= get_last_insn ();
6079 if (BARRIER_P (last
))
6080 last
= PREV_INSN (last
);
6081 if (JUMP_TABLE_DATA_P (last
))
6082 last
= PREV_INSN (PREV_INSN (last
));
6083 if (BARRIER_P (last
))
6084 last
= PREV_INSN (last
);
6087 update_bb_for_insn (bb
);
6093 /* Create a basic block for initialization code. */
6096 construct_init_block (void)
6098 basic_block init_block
, first_block
;
6102 /* Multiple entry points not supported yet. */
6103 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
) == 1);
6104 init_rtl_bb_info (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
6105 init_rtl_bb_info (EXIT_BLOCK_PTR_FOR_FN (cfun
));
6106 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
6107 EXIT_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
6109 e
= EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun
), 0);
6111 /* When entry edge points to first basic block, we don't need jump,
6112 otherwise we have to jump into proper target. */
6113 if (e
&& e
->dest
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
)
6115 tree label
= gimple_block_label (e
->dest
);
6117 emit_jump (jump_target_rtx (label
));
6121 flags
= EDGE_FALLTHRU
;
6123 init_block
= create_basic_block (NEXT_INSN (get_insns ()),
6125 ENTRY_BLOCK_PTR_FOR_FN (cfun
));
6126 init_block
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
6127 add_bb_to_loop (init_block
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
6130 first_block
= e
->dest
;
6131 redirect_edge_succ (e
, init_block
);
6132 make_single_succ_edge (init_block
, first_block
, flags
);
6135 make_single_succ_edge (init_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
),
6138 update_bb_for_insn (init_block
);
6142 /* For each lexical block, set BLOCK_NUMBER to the depth at which it is
6143 found in the block tree. */
6146 set_block_levels (tree block
, int level
)
6150 BLOCK_NUMBER (block
) = level
;
6151 set_block_levels (BLOCK_SUBBLOCKS (block
), level
+ 1);
6152 block
= BLOCK_CHAIN (block
);
6156 /* Create a block containing landing pads and similar stuff. */
6159 construct_exit_block (void)
6161 rtx_insn
*head
= get_last_insn ();
6163 basic_block exit_block
;
6167 basic_block prev_bb
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
;
6168 rtx_insn
*orig_end
= BB_END (prev_bb
);
6170 rtl_profile_for_bb (EXIT_BLOCK_PTR_FOR_FN (cfun
));
6172 /* Make sure the locus is set to the end of the function, so that
6173 epilogue line numbers and warnings are set properly. */
6174 if (LOCATION_LOCUS (cfun
->function_end_locus
) != UNKNOWN_LOCATION
)
6175 input_location
= cfun
->function_end_locus
;
6177 /* Generate rtl for function exit. */
6178 expand_function_end ();
6180 end
= get_last_insn ();
6183 /* While emitting the function end we could move end of the last basic
6185 BB_END (prev_bb
) = orig_end
;
6186 while (NEXT_INSN (head
) && NOTE_P (NEXT_INSN (head
)))
6187 head
= NEXT_INSN (head
);
6188 /* But make sure exit_block starts with RETURN_LABEL, otherwise the
6189 bb count counting will be confused. Any instructions before that
6190 label are emitted for the case where PREV_BB falls through into the
6191 exit block, so append those instructions to prev_bb in that case. */
6192 if (NEXT_INSN (head
) != return_label
)
6194 while (NEXT_INSN (head
) != return_label
)
6196 if (!NOTE_P (NEXT_INSN (head
)))
6197 BB_END (prev_bb
) = NEXT_INSN (head
);
6198 head
= NEXT_INSN (head
);
6201 exit_block
= create_basic_block (NEXT_INSN (head
), end
, prev_bb
);
6202 exit_block
->count
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
;
6203 add_bb_to_loop (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
6206 while (ix
< EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
))
6208 e
= EDGE_PRED (EXIT_BLOCK_PTR_FOR_FN (cfun
), ix
);
6209 if (!(e
->flags
& EDGE_ABNORMAL
))
6210 redirect_edge_succ (e
, exit_block
);
6215 e
= make_single_succ_edge (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
),
6217 FOR_EACH_EDGE (e2
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
6220 exit_block
->count
-= e2
->count ();
6222 update_bb_for_insn (exit_block
);
6225 /* Helper function for discover_nonconstant_array_refs.
6226 Look for ARRAY_REF nodes with non-constant indexes and mark them
6230 discover_nonconstant_array_refs_r (tree
* tp
, int *walk_subtrees
,
6231 void *data ATTRIBUTE_UNUSED
)
6235 if (IS_TYPE_OR_DECL_P (t
))
6237 else if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
6239 while (((TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
6240 && is_gimple_min_invariant (TREE_OPERAND (t
, 1))
6241 && (!TREE_OPERAND (t
, 2)
6242 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
6243 || (TREE_CODE (t
) == COMPONENT_REF
6244 && (!TREE_OPERAND (t
,2)
6245 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
6246 || TREE_CODE (t
) == BIT_FIELD_REF
6247 || TREE_CODE (t
) == REALPART_EXPR
6248 || TREE_CODE (t
) == IMAGPART_EXPR
6249 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
6250 || CONVERT_EXPR_P (t
))
6251 t
= TREE_OPERAND (t
, 0);
6253 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
6255 t
= get_base_address (t
);
6257 && DECL_MODE (t
) != BLKmode
)
6258 TREE_ADDRESSABLE (t
) = 1;
6263 /* References of size POLY_INT_CST to a fixed-size object must go
6264 through memory. It's more efficient to force that here than
6265 to create temporary slots on the fly. */
6266 else if ((TREE_CODE (t
) == MEM_REF
|| TREE_CODE (t
) == TARGET_MEM_REF
)
6267 && TYPE_SIZE (TREE_TYPE (t
))
6268 && POLY_INT_CST_P (TYPE_SIZE (TREE_TYPE (t
))))
6270 tree base
= get_base_address (t
);
6273 && DECL_MODE (base
) != BLKmode
6274 && GET_MODE_SIZE (DECL_MODE (base
)).is_constant ())
6275 TREE_ADDRESSABLE (base
) = 1;
6282 /* If there's a chance to get a pseudo for t then if it would be of float mode
6283 and the actual access is via an integer mode (lowered memcpy or similar
6284 access) then avoid the register expansion if the mode likely is not storage
6285 suitable for raw bits processing (like XFmode on i?86). */
6288 avoid_type_punning_on_regs (tree t
)
6290 machine_mode access_mode
= TYPE_MODE (TREE_TYPE (t
));
6291 if (access_mode
!= BLKmode
6292 && !SCALAR_INT_MODE_P (access_mode
))
6294 tree base
= get_base_address (t
);
6296 && !TREE_ADDRESSABLE (base
)
6297 && FLOAT_MODE_P (DECL_MODE (base
))
6298 && maybe_lt (GET_MODE_PRECISION (DECL_MODE (base
)),
6299 GET_MODE_BITSIZE (GET_MODE_INNER (DECL_MODE (base
))))
6300 /* Double check in the expensive way we really would get a pseudo. */
6301 && use_register_for_decl (base
))
6302 TREE_ADDRESSABLE (base
) = 1;
6305 /* RTL expansion is not able to compile array references with variable
6306 offsets for arrays stored in single register. Discover such
6307 expressions and mark variables as addressable to avoid this
6311 discover_nonconstant_array_refs (void)
6314 gimple_stmt_iterator gsi
;
6316 FOR_EACH_BB_FN (bb
, cfun
)
6317 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
6319 gimple
*stmt
= gsi_stmt (gsi
);
6320 if (!is_gimple_debug (stmt
))
6322 walk_gimple_op (stmt
, discover_nonconstant_array_refs_r
, NULL
);
6323 gcall
*call
= dyn_cast
<gcall
*> (stmt
);
6324 if (call
&& gimple_call_internal_p (call
))
6325 switch (gimple_call_internal_fn (call
))
6327 case IFN_LOAD_LANES
:
6328 /* The source must be a MEM. */
6329 mark_addressable (gimple_call_arg (call
, 0));
6331 case IFN_STORE_LANES
:
6332 /* The destination must be a MEM. */
6333 mark_addressable (gimple_call_lhs (call
));
6338 if (gimple_vdef (stmt
))
6340 tree t
= gimple_get_lhs (stmt
);
6341 if (t
&& REFERENCE_CLASS_P (t
))
6342 avoid_type_punning_on_regs (t
);
6348 /* This function sets crtl->args.internal_arg_pointer to a virtual
6349 register if DRAP is needed. Local register allocator will replace
6350 virtual_incoming_args_rtx with the virtual register. */
6353 expand_stack_alignment (void)
6356 unsigned int preferred_stack_boundary
;
6358 if (! SUPPORTS_STACK_ALIGNMENT
)
6361 if (cfun
->calls_alloca
6362 || cfun
->has_nonlocal_label
6363 || crtl
->has_nonlocal_goto
)
6364 crtl
->need_drap
= true;
6366 /* Call update_stack_boundary here again to update incoming stack
6367 boundary. It may set incoming stack alignment to a different
6368 value after RTL expansion. TARGET_FUNCTION_OK_FOR_SIBCALL may
6369 use the minimum incoming stack alignment to check if it is OK
6370 to perform sibcall optimization since sibcall optimization will
6371 only align the outgoing stack to incoming stack boundary. */
6372 if (targetm
.calls
.update_stack_boundary
)
6373 targetm
.calls
.update_stack_boundary ();
6375 /* The incoming stack frame has to be aligned at least at
6376 parm_stack_boundary. */
6377 gcc_assert (crtl
->parm_stack_boundary
<= INCOMING_STACK_BOUNDARY
);
6379 /* Update crtl->stack_alignment_estimated and use it later to align
6380 stack. We check PREFERRED_STACK_BOUNDARY if there may be non-call
6381 exceptions since callgraph doesn't collect incoming stack alignment
6383 if (cfun
->can_throw_non_call_exceptions
6384 && PREFERRED_STACK_BOUNDARY
> crtl
->preferred_stack_boundary
)
6385 preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
6387 preferred_stack_boundary
= crtl
->preferred_stack_boundary
;
6388 if (preferred_stack_boundary
> crtl
->stack_alignment_estimated
)
6389 crtl
->stack_alignment_estimated
= preferred_stack_boundary
;
6390 if (preferred_stack_boundary
> crtl
->stack_alignment_needed
)
6391 crtl
->stack_alignment_needed
= preferred_stack_boundary
;
6393 gcc_assert (crtl
->stack_alignment_needed
6394 <= crtl
->stack_alignment_estimated
);
6396 crtl
->stack_realign_needed
6397 = INCOMING_STACK_BOUNDARY
< crtl
->stack_alignment_estimated
;
6398 crtl
->stack_realign_tried
= crtl
->stack_realign_needed
;
6400 crtl
->stack_realign_processed
= true;
6402 /* Target has to redefine TARGET_GET_DRAP_RTX to support stack
6404 gcc_assert (targetm
.calls
.get_drap_rtx
!= NULL
);
6405 drap_rtx
= targetm
.calls
.get_drap_rtx ();
6407 /* stack_realign_drap and drap_rtx must match. */
6408 gcc_assert ((stack_realign_drap
!= 0) == (drap_rtx
!= NULL
));
6410 /* Do nothing if NULL is returned, which means DRAP is not needed. */
6411 if (drap_rtx
!= NULL
)
6413 crtl
->args
.internal_arg_pointer
= drap_rtx
;
6415 /* Call fixup_tail_calls to clean up REG_EQUIV note if DRAP is
6417 fixup_tail_calls ();
6423 expand_main_function (void)
6425 #if (defined(INVOKE__main) \
6426 || (!defined(HAS_INIT_SECTION) \
6427 && !defined(INIT_SECTION_ASM_OP) \
6428 && !defined(INIT_ARRAY_SECTION_ASM_OP)))
6429 emit_library_call (init_one_libfunc (NAME__MAIN
), LCT_NORMAL
, VOIDmode
);
6434 /* Expand code to initialize the stack_protect_guard. This is invoked at
6435 the beginning of a function to be protected. */
6438 stack_protect_prologue (void)
6440 tree guard_decl
= targetm
.stack_protect_guard ();
6443 crtl
->stack_protect_guard_decl
= guard_decl
;
6444 x
= expand_normal (crtl
->stack_protect_guard
);
6446 if (targetm
.have_stack_protect_combined_set () && guard_decl
)
6448 gcc_assert (DECL_P (guard_decl
));
6449 y
= DECL_RTL (guard_decl
);
6451 /* Allow the target to compute address of Y and copy it to X without
6452 leaking Y into a register. This combined address + copy pattern
6453 allows the target to prevent spilling of any intermediate results by
6454 splitting it after register allocator. */
6455 if (rtx_insn
*insn
= targetm
.gen_stack_protect_combined_set (x
, y
))
6463 y
= expand_normal (guard_decl
);
6467 /* Allow the target to copy from Y to X without leaking Y into a
6469 if (targetm
.have_stack_protect_set ())
6470 if (rtx_insn
*insn
= targetm
.gen_stack_protect_set (x
, y
))
6476 /* Otherwise do a straight move. */
6477 emit_move_insn (x
, y
);
6480 /* Translate the intermediate representation contained in the CFG
6481 from GIMPLE trees to RTL.
6483 We do conversion per basic block and preserve/update the tree CFG.
6484 This implies we have to do some magic as the CFG can simultaneously
6485 consist of basic blocks containing RTL and GIMPLE trees. This can
6486 confuse the CFG hooks, so be careful to not manipulate CFG during
6491 const pass_data pass_data_expand
=
6493 RTL_PASS
, /* type */
6494 "expand", /* name */
6495 OPTGROUP_NONE
, /* optinfo_flags */
6496 TV_EXPAND
, /* tv_id */
6497 ( PROP_ssa
| PROP_gimple_leh
| PROP_cfg
6500 | PROP_gimple_lva
), /* properties_required */
6501 PROP_rtl
, /* properties_provided */
6502 ( PROP_ssa
| PROP_trees
), /* properties_destroyed */
6503 0, /* todo_flags_start */
6504 0, /* todo_flags_finish */
6507 class pass_expand
: public rtl_opt_pass
6510 pass_expand (gcc::context
*ctxt
)
6511 : rtl_opt_pass (pass_data_expand
, ctxt
)
6514 /* opt_pass methods: */
6515 virtual unsigned int execute (function
*);
6517 }; // class pass_expand
6520 pass_expand::execute (function
*fun
)
6522 basic_block bb
, init_block
;
6525 rtx_insn
*var_seq
, *var_ret_seq
;
6528 timevar_push (TV_OUT_OF_SSA
);
6529 rewrite_out_of_ssa (&SA
);
6530 timevar_pop (TV_OUT_OF_SSA
);
6531 SA
.partition_to_pseudo
= XCNEWVEC (rtx
, SA
.map
->num_partitions
);
6533 if (MAY_HAVE_DEBUG_BIND_STMTS
&& flag_tree_ter
)
6535 gimple_stmt_iterator gsi
;
6536 FOR_EACH_BB_FN (bb
, cfun
)
6537 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
6538 if (gimple_debug_bind_p (gsi_stmt (gsi
)))
6539 avoid_deep_ter_for_debug (gsi_stmt (gsi
), 0);
6542 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
6543 discover_nonconstant_array_refs ();
6545 /* Make sure all values used by the optimization passes have sane
6549 /* Some backends want to know that we are expanding to RTL. */
6550 currently_expanding_to_rtl
= 1;
6551 /* Dominators are not kept up-to-date as we may create new basic-blocks. */
6552 free_dominance_info (CDI_DOMINATORS
);
6554 rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (fun
));
6556 insn_locations_init ();
6557 if (!DECL_IS_UNDECLARED_BUILTIN (current_function_decl
))
6559 /* Eventually, all FEs should explicitly set function_start_locus. */
6560 if (LOCATION_LOCUS (fun
->function_start_locus
) == UNKNOWN_LOCATION
)
6561 set_curr_insn_location
6562 (DECL_SOURCE_LOCATION (current_function_decl
));
6564 set_curr_insn_location (fun
->function_start_locus
);
6567 set_curr_insn_location (UNKNOWN_LOCATION
);
6568 prologue_location
= curr_insn_location ();
6570 #ifdef INSN_SCHEDULING
6571 init_sched_attrs ();
6574 /* Make sure first insn is a note even if we don't want linenums.
6575 This makes sure the first insn will never be deleted.
6576 Also, final expects a note to appear there. */
6577 emit_note (NOTE_INSN_DELETED
);
6579 targetm
.expand_to_rtl_hook ();
6580 crtl
->init_stack_alignment ();
6581 fun
->cfg
->max_jumptable_ents
= 0;
6583 /* Resovle the function section. Some targets, like ARM EABI rely on knowledge
6584 of the function section at exapnsion time to predict distance of calls. */
6585 resolve_unique_section (current_function_decl
, 0, flag_function_sections
);
6587 /* Expand the variables recorded during gimple lowering. */
6588 timevar_push (TV_VAR_EXPAND
);
6591 var_ret_seq
= expand_used_vars ();
6593 var_seq
= get_insns ();
6595 timevar_pop (TV_VAR_EXPAND
);
6597 /* Honor stack protection warnings. */
6598 if (warn_stack_protect
)
6600 if (fun
->calls_alloca
)
6601 warning (OPT_Wstack_protector
,
6602 "stack protector not protecting local variables: "
6603 "variable length buffer");
6604 if (has_short_buffer
&& !crtl
->stack_protect_guard
)
6605 warning (OPT_Wstack_protector
,
6606 "stack protector not protecting function: "
6607 "all local arrays are less than %d bytes long",
6608 (int) param_ssp_buffer_size
);
6611 /* Set up parameters and prepare for return, for the function. */
6612 expand_function_start (current_function_decl
);
6614 /* If we emitted any instructions for setting up the variables,
6615 emit them before the FUNCTION_START note. */
6618 emit_insn_before (var_seq
, parm_birth_insn
);
6620 /* In expand_function_end we'll insert the alloca save/restore
6621 before parm_birth_insn. We've just insertted an alloca call.
6622 Adjust the pointer to match. */
6623 parm_birth_insn
= var_seq
;
6626 /* Now propagate the RTL assignment of each partition to the
6627 underlying var of each SSA_NAME. */
6630 FOR_EACH_SSA_NAME (i
, name
, cfun
)
6632 /* We might have generated new SSA names in
6633 update_alias_info_with_stack_vars. They will have a NULL
6634 defining statements, and won't be part of the partitioning,
6636 if (!SSA_NAME_DEF_STMT (name
))
6639 adjust_one_expanded_partition_var (name
);
6642 /* Clean up RTL of variables that straddle across multiple
6643 partitions, and check that the rtl of any PARM_DECLs that are not
6644 cleaned up is that of their default defs. */
6645 FOR_EACH_SSA_NAME (i
, name
, cfun
)
6649 /* We might have generated new SSA names in
6650 update_alias_info_with_stack_vars. They will have a NULL
6651 defining statements, and won't be part of the partitioning,
6653 if (!SSA_NAME_DEF_STMT (name
))
6655 part
= var_to_partition (SA
.map
, name
);
6656 if (part
== NO_PARTITION
)
6659 /* If this decl was marked as living in multiple places, reset
6660 this now to NULL. */
6661 tree var
= SSA_NAME_VAR (name
);
6662 if (var
&& DECL_RTL_IF_SET (var
) == pc_rtx
)
6663 SET_DECL_RTL (var
, NULL
);
6664 /* Check that the pseudos chosen by assign_parms are those of
6665 the corresponding default defs. */
6666 else if (SSA_NAME_IS_DEFAULT_DEF (name
)
6667 && (TREE_CODE (var
) == PARM_DECL
6668 || TREE_CODE (var
) == RESULT_DECL
))
6670 rtx in
= DECL_RTL_IF_SET (var
);
6672 rtx out
= SA
.partition_to_pseudo
[part
];
6673 gcc_assert (in
== out
);
6675 /* Now reset VAR's RTL to IN, so that the _EXPR attrs match
6676 those expected by debug backends for each parm and for
6677 the result. This is particularly important for stabs,
6678 whose register elimination from parm's DECL_RTL may cause
6679 -fcompare-debug differences as SET_DECL_RTL changes reg's
6680 attrs. So, make sure the RTL already has the parm as the
6681 EXPR, so that it won't change. */
6682 SET_DECL_RTL (var
, NULL_RTX
);
6684 set_mem_attributes (in
, var
, true);
6685 SET_DECL_RTL (var
, in
);
6689 /* If this function is `main', emit a call to `__main'
6690 to run global initializers, etc. */
6691 if (DECL_NAME (current_function_decl
)
6692 && MAIN_NAME_P (DECL_NAME (current_function_decl
))
6693 && DECL_FILE_SCOPE_P (current_function_decl
))
6694 expand_main_function ();
6696 /* Initialize the stack_protect_guard field. This must happen after the
6697 call to __main (if any) so that the external decl is initialized. */
6698 if (crtl
->stack_protect_guard
&& targetm
.stack_protect_runtime_enabled_p ())
6699 stack_protect_prologue ();
6701 expand_phi_nodes (&SA
);
6703 /* Release any stale SSA redirection data. */
6704 redirect_edge_var_map_empty ();
6706 /* Register rtl specific functions for cfg. */
6707 rtl_register_cfg_hooks ();
6709 init_block
= construct_init_block ();
6711 /* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
6712 remaining edges later. */
6713 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->succs
)
6714 e
->flags
&= ~EDGE_EXECUTABLE
;
6716 /* If the function has too many markers, drop them while expanding. */
6717 if (cfun
->debug_marker_count
6718 >= param_max_debug_marker_count
)
6719 cfun
->debug_nonbind_markers
= false;
6721 lab_rtx_for_bb
= new hash_map
<basic_block
, rtx_code_label
*>;
6722 FOR_BB_BETWEEN (bb
, init_block
->next_bb
, EXIT_BLOCK_PTR_FOR_FN (fun
),
6724 bb
= expand_gimple_basic_block (bb
, var_ret_seq
!= NULL_RTX
);
6726 if (MAY_HAVE_DEBUG_BIND_INSNS
)
6727 expand_debug_locations ();
6729 if (deep_ter_debug_map
)
6731 delete deep_ter_debug_map
;
6732 deep_ter_debug_map
= NULL
;
6735 /* Free stuff we no longer need after GIMPLE optimizations. */
6736 free_dominance_info (CDI_DOMINATORS
);
6737 free_dominance_info (CDI_POST_DOMINATORS
);
6738 delete_tree_cfg_annotations (fun
);
6740 timevar_push (TV_OUT_OF_SSA
);
6741 finish_out_of_ssa (&SA
);
6742 timevar_pop (TV_OUT_OF_SSA
);
6744 timevar_push (TV_POST_EXPAND
);
6745 /* We are no longer in SSA form. */
6746 fun
->gimple_df
->in_ssa_p
= false;
6747 loops_state_clear (LOOP_CLOSED_SSA
);
6749 /* Expansion is used by optimization passes too, set maybe_hot_insn_p
6750 conservatively to true until they are all profile aware. */
6751 delete lab_rtx_for_bb
;
6752 free_histograms (fun
);
6754 construct_exit_block ();
6755 insn_locations_finalize ();
6759 rtx_insn
*after
= return_label
;
6760 rtx_insn
*next
= NEXT_INSN (after
);
6761 if (next
&& NOTE_INSN_BASIC_BLOCK_P (next
))
6763 emit_insn_after (var_ret_seq
, after
);
6766 if (hwasan_sanitize_stack_p ())
6767 hwasan_maybe_emit_frame_base_init ();
6769 /* Zap the tree EH table. */
6770 set_eh_throw_stmt_table (fun
, NULL
);
6772 /* We need JUMP_LABEL be set in order to redirect jumps, and hence
6773 split edges which edge insertions might do. */
6774 rebuild_jump_labels (get_insns ());
6776 /* If we have a single successor to the entry block, put the pending insns
6777 after parm birth, but before NOTE_INSNS_FUNCTION_BEG. */
6778 if (single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (fun
)))
6780 edge e
= single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (fun
));
6783 rtx_insn
*insns
= e
->insns
.r
;
6785 rebuild_jump_labels_chain (insns
);
6786 if (NOTE_P (parm_birth_insn
)
6787 && NOTE_KIND (parm_birth_insn
) == NOTE_INSN_FUNCTION_BEG
)
6788 emit_insn_before_noloc (insns
, parm_birth_insn
, e
->dest
);
6790 emit_insn_after_noloc (insns
, parm_birth_insn
, e
->dest
);
6794 /* Otherwise, as well as for other edges, take the usual way. */
6795 commit_edge_insertions ();
6797 /* We're done expanding trees to RTL. */
6798 currently_expanding_to_rtl
= 0;
6800 flush_mark_addressable_queue ();
6802 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->next_bb
,
6803 EXIT_BLOCK_PTR_FOR_FN (fun
), next_bb
)
6807 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
6809 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
6810 e
->flags
&= ~EDGE_EXECUTABLE
;
6812 /* At the moment not all abnormal edges match the RTL
6813 representation. It is safe to remove them here as
6814 find_many_sub_basic_blocks will rediscover them.
6815 In the future we should get this fixed properly. */
6816 if ((e
->flags
& EDGE_ABNORMAL
)
6817 && !(e
->flags
& EDGE_SIBCALL
))
6824 auto_sbitmap
blocks (last_basic_block_for_fn (fun
));
6825 bitmap_ones (blocks
);
6826 find_many_sub_basic_blocks (blocks
);
6827 purge_all_dead_edges ();
6829 /* After initial rtl generation, call back to finish generating
6830 exception support code. We need to do this before cleaning up
6831 the CFG as the code does not expect dead landing pads. */
6832 if (fun
->eh
->region_tree
!= NULL
)
6833 finish_eh_generation ();
6835 /* Call expand_stack_alignment after finishing all
6836 updates to crtl->preferred_stack_boundary. */
6837 expand_stack_alignment ();
6839 /* Fixup REG_EQUIV notes in the prologue if there are tailcalls in this
6841 if (crtl
->tail_call_emit
)
6842 fixup_tail_calls ();
6844 unsigned HOST_WIDE_INT patch_area_size
= function_entry_patch_area_size
;
6845 unsigned HOST_WIDE_INT patch_area_entry
= function_entry_patch_area_start
;
6847 tree patchable_function_entry_attr
6848 = lookup_attribute ("patchable_function_entry",
6849 DECL_ATTRIBUTES (cfun
->decl
));
6850 if (patchable_function_entry_attr
)
6852 tree pp_val
= TREE_VALUE (patchable_function_entry_attr
);
6853 tree patchable_function_entry_value1
= TREE_VALUE (pp_val
);
6855 patch_area_size
= tree_to_uhwi (patchable_function_entry_value1
);
6856 patch_area_entry
= 0;
6857 if (TREE_CHAIN (pp_val
) != NULL_TREE
)
6859 tree patchable_function_entry_value2
6860 = TREE_VALUE (TREE_CHAIN (pp_val
));
6861 patch_area_entry
= tree_to_uhwi (patchable_function_entry_value2
);
6865 if (patch_area_entry
> patch_area_size
)
6867 if (patch_area_size
> 0)
6868 warning (OPT_Wattributes
,
6869 "patchable function entry %wu exceeds size %wu",
6870 patch_area_entry
, patch_area_size
);
6871 patch_area_entry
= 0;
6874 crtl
->patch_area_size
= patch_area_size
;
6875 crtl
->patch_area_entry
= patch_area_entry
;
6877 /* BB subdivision may have created basic blocks that are only reachable
6878 from unlikely bbs but not marked as such in the profile. */
6880 propagate_unlikely_bbs_forward ();
6882 /* Remove unreachable blocks, otherwise we cannot compute dominators
6883 which are needed for loop state verification. As a side-effect
6884 this also compacts blocks.
6885 ??? We cannot remove trivially dead insns here as for example
6886 the DRAP reg on i?86 is not magically live at this point.
6887 gcc.c-torture/execute/ipa-sra-2.c execution, -Os -m32 fails otherwise. */
6888 cleanup_cfg (CLEANUP_NO_INSN_DEL
);
6890 checking_verify_flow_info ();
6892 /* Initialize pseudos allocated for hard registers. */
6893 emit_initial_value_sets ();
6895 /* And finally unshare all RTL. */
6898 /* There's no need to defer outputting this function any more; we
6899 know we want to output it. */
6900 DECL_DEFER_OUTPUT (current_function_decl
) = 0;
6902 /* Now that we're done expanding trees to RTL, we shouldn't have any
6903 more CONCATs anywhere. */
6904 generating_concat_p
= 0;
6909 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
6910 /* And the pass manager will dump RTL for us. */
6913 /* If we're emitting a nested function, make sure its parent gets
6914 emitted as well. Doing otherwise confuses debug info. */
6917 for (parent
= DECL_CONTEXT (current_function_decl
);
6918 parent
!= NULL_TREE
;
6919 parent
= get_containing_scope (parent
))
6920 if (TREE_CODE (parent
) == FUNCTION_DECL
)
6921 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent
)) = 1;
6924 TREE_ASM_WRITTEN (current_function_decl
) = 1;
6926 /* After expanding, the return labels are no longer needed. */
6927 return_label
= NULL
;
6928 naked_return_label
= NULL
;
6930 /* After expanding, the tm_restart map is no longer needed. */
6931 if (fun
->gimple_df
->tm_restart
)
6932 fun
->gimple_df
->tm_restart
= NULL
;
6934 /* Tag the blocks with a depth number so that change_scope can find
6935 the common parent easily. */
6936 set_block_levels (DECL_INITIAL (fun
->decl
), 0);
6937 default_rtl_profile ();
6939 /* For -dx discard loops now, otherwise IL verify in clean_state will
6941 if (rtl_dump_and_exit
)
6943 cfun
->curr_properties
&= ~PROP_loops
;
6944 loop_optimizer_finalize ();
6947 timevar_pop (TV_POST_EXPAND
);
6955 make_pass_expand (gcc::context
*ctxt
)
6957 return new pass_expand (ctxt
);