1 /* A pass for lowering trees to RTL.
2 Copyright (C) 2004-2021 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"
78 /* Some systems use __main in a way incompatible with its use in gcc, in these
79 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
80 give the same symbol without quotes for an alternative entry point. You
81 must define both, or neither. */
83 #define NAME__MAIN "__main"
86 /* This variable holds information helping the rewriting of SSA trees
90 /* This variable holds the currently expanded gimple statement for purposes
91 of comminucating the profile info to the builtin expanders. */
92 gimple
*currently_expanding_gimple_stmt
;
94 static rtx
expand_debug_expr (tree
);
96 static bool defer_stack_allocation (tree
, bool);
98 static void record_alignment_for_reg_var (unsigned int);
100 /* Return an expression tree corresponding to the RHS of GIMPLE
104 gimple_assign_rhs_to_tree (gimple
*stmt
)
107 switch (gimple_assign_rhs_class (stmt
))
109 case GIMPLE_TERNARY_RHS
:
110 t
= build3 (gimple_assign_rhs_code (stmt
),
111 TREE_TYPE (gimple_assign_lhs (stmt
)),
112 gimple_assign_rhs1 (stmt
), gimple_assign_rhs2 (stmt
),
113 gimple_assign_rhs3 (stmt
));
115 case GIMPLE_BINARY_RHS
:
116 t
= build2 (gimple_assign_rhs_code (stmt
),
117 TREE_TYPE (gimple_assign_lhs (stmt
)),
118 gimple_assign_rhs1 (stmt
), gimple_assign_rhs2 (stmt
));
120 case GIMPLE_UNARY_RHS
:
121 t
= build1 (gimple_assign_rhs_code (stmt
),
122 TREE_TYPE (gimple_assign_lhs (stmt
)),
123 gimple_assign_rhs1 (stmt
));
125 case GIMPLE_SINGLE_RHS
:
127 t
= gimple_assign_rhs1 (stmt
);
128 /* Avoid modifying this tree in place below. */
129 if ((gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (t
)
130 && gimple_location (stmt
) != EXPR_LOCATION (t
))
131 || (gimple_block (stmt
) && currently_expanding_to_rtl
140 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (t
))
141 SET_EXPR_LOCATION (t
, gimple_location (stmt
));
147 #ifndef STACK_ALIGNMENT_NEEDED
148 #define STACK_ALIGNMENT_NEEDED 1
151 #define SSAVAR(x) (TREE_CODE (x) == SSA_NAME ? SSA_NAME_VAR (x) : x)
153 /* Choose either CUR or NEXT as the leader DECL for a partition.
154 Prefer ignored decls, to simplify debug dumps and reduce ambiguity
155 out of the same user variable being in multiple partitions (this is
156 less likely for compiler-introduced temps). */
159 leader_merge (tree cur
, tree next
)
161 if (cur
== NULL
|| cur
== next
)
164 if (DECL_P (cur
) && DECL_IGNORED_P (cur
))
167 if (DECL_P (next
) && DECL_IGNORED_P (next
))
173 /* Associate declaration T with storage space X. If T is no
174 SSA name this is exactly SET_DECL_RTL, otherwise make the
175 partition of T associated with X. */
177 set_rtl (tree t
, rtx x
)
179 gcc_checking_assert (!x
180 || !(TREE_CODE (t
) == SSA_NAME
|| is_gimple_reg (t
))
181 || (use_register_for_decl (t
)
183 || (GET_CODE (x
) == CONCAT
184 && (REG_P (XEXP (x
, 0))
185 || SUBREG_P (XEXP (x
, 0)))
186 && (REG_P (XEXP (x
, 1))
187 || SUBREG_P (XEXP (x
, 1))))
188 /* We need to accept PARALLELs for RESUT_DECLs
189 because of vector types with BLKmode returned
190 in multiple registers, but they are supposed
191 to be uncoalesced. */
192 || (GET_CODE (x
) == PARALLEL
194 && TREE_CODE (SSAVAR (t
)) == RESULT_DECL
195 && (GET_MODE (x
) == BLKmode
196 || !flag_tree_coalesce_vars
)))
197 : (MEM_P (x
) || x
== pc_rtx
198 || (GET_CODE (x
) == CONCAT
199 && MEM_P (XEXP (x
, 0))
200 && MEM_P (XEXP (x
, 1))))));
201 /* Check that the RTL for SSA_NAMEs and gimple-reg PARM_DECLs and
202 RESULT_DECLs has the expected mode. For memory, we accept
203 unpromoted modes, since that's what we're likely to get. For
204 PARM_DECLs and RESULT_DECLs, we'll have been called by
205 set_parm_rtl, which will give us the default def, so we don't
206 have to compute it ourselves. For RESULT_DECLs, we accept mode
207 mismatches too, as long as we have BLKmode or are not coalescing
208 across variables, so that we don't reject BLKmode PARALLELs or
210 gcc_checking_assert (!x
|| x
== pc_rtx
|| TREE_CODE (t
) != SSA_NAME
212 && TREE_CODE (SSAVAR (t
)) == RESULT_DECL
213 && (promote_ssa_mode (t
, NULL
) == BLKmode
214 || !flag_tree_coalesce_vars
))
215 || !use_register_for_decl (t
)
216 || GET_MODE (x
) == promote_ssa_mode (t
, NULL
));
221 tree cur
= NULL_TREE
;
229 else if (SUBREG_P (xm
))
231 gcc_assert (subreg_lowpart_p (xm
));
232 xm
= SUBREG_REG (xm
);
235 else if (GET_CODE (xm
) == CONCAT
)
240 else if (GET_CODE (xm
) == PARALLEL
)
242 xm
= XVECEXP (xm
, 0, 0);
243 gcc_assert (GET_CODE (xm
) == EXPR_LIST
);
247 else if (xm
== pc_rtx
)
252 tree next
= skip
? cur
: leader_merge (cur
, SSAVAR (t
) ? SSAVAR (t
) : t
);
257 set_mem_attributes (x
,
258 next
&& TREE_CODE (next
) == SSA_NAME
262 set_reg_attrs_for_decl_rtl (next
, x
);
266 if (TREE_CODE (t
) == SSA_NAME
)
268 int part
= var_to_partition (SA
.map
, t
);
269 if (part
!= NO_PARTITION
)
271 if (SA
.partition_to_pseudo
[part
])
272 gcc_assert (SA
.partition_to_pseudo
[part
] == x
);
273 else if (x
!= pc_rtx
)
274 SA
.partition_to_pseudo
[part
] = x
;
276 /* For the benefit of debug information at -O0 (where
277 vartracking doesn't run) record the place also in the base
278 DECL. For PARMs and RESULTs, do so only when setting the
280 if (x
&& x
!= pc_rtx
&& SSA_NAME_VAR (t
)
281 && (VAR_P (SSA_NAME_VAR (t
))
282 || SSA_NAME_IS_DEFAULT_DEF (t
)))
284 tree var
= SSA_NAME_VAR (t
);
285 /* If we don't yet have something recorded, just record it now. */
286 if (!DECL_RTL_SET_P (var
))
287 SET_DECL_RTL (var
, x
);
288 /* If we have it set already to "multiple places" don't
290 else if (DECL_RTL (var
) == pc_rtx
)
292 /* If we have something recorded and it's not the same place
293 as we want to record now, we have multiple partitions for the
294 same base variable, with different places. We can't just
295 randomly chose one, hence we have to say that we don't know.
296 This only happens with optimization, and there var-tracking
297 will figure out the right thing. */
298 else if (DECL_RTL (var
) != x
)
299 SET_DECL_RTL (var
, pc_rtx
);
306 /* This structure holds data relevant to one variable that will be
307 placed in a stack slot. */
314 /* Initially, the size of the variable. Later, the size of the partition,
315 if this variable becomes it's partition's representative. */
318 /* The *byte* alignment required for this variable. Or as, with the
319 size, the alignment for this partition. */
322 /* The partition representative. */
323 size_t representative
;
325 /* The next stack variable in the partition, or EOC. */
328 /* The numbers of conflicting stack variables. */
332 #define EOC ((size_t)-1)
334 /* We have an array of such objects while deciding allocation. */
335 static class stack_var
*stack_vars
;
336 static size_t stack_vars_alloc
;
337 static size_t stack_vars_num
;
338 static hash_map
<tree
, size_t> *decl_to_stack_part
;
340 /* Conflict bitmaps go on this obstack. This allows us to destroy
341 all of them in one big sweep. */
342 static bitmap_obstack stack_var_bitmap_obstack
;
344 /* An array of indices such that stack_vars[stack_vars_sorted[i]].size
345 is non-decreasing. */
346 static size_t *stack_vars_sorted
;
348 /* The phase of the stack frame. This is the known misalignment of
349 virtual_stack_vars_rtx from PREFERRED_STACK_BOUNDARY. That is,
350 (frame_offset+frame_phase) % PREFERRED_STACK_BOUNDARY == 0. */
351 static int frame_phase
;
353 /* Used during expand_used_vars to remember if we saw any decls for
354 which we'd like to enable stack smashing protection. */
355 static bool has_protected_decls
;
357 /* Used during expand_used_vars. Remember if we say a character buffer
358 smaller than our cutoff threshold. Used for -Wstack-protector. */
359 static bool has_short_buffer
;
361 /* Compute the byte alignment to use for DECL. Ignore alignment
362 we can't do with expected alignment of the stack boundary. */
365 align_local_variable (tree decl
, bool really_expand
)
369 if (TREE_CODE (decl
) == SSA_NAME
)
371 tree type
= TREE_TYPE (decl
);
372 machine_mode mode
= TYPE_MODE (type
);
374 align
= TYPE_ALIGN (type
);
376 && align
< GET_MODE_ALIGNMENT (mode
))
377 align
= GET_MODE_ALIGNMENT (mode
);
380 align
= LOCAL_DECL_ALIGNMENT (decl
);
382 if (hwasan_sanitize_stack_p ())
383 align
= MAX (align
, (unsigned) HWASAN_TAG_GRANULE_SIZE
* BITS_PER_UNIT
);
385 if (TREE_CODE (decl
) != SSA_NAME
&& really_expand
)
386 /* Don't change DECL_ALIGN when called from estimated_stack_frame_size.
387 That is done before IPA and could bump alignment based on host
388 backend even for offloaded code which wants different
389 LOCAL_DECL_ALIGNMENT. */
390 SET_DECL_ALIGN (decl
, align
);
392 return align
/ BITS_PER_UNIT
;
395 /* Align given offset BASE with ALIGN. Truncate up if ALIGN_UP is true,
396 down otherwise. Return truncated BASE value. */
398 static inline unsigned HOST_WIDE_INT
399 align_base (HOST_WIDE_INT base
, unsigned HOST_WIDE_INT align
, bool align_up
)
401 return align_up
? (base
+ align
- 1) & -align
: base
& -align
;
404 /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
405 Return the frame offset. */
408 alloc_stack_frame_space (poly_int64 size
, unsigned HOST_WIDE_INT align
)
410 poly_int64 offset
, new_frame_offset
;
412 if (FRAME_GROWS_DOWNWARD
)
415 = aligned_lower_bound (frame_offset
- frame_phase
- size
,
416 align
) + frame_phase
;
417 offset
= new_frame_offset
;
422 = aligned_upper_bound (frame_offset
- frame_phase
,
423 align
) + frame_phase
;
424 offset
= new_frame_offset
;
425 new_frame_offset
+= size
;
427 frame_offset
= new_frame_offset
;
429 if (frame_offset_overflow (frame_offset
, cfun
->decl
))
430 frame_offset
= offset
= 0;
435 /* Ensure that the stack is aligned to ALIGN bytes.
436 Return the new frame offset. */
438 align_frame_offset (unsigned HOST_WIDE_INT align
)
440 return alloc_stack_frame_space (0, align
);
443 /* Accumulate DECL into STACK_VARS. */
446 add_stack_var (tree decl
, bool really_expand
)
450 if (stack_vars_num
>= stack_vars_alloc
)
452 if (stack_vars_alloc
)
453 stack_vars_alloc
= stack_vars_alloc
* 3 / 2;
455 stack_vars_alloc
= 32;
457 = XRESIZEVEC (class stack_var
, stack_vars
, stack_vars_alloc
);
459 if (!decl_to_stack_part
)
460 decl_to_stack_part
= new hash_map
<tree
, size_t>;
462 v
= &stack_vars
[stack_vars_num
];
463 decl_to_stack_part
->put (decl
, stack_vars_num
);
466 tree size
= TREE_CODE (decl
) == SSA_NAME
467 ? TYPE_SIZE_UNIT (TREE_TYPE (decl
))
468 : DECL_SIZE_UNIT (decl
);
469 v
->size
= tree_to_poly_uint64 (size
);
470 /* Ensure that all variables have size, so that &a != &b for any two
471 variables that are simultaneously live. */
472 if (known_eq (v
->size
, 0U))
474 v
->alignb
= align_local_variable (decl
, really_expand
);
475 /* An alignment of zero can mightily confuse us later. */
476 gcc_assert (v
->alignb
!= 0);
478 /* All variables are initially in their own partition. */
479 v
->representative
= stack_vars_num
;
482 /* All variables initially conflict with no other. */
485 /* Ensure that this decl doesn't get put onto the list twice. */
486 set_rtl (decl
, pc_rtx
);
491 /* Make the decls associated with luid's X and Y conflict. */
494 add_stack_var_conflict (size_t x
, size_t y
)
496 class stack_var
*a
= &stack_vars
[x
];
497 class stack_var
*b
= &stack_vars
[y
];
501 a
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
503 b
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
504 bitmap_set_bit (a
->conflicts
, y
);
505 bitmap_set_bit (b
->conflicts
, x
);
508 /* Check whether the decls associated with luid's X and Y conflict. */
511 stack_var_conflict_p (size_t x
, size_t y
)
513 class stack_var
*a
= &stack_vars
[x
];
514 class stack_var
*b
= &stack_vars
[y
];
517 /* Partitions containing an SSA name result from gimple registers
518 with things like unsupported modes. They are top-level and
519 hence conflict with everything else. */
520 if (TREE_CODE (a
->decl
) == SSA_NAME
|| TREE_CODE (b
->decl
) == SSA_NAME
)
523 if (!a
->conflicts
|| !b
->conflicts
)
525 return bitmap_bit_p (a
->conflicts
, y
);
528 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
529 enter its partition number into bitmap DATA. */
532 visit_op (gimple
*, tree op
, tree
, void *data
)
534 bitmap active
= (bitmap
)data
;
535 op
= get_base_address (op
);
538 && DECL_RTL_IF_SET (op
) == pc_rtx
)
540 size_t *v
= decl_to_stack_part
->get (op
);
542 bitmap_set_bit (active
, *v
);
547 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
548 record conflicts between it and all currently active other partitions
552 visit_conflict (gimple
*, tree op
, tree
, void *data
)
554 bitmap active
= (bitmap
)data
;
555 op
= get_base_address (op
);
558 && DECL_RTL_IF_SET (op
) == pc_rtx
)
560 size_t *v
= decl_to_stack_part
->get (op
);
561 if (v
&& bitmap_set_bit (active
, *v
))
566 gcc_assert (num
< stack_vars_num
);
567 EXECUTE_IF_SET_IN_BITMAP (active
, 0, i
, bi
)
568 add_stack_var_conflict (num
, i
);
574 /* Helper routine for add_scope_conflicts, calculating the active partitions
575 at the end of BB, leaving the result in WORK. We're called to generate
576 conflicts when FOR_CONFLICT is true, otherwise we're just tracking
580 add_scope_conflicts_1 (basic_block bb
, bitmap work
, bool for_conflict
)
584 gimple_stmt_iterator gsi
;
585 walk_stmt_load_store_addr_fn visit
;
588 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
589 bitmap_ior_into (work
, (bitmap
)e
->src
->aux
);
593 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
595 gimple
*stmt
= gsi_stmt (gsi
);
596 walk_stmt_load_store_addr_ops (stmt
, work
, NULL
, NULL
, visit
);
598 for (gsi
= gsi_after_labels (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
600 gimple
*stmt
= gsi_stmt (gsi
);
602 if (gimple_clobber_p (stmt
))
604 tree lhs
= gimple_assign_lhs (stmt
);
606 /* Nested function lowering might introduce LHSs
607 that are COMPONENT_REFs. */
610 if (DECL_RTL_IF_SET (lhs
) == pc_rtx
611 && (v
= decl_to_stack_part
->get (lhs
)))
612 bitmap_clear_bit (work
, *v
);
614 else if (!is_gimple_debug (stmt
))
617 && visit
== visit_op
)
619 /* If this is the first real instruction in this BB we need
620 to add conflicts for everything live at this point now.
621 Unlike classical liveness for named objects we can't
622 rely on seeing a def/use of the names we're interested in.
623 There might merely be indirect loads/stores. We'd not add any
624 conflicts for such partitions. */
627 EXECUTE_IF_SET_IN_BITMAP (work
, 0, i
, bi
)
629 class stack_var
*a
= &stack_vars
[i
];
631 a
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
632 bitmap_ior_into (a
->conflicts
, work
);
634 visit
= visit_conflict
;
636 walk_stmt_load_store_addr_ops (stmt
, work
, visit
, visit
, visit
);
641 /* Generate stack partition conflicts between all partitions that are
642 simultaneously live. */
645 add_scope_conflicts (void)
649 bitmap work
= BITMAP_ALLOC (NULL
);
653 /* We approximate the live range of a stack variable by taking the first
654 mention of its name as starting point(s), and by the end-of-scope
655 death clobber added by gimplify as ending point(s) of the range.
656 This overapproximates in the case we for instance moved an address-taken
657 operation upward, without also moving a dereference to it upwards.
658 But it's conservatively correct as a variable never can hold values
659 before its name is mentioned at least once.
661 We then do a mostly classical bitmap liveness algorithm. */
663 FOR_ALL_BB_FN (bb
, cfun
)
664 bb
->aux
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
666 rpo
= XNEWVEC (int, last_basic_block_for_fn (cfun
));
667 n_bbs
= pre_and_rev_post_order_compute (NULL
, rpo
, false);
674 for (i
= 0; i
< n_bbs
; i
++)
677 bb
= BASIC_BLOCK_FOR_FN (cfun
, rpo
[i
]);
678 active
= (bitmap
)bb
->aux
;
679 add_scope_conflicts_1 (bb
, work
, false);
680 if (bitmap_ior_into (active
, work
))
685 FOR_EACH_BB_FN (bb
, cfun
)
686 add_scope_conflicts_1 (bb
, work
, true);
690 FOR_ALL_BB_FN (bb
, cfun
)
691 BITMAP_FREE (bb
->aux
);
694 /* A subroutine of partition_stack_vars. A comparison function for qsort,
695 sorting an array of indices by the properties of the object. */
698 stack_var_cmp (const void *a
, const void *b
)
700 size_t ia
= *(const size_t *)a
;
701 size_t ib
= *(const size_t *)b
;
702 unsigned int aligna
= stack_vars
[ia
].alignb
;
703 unsigned int alignb
= stack_vars
[ib
].alignb
;
704 poly_int64 sizea
= stack_vars
[ia
].size
;
705 poly_int64 sizeb
= stack_vars
[ib
].size
;
706 tree decla
= stack_vars
[ia
].decl
;
707 tree declb
= stack_vars
[ib
].decl
;
709 unsigned int uida
, uidb
;
711 /* Primary compare on "large" alignment. Large comes first. */
712 largea
= (aligna
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
713 largeb
= (alignb
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
714 if (largea
!= largeb
)
715 return (int)largeb
- (int)largea
;
717 /* Secondary compare on size, decreasing */
718 int diff
= compare_sizes_for_sort (sizeb
, sizea
);
722 /* Tertiary compare on true alignment, decreasing. */
728 /* Final compare on ID for sort stability, increasing.
729 Two SSA names are compared by their version, SSA names come before
730 non-SSA names, and two normal decls are compared by their DECL_UID. */
731 if (TREE_CODE (decla
) == SSA_NAME
)
733 if (TREE_CODE (declb
) == SSA_NAME
)
734 uida
= SSA_NAME_VERSION (decla
), uidb
= SSA_NAME_VERSION (declb
);
738 else if (TREE_CODE (declb
) == SSA_NAME
)
741 uida
= DECL_UID (decla
), uidb
= DECL_UID (declb
);
749 struct part_traits
: unbounded_int_hashmap_traits
<size_t, bitmap
> {};
750 typedef hash_map
<size_t, bitmap
, part_traits
> part_hashmap
;
752 /* If the points-to solution *PI points to variables that are in a partition
753 together with other variables add all partition members to the pointed-to
757 add_partitioned_vars_to_ptset (struct pt_solution
*pt
,
758 part_hashmap
*decls_to_partitions
,
759 hash_set
<bitmap
> *visited
, bitmap temp
)
767 /* The pointed-to vars bitmap is shared, it is enough to
769 || visited
->add (pt
->vars
))
774 /* By using a temporary bitmap to store all members of the partitions
775 we have to add we make sure to visit each of the partitions only
777 EXECUTE_IF_SET_IN_BITMAP (pt
->vars
, 0, i
, bi
)
779 || !bitmap_bit_p (temp
, i
))
780 && (part
= decls_to_partitions
->get (i
)))
781 bitmap_ior_into (temp
, *part
);
782 if (!bitmap_empty_p (temp
))
783 bitmap_ior_into (pt
->vars
, temp
);
786 /* Update points-to sets based on partition info, so we can use them on RTL.
787 The bitmaps representing stack partitions will be saved until expand,
788 where partitioned decls used as bases in memory expressions will be
792 update_alias_info_with_stack_vars (void)
794 part_hashmap
*decls_to_partitions
= NULL
;
796 tree var
= NULL_TREE
;
798 for (i
= 0; i
< stack_vars_num
; i
++)
802 struct ptr_info_def
*pi
;
804 /* Not interested in partitions with single variable. */
805 if (stack_vars
[i
].representative
!= i
806 || stack_vars
[i
].next
== EOC
)
809 if (!decls_to_partitions
)
811 decls_to_partitions
= new part_hashmap
;
812 cfun
->gimple_df
->decls_to_pointers
= new hash_map
<tree
, tree
>;
815 /* Create an SSA_NAME that points to the partition for use
816 as base during alias-oracle queries on RTL for bases that
817 have been partitioned. */
818 if (var
== NULL_TREE
)
819 var
= create_tmp_var (ptr_type_node
);
820 name
= make_ssa_name (var
);
822 /* Create bitmaps representing partitions. They will be used for
823 points-to sets later, so use GGC alloc. */
824 part
= BITMAP_GGC_ALLOC ();
825 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
827 tree decl
= stack_vars
[j
].decl
;
828 unsigned int uid
= DECL_PT_UID (decl
);
829 bitmap_set_bit (part
, uid
);
830 decls_to_partitions
->put (uid
, part
);
831 cfun
->gimple_df
->decls_to_pointers
->put (decl
, name
);
832 if (TREE_ADDRESSABLE (decl
))
833 TREE_ADDRESSABLE (name
) = 1;
836 /* Make the SSA name point to all partition members. */
837 pi
= get_ptr_info (name
);
838 pt_solution_set (&pi
->pt
, part
, false);
841 /* Make all points-to sets that contain one member of a partition
842 contain all members of the partition. */
843 if (decls_to_partitions
)
847 hash_set
<bitmap
> visited
;
848 bitmap temp
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
850 FOR_EACH_SSA_NAME (i
, name
, cfun
)
852 struct ptr_info_def
*pi
;
854 if (POINTER_TYPE_P (TREE_TYPE (name
))
855 && ((pi
= SSA_NAME_PTR_INFO (name
)) != NULL
))
856 add_partitioned_vars_to_ptset (&pi
->pt
, decls_to_partitions
,
860 add_partitioned_vars_to_ptset (&cfun
->gimple_df
->escaped
,
861 decls_to_partitions
, &visited
, temp
);
863 delete decls_to_partitions
;
868 /* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
869 partitioning algorithm. Partitions A and B are known to be non-conflicting.
870 Merge them into a single partition A. */
873 union_stack_vars (size_t a
, size_t b
)
875 class stack_var
*vb
= &stack_vars
[b
];
879 gcc_assert (stack_vars
[b
].next
== EOC
);
880 /* Add B to A's partition. */
881 stack_vars
[b
].next
= stack_vars
[a
].next
;
882 stack_vars
[b
].representative
= a
;
883 stack_vars
[a
].next
= b
;
885 /* Make sure A is big enough to hold B. */
886 stack_vars
[a
].size
= upper_bound (stack_vars
[a
].size
, stack_vars
[b
].size
);
888 /* Update the required alignment of partition A to account for B. */
889 if (stack_vars
[a
].alignb
< stack_vars
[b
].alignb
)
890 stack_vars
[a
].alignb
= stack_vars
[b
].alignb
;
892 /* Update the interference graph and merge the conflicts. */
895 EXECUTE_IF_SET_IN_BITMAP (vb
->conflicts
, 0, u
, bi
)
896 add_stack_var_conflict (a
, stack_vars
[u
].representative
);
897 BITMAP_FREE (vb
->conflicts
);
901 /* A subroutine of expand_used_vars. Binpack the variables into
902 partitions constrained by the interference graph. The overall
903 algorithm used is as follows:
905 Sort the objects by size in descending order.
910 Look for the largest non-conflicting object B with size <= S.
917 partition_stack_vars (void)
919 size_t si
, sj
, n
= stack_vars_num
;
921 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
922 for (si
= 0; si
< n
; ++si
)
923 stack_vars_sorted
[si
] = si
;
928 qsort (stack_vars_sorted
, n
, sizeof (size_t), stack_var_cmp
);
930 for (si
= 0; si
< n
; ++si
)
932 size_t i
= stack_vars_sorted
[si
];
933 unsigned int ialign
= stack_vars
[i
].alignb
;
934 poly_int64 isize
= stack_vars
[i
].size
;
936 /* Ignore objects that aren't partition representatives. If we
937 see a var that is not a partition representative, it must
938 have been merged earlier. */
939 if (stack_vars
[i
].representative
!= i
)
942 for (sj
= si
+ 1; sj
< n
; ++sj
)
944 size_t j
= stack_vars_sorted
[sj
];
945 unsigned int jalign
= stack_vars
[j
].alignb
;
946 poly_int64 jsize
= stack_vars
[j
].size
;
948 /* Ignore objects that aren't partition representatives. */
949 if (stack_vars
[j
].representative
!= j
)
952 /* Do not mix objects of "small" (supported) alignment
953 and "large" (unsupported) alignment. */
954 if ((ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
955 != (jalign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
))
958 /* For Address Sanitizer do not mix objects with different
959 sizes, as the shorter vars wouldn't be adequately protected.
960 Don't do that for "large" (unsupported) alignment objects,
961 those aren't protected anyway. */
962 if (asan_sanitize_stack_p ()
963 && maybe_ne (isize
, jsize
)
964 && ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
967 /* Ignore conflicting objects. */
968 if (stack_var_conflict_p (i
, j
))
971 /* UNION the objects, placing J at OFFSET. */
972 union_stack_vars (i
, j
);
976 update_alias_info_with_stack_vars ();
979 /* A debugging aid for expand_used_vars. Dump the generated partitions. */
982 dump_stack_var_partition (void)
984 size_t si
, i
, j
, n
= stack_vars_num
;
986 for (si
= 0; si
< n
; ++si
)
988 i
= stack_vars_sorted
[si
];
990 /* Skip variables that aren't partition representatives, for now. */
991 if (stack_vars
[i
].representative
!= i
)
994 fprintf (dump_file
, "Partition %lu: size ", (unsigned long) i
);
995 print_dec (stack_vars
[i
].size
, dump_file
);
996 fprintf (dump_file
, " align %u\n", stack_vars
[i
].alignb
);
998 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1000 fputc ('\t', dump_file
);
1001 print_generic_expr (dump_file
, stack_vars
[j
].decl
, dump_flags
);
1003 fputc ('\n', dump_file
);
1007 /* Assign rtl to DECL at BASE + OFFSET. */
1010 expand_one_stack_var_at (tree decl
, rtx base
, unsigned base_align
,
1016 /* If this fails, we've overflowed the stack frame. Error nicely? */
1017 gcc_assert (known_eq (offset
, trunc_int_for_mode (offset
, Pmode
)));
1019 if (hwasan_sanitize_stack_p ())
1020 x
= targetm
.memtag
.add_tag (base
, offset
,
1021 hwasan_current_frame_tag ());
1023 x
= plus_constant (Pmode
, base
, offset
);
1025 x
= gen_rtx_MEM (TREE_CODE (decl
) == SSA_NAME
1026 ? TYPE_MODE (TREE_TYPE (decl
))
1027 : DECL_MODE (decl
), x
);
1029 /* Set alignment we actually gave this decl if it isn't an SSA name.
1030 If it is we generate stack slots only accidentally so it isn't as
1031 important, we'll simply set the alignment directly on the MEM. */
1033 if (stack_vars_base_reg_p (base
))
1034 offset
-= frame_phase
;
1035 align
= known_alignment (offset
);
1036 align
*= BITS_PER_UNIT
;
1037 if (align
== 0 || align
> base_align
)
1040 if (TREE_CODE (decl
) != SSA_NAME
)
1042 /* One would think that we could assert that we're not decreasing
1043 alignment here, but (at least) the i386 port does exactly this
1044 via the MINIMUM_ALIGNMENT hook. */
1046 SET_DECL_ALIGN (decl
, align
);
1047 DECL_USER_ALIGN (decl
) = 0;
1052 set_mem_align (x
, align
);
1055 class stack_vars_data
1058 /* Vector of offset pairs, always end of some padding followed
1059 by start of the padding that needs Address Sanitizer protection.
1060 The vector is in reversed, highest offset pairs come first. */
1061 auto_vec
<HOST_WIDE_INT
> asan_vec
;
1063 /* Vector of partition representative decls in between the paddings. */
1064 auto_vec
<tree
> asan_decl_vec
;
1066 /* Base pseudo register for Address Sanitizer protected automatic vars. */
1069 /* Alignment needed for the Address Sanitizer protected automatic vars. */
1070 unsigned int asan_alignb
;
1073 /* A subroutine of expand_used_vars. Give each partition representative
1074 a unique location within the stack frame. Update each partition member
1075 with that location. */
1077 expand_stack_vars (bool (*pred
) (size_t), class stack_vars_data
*data
)
1079 size_t si
, i
, j
, n
= stack_vars_num
;
1080 poly_uint64 large_size
= 0, large_alloc
= 0;
1081 rtx large_base
= NULL
;
1082 rtx large_untagged_base
= NULL
;
1083 unsigned large_align
= 0;
1084 bool large_allocation_done
= false;
1087 /* Determine if there are any variables requiring "large" alignment.
1088 Since these are dynamically allocated, we only process these if
1089 no predicate involved. */
1090 large_align
= stack_vars
[stack_vars_sorted
[0]].alignb
* BITS_PER_UNIT
;
1091 if (pred
== NULL
&& large_align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1093 /* Find the total size of these variables. */
1094 for (si
= 0; si
< n
; ++si
)
1098 i
= stack_vars_sorted
[si
];
1099 alignb
= stack_vars
[i
].alignb
;
1101 /* All "large" alignment decls come before all "small" alignment
1102 decls, but "large" alignment decls are not sorted based on
1103 their alignment. Increase large_align to track the largest
1104 required alignment. */
1105 if ((alignb
* BITS_PER_UNIT
) > large_align
)
1106 large_align
= alignb
* BITS_PER_UNIT
;
1108 /* Stop when we get to the first decl with "small" alignment. */
1109 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
1112 /* Skip variables that aren't partition representatives. */
1113 if (stack_vars
[i
].representative
!= i
)
1116 /* Skip variables that have already had rtl assigned. See also
1117 add_stack_var where we perpetrate this pc_rtx hack. */
1118 decl
= stack_vars
[i
].decl
;
1119 if (TREE_CODE (decl
) == SSA_NAME
1120 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)] != NULL_RTX
1121 : DECL_RTL (decl
) != pc_rtx
)
1124 large_size
= aligned_upper_bound (large_size
, alignb
);
1125 large_size
+= stack_vars
[i
].size
;
1129 for (si
= 0; si
< n
; ++si
)
1132 unsigned base_align
, alignb
;
1133 poly_int64 offset
= 0;
1135 i
= stack_vars_sorted
[si
];
1137 /* Skip variables that aren't partition representatives, for now. */
1138 if (stack_vars
[i
].representative
!= i
)
1141 /* Skip variables that have already had rtl assigned. See also
1142 add_stack_var where we perpetrate this pc_rtx hack. */
1143 decl
= stack_vars
[i
].decl
;
1144 if (TREE_CODE (decl
) == SSA_NAME
1145 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)] != NULL_RTX
1146 : DECL_RTL (decl
) != pc_rtx
)
1149 /* Check the predicate to see whether this variable should be
1150 allocated in this pass. */
1151 if (pred
&& !pred (i
))
1154 base
= (hwasan_sanitize_stack_p ()
1155 ? hwasan_frame_base ()
1156 : virtual_stack_vars_rtx
);
1157 alignb
= stack_vars
[i
].alignb
;
1158 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
1160 poly_int64 hwasan_orig_offset
;
1161 if (hwasan_sanitize_stack_p ())
1163 /* There must be no tag granule "shared" between different
1164 objects. This means that no HWASAN_TAG_GRANULE_SIZE byte
1165 chunk can have more than one object in it.
1167 We ensure this by forcing the end of the last bit of data to
1168 be aligned to HWASAN_TAG_GRANULE_SIZE bytes here, and setting
1169 the start of each variable to be aligned to
1170 HWASAN_TAG_GRANULE_SIZE bytes in `align_local_variable`.
1172 We can't align just one of the start or end, since there are
1173 untagged things stored on the stack which we do not align to
1174 HWASAN_TAG_GRANULE_SIZE bytes. If we only aligned the start
1175 or the end of tagged objects then untagged objects could end
1176 up sharing the first granule of a tagged object or sharing the
1177 last granule of a tagged object respectively. */
1178 hwasan_orig_offset
= align_frame_offset (HWASAN_TAG_GRANULE_SIZE
);
1179 gcc_assert (stack_vars
[i
].alignb
>= HWASAN_TAG_GRANULE_SIZE
);
1181 /* ASAN description strings don't yet have a syntax for expressing
1182 polynomial offsets. */
1183 HOST_WIDE_INT prev_offset
;
1184 if (asan_sanitize_stack_p ()
1186 && frame_offset
.is_constant (&prev_offset
)
1187 && stack_vars
[i
].size
.is_constant ())
1189 if (data
->asan_vec
.is_empty ())
1191 align_frame_offset (ASAN_RED_ZONE_SIZE
);
1192 prev_offset
= frame_offset
.to_constant ();
1194 prev_offset
= align_base (prev_offset
,
1195 ASAN_MIN_RED_ZONE_SIZE
,
1196 !FRAME_GROWS_DOWNWARD
);
1197 tree repr_decl
= NULL_TREE
;
1198 unsigned HOST_WIDE_INT size
1199 = asan_var_and_redzone_size (stack_vars
[i
].size
.to_constant ());
1200 if (data
->asan_vec
.is_empty ())
1201 size
= MAX (size
, ASAN_RED_ZONE_SIZE
);
1203 unsigned HOST_WIDE_INT alignment
= MAX (alignb
,
1204 ASAN_MIN_RED_ZONE_SIZE
);
1205 offset
= alloc_stack_frame_space (size
, alignment
);
1207 data
->asan_vec
.safe_push (prev_offset
);
1208 /* Allocating a constant amount of space from a constant
1209 starting offset must give a constant result. */
1210 data
->asan_vec
.safe_push ((offset
+ stack_vars
[i
].size
)
1212 /* Find best representative of the partition.
1213 Prefer those with DECL_NAME, even better
1214 satisfying asan_protect_stack_decl predicate. */
1215 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1216 if (asan_protect_stack_decl (stack_vars
[j
].decl
)
1217 && DECL_NAME (stack_vars
[j
].decl
))
1219 repr_decl
= stack_vars
[j
].decl
;
1222 else if (repr_decl
== NULL_TREE
1223 && DECL_P (stack_vars
[j
].decl
)
1224 && DECL_NAME (stack_vars
[j
].decl
))
1225 repr_decl
= stack_vars
[j
].decl
;
1226 if (repr_decl
== NULL_TREE
)
1227 repr_decl
= stack_vars
[i
].decl
;
1228 data
->asan_decl_vec
.safe_push (repr_decl
);
1230 /* Make sure a representative is unpoison if another
1231 variable in the partition is handled by
1232 use-after-scope sanitization. */
1233 if (asan_handled_variables
!= NULL
1234 && !asan_handled_variables
->contains (repr_decl
))
1236 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1237 if (asan_handled_variables
->contains (stack_vars
[j
].decl
))
1240 asan_handled_variables
->add (repr_decl
);
1243 data
->asan_alignb
= MAX (data
->asan_alignb
, alignb
);
1244 if (data
->asan_base
== NULL
)
1245 data
->asan_base
= gen_reg_rtx (Pmode
);
1246 base
= data
->asan_base
;
1248 if (!STRICT_ALIGNMENT
)
1249 base_align
= crtl
->max_used_stack_slot_alignment
;
1251 base_align
= MAX (crtl
->max_used_stack_slot_alignment
,
1252 GET_MODE_ALIGNMENT (SImode
)
1253 << ASAN_SHADOW_SHIFT
);
1257 offset
= alloc_stack_frame_space (stack_vars
[i
].size
, alignb
);
1258 base_align
= crtl
->max_used_stack_slot_alignment
;
1260 if (hwasan_sanitize_stack_p ())
1262 /* Align again since the point of this alignment is to handle
1263 the "end" of the object (i.e. smallest address after the
1264 stack object). For FRAME_GROWS_DOWNWARD that requires
1265 aligning the stack before allocating, but for a frame that
1266 grows upwards that requires aligning the stack after
1269 Use `frame_offset` to record the offset value rather than
1270 `offset` since the `frame_offset` describes the extent
1271 allocated for this particular variable while `offset`
1272 describes the address that this variable starts at. */
1273 align_frame_offset (HWASAN_TAG_GRANULE_SIZE
);
1274 hwasan_record_stack_var (virtual_stack_vars_rtx
, base
,
1275 hwasan_orig_offset
, frame_offset
);
1281 /* Large alignment is only processed in the last pass. */
1285 /* If there were any variables requiring "large" alignment, allocate
1287 if (maybe_ne (large_size
, 0U) && ! large_allocation_done
)
1290 rtx large_allocsize
;
1292 large_allocsize
= gen_int_mode (large_size
, Pmode
);
1293 get_dynamic_stack_size (&large_allocsize
, 0, large_align
, NULL
);
1294 loffset
= alloc_stack_frame_space
1295 (rtx_to_poly_int64 (large_allocsize
),
1296 PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
);
1297 large_base
= get_dynamic_stack_base (loffset
, large_align
, base
);
1298 large_allocation_done
= true;
1301 gcc_assert (large_base
!= NULL
);
1302 large_alloc
= aligned_upper_bound (large_alloc
, alignb
);
1303 offset
= large_alloc
;
1304 large_alloc
+= stack_vars
[i
].size
;
1305 if (hwasan_sanitize_stack_p ())
1307 /* An object with a large alignment requirement means that the
1308 alignment requirement is greater than the required alignment
1310 if (!large_untagged_base
)
1312 = targetm
.memtag
.untagged_pointer (large_base
, NULL_RTX
);
1313 /* Ensure the end of the variable is also aligned correctly. */
1314 poly_int64 align_again
1315 = aligned_upper_bound (large_alloc
, HWASAN_TAG_GRANULE_SIZE
);
1316 /* For large allocations we always allocate a chunk of space
1317 (which is addressed by large_untagged_base/large_base) and
1318 then use positive offsets from that. Hence the farthest
1319 offset is `align_again` and the nearest offset from the base
1321 hwasan_record_stack_var (large_untagged_base
, large_base
,
1322 offset
, align_again
);
1326 base_align
= large_align
;
1329 /* Create rtl for each variable based on their location within the
1331 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1333 expand_one_stack_var_at (stack_vars
[j
].decl
,
1334 base
, base_align
, offset
);
1336 if (hwasan_sanitize_stack_p ())
1337 hwasan_increment_frame_tag ();
1340 gcc_assert (known_eq (large_alloc
, large_size
));
1343 /* Take into account all sizes of partitions and reset DECL_RTLs. */
1345 account_stack_vars (void)
1347 size_t si
, j
, i
, n
= stack_vars_num
;
1348 poly_uint64 size
= 0;
1350 for (si
= 0; si
< n
; ++si
)
1352 i
= stack_vars_sorted
[si
];
1354 /* Skip variables that aren't partition representatives, for now. */
1355 if (stack_vars
[i
].representative
!= i
)
1358 size
+= stack_vars
[i
].size
;
1359 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1360 set_rtl (stack_vars
[j
].decl
, NULL
);
1365 /* Record the RTL assignment X for the default def of PARM. */
1368 set_parm_rtl (tree parm
, rtx x
)
1370 gcc_assert (TREE_CODE (parm
) == PARM_DECL
1371 || TREE_CODE (parm
) == RESULT_DECL
);
1373 if (x
&& !MEM_P (x
))
1375 unsigned int align
= MINIMUM_ALIGNMENT (TREE_TYPE (parm
),
1376 TYPE_MODE (TREE_TYPE (parm
)),
1377 TYPE_ALIGN (TREE_TYPE (parm
)));
1379 /* If the variable alignment is very large we'll dynamicaly
1380 allocate it, which means that in-frame portion is just a
1381 pointer. ??? We've got a pseudo for sure here, do we
1382 actually dynamically allocate its spilling area if needed?
1383 ??? Isn't it a problem when Pmode alignment also exceeds
1384 MAX_SUPPORTED_STACK_ALIGNMENT, as can happen on cris and lm32? */
1385 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1386 align
= GET_MODE_ALIGNMENT (Pmode
);
1388 record_alignment_for_reg_var (align
);
1391 tree ssa
= ssa_default_def (cfun
, parm
);
1393 return set_rtl (parm
, x
);
1395 int part
= var_to_partition (SA
.map
, ssa
);
1396 gcc_assert (part
!= NO_PARTITION
);
1398 bool changed
= bitmap_bit_p (SA
.partitions_for_parm_default_defs
, part
);
1399 gcc_assert (changed
);
1402 gcc_assert (DECL_RTL (parm
) == x
);
1405 /* A subroutine of expand_one_var. Called to immediately assign rtl
1406 to a variable to be allocated in the stack frame. */
1409 expand_one_stack_var_1 (tree var
)
1413 unsigned byte_align
;
1415 if (TREE_CODE (var
) == SSA_NAME
)
1417 tree type
= TREE_TYPE (var
);
1418 size
= tree_to_poly_uint64 (TYPE_SIZE_UNIT (type
));
1421 size
= tree_to_poly_uint64 (DECL_SIZE_UNIT (var
));
1423 byte_align
= align_local_variable (var
, true);
1425 /* We handle highly aligned variables in expand_stack_vars. */
1426 gcc_assert (byte_align
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
);
1429 if (hwasan_sanitize_stack_p ())
1431 /* Allocate zero bytes to align the stack. */
1432 poly_int64 hwasan_orig_offset
1433 = align_frame_offset (HWASAN_TAG_GRANULE_SIZE
);
1434 offset
= alloc_stack_frame_space (size
, byte_align
);
1435 align_frame_offset (HWASAN_TAG_GRANULE_SIZE
);
1436 base
= hwasan_frame_base ();
1437 /* Use `frame_offset` to automatically account for machines where the
1438 frame grows upwards.
1440 `offset` will always point to the "start" of the stack object, which
1441 will be the smallest address, for ! FRAME_GROWS_DOWNWARD this is *not*
1442 the "furthest" offset from the base delimiting the current stack
1443 object. `frame_offset` will always delimit the extent that the frame.
1445 hwasan_record_stack_var (virtual_stack_vars_rtx
, base
,
1446 hwasan_orig_offset
, frame_offset
);
1450 offset
= alloc_stack_frame_space (size
, byte_align
);
1451 base
= virtual_stack_vars_rtx
;
1454 expand_one_stack_var_at (var
, base
,
1455 crtl
->max_used_stack_slot_alignment
, offset
);
1457 if (hwasan_sanitize_stack_p ())
1458 hwasan_increment_frame_tag ();
1461 /* Wrapper for expand_one_stack_var_1 that checks SSA_NAMEs are
1462 already assigned some MEM. */
1465 expand_one_stack_var (tree var
)
1467 if (TREE_CODE (var
) == SSA_NAME
)
1469 int part
= var_to_partition (SA
.map
, var
);
1470 if (part
!= NO_PARTITION
)
1472 rtx x
= SA
.partition_to_pseudo
[part
];
1474 gcc_assert (MEM_P (x
));
1479 return expand_one_stack_var_1 (var
);
1482 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1483 that will reside in a hard register. */
1486 expand_one_hard_reg_var (tree var
)
1488 rest_of_decl_compilation (var
, 0, 0);
1491 /* Record the alignment requirements of some variable assigned to a
1495 record_alignment_for_reg_var (unsigned int align
)
1497 if (SUPPORTS_STACK_ALIGNMENT
1498 && crtl
->stack_alignment_estimated
< align
)
1500 /* stack_alignment_estimated shouldn't change after stack
1501 realign decision made */
1502 gcc_assert (!crtl
->stack_realign_processed
);
1503 crtl
->stack_alignment_estimated
= align
;
1506 /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
1507 So here we only make sure stack_alignment_needed >= align. */
1508 if (crtl
->stack_alignment_needed
< align
)
1509 crtl
->stack_alignment_needed
= align
;
1510 if (crtl
->max_used_stack_slot_alignment
< align
)
1511 crtl
->max_used_stack_slot_alignment
= align
;
1514 /* Create RTL for an SSA partition. */
1517 expand_one_ssa_partition (tree var
)
1519 int part
= var_to_partition (SA
.map
, var
);
1520 gcc_assert (part
!= NO_PARTITION
);
1522 if (SA
.partition_to_pseudo
[part
])
1525 unsigned int align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1526 TYPE_MODE (TREE_TYPE (var
)),
1527 TYPE_ALIGN (TREE_TYPE (var
)));
1529 /* If the variable alignment is very large we'll dynamicaly allocate
1530 it, which means that in-frame portion is just a pointer. */
1531 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1532 align
= GET_MODE_ALIGNMENT (Pmode
);
1534 record_alignment_for_reg_var (align
);
1536 if (!use_register_for_decl (var
))
1538 if (defer_stack_allocation (var
, true))
1539 add_stack_var (var
, true);
1541 expand_one_stack_var_1 (var
);
1545 machine_mode reg_mode
= promote_ssa_mode (var
, NULL
);
1546 rtx x
= gen_reg_rtx (reg_mode
);
1550 /* For a promoted variable, X will not be used directly but wrapped in a
1551 SUBREG with SUBREG_PROMOTED_VAR_P set, which means that the RTL land
1552 will assume that its upper bits can be inferred from its lower bits.
1553 Therefore, if X isn't initialized on every path from the entry, then
1554 we must do it manually in order to fulfill the above assumption. */
1555 if (reg_mode
!= TYPE_MODE (TREE_TYPE (var
))
1556 && bitmap_bit_p (SA
.partitions_for_undefined_values
, part
))
1557 emit_move_insn (x
, CONST0_RTX (reg_mode
));
1560 /* Record the association between the RTL generated for partition PART
1561 and the underlying variable of the SSA_NAME VAR. */
1564 adjust_one_expanded_partition_var (tree var
)
1569 tree decl
= SSA_NAME_VAR (var
);
1571 int part
= var_to_partition (SA
.map
, var
);
1572 if (part
== NO_PARTITION
)
1575 rtx x
= SA
.partition_to_pseudo
[part
];
1584 /* Note if the object is a user variable. */
1585 if (decl
&& !DECL_ARTIFICIAL (decl
))
1588 if (POINTER_TYPE_P (decl
? TREE_TYPE (decl
) : TREE_TYPE (var
)))
1589 mark_reg_pointer (x
, get_pointer_alignment (var
));
1592 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1593 that will reside in a pseudo register. */
1596 expand_one_register_var (tree var
)
1598 if (TREE_CODE (var
) == SSA_NAME
)
1600 int part
= var_to_partition (SA
.map
, var
);
1601 if (part
!= NO_PARTITION
)
1603 rtx x
= SA
.partition_to_pseudo
[part
];
1605 gcc_assert (REG_P (x
));
1612 tree type
= TREE_TYPE (decl
);
1613 machine_mode reg_mode
= promote_decl_mode (decl
, NULL
);
1614 rtx x
= gen_reg_rtx (reg_mode
);
1618 /* Note if the object is a user variable. */
1619 if (!DECL_ARTIFICIAL (decl
))
1622 if (POINTER_TYPE_P (type
))
1623 mark_reg_pointer (x
, get_pointer_alignment (var
));
1626 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
1627 has some associated error, e.g. its type is error-mark. We just need
1628 to pick something that won't crash the rest of the compiler. */
1631 expand_one_error_var (tree var
)
1633 machine_mode mode
= DECL_MODE (var
);
1636 if (mode
== BLKmode
)
1637 x
= gen_rtx_MEM (BLKmode
, const0_rtx
);
1638 else if (mode
== VOIDmode
)
1641 x
= gen_reg_rtx (mode
);
1643 SET_DECL_RTL (var
, x
);
1646 /* A subroutine of expand_one_var. VAR is a variable that will be
1647 allocated to the local stack frame. Return true if we wish to
1648 add VAR to STACK_VARS so that it will be coalesced with other
1649 variables. Return false to allocate VAR immediately.
1651 This function is used to reduce the number of variables considered
1652 for coalescing, which reduces the size of the quadratic problem. */
1655 defer_stack_allocation (tree var
, bool toplevel
)
1657 tree size_unit
= TREE_CODE (var
) == SSA_NAME
1658 ? TYPE_SIZE_UNIT (TREE_TYPE (var
))
1659 : DECL_SIZE_UNIT (var
);
1662 /* Whether the variable is small enough for immediate allocation not to be
1663 a problem with regard to the frame size. */
1665 = (poly_int_tree_p (size_unit
, &size
)
1666 && (estimated_poly_value (size
)
1667 < param_min_size_for_stack_sharing
));
1669 /* If stack protection is enabled, *all* stack variables must be deferred,
1670 so that we can re-order the strings to the top of the frame.
1671 Similarly for Address Sanitizer. */
1672 if (flag_stack_protect
|| asan_sanitize_stack_p ())
1675 unsigned int align
= TREE_CODE (var
) == SSA_NAME
1676 ? TYPE_ALIGN (TREE_TYPE (var
))
1679 /* We handle "large" alignment via dynamic allocation. We want to handle
1680 this extra complication in only one place, so defer them. */
1681 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1684 bool ignored
= TREE_CODE (var
) == SSA_NAME
1685 ? !SSAVAR (var
) || DECL_IGNORED_P (SSA_NAME_VAR (var
))
1686 : DECL_IGNORED_P (var
);
1688 /* When optimization is enabled, DECL_IGNORED_P variables originally scoped
1689 might be detached from their block and appear at toplevel when we reach
1690 here. We want to coalesce them with variables from other blocks when
1691 the immediate contribution to the frame size would be noticeable. */
1692 if (toplevel
&& optimize
> 0 && ignored
&& !smallish
)
1695 /* Variables declared in the outermost scope automatically conflict
1696 with every other variable. The only reason to want to defer them
1697 at all is that, after sorting, we can more efficiently pack
1698 small variables in the stack frame. Continue to defer at -O2. */
1699 if (toplevel
&& optimize
< 2)
1702 /* Without optimization, *most* variables are allocated from the
1703 stack, which makes the quadratic problem large exactly when we
1704 want compilation to proceed as quickly as possible. On the
1705 other hand, we don't want the function's stack frame size to
1706 get completely out of hand. So we avoid adding scalars and
1707 "small" aggregates to the list at all. */
1708 if (optimize
== 0 && smallish
)
1714 /* A subroutine of expand_used_vars. Expand one variable according to
1715 its flavor. Variables to be placed on the stack are not actually
1716 expanded yet, merely recorded.
1717 When REALLY_EXPAND is false, only add stack values to be allocated.
1718 Return stack usage this variable is supposed to take.
1722 expand_one_var (tree var
, bool toplevel
, bool really_expand
)
1724 unsigned int align
= BITS_PER_UNIT
;
1729 if (TREE_TYPE (var
) != error_mark_node
&& VAR_P (var
))
1731 if (is_global_var (var
))
1734 /* Because we don't know if VAR will be in register or on stack,
1735 we conservatively assume it will be on stack even if VAR is
1736 eventually put into register after RA pass. For non-automatic
1737 variables, which won't be on stack, we collect alignment of
1738 type and ignore user specified alignment. Similarly for
1739 SSA_NAMEs for which use_register_for_decl returns true. */
1740 if (TREE_STATIC (var
)
1741 || DECL_EXTERNAL (var
)
1742 || (TREE_CODE (origvar
) == SSA_NAME
&& use_register_for_decl (var
)))
1743 align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1744 TYPE_MODE (TREE_TYPE (var
)),
1745 TYPE_ALIGN (TREE_TYPE (var
)));
1746 else if (DECL_HAS_VALUE_EXPR_P (var
)
1747 || (DECL_RTL_SET_P (var
) && MEM_P (DECL_RTL (var
))))
1748 /* Don't consider debug only variables with DECL_HAS_VALUE_EXPR_P set
1749 or variables which were assigned a stack slot already by
1750 expand_one_stack_var_at - in the latter case DECL_ALIGN has been
1751 changed from the offset chosen to it. */
1752 align
= crtl
->stack_alignment_estimated
;
1754 align
= MINIMUM_ALIGNMENT (var
, DECL_MODE (var
), DECL_ALIGN (var
));
1756 /* If the variable alignment is very large we'll dynamicaly allocate
1757 it, which means that in-frame portion is just a pointer. */
1758 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1759 align
= GET_MODE_ALIGNMENT (Pmode
);
1762 record_alignment_for_reg_var (align
);
1765 if (TREE_CODE (origvar
) == SSA_NAME
)
1767 gcc_assert (!VAR_P (var
)
1768 || (!DECL_EXTERNAL (var
)
1769 && !DECL_HAS_VALUE_EXPR_P (var
)
1770 && !TREE_STATIC (var
)
1771 && TREE_TYPE (var
) != error_mark_node
1772 && !DECL_HARD_REGISTER (var
)
1775 if (!VAR_P (var
) && TREE_CODE (origvar
) != SSA_NAME
)
1777 else if (DECL_EXTERNAL (var
))
1779 else if (DECL_HAS_VALUE_EXPR_P (var
))
1781 else if (TREE_STATIC (var
))
1783 else if (TREE_CODE (origvar
) != SSA_NAME
&& DECL_RTL_SET_P (var
))
1785 else if (TREE_TYPE (var
) == error_mark_node
)
1788 expand_one_error_var (var
);
1790 else if (VAR_P (var
) && DECL_HARD_REGISTER (var
))
1794 expand_one_hard_reg_var (var
);
1795 if (!DECL_HARD_REGISTER (var
))
1796 /* Invalid register specification. */
1797 expand_one_error_var (var
);
1800 else if (use_register_for_decl (var
))
1803 expand_one_register_var (origvar
);
1805 else if (!poly_int_tree_p (DECL_SIZE_UNIT (var
), &size
)
1806 || !valid_constant_size_p (DECL_SIZE_UNIT (var
)))
1808 /* Reject variables which cover more than half of the address-space. */
1811 if (DECL_NONLOCAL_FRAME (var
))
1812 error_at (DECL_SOURCE_LOCATION (current_function_decl
),
1813 "total size of local objects is too large");
1815 error_at (DECL_SOURCE_LOCATION (var
),
1816 "size of variable %q+D is too large", var
);
1817 expand_one_error_var (var
);
1820 else if (defer_stack_allocation (var
, toplevel
))
1821 add_stack_var (origvar
, really_expand
);
1826 if (lookup_attribute ("naked",
1827 DECL_ATTRIBUTES (current_function_decl
)))
1828 error ("cannot allocate stack for variable %q+D, naked function",
1831 expand_one_stack_var (origvar
);
1838 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1839 expanding variables. Those variables that can be put into registers
1840 are allocated pseudos; those that can't are put on the stack.
1842 TOPLEVEL is true if this is the outermost BLOCK. */
1845 expand_used_vars_for_block (tree block
, bool toplevel
)
1849 /* Expand all variables at this level. */
1850 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1852 && ((!VAR_P (t
) && TREE_CODE (t
) != RESULT_DECL
)
1853 || !DECL_NONSHAREABLE (t
)))
1854 expand_one_var (t
, toplevel
, true);
1856 /* Expand all variables at containing levels. */
1857 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1858 expand_used_vars_for_block (t
, false);
1861 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1862 and clear TREE_USED on all local variables. */
1865 clear_tree_used (tree block
)
1869 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1870 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
1871 if ((!VAR_P (t
) && TREE_CODE (t
) != RESULT_DECL
)
1872 || !DECL_NONSHAREABLE (t
))
1875 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1876 clear_tree_used (t
);
1879 /* Examine TYPE and determine a bit mask of the following features. */
1881 #define SPCT_HAS_LARGE_CHAR_ARRAY 1
1882 #define SPCT_HAS_SMALL_CHAR_ARRAY 2
1883 #define SPCT_HAS_ARRAY 4
1884 #define SPCT_HAS_AGGREGATE 8
1887 stack_protect_classify_type (tree type
)
1889 unsigned int ret
= 0;
1892 switch (TREE_CODE (type
))
1895 t
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1896 if (t
== char_type_node
1897 || t
== signed_char_type_node
1898 || t
== unsigned_char_type_node
)
1900 unsigned HOST_WIDE_INT max
= param_ssp_buffer_size
;
1901 unsigned HOST_WIDE_INT len
;
1903 if (!TYPE_SIZE_UNIT (type
)
1904 || !tree_fits_uhwi_p (TYPE_SIZE_UNIT (type
)))
1907 len
= tree_to_uhwi (TYPE_SIZE_UNIT (type
));
1910 ret
= SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1912 ret
= SPCT_HAS_LARGE_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1915 ret
= SPCT_HAS_ARRAY
;
1919 case QUAL_UNION_TYPE
:
1921 ret
= SPCT_HAS_AGGREGATE
;
1922 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
1923 if (TREE_CODE (t
) == FIELD_DECL
)
1924 ret
|= stack_protect_classify_type (TREE_TYPE (t
));
1934 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
1935 part of the local stack frame. Remember if we ever return nonzero for
1936 any variable in this function. The return value is the phase number in
1937 which the variable should be allocated. */
1940 stack_protect_decl_phase (tree decl
)
1942 unsigned int bits
= stack_protect_classify_type (TREE_TYPE (decl
));
1945 if (bits
& SPCT_HAS_SMALL_CHAR_ARRAY
)
1946 has_short_buffer
= true;
1948 tree attribs
= DECL_ATTRIBUTES (current_function_decl
);
1949 if (!lookup_attribute ("no_stack_protector", attribs
)
1950 && (flag_stack_protect
== SPCT_FLAG_ALL
1951 || flag_stack_protect
== SPCT_FLAG_STRONG
1952 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
1953 && lookup_attribute ("stack_protect", attribs
))))
1955 if ((bits
& (SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_LARGE_CHAR_ARRAY
))
1956 && !(bits
& SPCT_HAS_AGGREGATE
))
1958 else if (bits
& SPCT_HAS_ARRAY
)
1962 ret
= (bits
& SPCT_HAS_LARGE_CHAR_ARRAY
) != 0;
1965 has_protected_decls
= true;
1970 /* Two helper routines that check for phase 1 and phase 2. These are used
1971 as callbacks for expand_stack_vars. */
1974 stack_protect_decl_phase_1 (size_t i
)
1976 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 1;
1980 stack_protect_decl_phase_2 (size_t i
)
1982 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 2;
1985 /* And helper function that checks for asan phase (with stack protector
1986 it is phase 3). This is used as callback for expand_stack_vars.
1987 Returns true if any of the vars in the partition need to be protected. */
1990 asan_decl_phase_3 (size_t i
)
1994 if (asan_protect_stack_decl (stack_vars
[i
].decl
))
1996 i
= stack_vars
[i
].next
;
2001 /* Ensure that variables in different stack protection phases conflict
2002 so that they are not merged and share the same stack slot.
2003 Return true if there are any address taken variables. */
2006 add_stack_protection_conflicts (void)
2008 size_t i
, j
, n
= stack_vars_num
;
2009 unsigned char *phase
;
2012 phase
= XNEWVEC (unsigned char, n
);
2013 for (i
= 0; i
< n
; ++i
)
2015 phase
[i
] = stack_protect_decl_phase (stack_vars
[i
].decl
);
2016 if (TREE_ADDRESSABLE (stack_vars
[i
].decl
))
2020 for (i
= 0; i
< n
; ++i
)
2022 unsigned char ph_i
= phase
[i
];
2023 for (j
= i
+ 1; j
< n
; ++j
)
2024 if (ph_i
!= phase
[j
])
2025 add_stack_var_conflict (i
, j
);
2032 /* Create a decl for the guard at the top of the stack frame. */
2035 create_stack_guard (void)
2037 tree guard
= build_decl (DECL_SOURCE_LOCATION (current_function_decl
),
2038 VAR_DECL
, NULL
, ptr_type_node
);
2039 TREE_THIS_VOLATILE (guard
) = 1;
2040 TREE_USED (guard
) = 1;
2041 expand_one_stack_var (guard
);
2042 crtl
->stack_protect_guard
= guard
;
2045 /* Prepare for expanding variables. */
2047 init_vars_expansion (void)
2049 /* Conflict bitmaps, and a few related temporary bitmaps, go here. */
2050 bitmap_obstack_initialize (&stack_var_bitmap_obstack
);
2052 /* A map from decl to stack partition. */
2053 decl_to_stack_part
= new hash_map
<tree
, size_t>;
2055 /* Initialize local stack smashing state. */
2056 has_protected_decls
= false;
2057 has_short_buffer
= false;
2058 if (hwasan_sanitize_stack_p ())
2059 hwasan_record_frame_init ();
2062 /* Free up stack variable graph data. */
2064 fini_vars_expansion (void)
2066 bitmap_obstack_release (&stack_var_bitmap_obstack
);
2068 XDELETEVEC (stack_vars
);
2069 if (stack_vars_sorted
)
2070 XDELETEVEC (stack_vars_sorted
);
2072 stack_vars_sorted
= NULL
;
2073 stack_vars_alloc
= stack_vars_num
= 0;
2074 delete decl_to_stack_part
;
2075 decl_to_stack_part
= NULL
;
2078 /* Make a fair guess for the size of the stack frame of the function
2079 in NODE. This doesn't have to be exact, the result is only used in
2080 the inline heuristics. So we don't want to run the full stack var
2081 packing algorithm (which is quadratic in the number of stack vars).
2082 Instead, we calculate the total size of all stack vars. This turns
2083 out to be a pretty fair estimate -- packing of stack vars doesn't
2084 happen very often. */
2087 estimated_stack_frame_size (struct cgraph_node
*node
)
2089 poly_int64 size
= 0;
2092 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
2096 init_vars_expansion ();
2098 FOR_EACH_LOCAL_DECL (fn
, i
, var
)
2099 if (auto_var_in_fn_p (var
, fn
->decl
))
2100 size
+= expand_one_var (var
, true, false);
2102 if (stack_vars_num
> 0)
2104 /* Fake sorting the stack vars for account_stack_vars (). */
2105 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
2106 for (i
= 0; i
< stack_vars_num
; ++i
)
2107 stack_vars_sorted
[i
] = i
;
2108 size
+= account_stack_vars ();
2111 fini_vars_expansion ();
2113 return estimated_poly_value (size
);
2116 /* Check if the current function has calls that use a return slot. */
2119 stack_protect_return_slot_p ()
2123 FOR_ALL_BB_FN (bb
, cfun
)
2124 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
2125 !gsi_end_p (gsi
); gsi_next (&gsi
))
2127 gimple
*stmt
= gsi_stmt (gsi
);
2128 /* This assumes that calls to internal-only functions never
2129 use a return slot. */
2130 if (is_gimple_call (stmt
)
2131 && !gimple_call_internal_p (stmt
)
2132 && aggregate_value_p (TREE_TYPE (gimple_call_fntype (stmt
)),
2133 gimple_call_fndecl (stmt
)))
2139 /* Expand all variables used in the function. */
2142 expand_used_vars (void)
2144 tree var
, outer_block
= DECL_INITIAL (current_function_decl
);
2145 auto_vec
<tree
> maybe_local_decls
;
2146 rtx_insn
*var_end_seq
= NULL
;
2149 bool gen_stack_protect_signal
= false;
2151 /* Compute the phase of the stack frame for this function. */
2153 int align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
2154 int off
= targetm
.starting_frame_offset () % align
;
2155 frame_phase
= off
? align
- off
: 0;
2158 /* Set TREE_USED on all variables in the local_decls. */
2159 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
2160 TREE_USED (var
) = 1;
2161 /* Clear TREE_USED on all variables associated with a block scope. */
2162 clear_tree_used (DECL_INITIAL (current_function_decl
));
2164 init_vars_expansion ();
2166 if (targetm
.use_pseudo_pic_reg ())
2167 pic_offset_table_rtx
= gen_reg_rtx (Pmode
);
2169 for (i
= 0; i
< SA
.map
->num_partitions
; i
++)
2171 if (bitmap_bit_p (SA
.partitions_for_parm_default_defs
, i
))
2174 tree var
= partition_to_var (SA
.map
, i
);
2176 gcc_assert (!virtual_operand_p (var
));
2178 expand_one_ssa_partition (var
);
2181 if (flag_stack_protect
== SPCT_FLAG_STRONG
)
2182 gen_stack_protect_signal
= stack_protect_return_slot_p ();
2184 /* At this point all variables on the local_decls with TREE_USED
2185 set are not associated with any block scope. Lay them out. */
2187 len
= vec_safe_length (cfun
->local_decls
);
2188 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
2190 bool expand_now
= false;
2192 /* Expanded above already. */
2193 if (is_gimple_reg (var
))
2195 TREE_USED (var
) = 0;
2198 /* We didn't set a block for static or extern because it's hard
2199 to tell the difference between a global variable (re)declared
2200 in a local scope, and one that's really declared there to
2201 begin with. And it doesn't really matter much, since we're
2202 not giving them stack space. Expand them now. */
2203 else if (TREE_STATIC (var
) || DECL_EXTERNAL (var
))
2206 /* Expand variables not associated with any block now. Those created by
2207 the optimizers could be live anywhere in the function. Those that
2208 could possibly have been scoped originally and detached from their
2209 block will have their allocation deferred so we coalesce them with
2210 others when optimization is enabled. */
2211 else if (TREE_USED (var
))
2214 /* Finally, mark all variables on the list as used. We'll use
2215 this in a moment when we expand those associated with scopes. */
2216 TREE_USED (var
) = 1;
2219 expand_one_var (var
, true, true);
2222 if (DECL_ARTIFICIAL (var
) && !DECL_IGNORED_P (var
))
2224 rtx rtl
= DECL_RTL_IF_SET (var
);
2226 /* Keep artificial non-ignored vars in cfun->local_decls
2227 chain until instantiate_decls. */
2228 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
2229 add_local_decl (cfun
, var
);
2230 else if (rtl
== NULL_RTX
)
2231 /* If rtl isn't set yet, which can happen e.g. with
2232 -fstack-protector, retry before returning from this
2234 maybe_local_decls
.safe_push (var
);
2238 /* We duplicated some of the decls in CFUN->LOCAL_DECLS.
2240 +-----------------+-----------------+
2241 | ...processed... | ...duplicates...|
2242 +-----------------+-----------------+
2244 +-- LEN points here.
2246 We just want the duplicates, as those are the artificial
2247 non-ignored vars that we want to keep until instantiate_decls.
2248 Move them down and truncate the array. */
2249 if (!vec_safe_is_empty (cfun
->local_decls
))
2250 cfun
->local_decls
->block_remove (0, len
);
2252 /* At this point, all variables within the block tree with TREE_USED
2253 set are actually used by the optimized function. Lay them out. */
2254 expand_used_vars_for_block (outer_block
, true);
2256 tree attribs
= DECL_ATTRIBUTES (current_function_decl
);
2257 if (stack_vars_num
> 0)
2259 bool has_addressable_vars
= false;
2261 add_scope_conflicts ();
2263 /* If stack protection is enabled, we don't share space between
2264 vulnerable data and non-vulnerable data. */
2265 if (flag_stack_protect
!= 0
2266 && !lookup_attribute ("no_stack_protector", attribs
)
2267 && (flag_stack_protect
!= SPCT_FLAG_EXPLICIT
2268 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
2269 && lookup_attribute ("stack_protect", attribs
))))
2270 has_addressable_vars
= add_stack_protection_conflicts ();
2272 if (flag_stack_protect
== SPCT_FLAG_STRONG
&& has_addressable_vars
)
2273 gen_stack_protect_signal
= true;
2275 /* Now that we have collected all stack variables, and have computed a
2276 minimal interference graph, attempt to save some stack space. */
2277 partition_stack_vars ();
2279 dump_stack_var_partition ();
2283 if (!lookup_attribute ("no_stack_protector", attribs
))
2284 switch (flag_stack_protect
)
2287 create_stack_guard ();
2290 case SPCT_FLAG_STRONG
:
2291 if (gen_stack_protect_signal
2292 || cfun
->calls_alloca
2293 || has_protected_decls
2294 || lookup_attribute ("stack_protect",
2295 DECL_ATTRIBUTES (current_function_decl
)))
2296 create_stack_guard ();
2299 case SPCT_FLAG_DEFAULT
:
2300 if (cfun
->calls_alloca
2301 || has_protected_decls
2302 || lookup_attribute ("stack_protect",
2303 DECL_ATTRIBUTES (current_function_decl
)))
2304 create_stack_guard ();
2307 case SPCT_FLAG_EXPLICIT
:
2308 if (lookup_attribute ("stack_protect",
2309 DECL_ATTRIBUTES (current_function_decl
)))
2310 create_stack_guard ();
2317 /* Assign rtl to each variable based on these partitions. */
2318 if (stack_vars_num
> 0)
2320 class stack_vars_data data
;
2322 data
.asan_base
= NULL_RTX
;
2323 data
.asan_alignb
= 0;
2325 /* Reorder decls to be protected by iterating over the variables
2326 array multiple times, and allocating out of each phase in turn. */
2327 /* ??? We could probably integrate this into the qsort we did
2328 earlier, such that we naturally see these variables first,
2329 and thus naturally allocate things in the right order. */
2330 if (has_protected_decls
)
2332 /* Phase 1 contains only character arrays. */
2333 expand_stack_vars (stack_protect_decl_phase_1
, &data
);
2335 /* Phase 2 contains other kinds of arrays. */
2336 if (!lookup_attribute ("no_stack_protector", attribs
)
2337 && (flag_stack_protect
== SPCT_FLAG_ALL
2338 || flag_stack_protect
== SPCT_FLAG_STRONG
2339 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
2340 && lookup_attribute ("stack_protect", attribs
))))
2341 expand_stack_vars (stack_protect_decl_phase_2
, &data
);
2344 if (asan_sanitize_stack_p ())
2345 /* Phase 3, any partitions that need asan protection
2346 in addition to phase 1 and 2. */
2347 expand_stack_vars (asan_decl_phase_3
, &data
);
2349 /* ASAN description strings don't yet have a syntax for expressing
2350 polynomial offsets. */
2351 HOST_WIDE_INT prev_offset
;
2352 if (!data
.asan_vec
.is_empty ()
2353 && frame_offset
.is_constant (&prev_offset
))
2355 HOST_WIDE_INT offset
, sz
, redzonesz
;
2356 redzonesz
= ASAN_RED_ZONE_SIZE
;
2357 sz
= data
.asan_vec
[0] - prev_offset
;
2358 if (data
.asan_alignb
> ASAN_RED_ZONE_SIZE
2359 && data
.asan_alignb
<= 4096
2360 && sz
+ ASAN_RED_ZONE_SIZE
>= (int) data
.asan_alignb
)
2361 redzonesz
= ((sz
+ ASAN_RED_ZONE_SIZE
+ data
.asan_alignb
- 1)
2362 & ~(data
.asan_alignb
- HOST_WIDE_INT_1
)) - sz
;
2363 /* Allocating a constant amount of space from a constant
2364 starting offset must give a constant result. */
2365 offset
= (alloc_stack_frame_space (redzonesz
, ASAN_RED_ZONE_SIZE
)
2367 data
.asan_vec
.safe_push (prev_offset
);
2368 data
.asan_vec
.safe_push (offset
);
2369 /* Leave space for alignment if STRICT_ALIGNMENT. */
2370 if (STRICT_ALIGNMENT
)
2371 alloc_stack_frame_space ((GET_MODE_ALIGNMENT (SImode
)
2372 << ASAN_SHADOW_SHIFT
)
2373 / BITS_PER_UNIT
, 1);
2376 = asan_emit_stack_protection (virtual_stack_vars_rtx
,
2379 data
.asan_vec
.address (),
2380 data
.asan_decl_vec
.address (),
2381 data
.asan_vec
.length ());
2384 expand_stack_vars (NULL
, &data
);
2387 if (hwasan_sanitize_stack_p ())
2388 hwasan_emit_prologue ();
2389 if (asan_sanitize_allocas_p () && cfun
->calls_alloca
)
2390 var_end_seq
= asan_emit_allocas_unpoison (virtual_stack_dynamic_rtx
,
2391 virtual_stack_vars_rtx
,
2393 else if (hwasan_sanitize_allocas_p () && cfun
->calls_alloca
)
2394 /* When using out-of-line instrumentation we only want to emit one function
2395 call for clearing the tags in a region of shadow stack. When there are
2396 alloca calls in this frame we want to emit a call using the
2397 virtual_stack_dynamic_rtx, but when not we use the hwasan_frame_extent
2398 rtx we created in expand_stack_vars. */
2399 var_end_seq
= hwasan_emit_untag_frame (virtual_stack_dynamic_rtx
,
2400 virtual_stack_vars_rtx
);
2401 else if (hwasan_sanitize_stack_p ())
2402 /* If no variables were stored on the stack, `hwasan_get_frame_extent`
2403 will return NULL_RTX and hence `hwasan_emit_untag_frame` will return
2404 NULL (i.e. an empty sequence). */
2405 var_end_seq
= hwasan_emit_untag_frame (hwasan_get_frame_extent (),
2406 virtual_stack_vars_rtx
);
2408 fini_vars_expansion ();
2410 /* If there were any artificial non-ignored vars without rtl
2411 found earlier, see if deferred stack allocation hasn't assigned
2413 FOR_EACH_VEC_ELT_REVERSE (maybe_local_decls
, i
, var
)
2415 rtx rtl
= DECL_RTL_IF_SET (var
);
2417 /* Keep artificial non-ignored vars in cfun->local_decls
2418 chain until instantiate_decls. */
2419 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
2420 add_local_decl (cfun
, var
);
2423 /* If the target requires that FRAME_OFFSET be aligned, do it. */
2424 if (STACK_ALIGNMENT_NEEDED
)
2426 HOST_WIDE_INT align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
2427 if (FRAME_GROWS_DOWNWARD
)
2428 frame_offset
= aligned_lower_bound (frame_offset
, align
);
2430 frame_offset
= aligned_upper_bound (frame_offset
, align
);
2437 /* If we need to produce a detailed dump, print the tree representation
2438 for STMT to the dump file. SINCE is the last RTX after which the RTL
2439 generated for STMT should have been appended. */
2442 maybe_dump_rtl_for_gimple_stmt (gimple
*stmt
, rtx_insn
*since
)
2444 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2446 fprintf (dump_file
, "\n;; ");
2447 print_gimple_stmt (dump_file
, stmt
, 0,
2448 TDF_SLIM
| (dump_flags
& TDF_LINENO
));
2449 fprintf (dump_file
, "\n");
2451 print_rtl (dump_file
, since
? NEXT_INSN (since
) : since
);
2455 /* Maps the blocks that do not contain tree labels to rtx labels. */
2457 static hash_map
<basic_block
, rtx_code_label
*> *lab_rtx_for_bb
;
2459 /* Returns the label_rtx expression for a label starting basic block BB. */
2461 static rtx_code_label
*
2462 label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED
)
2464 gimple_stmt_iterator gsi
;
2467 if (bb
->flags
& BB_RTL
)
2468 return block_label (bb
);
2470 rtx_code_label
**elt
= lab_rtx_for_bb
->get (bb
);
2474 /* Find the tree label if it is present. */
2476 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2480 lab_stmt
= dyn_cast
<glabel
*> (gsi_stmt (gsi
));
2484 lab
= gimple_label_label (lab_stmt
);
2485 if (DECL_NONLOCAL (lab
))
2488 return jump_target_rtx (lab
);
2491 rtx_code_label
*l
= gen_label_rtx ();
2492 lab_rtx_for_bb
->put (bb
, l
);
2497 /* A subroutine of expand_gimple_cond. Given E, a fallthrough edge
2498 of a basic block where we just expanded the conditional at the end,
2499 possibly clean up the CFG and instruction sequence. LAST is the
2500 last instruction before the just emitted jump sequence. */
2503 maybe_cleanup_end_of_block (edge e
, rtx_insn
*last
)
2505 /* Special case: when jumpif decides that the condition is
2506 trivial it emits an unconditional jump (and the necessary
2507 barrier). But we still have two edges, the fallthru one is
2508 wrong. purge_dead_edges would clean this up later. Unfortunately
2509 we have to insert insns (and split edges) before
2510 find_many_sub_basic_blocks and hence before purge_dead_edges.
2511 But splitting edges might create new blocks which depend on the
2512 fact that if there are two edges there's no barrier. So the
2513 barrier would get lost and verify_flow_info would ICE. Instead
2514 of auditing all edge splitters to care for the barrier (which
2515 normally isn't there in a cleaned CFG), fix it here. */
2516 if (BARRIER_P (get_last_insn ()))
2520 /* Now, we have a single successor block, if we have insns to
2521 insert on the remaining edge we potentially will insert
2522 it at the end of this block (if the dest block isn't feasible)
2523 in order to avoid splitting the edge. This insertion will take
2524 place in front of the last jump. But we might have emitted
2525 multiple jumps (conditional and one unconditional) to the
2526 same destination. Inserting in front of the last one then
2527 is a problem. See PR 40021. We fix this by deleting all
2528 jumps except the last unconditional one. */
2529 insn
= PREV_INSN (get_last_insn ());
2530 /* Make sure we have an unconditional jump. Otherwise we're
2532 gcc_assert (JUMP_P (insn
) && !any_condjump_p (insn
));
2533 for (insn
= PREV_INSN (insn
); insn
!= last
;)
2535 insn
= PREV_INSN (insn
);
2536 if (JUMP_P (NEXT_INSN (insn
)))
2538 if (!any_condjump_p (NEXT_INSN (insn
)))
2540 gcc_assert (BARRIER_P (NEXT_INSN (NEXT_INSN (insn
))));
2541 delete_insn (NEXT_INSN (NEXT_INSN (insn
)));
2543 delete_insn (NEXT_INSN (insn
));
2549 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_COND.
2550 Returns a new basic block if we've terminated the current basic
2551 block and created a new one. */
2554 expand_gimple_cond (basic_block bb
, gcond
*stmt
)
2556 basic_block new_bb
, dest
;
2559 rtx_insn
*last2
, *last
;
2560 enum tree_code code
;
2563 code
= gimple_cond_code (stmt
);
2564 op0
= gimple_cond_lhs (stmt
);
2565 op1
= gimple_cond_rhs (stmt
);
2566 /* We're sometimes presented with such code:
2570 This would expand to two comparisons which then later might
2571 be cleaned up by combine. But some pattern matchers like if-conversion
2572 work better when there's only one compare, so make up for this
2573 here as special exception if TER would have made the same change. */
2575 && TREE_CODE (op0
) == SSA_NAME
2576 && TREE_CODE (TREE_TYPE (op0
)) == BOOLEAN_TYPE
2577 && TREE_CODE (op1
) == INTEGER_CST
2578 && ((gimple_cond_code (stmt
) == NE_EXPR
2579 && integer_zerop (op1
))
2580 || (gimple_cond_code (stmt
) == EQ_EXPR
2581 && integer_onep (op1
)))
2582 && bitmap_bit_p (SA
.values
, SSA_NAME_VERSION (op0
)))
2584 gimple
*second
= SSA_NAME_DEF_STMT (op0
);
2585 if (gimple_code (second
) == GIMPLE_ASSIGN
)
2587 enum tree_code code2
= gimple_assign_rhs_code (second
);
2588 if (TREE_CODE_CLASS (code2
) == tcc_comparison
)
2591 op0
= gimple_assign_rhs1 (second
);
2592 op1
= gimple_assign_rhs2 (second
);
2594 /* If jumps are cheap and the target does not support conditional
2595 compare, turn some more codes into jumpy sequences. */
2596 else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4
2597 && targetm
.gen_ccmp_first
== NULL
)
2599 if ((code2
== BIT_AND_EXPR
2600 && TYPE_PRECISION (TREE_TYPE (op0
)) == 1
2601 && TREE_CODE (gimple_assign_rhs2 (second
)) != INTEGER_CST
)
2602 || code2
== TRUTH_AND_EXPR
)
2604 code
= TRUTH_ANDIF_EXPR
;
2605 op0
= gimple_assign_rhs1 (second
);
2606 op1
= gimple_assign_rhs2 (second
);
2608 else if (code2
== BIT_IOR_EXPR
|| code2
== TRUTH_OR_EXPR
)
2610 code
= TRUTH_ORIF_EXPR
;
2611 op0
= gimple_assign_rhs1 (second
);
2612 op1
= gimple_assign_rhs2 (second
);
2618 /* Optimize (x % C1) == C2 or (x % C1) != C2 if it is beneficial
2619 into (x - C2) * C3 < C4. */
2620 if ((code
== EQ_EXPR
|| code
== NE_EXPR
)
2621 && TREE_CODE (op0
) == SSA_NAME
2622 && TREE_CODE (op1
) == INTEGER_CST
)
2623 code
= maybe_optimize_mod_cmp (code
, &op0
, &op1
);
2625 /* Optimize (x - y) < 0 into x < y if x - y has undefined overflow. */
2626 if (!TYPE_UNSIGNED (TREE_TYPE (op0
))
2627 && (code
== LT_EXPR
|| code
== LE_EXPR
2628 || code
== GT_EXPR
|| code
== GE_EXPR
)
2629 && integer_zerop (op1
)
2630 && TREE_CODE (op0
) == SSA_NAME
)
2631 maybe_optimize_sub_cmp_0 (code
, &op0
, &op1
);
2633 last2
= last
= get_last_insn ();
2635 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
2636 set_curr_insn_location (gimple_location (stmt
));
2638 /* These flags have no purpose in RTL land. */
2639 true_edge
->flags
&= ~EDGE_TRUE_VALUE
;
2640 false_edge
->flags
&= ~EDGE_FALSE_VALUE
;
2642 /* We can either have a pure conditional jump with one fallthru edge or
2643 two-way jump that needs to be decomposed into two basic blocks. */
2644 if (false_edge
->dest
== bb
->next_bb
)
2646 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2647 true_edge
->probability
);
2648 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2649 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2650 set_curr_insn_location (true_edge
->goto_locus
);
2651 false_edge
->flags
|= EDGE_FALLTHRU
;
2652 maybe_cleanup_end_of_block (false_edge
, last
);
2655 if (true_edge
->dest
== bb
->next_bb
)
2657 jumpifnot_1 (code
, op0
, op1
, label_rtx_for_bb (false_edge
->dest
),
2658 false_edge
->probability
);
2659 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2660 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2661 set_curr_insn_location (false_edge
->goto_locus
);
2662 true_edge
->flags
|= EDGE_FALLTHRU
;
2663 maybe_cleanup_end_of_block (true_edge
, last
);
2667 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2668 true_edge
->probability
);
2669 last
= get_last_insn ();
2670 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2671 set_curr_insn_location (false_edge
->goto_locus
);
2672 emit_jump (label_rtx_for_bb (false_edge
->dest
));
2675 if (BARRIER_P (BB_END (bb
)))
2676 BB_END (bb
) = PREV_INSN (BB_END (bb
));
2677 update_bb_for_insn (bb
);
2679 new_bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
2680 dest
= false_edge
->dest
;
2681 redirect_edge_succ (false_edge
, new_bb
);
2682 false_edge
->flags
|= EDGE_FALLTHRU
;
2683 new_bb
->count
= false_edge
->count ();
2684 loop_p loop
= find_common_loop (bb
->loop_father
, dest
->loop_father
);
2685 add_bb_to_loop (new_bb
, loop
);
2686 if (loop
->latch
== bb
2687 && loop
->header
== dest
)
2688 loop
->latch
= new_bb
;
2689 make_single_succ_edge (new_bb
, dest
, 0);
2690 if (BARRIER_P (BB_END (new_bb
)))
2691 BB_END (new_bb
) = PREV_INSN (BB_END (new_bb
));
2692 update_bb_for_insn (new_bb
);
2694 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
2696 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2698 set_curr_insn_location (true_edge
->goto_locus
);
2699 true_edge
->goto_locus
= curr_insn_location ();
2705 /* Mark all calls that can have a transaction restart. */
2708 mark_transaction_restart_calls (gimple
*stmt
)
2710 struct tm_restart_node dummy
;
2711 tm_restart_node
**slot
;
2713 if (!cfun
->gimple_df
->tm_restart
)
2717 slot
= cfun
->gimple_df
->tm_restart
->find_slot (&dummy
, NO_INSERT
);
2720 struct tm_restart_node
*n
= *slot
;
2721 tree list
= n
->label_or_list
;
2724 for (insn
= next_real_insn (get_last_insn ());
2726 insn
= next_real_insn (insn
))
2729 if (TREE_CODE (list
) == LABEL_DECL
)
2730 add_reg_note (insn
, REG_TM
, label_rtx (list
));
2732 for (; list
; list
= TREE_CHAIN (list
))
2733 add_reg_note (insn
, REG_TM
, label_rtx (TREE_VALUE (list
)));
2737 /* A subroutine of expand_gimple_stmt_1, expanding one GIMPLE_CALL
2741 expand_call_stmt (gcall
*stmt
)
2743 tree exp
, decl
, lhs
;
2747 if (gimple_call_internal_p (stmt
))
2749 expand_internal_call (stmt
);
2753 /* If this is a call to a built-in function and it has no effect other
2754 than setting the lhs, try to implement it using an internal function
2756 decl
= gimple_call_fndecl (stmt
);
2757 if (gimple_call_lhs (stmt
)
2758 && !gimple_has_side_effects (stmt
)
2759 && (optimize
|| (decl
&& called_as_built_in (decl
))))
2761 internal_fn ifn
= replacement_internal_fn (stmt
);
2762 if (ifn
!= IFN_LAST
)
2764 expand_internal_call (ifn
, stmt
);
2769 exp
= build_vl_exp (CALL_EXPR
, gimple_call_num_args (stmt
) + 3);
2771 CALL_EXPR_FN (exp
) = gimple_call_fn (stmt
);
2772 builtin_p
= decl
&& fndecl_built_in_p (decl
);
2774 /* If this is not a builtin function, the function type through which the
2775 call is made may be different from the type of the function. */
2778 = fold_convert (build_pointer_type (gimple_call_fntype (stmt
)),
2779 CALL_EXPR_FN (exp
));
2781 TREE_TYPE (exp
) = gimple_call_return_type (stmt
);
2782 CALL_EXPR_STATIC_CHAIN (exp
) = gimple_call_chain (stmt
);
2784 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2786 tree arg
= gimple_call_arg (stmt
, i
);
2788 /* TER addresses into arguments of builtin functions so we have a
2789 chance to infer more correct alignment information. See PR39954. */
2791 && TREE_CODE (arg
) == SSA_NAME
2792 && (def
= get_gimple_for_ssa_name (arg
))
2793 && gimple_assign_rhs_code (def
) == ADDR_EXPR
)
2794 arg
= gimple_assign_rhs1 (def
);
2795 CALL_EXPR_ARG (exp
, i
) = arg
;
2798 if (gimple_has_side_effects (stmt
))
2799 TREE_SIDE_EFFECTS (exp
) = 1;
2801 if (gimple_call_nothrow_p (stmt
))
2802 TREE_NOTHROW (exp
) = 1;
2804 if (gimple_no_warning_p (stmt
))
2805 TREE_NO_WARNING (exp
) = 1;
2807 CALL_EXPR_TAILCALL (exp
) = gimple_call_tail_p (stmt
);
2808 CALL_EXPR_MUST_TAIL_CALL (exp
) = gimple_call_must_tail_p (stmt
);
2809 CALL_EXPR_RETURN_SLOT_OPT (exp
) = gimple_call_return_slot_opt_p (stmt
);
2811 && fndecl_built_in_p (decl
, BUILT_IN_NORMAL
)
2812 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (decl
)))
2813 CALL_ALLOCA_FOR_VAR_P (exp
) = gimple_call_alloca_for_var_p (stmt
);
2815 CALL_FROM_THUNK_P (exp
) = gimple_call_from_thunk_p (stmt
);
2816 CALL_EXPR_VA_ARG_PACK (exp
) = gimple_call_va_arg_pack_p (stmt
);
2817 CALL_EXPR_BY_DESCRIPTOR (exp
) = gimple_call_by_descriptor_p (stmt
);
2818 SET_EXPR_LOCATION (exp
, gimple_location (stmt
));
2820 /* Ensure RTL is created for debug args. */
2821 if (decl
&& DECL_HAS_DEBUG_ARGS_P (decl
))
2823 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (decl
);
2828 for (ix
= 1; (*debug_args
)->iterate (ix
, &dtemp
); ix
+= 2)
2830 gcc_assert (TREE_CODE (dtemp
) == DEBUG_EXPR_DECL
);
2831 expand_debug_expr (dtemp
);
2835 rtx_insn
*before_call
= get_last_insn ();
2836 lhs
= gimple_call_lhs (stmt
);
2838 expand_assignment (lhs
, exp
, false);
2840 expand_expr (exp
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2842 /* If the gimple call is an indirect call and has 'nocf_check'
2843 attribute find a generated CALL insn to mark it as no
2844 control-flow verification is needed. */
2845 if (gimple_call_nocf_check_p (stmt
)
2846 && !gimple_call_fndecl (stmt
))
2848 rtx_insn
*last
= get_last_insn ();
2849 while (!CALL_P (last
)
2850 && last
!= before_call
)
2851 last
= PREV_INSN (last
);
2853 if (last
!= before_call
)
2854 add_reg_note (last
, REG_CALL_NOCF_CHECK
, const0_rtx
);
2857 mark_transaction_restart_calls (stmt
);
2861 /* Generate RTL for an asm statement (explicit assembler code).
2862 STRING is a STRING_CST node containing the assembler code text,
2863 or an ADDR_EXPR containing a STRING_CST. VOL nonzero means the
2864 insn is volatile; don't optimize it. */
2867 expand_asm_loc (tree string
, int vol
, location_t locus
)
2871 body
= gen_rtx_ASM_INPUT_loc (VOIDmode
,
2872 ggc_strdup (TREE_STRING_POINTER (string
)),
2875 MEM_VOLATILE_P (body
) = vol
;
2877 /* Non-empty basic ASM implicitly clobbers memory. */
2878 if (TREE_STRING_LENGTH (string
) != 0)
2881 unsigned i
, nclobbers
;
2882 auto_vec
<rtx
> input_rvec
, output_rvec
;
2883 auto_vec
<machine_mode
> input_mode
;
2884 auto_vec
<const char *> constraints
;
2885 auto_vec
<rtx
> clobber_rvec
;
2886 HARD_REG_SET clobbered_regs
;
2887 CLEAR_HARD_REG_SET (clobbered_regs
);
2889 clob
= gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
));
2890 clobber_rvec
.safe_push (clob
);
2892 if (targetm
.md_asm_adjust
)
2893 targetm
.md_asm_adjust (output_rvec
, input_rvec
, input_mode
,
2894 constraints
, clobber_rvec
, clobbered_regs
);
2897 nclobbers
= clobber_rvec
.length ();
2898 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (1 + nclobbers
));
2900 XVECEXP (body
, 0, 0) = asm_op
;
2901 for (i
= 0; i
< nclobbers
; i
++)
2902 XVECEXP (body
, 0, i
+ 1) = gen_rtx_CLOBBER (VOIDmode
, clobber_rvec
[i
]);
2908 /* Return the number of times character C occurs in string S. */
2910 n_occurrences (int c
, const char *s
)
2918 /* A subroutine of expand_asm_operands. Check that all operands have
2919 the same number of alternatives. Return true if so. */
2922 check_operand_nalternatives (const vec
<const char *> &constraints
)
2924 unsigned len
= constraints
.length();
2927 int nalternatives
= n_occurrences (',', constraints
[0]);
2929 if (nalternatives
+ 1 > MAX_RECOG_ALTERNATIVES
)
2931 error ("too many alternatives in %<asm%>");
2935 for (unsigned i
= 1; i
< len
; ++i
)
2936 if (n_occurrences (',', constraints
[i
]) != nalternatives
)
2938 error ("operand constraints for %<asm%> differ "
2939 "in number of alternatives");
2946 /* Check for overlap between registers marked in CLOBBERED_REGS and
2947 anything inappropriate in T. Emit error and return the register
2948 variable definition for error, NULL_TREE for ok. */
2951 tree_conflicts_with_clobbers_p (tree t
, HARD_REG_SET
*clobbered_regs
)
2953 /* Conflicts between asm-declared register variables and the clobber
2954 list are not allowed. */
2955 tree overlap
= tree_overlaps_hard_reg_set (t
, clobbered_regs
);
2959 error ("%<asm%> specifier for variable %qE conflicts with "
2960 "%<asm%> clobber list",
2961 DECL_NAME (overlap
));
2963 /* Reset registerness to stop multiple errors emitted for a single
2965 DECL_REGISTER (overlap
) = 0;
2972 /* Check that the given REGNO spanning NREGS is a valid
2973 asm clobber operand. Some HW registers cannot be
2974 saved/restored, hence they should not be clobbered by
2977 asm_clobber_reg_is_valid (int regno
, int nregs
, const char *regname
)
2979 bool is_valid
= true;
2980 HARD_REG_SET regset
;
2982 CLEAR_HARD_REG_SET (regset
);
2984 add_range_to_hard_reg_set (®set
, regno
, nregs
);
2986 /* Clobbering the PIC register is an error. */
2987 if (PIC_OFFSET_TABLE_REGNUM
!= INVALID_REGNUM
2988 && overlaps_hard_reg_set_p (regset
, Pmode
, PIC_OFFSET_TABLE_REGNUM
))
2990 /* ??? Diagnose during gimplification? */
2991 error ("PIC register clobbered by %qs in %<asm%>", regname
);
2994 else if (!in_hard_reg_set_p
2995 (accessible_reg_set
, reg_raw_mode
[regno
], regno
))
2997 /* ??? Diagnose during gimplification? */
2998 error ("the register %qs cannot be clobbered in %<asm%>"
2999 " for the current target", regname
);
3003 /* Clobbering the stack pointer register is deprecated. GCC expects
3004 the value of the stack pointer after an asm statement to be the same
3005 as it was before, so no asm can validly clobber the stack pointer in
3006 the usual sense. Adding the stack pointer to the clobber list has
3007 traditionally had some undocumented and somewhat obscure side-effects. */
3008 if (overlaps_hard_reg_set_p (regset
, Pmode
, STACK_POINTER_REGNUM
))
3010 crtl
->sp_is_clobbered_by_asm
= true;
3011 if (warning (OPT_Wdeprecated
, "listing the stack pointer register"
3012 " %qs in a clobber list is deprecated", regname
))
3013 inform (input_location
, "the value of the stack pointer after"
3014 " an %<asm%> statement must be the same as it was before"
3021 /* Generate RTL for an asm statement with arguments.
3022 STRING is the instruction template.
3023 OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
3024 Each output or input has an expression in the TREE_VALUE and
3025 a tree list in TREE_PURPOSE which in turn contains a constraint
3026 name in TREE_VALUE (or NULL_TREE) and a constraint string
3028 CLOBBERS is a list of STRING_CST nodes each naming a hard register
3029 that is clobbered by this insn.
3031 LABELS is a list of labels, and if LABELS is non-NULL, FALLTHRU_BB
3032 should be the fallthru basic block of the asm goto.
3034 Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
3035 Some elements of OUTPUTS may be replaced with trees representing temporary
3036 values. The caller should copy those temporary values to the originally
3039 VOL nonzero means the insn is volatile; don't optimize it. */
3042 expand_asm_stmt (gasm
*stmt
)
3044 class save_input_location
3049 explicit save_input_location(location_t where
)
3051 old
= input_location
;
3052 input_location
= where
;
3055 ~save_input_location()
3057 input_location
= old
;
3061 location_t locus
= gimple_location (stmt
);
3063 if (gimple_asm_input_p (stmt
))
3065 const char *s
= gimple_asm_string (stmt
);
3066 tree string
= build_string (strlen (s
), s
);
3067 expand_asm_loc (string
, gimple_asm_volatile_p (stmt
), locus
);
3071 /* There are some legacy diagnostics in here, and also avoids an extra
3072 parameter to targetm.md_asm_adjust. */
3073 save_input_location
s_i_l(locus
);
3075 unsigned noutputs
= gimple_asm_noutputs (stmt
);
3076 unsigned ninputs
= gimple_asm_ninputs (stmt
);
3077 unsigned nlabels
= gimple_asm_nlabels (stmt
);
3080 /* ??? Diagnose during gimplification? */
3081 if (ninputs
+ noutputs
+ nlabels
> MAX_RECOG_OPERANDS
)
3083 error ("more than %d operands in %<asm%>", MAX_RECOG_OPERANDS
);
3087 auto_vec
<tree
, MAX_RECOG_OPERANDS
> output_tvec
;
3088 auto_vec
<tree
, MAX_RECOG_OPERANDS
> input_tvec
;
3089 auto_vec
<const char *, MAX_RECOG_OPERANDS
> constraints
;
3091 /* Copy the gimple vectors into new vectors that we can manipulate. */
3093 output_tvec
.safe_grow (noutputs
, true);
3094 input_tvec
.safe_grow (ninputs
, true);
3095 constraints
.safe_grow (noutputs
+ ninputs
, true);
3097 for (i
= 0; i
< noutputs
; ++i
)
3099 tree t
= gimple_asm_output_op (stmt
, i
);
3100 output_tvec
[i
] = TREE_VALUE (t
);
3101 constraints
[i
] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
3103 for (i
= 0; i
< ninputs
; i
++)
3105 tree t
= gimple_asm_input_op (stmt
, i
);
3106 input_tvec
[i
] = TREE_VALUE (t
);
3107 constraints
[i
+ noutputs
]
3108 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
3111 /* ??? Diagnose during gimplification? */
3112 if (! check_operand_nalternatives (constraints
))
3115 /* Count the number of meaningful clobbered registers, ignoring what
3116 we would ignore later. */
3117 auto_vec
<rtx
> clobber_rvec
;
3118 HARD_REG_SET clobbered_regs
;
3119 CLEAR_HARD_REG_SET (clobbered_regs
);
3121 if (unsigned n
= gimple_asm_nclobbers (stmt
))
3123 clobber_rvec
.reserve (n
);
3124 for (i
= 0; i
< n
; i
++)
3126 tree t
= gimple_asm_clobber_op (stmt
, i
);
3127 const char *regname
= TREE_STRING_POINTER (TREE_VALUE (t
));
3130 j
= decode_reg_name_and_count (regname
, &nregs
);
3135 /* ??? Diagnose during gimplification? */
3136 error ("unknown register name %qs in %<asm%>", regname
);
3140 rtx x
= gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
));
3141 clobber_rvec
.safe_push (x
);
3145 /* Otherwise we should have -1 == empty string
3146 or -3 == cc, which is not a register. */
3147 gcc_assert (j
== -1 || j
== -3);
3151 for (int reg
= j
; reg
< j
+ nregs
; reg
++)
3153 if (!asm_clobber_reg_is_valid (reg
, nregs
, regname
))
3156 SET_HARD_REG_BIT (clobbered_regs
, reg
);
3157 rtx x
= gen_rtx_REG (reg_raw_mode
[reg
], reg
);
3158 clobber_rvec
.safe_push (x
);
3163 /* First pass over inputs and outputs checks validity and sets
3164 mark_addressable if needed. */
3165 /* ??? Diagnose during gimplification? */
3167 for (i
= 0; i
< noutputs
; ++i
)
3169 tree val
= output_tvec
[i
];
3170 tree type
= TREE_TYPE (val
);
3171 const char *constraint
;
3176 /* Try to parse the output constraint. If that fails, there's
3177 no point in going further. */
3178 constraint
= constraints
[i
];
3179 if (!parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
3180 &allows_mem
, &allows_reg
, &is_inout
))
3183 /* If the output is a hard register, verify it doesn't conflict with
3184 any other operand's possible hard register use. */
3186 && REG_P (DECL_RTL (val
))
3187 && HARD_REGISTER_P (DECL_RTL (val
)))
3189 unsigned j
, output_hregno
= REGNO (DECL_RTL (val
));
3190 bool early_clobber_p
= strchr (constraints
[i
], '&') != NULL
;
3191 unsigned long match
;
3193 /* Verify the other outputs do not use the same hard register. */
3194 for (j
= i
+ 1; j
< noutputs
; ++j
)
3195 if (DECL_P (output_tvec
[j
])
3196 && REG_P (DECL_RTL (output_tvec
[j
]))
3197 && HARD_REGISTER_P (DECL_RTL (output_tvec
[j
]))
3198 && output_hregno
== REGNO (DECL_RTL (output_tvec
[j
])))
3199 error ("invalid hard register usage between output operands");
3201 /* Verify matching constraint operands use the same hard register
3202 and that the non-matching constraint operands do not use the same
3203 hard register if the output is an early clobber operand. */
3204 for (j
= 0; j
< ninputs
; ++j
)
3205 if (DECL_P (input_tvec
[j
])
3206 && REG_P (DECL_RTL (input_tvec
[j
]))
3207 && HARD_REGISTER_P (DECL_RTL (input_tvec
[j
])))
3209 unsigned input_hregno
= REGNO (DECL_RTL (input_tvec
[j
]));
3210 switch (*constraints
[j
+ noutputs
])
3212 case '0': case '1': case '2': case '3': case '4':
3213 case '5': case '6': case '7': case '8': case '9':
3214 match
= strtoul (constraints
[j
+ noutputs
], NULL
, 10);
3221 && output_hregno
!= input_hregno
)
3222 error ("invalid hard register usage between output operand "
3223 "and matching constraint operand");
3224 else if (early_clobber_p
3226 && output_hregno
== input_hregno
)
3227 error ("invalid hard register usage between earlyclobber "
3228 "operand and input operand");
3236 && REG_P (DECL_RTL (val
))
3237 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
))))
3238 mark_addressable (val
);
3241 for (i
= 0; i
< ninputs
; ++i
)
3243 bool allows_reg
, allows_mem
;
3244 const char *constraint
;
3246 constraint
= constraints
[i
+ noutputs
];
3247 if (! parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
3248 constraints
.address (),
3249 &allows_mem
, &allows_reg
))
3252 if (! allows_reg
&& allows_mem
)
3253 mark_addressable (input_tvec
[i
]);
3256 /* Second pass evaluates arguments. */
3258 /* Make sure stack is consistent for asm goto. */
3260 do_pending_stack_adjust ();
3261 int old_generating_concat_p
= generating_concat_p
;
3263 /* Vector of RTX's of evaluated output operands. */
3264 auto_vec
<rtx
, MAX_RECOG_OPERANDS
> output_rvec
;
3265 auto_vec
<int, MAX_RECOG_OPERANDS
> inout_opnum
;
3266 rtx_insn
*after_rtl_seq
= NULL
, *after_rtl_end
= NULL
;
3268 output_rvec
.safe_grow (noutputs
, true);
3270 for (i
= 0; i
< noutputs
; ++i
)
3272 tree val
= output_tvec
[i
];
3273 tree type
= TREE_TYPE (val
);
3274 bool is_inout
, allows_reg
, allows_mem
, ok
;
3277 ok
= parse_output_constraint (&constraints
[i
], i
, ninputs
,
3278 noutputs
, &allows_mem
, &allows_reg
,
3282 /* If an output operand is not a decl or indirect ref and our constraint
3283 allows a register, make a temporary to act as an intermediate.
3284 Make the asm insn write into that, then we will copy it to
3285 the real output operand. Likewise for promoted variables. */
3287 generating_concat_p
= 0;
3289 if ((TREE_CODE (val
) == INDIRECT_REF
&& allows_mem
)
3291 && (allows_mem
|| REG_P (DECL_RTL (val
)))
3292 && ! (REG_P (DECL_RTL (val
))
3293 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
)))
3296 || TREE_ADDRESSABLE (type
))
3298 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
3299 !allows_reg
? EXPAND_MEMORY
: EXPAND_WRITE
);
3301 op
= validize_mem (op
);
3303 if (! allows_reg
&& !MEM_P (op
))
3304 error ("output number %d not directly addressable", i
);
3305 if ((! allows_mem
&& MEM_P (op
) && GET_MODE (op
) != BLKmode
)
3306 || GET_CODE (op
) == CONCAT
)
3309 op
= gen_reg_rtx (GET_MODE (op
));
3311 generating_concat_p
= old_generating_concat_p
;
3314 emit_move_insn (op
, old_op
);
3316 push_to_sequence2 (after_rtl_seq
, after_rtl_end
);
3317 emit_move_insn (old_op
, op
);
3318 after_rtl_seq
= get_insns ();
3319 after_rtl_end
= get_last_insn ();
3325 op
= assign_temp (type
, 0, 1);
3326 op
= validize_mem (op
);
3327 if (!MEM_P (op
) && TREE_CODE (val
) == SSA_NAME
)
3328 set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (val
), op
);
3330 generating_concat_p
= old_generating_concat_p
;
3332 push_to_sequence2 (after_rtl_seq
, after_rtl_end
);
3333 expand_assignment (val
, make_tree (type
, op
), false);
3334 after_rtl_seq
= get_insns ();
3335 after_rtl_end
= get_last_insn ();
3338 output_rvec
[i
] = op
;
3341 inout_opnum
.safe_push (i
);
3344 auto_vec
<rtx
, MAX_RECOG_OPERANDS
> input_rvec
;
3345 auto_vec
<machine_mode
, MAX_RECOG_OPERANDS
> input_mode
;
3347 input_rvec
.safe_grow (ninputs
, true);
3348 input_mode
.safe_grow (ninputs
, true);
3350 generating_concat_p
= 0;
3352 for (i
= 0; i
< ninputs
; ++i
)
3354 tree val
= input_tvec
[i
];
3355 tree type
= TREE_TYPE (val
);
3356 bool allows_reg
, allows_mem
, ok
;
3357 const char *constraint
;
3360 constraint
= constraints
[i
+ noutputs
];
3361 ok
= parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
3362 constraints
.address (),
3363 &allows_mem
, &allows_reg
);
3366 /* EXPAND_INITIALIZER will not generate code for valid initializer
3367 constants, but will still generate code for other types of operand.
3368 This is the behavior we want for constant constraints. */
3369 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
3370 allows_reg
? EXPAND_NORMAL
3371 : allows_mem
? EXPAND_MEMORY
3372 : EXPAND_INITIALIZER
);
3374 /* Never pass a CONCAT to an ASM. */
3375 if (GET_CODE (op
) == CONCAT
)
3376 op
= force_reg (GET_MODE (op
), op
);
3377 else if (MEM_P (op
))
3378 op
= validize_mem (op
);
3380 if (asm_operand_ok (op
, constraint
, NULL
) <= 0)
3382 if (allows_reg
&& TYPE_MODE (type
) != BLKmode
)
3383 op
= force_reg (TYPE_MODE (type
), op
);
3384 else if (!allows_mem
)
3385 warning (0, "%<asm%> operand %d probably does not match "
3388 else if (MEM_P (op
))
3390 /* We won't recognize either volatile memory or memory
3391 with a queued address as available a memory_operand
3392 at this point. Ignore it: clearly this *is* a memory. */
3398 input_mode
[i
] = TYPE_MODE (type
);
3401 /* For in-out operands, copy output rtx to input rtx. */
3402 unsigned ninout
= inout_opnum
.length();
3403 for (i
= 0; i
< ninout
; i
++)
3405 int j
= inout_opnum
[i
];
3406 rtx o
= output_rvec
[j
];
3408 input_rvec
.safe_push (o
);
3409 input_mode
.safe_push (GET_MODE (o
));
3412 sprintf (buffer
, "%d", j
);
3413 constraints
.safe_push (ggc_strdup (buffer
));
3417 /* Sometimes we wish to automatically clobber registers across an asm.
3418 Case in point is when the i386 backend moved from cc0 to a hard reg --
3419 maintaining source-level compatibility means automatically clobbering
3420 the flags register. */
3421 rtx_insn
*after_md_seq
= NULL
;
3422 if (targetm
.md_asm_adjust
)
3424 = targetm
.md_asm_adjust (output_rvec
, input_rvec
, input_mode
,
3425 constraints
, clobber_rvec
, clobbered_regs
);
3427 /* Do not allow the hook to change the output and input count,
3428 lest it mess up the operand numbering. */
3429 gcc_assert (output_rvec
.length() == noutputs
);
3430 gcc_assert (input_rvec
.length() == ninputs
);
3431 gcc_assert (constraints
.length() == noutputs
+ ninputs
);
3433 /* But it certainly can adjust the clobbers. */
3434 unsigned nclobbers
= clobber_rvec
.length ();
3436 /* Third pass checks for easy conflicts. */
3437 /* ??? Why are we doing this on trees instead of rtx. */
3439 bool clobber_conflict_found
= 0;
3440 for (i
= 0; i
< noutputs
; ++i
)
3441 if (tree_conflicts_with_clobbers_p (output_tvec
[i
], &clobbered_regs
))
3442 clobber_conflict_found
= 1;
3443 for (i
= 0; i
< ninputs
- ninout
; ++i
)
3444 if (tree_conflicts_with_clobbers_p (input_tvec
[i
], &clobbered_regs
))
3445 clobber_conflict_found
= 1;
3447 /* Make vectors for the expression-rtx, constraint strings,
3448 and named operands. */
3450 rtvec argvec
= rtvec_alloc (ninputs
);
3451 rtvec constraintvec
= rtvec_alloc (ninputs
);
3452 rtvec labelvec
= rtvec_alloc (nlabels
);
3454 rtx body
= gen_rtx_ASM_OPERANDS ((noutputs
== 0 ? VOIDmode
3455 : GET_MODE (output_rvec
[0])),
3456 ggc_strdup (gimple_asm_string (stmt
)),
3457 "", 0, argvec
, constraintvec
,
3459 MEM_VOLATILE_P (body
) = gimple_asm_volatile_p (stmt
);
3461 for (i
= 0; i
< ninputs
; ++i
)
3463 ASM_OPERANDS_INPUT (body
, i
) = input_rvec
[i
];
3464 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body
, i
)
3465 = gen_rtx_ASM_INPUT_loc (input_mode
[i
],
3466 constraints
[i
+ noutputs
],
3470 /* Copy labels to the vector. */
3471 rtx_code_label
*fallthru_label
= NULL
;
3474 basic_block fallthru_bb
= NULL
;
3475 edge fallthru
= find_fallthru_edge (gimple_bb (stmt
)->succs
);
3477 fallthru_bb
= fallthru
->dest
;
3479 for (i
= 0; i
< nlabels
; ++i
)
3481 tree label
= TREE_VALUE (gimple_asm_label_op (stmt
, i
));
3483 /* If asm goto has any labels in the fallthru basic block, use
3484 a label that we emit immediately after the asm goto. Expansion
3485 may insert further instructions into the same basic block after
3486 asm goto and if we don't do this, insertion of instructions on
3487 the fallthru edge might misbehave. See PR58670. */
3488 if (fallthru_bb
&& label_to_block (cfun
, label
) == fallthru_bb
)
3490 if (fallthru_label
== NULL_RTX
)
3491 fallthru_label
= gen_label_rtx ();
3495 r
= label_rtx (label
);
3496 ASM_OPERANDS_LABEL (body
, i
) = gen_rtx_LABEL_REF (Pmode
, r
);
3500 /* Now, for each output, construct an rtx
3501 (set OUTPUT (asm_operands INSN OUTPUTCONSTRAINT OUTPUTNUMBER
3502 ARGVEC CONSTRAINTS OPNAMES))
3503 If there is more than one, put them inside a PARALLEL. */
3505 if (noutputs
== 0 && nclobbers
== 0)
3507 /* No output operands: put in a raw ASM_OPERANDS rtx. */
3509 emit_jump_insn (body
);
3513 else if (noutputs
== 1 && nclobbers
== 0)
3515 ASM_OPERANDS_OUTPUT_CONSTRAINT (body
) = constraints
[0];
3517 emit_jump_insn (gen_rtx_SET (output_rvec
[0], body
));
3519 emit_insn (gen_rtx_SET (output_rvec
[0], body
));
3529 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (num
+ nclobbers
));
3531 /* For each output operand, store a SET. */
3532 for (i
= 0; i
< noutputs
; ++i
)
3534 rtx src
, o
= output_rvec
[i
];
3537 ASM_OPERANDS_OUTPUT_CONSTRAINT (obody
) = constraints
[0];
3542 src
= gen_rtx_ASM_OPERANDS (GET_MODE (o
),
3543 ASM_OPERANDS_TEMPLATE (obody
),
3544 constraints
[i
], i
, argvec
,
3545 constraintvec
, labelvec
, locus
);
3546 MEM_VOLATILE_P (src
) = gimple_asm_volatile_p (stmt
);
3548 XVECEXP (body
, 0, i
) = gen_rtx_SET (o
, src
);
3551 /* If there are no outputs (but there are some clobbers)
3552 store the bare ASM_OPERANDS into the PARALLEL. */
3554 XVECEXP (body
, 0, i
++) = obody
;
3556 /* Store (clobber REG) for each clobbered register specified. */
3557 for (unsigned j
= 0; j
< nclobbers
; ++j
)
3559 rtx clobbered_reg
= clobber_rvec
[j
];
3561 /* Do sanity check for overlap between clobbers and respectively
3562 input and outputs that hasn't been handled. Such overlap
3563 should have been detected and reported above. */
3564 if (!clobber_conflict_found
&& REG_P (clobbered_reg
))
3566 /* We test the old body (obody) contents to avoid
3567 tripping over the under-construction body. */
3568 for (unsigned k
= 0; k
< noutputs
; ++k
)
3569 if (reg_overlap_mentioned_p (clobbered_reg
, output_rvec
[k
]))
3570 internal_error ("%<asm%> clobber conflict with "
3573 for (unsigned k
= 0; k
< ninputs
- ninout
; ++k
)
3574 if (reg_overlap_mentioned_p (clobbered_reg
, input_rvec
[k
]))
3575 internal_error ("%<asm%> clobber conflict with "
3579 XVECEXP (body
, 0, i
++) = gen_rtx_CLOBBER (VOIDmode
, clobbered_reg
);
3583 emit_jump_insn (body
);
3588 generating_concat_p
= old_generating_concat_p
;
3591 emit_label (fallthru_label
);
3594 emit_insn (after_md_seq
);
3598 emit_insn (after_rtl_seq
);
3604 FOR_EACH_EDGE (e
, ei
, gimple_bb (stmt
)->succs
)
3607 for (rtx_insn
*curr
= after_rtl_seq
;
3609 curr
= NEXT_INSN (curr
))
3610 emit_insn (copy_insn (PATTERN (curr
)));
3611 rtx_insn
*copy
= get_insns ();
3613 insert_insn_on_edge (copy
, e
);
3619 crtl
->has_asm_statement
= 1;
3622 /* Emit code to jump to the address
3623 specified by the pointer expression EXP. */
3626 expand_computed_goto (tree exp
)
3628 rtx x
= expand_normal (exp
);
3630 do_pending_stack_adjust ();
3631 emit_indirect_jump (x
);
3634 /* Generate RTL code for a `goto' statement with target label LABEL.
3635 LABEL should be a LABEL_DECL tree node that was or will later be
3636 defined with `expand_label'. */
3639 expand_goto (tree label
)
3643 /* Check for a nonlocal goto to a containing function. Should have
3644 gotten translated to __builtin_nonlocal_goto. */
3645 tree context
= decl_function_context (label
);
3646 gcc_assert (!context
|| context
== current_function_decl
);
3649 emit_jump (jump_target_rtx (label
));
3652 /* Output a return with no value. */
3655 expand_null_return_1 (void)
3657 clear_pending_stack_adjust ();
3658 do_pending_stack_adjust ();
3659 emit_jump (return_label
);
3662 /* Generate RTL to return from the current function, with no value.
3663 (That is, we do not do anything about returning any value.) */
3666 expand_null_return (void)
3668 /* If this function was declared to return a value, but we
3669 didn't, clobber the return registers so that they are not
3670 propagated live to the rest of the function. */
3671 clobber_return_register ();
3673 expand_null_return_1 ();
3676 /* Generate RTL to return from the current function, with value VAL. */
3679 expand_value_return (rtx val
)
3681 /* Copy the value to the return location unless it's already there. */
3683 tree decl
= DECL_RESULT (current_function_decl
);
3684 rtx return_reg
= DECL_RTL (decl
);
3685 if (return_reg
!= val
)
3687 tree funtype
= TREE_TYPE (current_function_decl
);
3688 tree type
= TREE_TYPE (decl
);
3689 int unsignedp
= TYPE_UNSIGNED (type
);
3690 machine_mode old_mode
= DECL_MODE (decl
);
3692 if (DECL_BY_REFERENCE (decl
))
3693 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 2);
3695 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 1);
3697 if (mode
!= old_mode
)
3698 val
= convert_modes (mode
, old_mode
, val
, unsignedp
);
3700 if (GET_CODE (return_reg
) == PARALLEL
)
3701 emit_group_load (return_reg
, val
, type
, int_size_in_bytes (type
));
3703 emit_move_insn (return_reg
, val
);
3706 expand_null_return_1 ();
3709 /* Generate RTL to evaluate the expression RETVAL and return it
3710 from the current function. */
3713 expand_return (tree retval
)
3719 /* If function wants no value, give it none. */
3720 if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl
))) == VOID_TYPE
)
3722 expand_normal (retval
);
3723 expand_null_return ();
3727 if (retval
== error_mark_node
)
3729 /* Treat this like a return of no value from a function that
3731 expand_null_return ();
3734 else if ((TREE_CODE (retval
) == MODIFY_EXPR
3735 || TREE_CODE (retval
) == INIT_EXPR
)
3736 && TREE_CODE (TREE_OPERAND (retval
, 0)) == RESULT_DECL
)
3737 retval_rhs
= TREE_OPERAND (retval
, 1);
3739 retval_rhs
= retval
;
3741 result_rtl
= DECL_RTL (DECL_RESULT (current_function_decl
));
3743 /* If we are returning the RESULT_DECL, then the value has already
3744 been stored into it, so we don't have to do anything special. */
3745 if (TREE_CODE (retval_rhs
) == RESULT_DECL
)
3746 expand_value_return (result_rtl
);
3748 /* If the result is an aggregate that is being returned in one (or more)
3749 registers, load the registers here. */
3751 else if (retval_rhs
!= 0
3752 && TYPE_MODE (TREE_TYPE (retval_rhs
)) == BLKmode
3753 && REG_P (result_rtl
))
3755 val
= copy_blkmode_to_reg (GET_MODE (result_rtl
), retval_rhs
);
3758 /* Use the mode of the result value on the return register. */
3759 PUT_MODE (result_rtl
, GET_MODE (val
));
3760 expand_value_return (val
);
3763 expand_null_return ();
3765 else if (retval_rhs
!= 0
3766 && !VOID_TYPE_P (TREE_TYPE (retval_rhs
))
3767 && (REG_P (result_rtl
)
3768 || (GET_CODE (result_rtl
) == PARALLEL
)))
3770 /* Compute the return value into a temporary (usually a pseudo reg). */
3772 = assign_temp (TREE_TYPE (DECL_RESULT (current_function_decl
)), 0, 1);
3773 val
= expand_expr (retval_rhs
, val
, GET_MODE (val
), EXPAND_NORMAL
);
3774 val
= force_not_mem (val
);
3775 expand_value_return (val
);
3779 /* No hard reg used; calculate value into hard return reg. */
3780 expand_expr (retval
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3781 expand_value_return (result_rtl
);
3785 /* Expand a clobber of LHS. If LHS is stored it in a multi-part
3786 register, tell the rtl optimizers that its value is no longer
3790 expand_clobber (tree lhs
)
3794 rtx decl_rtl
= DECL_RTL_IF_SET (lhs
);
3795 if (decl_rtl
&& REG_P (decl_rtl
))
3797 machine_mode decl_mode
= GET_MODE (decl_rtl
);
3798 if (maybe_gt (GET_MODE_SIZE (decl_mode
),
3799 REGMODE_NATURAL_SIZE (decl_mode
)))
3800 emit_clobber (decl_rtl
);
3805 /* A subroutine of expand_gimple_stmt, expanding one gimple statement
3806 STMT that doesn't require special handling for outgoing edges. That
3807 is no tailcalls and no GIMPLE_COND. */
3810 expand_gimple_stmt_1 (gimple
*stmt
)
3814 set_curr_insn_location (gimple_location (stmt
));
3816 switch (gimple_code (stmt
))
3819 op0
= gimple_goto_dest (stmt
);
3820 if (TREE_CODE (op0
) == LABEL_DECL
)
3823 expand_computed_goto (op0
);
3826 expand_label (gimple_label_label (as_a
<glabel
*> (stmt
)));
3829 case GIMPLE_PREDICT
:
3833 gswitch
*swtch
= as_a
<gswitch
*> (stmt
);
3834 if (gimple_switch_num_labels (swtch
) == 1)
3835 expand_goto (CASE_LABEL (gimple_switch_default_label (swtch
)));
3837 expand_case (swtch
);
3841 expand_asm_stmt (as_a
<gasm
*> (stmt
));
3844 expand_call_stmt (as_a
<gcall
*> (stmt
));
3849 op0
= gimple_return_retval (as_a
<greturn
*> (stmt
));
3851 /* If a return doesn't have a location, it very likely represents
3852 multiple user returns so we cannot let it inherit the location
3853 of the last statement of the previous basic block in RTL. */
3854 if (!gimple_has_location (stmt
))
3855 set_curr_insn_location (cfun
->function_end_locus
);
3857 if (op0
&& op0
!= error_mark_node
)
3859 tree result
= DECL_RESULT (current_function_decl
);
3861 /* If we are not returning the current function's RESULT_DECL,
3862 build an assignment to it. */
3865 /* I believe that a function's RESULT_DECL is unique. */
3866 gcc_assert (TREE_CODE (op0
) != RESULT_DECL
);
3868 /* ??? We'd like to use simply expand_assignment here,
3869 but this fails if the value is of BLKmode but the return
3870 decl is a register. expand_return has special handling
3871 for this combination, which eventually should move
3872 to common code. See comments there. Until then, let's
3873 build a modify expression :-/ */
3874 op0
= build2 (MODIFY_EXPR
, TREE_TYPE (result
),
3880 expand_null_return ();
3882 expand_return (op0
);
3888 gassign
*assign_stmt
= as_a
<gassign
*> (stmt
);
3889 tree lhs
= gimple_assign_lhs (assign_stmt
);
3891 /* Tree expand used to fiddle with |= and &= of two bitfield
3892 COMPONENT_REFs here. This can't happen with gimple, the LHS
3893 of binary assigns must be a gimple reg. */
3895 if (TREE_CODE (lhs
) != SSA_NAME
3896 || gimple_assign_rhs_class (assign_stmt
) == GIMPLE_SINGLE_RHS
)
3898 tree rhs
= gimple_assign_rhs1 (assign_stmt
);
3899 gcc_assert (gimple_assign_rhs_class (assign_stmt
)
3900 == GIMPLE_SINGLE_RHS
);
3901 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (rhs
)
3902 /* Do not put locations on possibly shared trees. */
3903 && !is_gimple_min_invariant (rhs
))
3904 SET_EXPR_LOCATION (rhs
, gimple_location (stmt
));
3905 if (TREE_CLOBBER_P (rhs
))
3906 /* This is a clobber to mark the going out of scope for
3908 expand_clobber (lhs
);
3910 expand_assignment (lhs
, rhs
,
3911 gimple_assign_nontemporal_move_p (
3917 bool nontemporal
= gimple_assign_nontemporal_move_p (assign_stmt
);
3918 struct separate_ops ops
;
3919 bool promoted
= false;
3921 target
= expand_expr (lhs
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
3922 if (GET_CODE (target
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (target
))
3925 ops
.code
= gimple_assign_rhs_code (assign_stmt
);
3926 ops
.type
= TREE_TYPE (lhs
);
3927 switch (get_gimple_rhs_class (ops
.code
))
3929 case GIMPLE_TERNARY_RHS
:
3930 ops
.op2
= gimple_assign_rhs3 (assign_stmt
);
3932 case GIMPLE_BINARY_RHS
:
3933 ops
.op1
= gimple_assign_rhs2 (assign_stmt
);
3935 case GIMPLE_UNARY_RHS
:
3936 ops
.op0
= gimple_assign_rhs1 (assign_stmt
);
3941 ops
.location
= gimple_location (stmt
);
3943 /* If we want to use a nontemporal store, force the value to
3944 register first. If we store into a promoted register,
3945 don't directly expand to target. */
3946 temp
= nontemporal
|| promoted
? NULL_RTX
: target
;
3947 temp
= expand_expr_real_2 (&ops
, temp
, GET_MODE (target
),
3954 int unsignedp
= SUBREG_PROMOTED_SIGN (target
);
3955 /* If TEMP is a VOIDmode constant, use convert_modes to make
3956 sure that we properly convert it. */
3957 if (CONSTANT_P (temp
) && GET_MODE (temp
) == VOIDmode
)
3959 temp
= convert_modes (GET_MODE (target
),
3960 TYPE_MODE (ops
.type
),
3962 temp
= convert_modes (GET_MODE (SUBREG_REG (target
)),
3963 GET_MODE (target
), temp
, unsignedp
);
3966 convert_move (SUBREG_REG (target
), temp
, unsignedp
);
3968 else if (nontemporal
&& emit_storent_insn (target
, temp
))
3972 temp
= force_operand (temp
, target
);
3974 emit_move_insn (target
, temp
);
3985 /* Expand one gimple statement STMT and return the last RTL instruction
3986 before any of the newly generated ones.
3988 In addition to generating the necessary RTL instructions this also
3989 sets REG_EH_REGION notes if necessary and sets the current source
3990 location for diagnostics. */
3993 expand_gimple_stmt (gimple
*stmt
)
3995 location_t saved_location
= input_location
;
3996 rtx_insn
*last
= get_last_insn ();
4001 /* We need to save and restore the current source location so that errors
4002 discovered during expansion are emitted with the right location. But
4003 it would be better if the diagnostic routines used the source location
4004 embedded in the tree nodes rather than globals. */
4005 if (gimple_has_location (stmt
))
4006 input_location
= gimple_location (stmt
);
4008 expand_gimple_stmt_1 (stmt
);
4010 /* Free any temporaries used to evaluate this statement. */
4013 input_location
= saved_location
;
4015 /* Mark all insns that may trap. */
4016 lp_nr
= lookup_stmt_eh_lp (stmt
);
4020 for (insn
= next_real_insn (last
); insn
;
4021 insn
= next_real_insn (insn
))
4023 if (! find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
4024 /* If we want exceptions for non-call insns, any
4025 may_trap_p instruction may throw. */
4026 && GET_CODE (PATTERN (insn
)) != CLOBBER
4027 && GET_CODE (PATTERN (insn
)) != USE
4028 && insn_could_throw_p (insn
))
4029 make_reg_eh_region_note (insn
, 0, lp_nr
);
4036 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_CALL
4037 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
4038 generated a tail call (something that might be denied by the ABI
4039 rules governing the call; see calls.c).
4041 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
4042 can still reach the rest of BB. The case here is __builtin_sqrt,
4043 where the NaN result goes through the external function (with a
4044 tailcall) and the normal result happens via a sqrt instruction. */
4047 expand_gimple_tailcall (basic_block bb
, gcall
*stmt
, bool *can_fallthru
)
4049 rtx_insn
*last2
, *last
;
4052 profile_probability probability
;
4054 last2
= last
= expand_gimple_stmt (stmt
);
4056 for (last
= NEXT_INSN (last
); last
; last
= NEXT_INSN (last
))
4057 if (CALL_P (last
) && SIBLING_CALL_P (last
))
4060 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
4062 *can_fallthru
= true;
4066 /* ??? Wouldn't it be better to just reset any pending stack adjust?
4067 Any instructions emitted here are about to be deleted. */
4068 do_pending_stack_adjust ();
4070 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
4071 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
4072 EH or abnormal edges, we shouldn't have created a tail call in
4073 the first place. So it seems to me we should just be removing
4074 all edges here, or redirecting the existing fallthru edge to
4077 probability
= profile_probability::never ();
4079 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
4081 if (!(e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
)))
4083 if (e
->dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
4084 e
->dest
->count
-= e
->count ();
4085 probability
+= e
->probability
;
4092 /* This is somewhat ugly: the call_expr expander often emits instructions
4093 after the sibcall (to perform the function return). These confuse the
4094 find_many_sub_basic_blocks code, so we need to get rid of these. */
4095 last
= NEXT_INSN (last
);
4096 gcc_assert (BARRIER_P (last
));
4098 *can_fallthru
= false;
4099 while (NEXT_INSN (last
))
4101 /* For instance an sqrt builtin expander expands if with
4102 sibcall in the then and label for `else`. */
4103 if (LABEL_P (NEXT_INSN (last
)))
4105 *can_fallthru
= true;
4108 delete_insn (NEXT_INSN (last
));
4111 e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_ABNORMAL
4113 e
->probability
= probability
;
4115 update_bb_for_insn (bb
);
4117 if (NEXT_INSN (last
))
4119 bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
4122 if (BARRIER_P (last
))
4123 BB_END (bb
) = PREV_INSN (last
);
4126 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
4131 /* Return the difference between the floor and the truncated result of
4132 a signed division by OP1 with remainder MOD. */
4134 floor_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
4136 /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
4137 return gen_rtx_IF_THEN_ELSE
4138 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
4139 gen_rtx_IF_THEN_ELSE
4140 (mode
, gen_rtx_LT (BImode
,
4141 gen_rtx_DIV (mode
, op1
, mod
),
4143 constm1_rtx
, const0_rtx
),
4147 /* Return the difference between the ceil and the truncated result of
4148 a signed division by OP1 with remainder MOD. */
4150 ceil_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
4152 /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
4153 return gen_rtx_IF_THEN_ELSE
4154 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
4155 gen_rtx_IF_THEN_ELSE
4156 (mode
, gen_rtx_GT (BImode
,
4157 gen_rtx_DIV (mode
, op1
, mod
),
4159 const1_rtx
, const0_rtx
),
4163 /* Return the difference between the ceil and the truncated result of
4164 an unsigned division by OP1 with remainder MOD. */
4166 ceil_udiv_adjust (machine_mode mode
, rtx mod
, rtx op1 ATTRIBUTE_UNUSED
)
4168 /* (mod != 0 ? 1 : 0) */
4169 return gen_rtx_IF_THEN_ELSE
4170 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
4171 const1_rtx
, const0_rtx
);
4174 /* Return the difference between the rounded and the truncated result
4175 of a signed division by OP1 with remainder MOD. Halfway cases are
4176 rounded away from zero, rather than to the nearest even number. */
4178 round_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
4180 /* (abs (mod) >= abs (op1) - abs (mod)
4181 ? (op1 / mod > 0 ? 1 : -1)
4183 return gen_rtx_IF_THEN_ELSE
4184 (mode
, gen_rtx_GE (BImode
, gen_rtx_ABS (mode
, mod
),
4185 gen_rtx_MINUS (mode
,
4186 gen_rtx_ABS (mode
, op1
),
4187 gen_rtx_ABS (mode
, mod
))),
4188 gen_rtx_IF_THEN_ELSE
4189 (mode
, gen_rtx_GT (BImode
,
4190 gen_rtx_DIV (mode
, op1
, mod
),
4192 const1_rtx
, constm1_rtx
),
4196 /* Return the difference between the rounded and the truncated result
4197 of a unsigned division by OP1 with remainder MOD. Halfway cases
4198 are rounded away from zero, rather than to the nearest even
4201 round_udiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
4203 /* (mod >= op1 - mod ? 1 : 0) */
4204 return gen_rtx_IF_THEN_ELSE
4205 (mode
, gen_rtx_GE (BImode
, mod
,
4206 gen_rtx_MINUS (mode
, op1
, mod
)),
4207 const1_rtx
, const0_rtx
);
4210 /* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
4214 convert_debug_memory_address (scalar_int_mode mode
, rtx x
,
4217 #ifndef POINTERS_EXTEND_UNSIGNED
4218 gcc_assert (mode
== Pmode
4219 || mode
== targetm
.addr_space
.address_mode (as
));
4220 gcc_assert (GET_MODE (x
) == mode
|| GET_MODE (x
) == VOIDmode
);
4224 gcc_assert (targetm
.addr_space
.valid_pointer_mode (mode
, as
));
4226 if (GET_MODE (x
) == mode
|| GET_MODE (x
) == VOIDmode
)
4229 /* X must have some form of address mode already. */
4230 scalar_int_mode xmode
= as_a
<scalar_int_mode
> (GET_MODE (x
));
4231 if (GET_MODE_PRECISION (mode
) < GET_MODE_PRECISION (xmode
))
4232 x
= lowpart_subreg (mode
, x
, xmode
);
4233 else if (POINTERS_EXTEND_UNSIGNED
> 0)
4234 x
= gen_rtx_ZERO_EXTEND (mode
, x
);
4235 else if (!POINTERS_EXTEND_UNSIGNED
)
4236 x
= gen_rtx_SIGN_EXTEND (mode
, x
);
4239 switch (GET_CODE (x
))
4242 if ((SUBREG_PROMOTED_VAR_P (x
)
4243 || (REG_P (SUBREG_REG (x
)) && REG_POINTER (SUBREG_REG (x
)))
4244 || (GET_CODE (SUBREG_REG (x
)) == PLUS
4245 && REG_P (XEXP (SUBREG_REG (x
), 0))
4246 && REG_POINTER (XEXP (SUBREG_REG (x
), 0))
4247 && CONST_INT_P (XEXP (SUBREG_REG (x
), 1))))
4248 && GET_MODE (SUBREG_REG (x
)) == mode
)
4249 return SUBREG_REG (x
);
4252 temp
= gen_rtx_LABEL_REF (mode
, label_ref_label (x
));
4253 LABEL_REF_NONLOCAL_P (temp
) = LABEL_REF_NONLOCAL_P (x
);
4256 temp
= shallow_copy_rtx (x
);
4257 PUT_MODE (temp
, mode
);
4260 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
4262 temp
= gen_rtx_CONST (mode
, temp
);
4266 if (CONST_INT_P (XEXP (x
, 1)))
4268 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
4270 return gen_rtx_fmt_ee (GET_CODE (x
), mode
, temp
, XEXP (x
, 1));
4276 /* Don't know how to express ptr_extend as operation in debug info. */
4279 #endif /* POINTERS_EXTEND_UNSIGNED */
4284 /* Map from SSA_NAMEs to corresponding DEBUG_EXPR_DECLs created
4285 by avoid_deep_ter_for_debug. */
4287 static hash_map
<tree
, tree
> *deep_ter_debug_map
;
4289 /* Split too deep TER chains for debug stmts using debug temporaries. */
4292 avoid_deep_ter_for_debug (gimple
*stmt
, int depth
)
4294 use_operand_p use_p
;
4296 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
4298 tree use
= USE_FROM_PTR (use_p
);
4299 if (TREE_CODE (use
) != SSA_NAME
|| SSA_NAME_IS_DEFAULT_DEF (use
))
4301 gimple
*g
= get_gimple_for_ssa_name (use
);
4304 if (depth
> 6 && !stmt_ends_bb_p (g
))
4306 if (deep_ter_debug_map
== NULL
)
4307 deep_ter_debug_map
= new hash_map
<tree
, tree
>;
4309 tree
&vexpr
= deep_ter_debug_map
->get_or_insert (use
);
4312 vexpr
= make_node (DEBUG_EXPR_DECL
);
4313 gimple
*def_temp
= gimple_build_debug_bind (vexpr
, use
, g
);
4314 DECL_ARTIFICIAL (vexpr
) = 1;
4315 TREE_TYPE (vexpr
) = TREE_TYPE (use
);
4316 SET_DECL_MODE (vexpr
, TYPE_MODE (TREE_TYPE (use
)));
4317 gimple_stmt_iterator gsi
= gsi_for_stmt (g
);
4318 gsi_insert_after (&gsi
, def_temp
, GSI_NEW_STMT
);
4319 avoid_deep_ter_for_debug (def_temp
, 0);
4322 avoid_deep_ter_for_debug (g
, depth
+ 1);
4326 /* Return an RTX equivalent to the value of the parameter DECL. */
4329 expand_debug_parm_decl (tree decl
)
4331 rtx incoming
= DECL_INCOMING_RTL (decl
);
4334 && GET_MODE (incoming
) != BLKmode
4335 && ((REG_P (incoming
) && HARD_REGISTER_P (incoming
))
4336 || (MEM_P (incoming
)
4337 && REG_P (XEXP (incoming
, 0))
4338 && HARD_REGISTER_P (XEXP (incoming
, 0)))))
4340 rtx rtl
= gen_rtx_ENTRY_VALUE (GET_MODE (incoming
));
4342 #ifdef HAVE_window_save
4343 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
4344 If the target machine has an explicit window save instruction, the
4345 actual entry value is the corresponding OUTGOING_REGNO instead. */
4346 if (REG_P (incoming
)
4347 && OUTGOING_REGNO (REGNO (incoming
)) != REGNO (incoming
))
4349 = gen_rtx_REG_offset (incoming
, GET_MODE (incoming
),
4350 OUTGOING_REGNO (REGNO (incoming
)), 0);
4351 else if (MEM_P (incoming
))
4353 rtx reg
= XEXP (incoming
, 0);
4354 if (OUTGOING_REGNO (REGNO (reg
)) != REGNO (reg
))
4356 reg
= gen_raw_REG (GET_MODE (reg
), OUTGOING_REGNO (REGNO (reg
)));
4357 incoming
= replace_equiv_address_nv (incoming
, reg
);
4360 incoming
= copy_rtx (incoming
);
4364 ENTRY_VALUE_EXP (rtl
) = incoming
;
4369 && GET_MODE (incoming
) != BLKmode
4370 && !TREE_ADDRESSABLE (decl
)
4372 && (XEXP (incoming
, 0) == virtual_incoming_args_rtx
4373 || (GET_CODE (XEXP (incoming
, 0)) == PLUS
4374 && XEXP (XEXP (incoming
, 0), 0) == virtual_incoming_args_rtx
4375 && CONST_INT_P (XEXP (XEXP (incoming
, 0), 1)))))
4376 return copy_rtx (incoming
);
4381 /* Return an RTX equivalent to the value of the tree expression EXP. */
4384 expand_debug_expr (tree exp
)
4386 rtx op0
= NULL_RTX
, op1
= NULL_RTX
, op2
= NULL_RTX
;
4387 machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
4388 machine_mode inner_mode
= VOIDmode
;
4389 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (exp
));
4391 scalar_int_mode op0_mode
, op1_mode
, addr_mode
;
4393 switch (TREE_CODE_CLASS (TREE_CODE (exp
)))
4395 case tcc_expression
:
4396 switch (TREE_CODE (exp
))
4401 case WIDEN_MULT_PLUS_EXPR
:
4402 case WIDEN_MULT_MINUS_EXPR
:
4405 case TRUTH_ANDIF_EXPR
:
4406 case TRUTH_ORIF_EXPR
:
4407 case TRUTH_AND_EXPR
:
4409 case TRUTH_XOR_EXPR
:
4412 case TRUTH_NOT_EXPR
:
4421 op2
= expand_debug_expr (TREE_OPERAND (exp
, 2));
4428 if (mode
== BLKmode
)
4430 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
4433 switch (TREE_CODE (exp
))
4439 case WIDEN_LSHIFT_EXPR
:
4440 /* Ensure second operand isn't wider than the first one. */
4441 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 1)));
4442 if (is_a
<scalar_int_mode
> (inner_mode
, &op1_mode
)
4443 && (GET_MODE_UNIT_PRECISION (mode
)
4444 < GET_MODE_PRECISION (op1_mode
)))
4445 op1
= lowpart_subreg (GET_MODE_INNER (mode
), op1
, op1_mode
);
4454 if (mode
== BLKmode
)
4456 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4457 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4462 case tcc_comparison
:
4463 unsignedp
= TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4471 case tcc_exceptional
:
4472 case tcc_declaration
:
4478 switch (TREE_CODE (exp
))
4481 if (!lookup_constant_def (exp
))
4483 if (strlen (TREE_STRING_POINTER (exp
)) + 1
4484 != (size_t) TREE_STRING_LENGTH (exp
))
4486 op0
= gen_rtx_CONST_STRING (Pmode
, TREE_STRING_POINTER (exp
));
4487 op0
= gen_rtx_MEM (BLKmode
, op0
);
4488 set_mem_attributes (op0
, exp
, 0);
4496 op0
= expand_expr (exp
, NULL_RTX
, mode
, EXPAND_INITIALIZER
);
4500 return immed_wide_int_const (poly_int_cst_value (exp
), mode
);
4503 gcc_assert (COMPLEX_MODE_P (mode
));
4504 op0
= expand_debug_expr (TREE_REALPART (exp
));
4505 op1
= expand_debug_expr (TREE_IMAGPART (exp
));
4506 return gen_rtx_CONCAT (mode
, op0
, op1
);
4508 case DEBUG_EXPR_DECL
:
4509 op0
= DECL_RTL_IF_SET (exp
);
4514 op0
= gen_rtx_DEBUG_EXPR (mode
);
4515 DEBUG_EXPR_TREE_DECL (op0
) = exp
;
4516 SET_DECL_RTL (exp
, op0
);
4526 op0
= DECL_RTL_IF_SET (exp
);
4528 /* This decl was probably optimized away. */
4530 /* At least label RTXen are sometimes replaced by
4531 NOTE_INSN_DELETED_LABEL. Any notes here are not
4532 handled by copy_rtx. */
4536 || DECL_EXTERNAL (exp
)
4537 || !TREE_STATIC (exp
)
4539 || DECL_HARD_REGISTER (exp
)
4540 || DECL_IN_CONSTANT_POOL (exp
)
4541 || mode
== VOIDmode
)
4544 op0
= make_decl_rtl_for_debug (exp
);
4546 || GET_CODE (XEXP (op0
, 0)) != SYMBOL_REF
4547 || SYMBOL_REF_DECL (XEXP (op0
, 0)) != exp
)
4551 op0
= copy_rtx (op0
);
4553 if (GET_MODE (op0
) == BLKmode
4554 /* If op0 is not BLKmode, but mode is, adjust_mode
4555 below would ICE. While it is likely a FE bug,
4556 try to be robust here. See PR43166. */
4558 || (mode
== VOIDmode
&& GET_MODE (op0
) != VOIDmode
))
4560 gcc_assert (MEM_P (op0
));
4561 op0
= adjust_address_nv (op0
, mode
, 0);
4571 inner_mode
= GET_MODE (op0
);
4573 if (mode
== inner_mode
)
4576 if (inner_mode
== VOIDmode
)
4578 if (TREE_CODE (exp
) == SSA_NAME
)
4579 inner_mode
= TYPE_MODE (TREE_TYPE (exp
));
4581 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4582 if (mode
== inner_mode
)
4586 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
4588 if (GET_MODE_UNIT_BITSIZE (mode
)
4589 == GET_MODE_UNIT_BITSIZE (inner_mode
))
4590 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
4591 else if (GET_MODE_UNIT_BITSIZE (mode
)
4592 < GET_MODE_UNIT_BITSIZE (inner_mode
))
4593 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
4595 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
4597 else if (FLOAT_MODE_P (mode
))
4599 gcc_assert (TREE_CODE (exp
) != SSA_NAME
);
4600 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
4601 op0
= simplify_gen_unary (UNSIGNED_FLOAT
, mode
, op0
, inner_mode
);
4603 op0
= simplify_gen_unary (FLOAT
, mode
, op0
, inner_mode
);
4605 else if (FLOAT_MODE_P (inner_mode
))
4608 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
4610 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
4612 else if (GET_MODE_UNIT_PRECISION (mode
)
4613 == GET_MODE_UNIT_PRECISION (inner_mode
))
4614 op0
= lowpart_subreg (mode
, op0
, inner_mode
);
4615 else if (GET_MODE_UNIT_PRECISION (mode
)
4616 < GET_MODE_UNIT_PRECISION (inner_mode
))
4617 op0
= simplify_gen_unary (TRUNCATE
, mode
, op0
, inner_mode
);
4618 else if (UNARY_CLASS_P (exp
)
4619 ? TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)))
4621 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
4623 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
4629 if (!is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
4631 tree newexp
= fold_binary (MEM_REF
, TREE_TYPE (exp
),
4632 TREE_OPERAND (exp
, 0),
4633 TREE_OPERAND (exp
, 1));
4635 return expand_debug_expr (newexp
);
4639 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4640 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4644 if (TREE_CODE (exp
) == MEM_REF
)
4646 if (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
4647 || (GET_CODE (op0
) == PLUS
4648 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
))
4649 /* (mem (debug_implicit_ptr)) might confuse aliasing.
4650 Instead just use get_inner_reference. */
4653 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
4655 if (!op1
|| !poly_int_rtx_p (op1
, &offset
))
4658 op0
= plus_constant (inner_mode
, op0
, offset
);
4661 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))));
4663 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
4665 if (op0
== NULL_RTX
)
4668 op0
= gen_rtx_MEM (mode
, op0
);
4669 set_mem_attributes (op0
, exp
, 0);
4670 if (TREE_CODE (exp
) == MEM_REF
4671 && !is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
4672 set_mem_expr (op0
, NULL_TREE
);
4673 set_mem_addr_space (op0
, as
);
4677 case TARGET_MEM_REF
:
4678 if (TREE_CODE (TMR_BASE (exp
)) == ADDR_EXPR
4679 && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp
), 0)))
4682 op0
= expand_debug_expr
4683 (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp
)), exp
));
4687 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))));
4688 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
4690 if (op0
== NULL_RTX
)
4693 op0
= gen_rtx_MEM (mode
, op0
);
4695 set_mem_attributes (op0
, exp
, 0);
4696 set_mem_addr_space (op0
, as
);
4702 case ARRAY_RANGE_REF
:
4707 case VIEW_CONVERT_EXPR
:
4710 poly_int64 bitsize
, bitpos
;
4712 int reversep
, volatilep
= 0;
4714 = get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
, &mode1
,
4715 &unsignedp
, &reversep
, &volatilep
);
4718 if (known_eq (bitsize
, 0))
4721 orig_op0
= op0
= expand_debug_expr (tem
);
4728 machine_mode addrmode
, offmode
;
4733 op0
= XEXP (op0
, 0);
4734 addrmode
= GET_MODE (op0
);
4735 if (addrmode
== VOIDmode
)
4738 op1
= expand_debug_expr (offset
);
4742 offmode
= GET_MODE (op1
);
4743 if (offmode
== VOIDmode
)
4744 offmode
= TYPE_MODE (TREE_TYPE (offset
));
4746 if (addrmode
!= offmode
)
4747 op1
= lowpart_subreg (addrmode
, op1
, offmode
);
4749 /* Don't use offset_address here, we don't need a
4750 recognizable address, and we don't want to generate
4752 op0
= gen_rtx_MEM (mode
, simplify_gen_binary (PLUS
, addrmode
,
4758 if (mode1
== VOIDmode
)
4760 if (maybe_gt (bitsize
, MAX_BITSIZE_MODE_ANY_INT
))
4763 mode1
= smallest_int_mode_for_size (bitsize
);
4765 poly_int64 bytepos
= bits_to_bytes_round_down (bitpos
);
4766 if (maybe_ne (bytepos
, 0))
4768 op0
= adjust_address_nv (op0
, mode1
, bytepos
);
4769 bitpos
= num_trailing_bits (bitpos
);
4771 else if (known_eq (bitpos
, 0)
4772 && known_eq (bitsize
, GET_MODE_BITSIZE (mode
)))
4773 op0
= adjust_address_nv (op0
, mode
, 0);
4774 else if (GET_MODE (op0
) != mode1
)
4775 op0
= adjust_address_nv (op0
, mode1
, 0);
4777 op0
= copy_rtx (op0
);
4778 if (op0
== orig_op0
)
4779 op0
= shallow_copy_rtx (op0
);
4780 if (TREE_CODE (tem
) != SSA_NAME
)
4781 set_mem_attributes (op0
, exp
, 0);
4784 if (known_eq (bitpos
, 0) && mode
== GET_MODE (op0
))
4787 if (maybe_lt (bitpos
, 0))
4790 if (GET_MODE (op0
) == BLKmode
|| mode
== BLKmode
)
4794 if (multiple_p (bitpos
, BITS_PER_UNIT
, &bytepos
)
4795 && known_eq (bitsize
, GET_MODE_BITSIZE (mode1
)))
4797 machine_mode opmode
= GET_MODE (op0
);
4799 if (opmode
== VOIDmode
)
4800 opmode
= TYPE_MODE (TREE_TYPE (tem
));
4802 /* This condition may hold if we're expanding the address
4803 right past the end of an array that turned out not to
4804 be addressable (i.e., the address was only computed in
4805 debug stmts). The gen_subreg below would rightfully
4806 crash, and the address doesn't really exist, so just
4808 if (known_ge (bitpos
, GET_MODE_BITSIZE (opmode
)))
4811 if (multiple_p (bitpos
, GET_MODE_BITSIZE (mode
)))
4812 return simplify_gen_subreg (mode
, op0
, opmode
, bytepos
);
4815 return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0
))
4816 && TYPE_UNSIGNED (TREE_TYPE (exp
))
4818 : ZERO_EXTRACT
, mode
,
4819 GET_MODE (op0
) != VOIDmode
4821 : TYPE_MODE (TREE_TYPE (tem
)),
4822 op0
, gen_int_mode (bitsize
, word_mode
),
4823 gen_int_mode (bitpos
, word_mode
));
4828 return simplify_gen_unary (ABS
, mode
, op0
, mode
);
4831 return simplify_gen_unary (NEG
, mode
, op0
, mode
);
4834 return simplify_gen_unary (NOT
, mode
, op0
, mode
);
4837 return simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4839 ? UNSIGNED_FLOAT
: FLOAT
, mode
, op0
,
4842 case FIX_TRUNC_EXPR
:
4843 return simplify_gen_unary (unsignedp
? UNSIGNED_FIX
: FIX
, mode
, op0
,
4846 case POINTER_PLUS_EXPR
:
4847 /* For the rare target where pointers are not the same size as
4848 size_t, we need to check for mis-matched modes and correct
4851 && is_a
<scalar_int_mode
> (GET_MODE (op0
), &op0_mode
)
4852 && is_a
<scalar_int_mode
> (GET_MODE (op1
), &op1_mode
)
4853 && op0_mode
!= op1_mode
)
4855 if (GET_MODE_BITSIZE (op0_mode
) < GET_MODE_BITSIZE (op1_mode
)
4856 /* If OP0 is a partial mode, then we must truncate, even
4857 if it has the same bitsize as OP1 as GCC's
4858 representation of partial modes is opaque. */
4859 || (GET_MODE_CLASS (op0_mode
) == MODE_PARTIAL_INT
4860 && (GET_MODE_BITSIZE (op0_mode
)
4861 == GET_MODE_BITSIZE (op1_mode
))))
4862 op1
= simplify_gen_unary (TRUNCATE
, op0_mode
, op1
, op1_mode
);
4864 /* We always sign-extend, regardless of the signedness of
4865 the operand, because the operand is always unsigned
4866 here even if the original C expression is signed. */
4867 op1
= simplify_gen_unary (SIGN_EXTEND
, op0_mode
, op1
, op1_mode
);
4871 return simplify_gen_binary (PLUS
, mode
, op0
, op1
);
4874 case POINTER_DIFF_EXPR
:
4875 return simplify_gen_binary (MINUS
, mode
, op0
, op1
);
4878 return simplify_gen_binary (MULT
, mode
, op0
, op1
);
4881 case TRUNC_DIV_EXPR
:
4882 case EXACT_DIV_EXPR
:
4884 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4886 return simplify_gen_binary (DIV
, mode
, op0
, op1
);
4888 case TRUNC_MOD_EXPR
:
4889 return simplify_gen_binary (unsignedp
? UMOD
: MOD
, mode
, op0
, op1
);
4891 case FLOOR_DIV_EXPR
:
4893 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4896 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4897 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4898 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4899 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4902 case FLOOR_MOD_EXPR
:
4904 return simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4907 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4908 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4909 adj
= simplify_gen_unary (NEG
, mode
,
4910 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4912 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4918 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4919 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4920 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4921 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4925 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4926 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4927 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4928 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4934 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4935 rtx adj
= ceil_udiv_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
);
4943 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4944 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4945 adj
= simplify_gen_unary (NEG
, mode
,
4946 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4948 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4951 case ROUND_DIV_EXPR
:
4954 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4955 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4956 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4957 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4961 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4962 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4963 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4964 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4967 case ROUND_MOD_EXPR
:
4970 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4971 rtx adj
= round_udiv_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 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4980 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4981 adj
= simplify_gen_unary (NEG
, mode
,
4982 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4984 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4988 return simplify_gen_binary (ASHIFT
, mode
, op0
, op1
);
4992 return simplify_gen_binary (LSHIFTRT
, mode
, op0
, op1
);
4994 return simplify_gen_binary (ASHIFTRT
, mode
, op0
, op1
);
4997 return simplify_gen_binary (ROTATE
, mode
, op0
, op1
);
5000 return simplify_gen_binary (ROTATERT
, mode
, op0
, op1
);
5003 return simplify_gen_binary (unsignedp
? UMIN
: SMIN
, mode
, op0
, op1
);
5006 return simplify_gen_binary (unsignedp
? UMAX
: SMAX
, mode
, op0
, op1
);
5009 case TRUTH_AND_EXPR
:
5010 return simplify_gen_binary (AND
, mode
, op0
, op1
);
5014 return simplify_gen_binary (IOR
, mode
, op0
, op1
);
5017 case TRUTH_XOR_EXPR
:
5018 return simplify_gen_binary (XOR
, mode
, op0
, op1
);
5020 case TRUTH_ANDIF_EXPR
:
5021 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, const0_rtx
);
5023 case TRUTH_ORIF_EXPR
:
5024 return gen_rtx_IF_THEN_ELSE (mode
, op0
, const_true_rtx
, op1
);
5026 case TRUTH_NOT_EXPR
:
5027 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, const0_rtx
);
5030 return simplify_gen_relational (unsignedp
? LTU
: LT
, mode
, inner_mode
,
5034 return simplify_gen_relational (unsignedp
? LEU
: LE
, mode
, inner_mode
,
5038 return simplify_gen_relational (unsignedp
? GTU
: GT
, mode
, inner_mode
,
5042 return simplify_gen_relational (unsignedp
? GEU
: GE
, mode
, inner_mode
,
5046 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, op1
);
5049 return simplify_gen_relational (NE
, mode
, inner_mode
, op0
, op1
);
5051 case UNORDERED_EXPR
:
5052 return simplify_gen_relational (UNORDERED
, mode
, inner_mode
, op0
, op1
);
5055 return simplify_gen_relational (ORDERED
, mode
, inner_mode
, op0
, op1
);
5058 return simplify_gen_relational (UNLT
, mode
, inner_mode
, op0
, op1
);
5061 return simplify_gen_relational (UNLE
, mode
, inner_mode
, op0
, op1
);
5064 return simplify_gen_relational (UNGT
, mode
, inner_mode
, op0
, op1
);
5067 return simplify_gen_relational (UNGE
, mode
, inner_mode
, op0
, op1
);
5070 return simplify_gen_relational (UNEQ
, mode
, inner_mode
, op0
, op1
);
5073 return simplify_gen_relational (LTGT
, mode
, inner_mode
, op0
, op1
);
5076 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, op2
);
5079 gcc_assert (COMPLEX_MODE_P (mode
));
5080 if (GET_MODE (op0
) == VOIDmode
)
5081 op0
= gen_rtx_CONST (GET_MODE_INNER (mode
), op0
);
5082 if (GET_MODE (op1
) == VOIDmode
)
5083 op1
= gen_rtx_CONST (GET_MODE_INNER (mode
), op1
);
5084 return gen_rtx_CONCAT (mode
, op0
, op1
);
5087 if (GET_CODE (op0
) == CONCAT
)
5088 return gen_rtx_CONCAT (mode
, XEXP (op0
, 0),
5089 simplify_gen_unary (NEG
, GET_MODE_INNER (mode
),
5091 GET_MODE_INNER (mode
)));
5094 scalar_mode imode
= GET_MODE_INNER (mode
);
5099 re
= adjust_address_nv (op0
, imode
, 0);
5100 im
= adjust_address_nv (op0
, imode
, GET_MODE_SIZE (imode
));
5104 scalar_int_mode ifmode
;
5105 scalar_int_mode ihmode
;
5107 if (!int_mode_for_mode (mode
).exists (&ifmode
)
5108 || !int_mode_for_mode (imode
).exists (&ihmode
))
5110 halfsize
= GEN_INT (GET_MODE_BITSIZE (ihmode
));
5113 re
= gen_rtx_SUBREG (ifmode
, re
, 0);
5114 re
= gen_rtx_ZERO_EXTRACT (ihmode
, re
, halfsize
, const0_rtx
);
5115 if (imode
!= ihmode
)
5116 re
= gen_rtx_SUBREG (imode
, re
, 0);
5117 im
= copy_rtx (op0
);
5119 im
= gen_rtx_SUBREG (ifmode
, im
, 0);
5120 im
= gen_rtx_ZERO_EXTRACT (ihmode
, im
, halfsize
, halfsize
);
5121 if (imode
!= ihmode
)
5122 im
= gen_rtx_SUBREG (imode
, im
, 0);
5124 im
= gen_rtx_NEG (imode
, im
);
5125 return gen_rtx_CONCAT (mode
, re
, im
);
5129 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
5130 if (!op0
|| !MEM_P (op0
))
5132 if ((TREE_CODE (TREE_OPERAND (exp
, 0)) == VAR_DECL
5133 || TREE_CODE (TREE_OPERAND (exp
, 0)) == PARM_DECL
5134 || TREE_CODE (TREE_OPERAND (exp
, 0)) == RESULT_DECL
)
5135 && (!TREE_ADDRESSABLE (TREE_OPERAND (exp
, 0))
5136 || target_for_debug_bind (TREE_OPERAND (exp
, 0))))
5137 return gen_rtx_DEBUG_IMPLICIT_PTR (mode
, TREE_OPERAND (exp
, 0));
5139 if (handled_component_p (TREE_OPERAND (exp
, 0)))
5141 poly_int64 bitoffset
, bitsize
, maxsize
, byteoffset
;
5144 = get_ref_base_and_extent (TREE_OPERAND (exp
, 0), &bitoffset
,
5145 &bitsize
, &maxsize
, &reverse
);
5147 || TREE_CODE (decl
) == PARM_DECL
5148 || TREE_CODE (decl
) == RESULT_DECL
)
5149 && (!TREE_ADDRESSABLE (decl
)
5150 || target_for_debug_bind (decl
))
5151 && multiple_p (bitoffset
, BITS_PER_UNIT
, &byteoffset
)
5152 && known_gt (bitsize
, 0)
5153 && known_eq (bitsize
, maxsize
))
5155 rtx base
= gen_rtx_DEBUG_IMPLICIT_PTR (mode
, decl
);
5156 return plus_constant (mode
, base
, byteoffset
);
5160 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == MEM_REF
5161 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
5164 op0
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
5167 && (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
5168 || (GET_CODE (op0
) == PLUS
5169 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
5170 && CONST_INT_P (XEXP (op0
, 1)))))
5172 op1
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
5175 if (!op1
|| !poly_int_rtx_p (op1
, &offset
))
5178 return plus_constant (mode
, op0
, offset
);
5185 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)));
5186 addr_mode
= SCALAR_INT_TYPE_MODE (TREE_TYPE (exp
));
5187 op0
= convert_debug_memory_address (addr_mode
, XEXP (op0
, 0), as
);
5193 unsigned HOST_WIDE_INT i
, nelts
;
5195 if (!VECTOR_CST_NELTS (exp
).is_constant (&nelts
))
5198 op0
= gen_rtx_CONCATN (mode
, rtvec_alloc (nelts
));
5200 for (i
= 0; i
< nelts
; ++i
)
5202 op1
= expand_debug_expr (VECTOR_CST_ELT (exp
, i
));
5205 XVECEXP (op0
, 0, i
) = op1
;
5212 if (TREE_CLOBBER_P (exp
))
5214 else if (TREE_CODE (TREE_TYPE (exp
)) == VECTOR_TYPE
)
5217 unsigned HOST_WIDE_INT nelts
;
5220 if (!TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)).is_constant (&nelts
))
5221 goto flag_unsupported
;
5223 op0
= gen_rtx_CONCATN (mode
, rtvec_alloc (nelts
));
5225 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), i
, val
)
5227 op1
= expand_debug_expr (val
);
5230 XVECEXP (op0
, 0, i
) = op1
;
5235 op1
= expand_debug_expr
5236 (build_zero_cst (TREE_TYPE (TREE_TYPE (exp
))));
5241 for (; i
< nelts
; i
++)
5242 XVECEXP (op0
, 0, i
) = op1
;
5248 goto flag_unsupported
;
5251 /* ??? Maybe handle some builtins? */
5256 gimple
*g
= get_gimple_for_ssa_name (exp
);
5260 if (deep_ter_debug_map
)
5262 tree
*slot
= deep_ter_debug_map
->get (exp
);
5267 t
= gimple_assign_rhs_to_tree (g
);
5268 op0
= expand_debug_expr (t
);
5274 /* If this is a reference to an incoming value of
5275 parameter that is never used in the code or where the
5276 incoming value is never used in the code, use
5277 PARM_DECL's DECL_RTL if set. */
5278 if (SSA_NAME_IS_DEFAULT_DEF (exp
)
5279 && SSA_NAME_VAR (exp
)
5280 && TREE_CODE (SSA_NAME_VAR (exp
)) == PARM_DECL
5281 && has_zero_uses (exp
))
5283 op0
= expand_debug_parm_decl (SSA_NAME_VAR (exp
));
5286 op0
= expand_debug_expr (SSA_NAME_VAR (exp
));
5291 int part
= var_to_partition (SA
.map
, exp
);
5293 if (part
== NO_PARTITION
)
5296 gcc_assert (part
>= 0 && (unsigned)part
< SA
.map
->num_partitions
);
5298 op0
= copy_rtx (SA
.partition_to_pseudo
[part
]);
5306 /* Vector stuff. For most of the codes we don't have rtl codes. */
5307 case REALIGN_LOAD_EXPR
:
5309 case VEC_PACK_FIX_TRUNC_EXPR
:
5310 case VEC_PACK_FLOAT_EXPR
:
5311 case VEC_PACK_SAT_EXPR
:
5312 case VEC_PACK_TRUNC_EXPR
:
5313 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
5314 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
5315 case VEC_UNPACK_FLOAT_HI_EXPR
:
5316 case VEC_UNPACK_FLOAT_LO_EXPR
:
5317 case VEC_UNPACK_HI_EXPR
:
5318 case VEC_UNPACK_LO_EXPR
:
5319 case VEC_WIDEN_MULT_HI_EXPR
:
5320 case VEC_WIDEN_MULT_LO_EXPR
:
5321 case VEC_WIDEN_MULT_EVEN_EXPR
:
5322 case VEC_WIDEN_MULT_ODD_EXPR
:
5323 case VEC_WIDEN_LSHIFT_HI_EXPR
:
5324 case VEC_WIDEN_LSHIFT_LO_EXPR
:
5326 case VEC_DUPLICATE_EXPR
:
5327 case VEC_SERIES_EXPR
:
5332 case ADDR_SPACE_CONVERT_EXPR
:
5333 case FIXED_CONVERT_EXPR
:
5335 case WITH_SIZE_EXPR
:
5336 case BIT_INSERT_EXPR
:
5340 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5341 && SCALAR_INT_MODE_P (mode
))
5344 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5346 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
5349 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5351 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op1
,
5353 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
5354 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
5358 case WIDEN_MULT_EXPR
:
5359 case WIDEN_MULT_PLUS_EXPR
:
5360 case WIDEN_MULT_MINUS_EXPR
:
5361 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5362 && SCALAR_INT_MODE_P (mode
))
5364 inner_mode
= GET_MODE (op0
);
5365 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
5366 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
5368 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
5369 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 1))))
5370 op1
= simplify_gen_unary (ZERO_EXTEND
, mode
, op1
, inner_mode
);
5372 op1
= simplify_gen_unary (SIGN_EXTEND
, mode
, op1
, inner_mode
);
5373 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
5374 if (TREE_CODE (exp
) == WIDEN_MULT_EXPR
)
5376 else if (TREE_CODE (exp
) == WIDEN_MULT_PLUS_EXPR
)
5377 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
5379 return simplify_gen_binary (MINUS
, mode
, op2
, op0
);
5383 case MULT_HIGHPART_EXPR
:
5384 /* ??? Similar to the above. */
5387 case WIDEN_SUM_EXPR
:
5388 case WIDEN_LSHIFT_EXPR
:
5389 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5390 && SCALAR_INT_MODE_P (mode
))
5393 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5395 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
5397 return simplify_gen_binary (TREE_CODE (exp
) == WIDEN_LSHIFT_EXPR
5398 ? ASHIFT
: PLUS
, mode
, op0
, op1
);
5413 /* Return an RTX equivalent to the source bind value of the tree expression
5417 expand_debug_source_expr (tree exp
)
5420 machine_mode mode
= VOIDmode
, inner_mode
;
5422 switch (TREE_CODE (exp
))
5425 if (DECL_ABSTRACT_ORIGIN (exp
))
5426 return expand_debug_source_expr (DECL_ABSTRACT_ORIGIN (exp
));
5430 mode
= DECL_MODE (exp
);
5431 op0
= expand_debug_parm_decl (exp
);
5434 /* See if this isn't an argument that has been completely
5436 if (!DECL_RTL_SET_P (exp
)
5437 && !DECL_INCOMING_RTL (exp
)
5438 && DECL_ABSTRACT_ORIGIN (current_function_decl
))
5440 tree aexp
= DECL_ORIGIN (exp
);
5441 if (DECL_CONTEXT (aexp
)
5442 == DECL_ABSTRACT_ORIGIN (current_function_decl
))
5444 vec
<tree
, va_gc
> **debug_args
;
5447 debug_args
= decl_debug_args_lookup (current_function_decl
);
5448 if (debug_args
!= NULL
)
5450 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, &ddecl
);
5453 return gen_rtx_DEBUG_PARAMETER_REF (mode
, aexp
);
5463 if (op0
== NULL_RTX
)
5466 inner_mode
= GET_MODE (op0
);
5467 if (mode
== inner_mode
)
5470 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
5472 if (GET_MODE_UNIT_BITSIZE (mode
)
5473 == GET_MODE_UNIT_BITSIZE (inner_mode
))
5474 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
5475 else if (GET_MODE_UNIT_BITSIZE (mode
)
5476 < GET_MODE_UNIT_BITSIZE (inner_mode
))
5477 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
5479 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
5481 else if (FLOAT_MODE_P (mode
))
5483 else if (FLOAT_MODE_P (inner_mode
))
5485 if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
5486 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
5488 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
5490 else if (GET_MODE_UNIT_PRECISION (mode
)
5491 == GET_MODE_UNIT_PRECISION (inner_mode
))
5492 op0
= lowpart_subreg (mode
, op0
, inner_mode
);
5493 else if (GET_MODE_UNIT_PRECISION (mode
)
5494 < GET_MODE_UNIT_PRECISION (inner_mode
))
5495 op0
= simplify_gen_unary (TRUNCATE
, mode
, op0
, inner_mode
);
5496 else if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
5497 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
5499 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
5504 /* Ensure INSN_VAR_LOCATION_LOC (insn) doesn't have unbound complexity.
5505 Allow 4 levels of rtl nesting for most rtl codes, and if we see anything
5506 deeper than that, create DEBUG_EXPRs and emit DEBUG_INSNs before INSN. */
5509 avoid_complex_debug_insns (rtx_insn
*insn
, rtx
*exp_p
, int depth
)
5513 if (exp
== NULL_RTX
)
5516 if ((OBJECT_P (exp
) && !MEM_P (exp
)) || GET_CODE (exp
) == CLOBBER
)
5521 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
5522 rtx dval
= make_debug_expr_from_rtl (exp
);
5524 /* Emit a debug bind insn before INSN. */
5525 rtx bind
= gen_rtx_VAR_LOCATION (GET_MODE (exp
),
5526 DEBUG_EXPR_TREE_DECL (dval
), exp
,
5527 VAR_INIT_STATUS_INITIALIZED
);
5529 emit_debug_insn_before (bind
, insn
);
5534 const char *format_ptr
= GET_RTX_FORMAT (GET_CODE (exp
));
5536 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
5537 switch (*format_ptr
++)
5540 avoid_complex_debug_insns (insn
, &XEXP (exp
, i
), depth
+ 1);
5545 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
5546 avoid_complex_debug_insns (insn
, &XVECEXP (exp
, i
, j
), depth
+ 1);
5554 /* Expand the _LOCs in debug insns. We run this after expanding all
5555 regular insns, so that any variables referenced in the function
5556 will have their DECL_RTLs set. */
5559 expand_debug_locations (void)
5562 rtx_insn
*last
= get_last_insn ();
5563 int save_strict_alias
= flag_strict_aliasing
;
5565 /* New alias sets while setting up memory attributes cause
5566 -fcompare-debug failures, even though it doesn't bring about any
5568 flag_strict_aliasing
= 0;
5570 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
5571 if (DEBUG_BIND_INSN_P (insn
))
5573 tree value
= (tree
)INSN_VAR_LOCATION_LOC (insn
);
5575 rtx_insn
*prev_insn
, *insn2
;
5578 if (value
== NULL_TREE
)
5582 if (INSN_VAR_LOCATION_STATUS (insn
)
5583 == VAR_INIT_STATUS_UNINITIALIZED
)
5584 val
= expand_debug_source_expr (value
);
5585 /* The avoid_deep_ter_for_debug function inserts
5586 debug bind stmts after SSA_NAME definition, with the
5587 SSA_NAME as the whole bind location. Disable temporarily
5588 expansion of that SSA_NAME into the DEBUG_EXPR_DECL
5589 being defined in this DEBUG_INSN. */
5590 else if (deep_ter_debug_map
&& TREE_CODE (value
) == SSA_NAME
)
5592 tree
*slot
= deep_ter_debug_map
->get (value
);
5595 if (*slot
== INSN_VAR_LOCATION_DECL (insn
))
5600 val
= expand_debug_expr (value
);
5602 *slot
= INSN_VAR_LOCATION_DECL (insn
);
5605 val
= expand_debug_expr (value
);
5606 gcc_assert (last
== get_last_insn ());
5610 val
= gen_rtx_UNKNOWN_VAR_LOC ();
5613 mode
= GET_MODE (INSN_VAR_LOCATION (insn
));
5615 gcc_assert (mode
== GET_MODE (val
)
5616 || (GET_MODE (val
) == VOIDmode
5617 && (CONST_SCALAR_INT_P (val
)
5618 || GET_CODE (val
) == CONST_FIXED
5619 || GET_CODE (val
) == LABEL_REF
)));
5622 INSN_VAR_LOCATION_LOC (insn
) = val
;
5623 prev_insn
= PREV_INSN (insn
);
5624 for (insn2
= insn
; insn2
!= prev_insn
; insn2
= PREV_INSN (insn2
))
5625 avoid_complex_debug_insns (insn2
, &INSN_VAR_LOCATION_LOC (insn2
), 0);
5628 flag_strict_aliasing
= save_strict_alias
;
5631 /* Performs swapping operands of commutative operations to expand
5632 the expensive one first. */
5635 reorder_operands (basic_block bb
)
5637 unsigned int *lattice
; /* Hold cost of each statement. */
5638 unsigned int i
= 0, n
= 0;
5639 gimple_stmt_iterator gsi
;
5645 use_operand_p use_p
;
5646 gimple
*def0
, *def1
;
5648 /* Compute cost of each statement using estimate_num_insns. */
5649 stmts
= bb_seq (bb
);
5650 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5652 stmt
= gsi_stmt (gsi
);
5653 if (!is_gimple_debug (stmt
))
5654 gimple_set_uid (stmt
, n
++);
5656 lattice
= XNEWVEC (unsigned int, n
);
5657 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5660 stmt
= gsi_stmt (gsi
);
5661 if (is_gimple_debug (stmt
))
5663 cost
= estimate_num_insns (stmt
, &eni_size_weights
);
5665 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
5667 tree use
= USE_FROM_PTR (use_p
);
5669 if (TREE_CODE (use
) != SSA_NAME
)
5671 def_stmt
= get_gimple_for_ssa_name (use
);
5674 lattice
[i
] += lattice
[gimple_uid (def_stmt
)];
5677 if (!is_gimple_assign (stmt
)
5678 || !commutative_tree_code (gimple_assign_rhs_code (stmt
)))
5680 op0
= gimple_op (stmt
, 1);
5681 op1
= gimple_op (stmt
, 2);
5682 if (TREE_CODE (op0
) != SSA_NAME
5683 || TREE_CODE (op1
) != SSA_NAME
)
5685 /* Swap operands if the second one is more expensive. */
5686 def0
= get_gimple_for_ssa_name (op0
);
5687 def1
= get_gimple_for_ssa_name (op1
);
5691 if (!def0
|| lattice
[gimple_uid (def1
)] > lattice
[gimple_uid (def0
)])
5695 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5697 fprintf (dump_file
, "Swap operands in stmt:\n");
5698 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
5699 fprintf (dump_file
, "Cost left opnd=%d, right opnd=%d\n",
5700 def0
? lattice
[gimple_uid (def0
)] : 0,
5701 lattice
[gimple_uid (def1
)]);
5703 swap_ssa_operands (stmt
, gimple_assign_rhs1_ptr (stmt
),
5704 gimple_assign_rhs2_ptr (stmt
));
5710 /* Expand basic block BB from GIMPLE trees to RTL. */
5713 expand_gimple_basic_block (basic_block bb
, bool disable_tail_calls
)
5715 gimple_stmt_iterator gsi
;
5717 gimple
*stmt
= NULL
;
5718 rtx_note
*note
= NULL
;
5724 fprintf (dump_file
, "\n;; Generating RTL for gimple basic block %d\n",
5727 /* Note that since we are now transitioning from GIMPLE to RTL, we
5728 cannot use the gsi_*_bb() routines because they expect the basic
5729 block to be in GIMPLE, instead of RTL. Therefore, we need to
5730 access the BB sequence directly. */
5732 reorder_operands (bb
);
5733 stmts
= bb_seq (bb
);
5734 bb
->il
.gimple
.seq
= NULL
;
5735 bb
->il
.gimple
.phi_nodes
= NULL
;
5736 rtl_profile_for_bb (bb
);
5737 init_rtl_bb_info (bb
);
5738 bb
->flags
|= BB_RTL
;
5740 /* Remove the RETURN_EXPR if we may fall though to the exit
5742 gsi
= gsi_last (stmts
);
5743 if (!gsi_end_p (gsi
)
5744 && gimple_code (gsi_stmt (gsi
)) == GIMPLE_RETURN
)
5746 greturn
*ret_stmt
= as_a
<greturn
*> (gsi_stmt (gsi
));
5748 gcc_assert (single_succ_p (bb
));
5749 gcc_assert (single_succ (bb
) == EXIT_BLOCK_PTR_FOR_FN (cfun
));
5751 if (bb
->next_bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
)
5752 && !gimple_return_retval (ret_stmt
))
5754 gsi_remove (&gsi
, false);
5755 single_succ_edge (bb
)->flags
|= EDGE_FALLTHRU
;
5759 gsi
= gsi_start (stmts
);
5760 if (!gsi_end_p (gsi
))
5762 stmt
= gsi_stmt (gsi
);
5763 if (gimple_code (stmt
) != GIMPLE_LABEL
)
5767 rtx_code_label
**elt
= lab_rtx_for_bb
->get (bb
);
5771 gcc_checking_assert (!note
);
5772 last
= get_last_insn ();
5776 expand_gimple_stmt (stmt
);
5783 BB_HEAD (bb
) = NEXT_INSN (last
);
5784 if (NOTE_P (BB_HEAD (bb
)))
5785 BB_HEAD (bb
) = NEXT_INSN (BB_HEAD (bb
));
5786 gcc_assert (LABEL_P (BB_HEAD (bb
)));
5787 note
= emit_note_after (NOTE_INSN_BASIC_BLOCK
, BB_HEAD (bb
));
5789 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5792 BB_HEAD (bb
) = note
= emit_note (NOTE_INSN_BASIC_BLOCK
);
5795 NOTE_BASIC_BLOCK (note
) = bb
;
5797 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
5801 stmt
= gsi_stmt (gsi
);
5803 /* If this statement is a non-debug one, and we generate debug
5804 insns, then this one might be the last real use of a TERed
5805 SSA_NAME, but where there are still some debug uses further
5806 down. Expanding the current SSA name in such further debug
5807 uses by their RHS might lead to wrong debug info, as coalescing
5808 might make the operands of such RHS be placed into the same
5809 pseudo as something else. Like so:
5810 a_1 = a_0 + 1; // Assume a_1 is TERed and a_0 is dead
5814 As a_0 and a_2 don't overlap in lifetime, assume they are coalesced.
5815 If we now would expand a_1 by it's RHS (a_0 + 1) in the debug use,
5816 the write to a_2 would actually have clobbered the place which
5819 So, instead of that, we recognize the situation, and generate
5820 debug temporaries at the last real use of TERed SSA names:
5827 if (MAY_HAVE_DEBUG_BIND_INSNS
5829 && !is_gimple_debug (stmt
))
5835 location_t sloc
= curr_insn_location ();
5837 /* Look for SSA names that have their last use here (TERed
5838 names always have only one real use). */
5839 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
)
5840 if ((def
= get_gimple_for_ssa_name (op
)))
5842 imm_use_iterator imm_iter
;
5843 use_operand_p use_p
;
5844 bool have_debug_uses
= false;
5846 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, op
)
5848 if (gimple_debug_bind_p (USE_STMT (use_p
)))
5850 have_debug_uses
= true;
5855 if (have_debug_uses
)
5857 /* OP is a TERed SSA name, with DEF its defining
5858 statement, and where OP is used in further debug
5859 instructions. Generate a debug temporary, and
5860 replace all uses of OP in debug insns with that
5863 tree value
= gimple_assign_rhs_to_tree (def
);
5864 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
5868 set_curr_insn_location (gimple_location (def
));
5870 DECL_ARTIFICIAL (vexpr
) = 1;
5871 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
5873 mode
= DECL_MODE (value
);
5875 mode
= TYPE_MODE (TREE_TYPE (value
));
5876 SET_DECL_MODE (vexpr
, mode
);
5878 val
= gen_rtx_VAR_LOCATION
5879 (mode
, vexpr
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5881 emit_debug_insn (val
);
5883 FOR_EACH_IMM_USE_STMT (debugstmt
, imm_iter
, op
)
5885 if (!gimple_debug_bind_p (debugstmt
))
5888 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
5889 SET_USE (use_p
, vexpr
);
5891 update_stmt (debugstmt
);
5895 set_curr_insn_location (sloc
);
5898 currently_expanding_gimple_stmt
= stmt
;
5900 /* Expand this statement, then evaluate the resulting RTL and
5901 fixup the CFG accordingly. */
5902 if (gimple_code (stmt
) == GIMPLE_COND
)
5904 new_bb
= expand_gimple_cond (bb
, as_a
<gcond
*> (stmt
));
5908 else if (is_gimple_debug (stmt
))
5910 location_t sloc
= curr_insn_location ();
5911 gimple_stmt_iterator nsi
= gsi
;
5916 tree value
= NULL_TREE
;
5920 if (!gimple_debug_nonbind_marker_p (stmt
))
5922 if (gimple_debug_bind_p (stmt
))
5924 var
= gimple_debug_bind_get_var (stmt
);
5926 if (TREE_CODE (var
) != DEBUG_EXPR_DECL
5927 && TREE_CODE (var
) != LABEL_DECL
5928 && !target_for_debug_bind (var
))
5929 goto delink_debug_stmt
;
5931 if (DECL_P (var
) && !VECTOR_TYPE_P (TREE_TYPE (var
)))
5932 mode
= DECL_MODE (var
);
5934 mode
= TYPE_MODE (TREE_TYPE (var
));
5936 if (gimple_debug_bind_has_value_p (stmt
))
5937 value
= gimple_debug_bind_get_value (stmt
);
5939 val
= gen_rtx_VAR_LOCATION
5940 (mode
, var
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5942 else if (gimple_debug_source_bind_p (stmt
))
5944 var
= gimple_debug_source_bind_get_var (stmt
);
5946 value
= gimple_debug_source_bind_get_value (stmt
);
5948 if (!VECTOR_TYPE_P (TREE_TYPE (var
)))
5949 mode
= DECL_MODE (var
);
5951 mode
= TYPE_MODE (TREE_TYPE (var
));
5953 val
= gen_rtx_VAR_LOCATION (mode
, var
, (rtx
)value
,
5954 VAR_INIT_STATUS_UNINITIALIZED
);
5959 /* If this function was first compiled with markers
5960 enabled, but they're now disable (e.g. LTO), drop
5961 them on the floor. */
5962 else if (gimple_debug_nonbind_marker_p (stmt
)
5963 && !MAY_HAVE_DEBUG_MARKER_INSNS
)
5964 goto delink_debug_stmt
;
5965 else if (gimple_debug_begin_stmt_p (stmt
))
5966 val
= GEN_RTX_DEBUG_MARKER_BEGIN_STMT_PAT ();
5967 else if (gimple_debug_inline_entry_p (stmt
))
5968 val
= GEN_RTX_DEBUG_MARKER_INLINE_ENTRY_PAT ();
5972 last
= get_last_insn ();
5974 set_curr_insn_location (gimple_location (stmt
));
5976 emit_debug_insn (val
);
5978 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5980 /* We can't dump the insn with a TREE where an RTX
5982 if (GET_CODE (val
) == VAR_LOCATION
)
5984 gcc_checking_assert (PAT_VAR_LOCATION_LOC (val
) == (rtx
)value
);
5985 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
5987 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5988 if (GET_CODE (val
) == VAR_LOCATION
)
5989 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
5993 /* In order not to generate too many debug temporaries,
5994 we delink all uses of debug statements we already expanded.
5995 Therefore debug statements between definition and real
5996 use of TERed SSA names will continue to use the SSA name,
5997 and not be replaced with debug temps. */
5998 delink_stmt_imm_use (stmt
);
6002 if (gsi_end_p (nsi
))
6004 stmt
= gsi_stmt (nsi
);
6005 if (!is_gimple_debug (stmt
))
6009 set_curr_insn_location (sloc
);
6013 gcall
*call_stmt
= dyn_cast
<gcall
*> (stmt
);
6015 && gimple_call_tail_p (call_stmt
)
6016 && disable_tail_calls
)
6017 gimple_call_set_tail (call_stmt
, false);
6019 if (call_stmt
&& gimple_call_tail_p (call_stmt
))
6022 new_bb
= expand_gimple_tailcall (bb
, call_stmt
, &can_fallthru
);
6033 def_operand_p def_p
;
6034 def_p
= SINGLE_SSA_DEF_OPERAND (stmt
, SSA_OP_DEF
);
6038 /* Ignore this stmt if it is in the list of
6039 replaceable expressions. */
6041 && bitmap_bit_p (SA
.values
,
6042 SSA_NAME_VERSION (DEF_FROM_PTR (def_p
))))
6045 last
= expand_gimple_stmt (stmt
);
6046 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
6051 currently_expanding_gimple_stmt
= NULL
;
6053 /* Expand implicit goto and convert goto_locus. */
6054 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6056 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
6057 set_curr_insn_location (e
->goto_locus
);
6058 if ((e
->flags
& EDGE_FALLTHRU
) && e
->dest
!= bb
->next_bb
)
6060 emit_jump (label_rtx_for_bb (e
->dest
));
6061 e
->flags
&= ~EDGE_FALLTHRU
;
6065 /* Expanded RTL can create a jump in the last instruction of block.
6066 This later might be assumed to be a jump to successor and break edge insertion.
6067 We need to insert dummy move to prevent this. PR41440. */
6068 if (single_succ_p (bb
)
6069 && (single_succ_edge (bb
)->flags
& EDGE_FALLTHRU
)
6070 && (last
= get_last_insn ())
6072 || (DEBUG_INSN_P (last
)
6073 && JUMP_P (prev_nondebug_insn (last
)))))
6075 rtx dummy
= gen_reg_rtx (SImode
);
6076 emit_insn_after_noloc (gen_move_insn (dummy
, dummy
), last
, NULL
);
6079 do_pending_stack_adjust ();
6081 /* Find the block tail. The last insn in the block is the insn
6082 before a barrier and/or table jump insn. */
6083 last
= get_last_insn ();
6084 if (BARRIER_P (last
))
6085 last
= PREV_INSN (last
);
6086 if (JUMP_TABLE_DATA_P (last
))
6087 last
= PREV_INSN (PREV_INSN (last
));
6088 if (BARRIER_P (last
))
6089 last
= PREV_INSN (last
);
6092 update_bb_for_insn (bb
);
6098 /* Create a basic block for initialization code. */
6101 construct_init_block (void)
6103 basic_block init_block
, first_block
;
6107 /* Multiple entry points not supported yet. */
6108 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
) == 1);
6109 init_rtl_bb_info (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
6110 init_rtl_bb_info (EXIT_BLOCK_PTR_FOR_FN (cfun
));
6111 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
6112 EXIT_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
6114 e
= EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun
), 0);
6116 /* When entry edge points to first basic block, we don't need jump,
6117 otherwise we have to jump into proper target. */
6118 if (e
&& e
->dest
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
)
6120 tree label
= gimple_block_label (e
->dest
);
6122 emit_jump (jump_target_rtx (label
));
6126 flags
= EDGE_FALLTHRU
;
6128 init_block
= create_basic_block (NEXT_INSN (get_insns ()),
6130 ENTRY_BLOCK_PTR_FOR_FN (cfun
));
6131 init_block
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
6132 add_bb_to_loop (init_block
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
6135 first_block
= e
->dest
;
6136 redirect_edge_succ (e
, init_block
);
6137 make_single_succ_edge (init_block
, first_block
, flags
);
6140 make_single_succ_edge (init_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
),
6143 update_bb_for_insn (init_block
);
6147 /* For each lexical block, set BLOCK_NUMBER to the depth at which it is
6148 found in the block tree. */
6151 set_block_levels (tree block
, int level
)
6155 BLOCK_NUMBER (block
) = level
;
6156 set_block_levels (BLOCK_SUBBLOCKS (block
), level
+ 1);
6157 block
= BLOCK_CHAIN (block
);
6161 /* Create a block containing landing pads and similar stuff. */
6164 construct_exit_block (void)
6166 rtx_insn
*head
= get_last_insn ();
6168 basic_block exit_block
;
6172 basic_block prev_bb
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
;
6173 rtx_insn
*orig_end
= BB_END (prev_bb
);
6175 rtl_profile_for_bb (EXIT_BLOCK_PTR_FOR_FN (cfun
));
6177 /* Make sure the locus is set to the end of the function, so that
6178 epilogue line numbers and warnings are set properly. */
6179 if (LOCATION_LOCUS (cfun
->function_end_locus
) != UNKNOWN_LOCATION
)
6180 input_location
= cfun
->function_end_locus
;
6182 /* Generate rtl for function exit. */
6183 expand_function_end ();
6185 end
= get_last_insn ();
6188 /* While emitting the function end we could move end of the last basic
6190 BB_END (prev_bb
) = orig_end
;
6191 while (NEXT_INSN (head
) && NOTE_P (NEXT_INSN (head
)))
6192 head
= NEXT_INSN (head
);
6193 /* But make sure exit_block starts with RETURN_LABEL, otherwise the
6194 bb count counting will be confused. Any instructions before that
6195 label are emitted for the case where PREV_BB falls through into the
6196 exit block, so append those instructions to prev_bb in that case. */
6197 if (NEXT_INSN (head
) != return_label
)
6199 while (NEXT_INSN (head
) != return_label
)
6201 if (!NOTE_P (NEXT_INSN (head
)))
6202 BB_END (prev_bb
) = NEXT_INSN (head
);
6203 head
= NEXT_INSN (head
);
6206 exit_block
= create_basic_block (NEXT_INSN (head
), end
, prev_bb
);
6207 exit_block
->count
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
;
6208 add_bb_to_loop (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
6211 while (ix
< EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
))
6213 e
= EDGE_PRED (EXIT_BLOCK_PTR_FOR_FN (cfun
), ix
);
6214 if (!(e
->flags
& EDGE_ABNORMAL
))
6215 redirect_edge_succ (e
, exit_block
);
6220 e
= make_single_succ_edge (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
),
6222 FOR_EACH_EDGE (e2
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
6225 exit_block
->count
-= e2
->count ();
6227 update_bb_for_insn (exit_block
);
6230 /* Helper function for discover_nonconstant_array_refs.
6231 Look for ARRAY_REF nodes with non-constant indexes and mark them
6235 discover_nonconstant_array_refs_r (tree
* tp
, int *walk_subtrees
,
6236 void *data ATTRIBUTE_UNUSED
)
6240 if (IS_TYPE_OR_DECL_P (t
))
6242 else if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
6244 while (((TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
6245 && is_gimple_min_invariant (TREE_OPERAND (t
, 1))
6246 && (!TREE_OPERAND (t
, 2)
6247 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
6248 || (TREE_CODE (t
) == COMPONENT_REF
6249 && (!TREE_OPERAND (t
,2)
6250 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
6251 || TREE_CODE (t
) == BIT_FIELD_REF
6252 || TREE_CODE (t
) == REALPART_EXPR
6253 || TREE_CODE (t
) == IMAGPART_EXPR
6254 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
6255 || CONVERT_EXPR_P (t
))
6256 t
= TREE_OPERAND (t
, 0);
6258 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
6260 t
= get_base_address (t
);
6262 && DECL_MODE (t
) != BLKmode
)
6263 TREE_ADDRESSABLE (t
) = 1;
6268 /* References of size POLY_INT_CST to a fixed-size object must go
6269 through memory. It's more efficient to force that here than
6270 to create temporary slots on the fly. */
6271 else if ((TREE_CODE (t
) == MEM_REF
|| TREE_CODE (t
) == TARGET_MEM_REF
)
6272 && TYPE_SIZE (TREE_TYPE (t
))
6273 && POLY_INT_CST_P (TYPE_SIZE (TREE_TYPE (t
))))
6275 tree base
= get_base_address (t
);
6278 && DECL_MODE (base
) != BLKmode
6279 && GET_MODE_SIZE (DECL_MODE (base
)).is_constant ())
6280 TREE_ADDRESSABLE (base
) = 1;
6287 /* If there's a chance to get a pseudo for t then if it would be of float mode
6288 and the actual access is via an integer mode (lowered memcpy or similar
6289 access) then avoid the register expansion if the mode likely is not storage
6290 suitable for raw bits processing (like XFmode on i?86). */
6293 avoid_type_punning_on_regs (tree t
)
6295 machine_mode access_mode
= TYPE_MODE (TREE_TYPE (t
));
6296 if (access_mode
!= BLKmode
6297 && !SCALAR_INT_MODE_P (access_mode
))
6299 tree base
= get_base_address (t
);
6301 && !TREE_ADDRESSABLE (base
)
6302 && FLOAT_MODE_P (DECL_MODE (base
))
6303 && maybe_lt (GET_MODE_PRECISION (DECL_MODE (base
)),
6304 GET_MODE_BITSIZE (GET_MODE_INNER (DECL_MODE (base
))))
6305 /* Double check in the expensive way we really would get a pseudo. */
6306 && use_register_for_decl (base
))
6307 TREE_ADDRESSABLE (base
) = 1;
6310 /* RTL expansion is not able to compile array references with variable
6311 offsets for arrays stored in single register. Discover such
6312 expressions and mark variables as addressable to avoid this
6316 discover_nonconstant_array_refs (void)
6319 gimple_stmt_iterator gsi
;
6321 FOR_EACH_BB_FN (bb
, cfun
)
6322 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
6324 gimple
*stmt
= gsi_stmt (gsi
);
6325 if (!is_gimple_debug (stmt
))
6327 walk_gimple_op (stmt
, discover_nonconstant_array_refs_r
, NULL
);
6328 gcall
*call
= dyn_cast
<gcall
*> (stmt
);
6329 if (call
&& gimple_call_internal_p (call
))
6330 switch (gimple_call_internal_fn (call
))
6332 case IFN_LOAD_LANES
:
6333 /* The source must be a MEM. */
6334 mark_addressable (gimple_call_arg (call
, 0));
6336 case IFN_STORE_LANES
:
6337 /* The destination must be a MEM. */
6338 mark_addressable (gimple_call_lhs (call
));
6343 if (gimple_vdef (stmt
))
6345 tree t
= gimple_get_lhs (stmt
);
6346 if (t
&& REFERENCE_CLASS_P (t
))
6347 avoid_type_punning_on_regs (t
);
6353 /* This function sets crtl->args.internal_arg_pointer to a virtual
6354 register if DRAP is needed. Local register allocator will replace
6355 virtual_incoming_args_rtx with the virtual register. */
6358 expand_stack_alignment (void)
6361 unsigned int preferred_stack_boundary
;
6363 if (! SUPPORTS_STACK_ALIGNMENT
)
6366 if (cfun
->calls_alloca
6367 || cfun
->has_nonlocal_label
6368 || crtl
->has_nonlocal_goto
)
6369 crtl
->need_drap
= true;
6371 /* Call update_stack_boundary here again to update incoming stack
6372 boundary. It may set incoming stack alignment to a different
6373 value after RTL expansion. TARGET_FUNCTION_OK_FOR_SIBCALL may
6374 use the minimum incoming stack alignment to check if it is OK
6375 to perform sibcall optimization since sibcall optimization will
6376 only align the outgoing stack to incoming stack boundary. */
6377 if (targetm
.calls
.update_stack_boundary
)
6378 targetm
.calls
.update_stack_boundary ();
6380 /* The incoming stack frame has to be aligned at least at
6381 parm_stack_boundary. */
6382 gcc_assert (crtl
->parm_stack_boundary
<= INCOMING_STACK_BOUNDARY
);
6384 /* Update crtl->stack_alignment_estimated and use it later to align
6385 stack. We check PREFERRED_STACK_BOUNDARY if there may be non-call
6386 exceptions since callgraph doesn't collect incoming stack alignment
6388 if (cfun
->can_throw_non_call_exceptions
6389 && PREFERRED_STACK_BOUNDARY
> crtl
->preferred_stack_boundary
)
6390 preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
6392 preferred_stack_boundary
= crtl
->preferred_stack_boundary
;
6393 if (preferred_stack_boundary
> crtl
->stack_alignment_estimated
)
6394 crtl
->stack_alignment_estimated
= preferred_stack_boundary
;
6395 if (preferred_stack_boundary
> crtl
->stack_alignment_needed
)
6396 crtl
->stack_alignment_needed
= preferred_stack_boundary
;
6398 gcc_assert (crtl
->stack_alignment_needed
6399 <= crtl
->stack_alignment_estimated
);
6401 crtl
->stack_realign_needed
6402 = INCOMING_STACK_BOUNDARY
< crtl
->stack_alignment_estimated
;
6403 crtl
->stack_realign_tried
= crtl
->stack_realign_needed
;
6405 crtl
->stack_realign_processed
= true;
6407 /* Target has to redefine TARGET_GET_DRAP_RTX to support stack
6409 gcc_assert (targetm
.calls
.get_drap_rtx
!= NULL
);
6410 drap_rtx
= targetm
.calls
.get_drap_rtx ();
6412 /* stack_realign_drap and drap_rtx must match. */
6413 gcc_assert ((stack_realign_drap
!= 0) == (drap_rtx
!= NULL
));
6415 /* Do nothing if NULL is returned, which means DRAP is not needed. */
6416 if (drap_rtx
!= NULL
)
6418 crtl
->args
.internal_arg_pointer
= drap_rtx
;
6420 /* Call fixup_tail_calls to clean up REG_EQUIV note if DRAP is
6422 fixup_tail_calls ();
6428 expand_main_function (void)
6430 #if (defined(INVOKE__main) \
6431 || (!defined(HAS_INIT_SECTION) \
6432 && !defined(INIT_SECTION_ASM_OP) \
6433 && !defined(INIT_ARRAY_SECTION_ASM_OP)))
6434 emit_library_call (init_one_libfunc (NAME__MAIN
), LCT_NORMAL
, VOIDmode
);
6439 /* Expand code to initialize the stack_protect_guard. This is invoked at
6440 the beginning of a function to be protected. */
6443 stack_protect_prologue (void)
6445 tree guard_decl
= targetm
.stack_protect_guard ();
6448 crtl
->stack_protect_guard_decl
= guard_decl
;
6449 x
= expand_normal (crtl
->stack_protect_guard
);
6451 if (targetm
.have_stack_protect_combined_set () && guard_decl
)
6453 gcc_assert (DECL_P (guard_decl
));
6454 y
= DECL_RTL (guard_decl
);
6456 /* Allow the target to compute address of Y and copy it to X without
6457 leaking Y into a register. This combined address + copy pattern
6458 allows the target to prevent spilling of any intermediate results by
6459 splitting it after register allocator. */
6460 if (rtx_insn
*insn
= targetm
.gen_stack_protect_combined_set (x
, y
))
6468 y
= expand_normal (guard_decl
);
6472 /* Allow the target to copy from Y to X without leaking Y into a
6474 if (targetm
.have_stack_protect_set ())
6475 if (rtx_insn
*insn
= targetm
.gen_stack_protect_set (x
, y
))
6481 /* Otherwise do a straight move. */
6482 emit_move_insn (x
, y
);
6485 /* Translate the intermediate representation contained in the CFG
6486 from GIMPLE trees to RTL.
6488 We do conversion per basic block and preserve/update the tree CFG.
6489 This implies we have to do some magic as the CFG can simultaneously
6490 consist of basic blocks containing RTL and GIMPLE trees. This can
6491 confuse the CFG hooks, so be careful to not manipulate CFG during
6496 const pass_data pass_data_expand
=
6498 RTL_PASS
, /* type */
6499 "expand", /* name */
6500 OPTGROUP_NONE
, /* optinfo_flags */
6501 TV_EXPAND
, /* tv_id */
6502 ( PROP_ssa
| PROP_gimple_leh
| PROP_cfg
6505 | PROP_gimple_lva
), /* properties_required */
6506 PROP_rtl
, /* properties_provided */
6507 ( PROP_ssa
| PROP_gimple
), /* properties_destroyed */
6508 0, /* todo_flags_start */
6509 0, /* todo_flags_finish */
6512 class pass_expand
: public rtl_opt_pass
6515 pass_expand (gcc::context
*ctxt
)
6516 : rtl_opt_pass (pass_data_expand
, ctxt
)
6519 /* opt_pass methods: */
6520 virtual unsigned int execute (function
*);
6522 }; // class pass_expand
6525 pass_expand::execute (function
*fun
)
6527 basic_block bb
, init_block
;
6530 rtx_insn
*var_seq
, *var_ret_seq
;
6533 timevar_push (TV_OUT_OF_SSA
);
6534 rewrite_out_of_ssa (&SA
);
6535 timevar_pop (TV_OUT_OF_SSA
);
6536 SA
.partition_to_pseudo
= XCNEWVEC (rtx
, SA
.map
->num_partitions
);
6538 if (MAY_HAVE_DEBUG_BIND_STMTS
&& flag_tree_ter
)
6540 gimple_stmt_iterator gsi
;
6541 FOR_EACH_BB_FN (bb
, cfun
)
6542 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
6543 if (gimple_debug_bind_p (gsi_stmt (gsi
)))
6544 avoid_deep_ter_for_debug (gsi_stmt (gsi
), 0);
6547 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
6548 discover_nonconstant_array_refs ();
6550 /* Make sure all values used by the optimization passes have sane
6554 /* Some backends want to know that we are expanding to RTL. */
6555 currently_expanding_to_rtl
= 1;
6556 /* Dominators are not kept up-to-date as we may create new basic-blocks. */
6557 free_dominance_info (CDI_DOMINATORS
);
6559 rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (fun
));
6561 insn_locations_init ();
6562 if (!DECL_IS_UNDECLARED_BUILTIN (current_function_decl
))
6564 /* Eventually, all FEs should explicitly set function_start_locus. */
6565 if (LOCATION_LOCUS (fun
->function_start_locus
) == UNKNOWN_LOCATION
)
6566 set_curr_insn_location
6567 (DECL_SOURCE_LOCATION (current_function_decl
));
6569 set_curr_insn_location (fun
->function_start_locus
);
6572 set_curr_insn_location (UNKNOWN_LOCATION
);
6573 prologue_location
= curr_insn_location ();
6575 #ifdef INSN_SCHEDULING
6576 init_sched_attrs ();
6579 /* Make sure first insn is a note even if we don't want linenums.
6580 This makes sure the first insn will never be deleted.
6581 Also, final expects a note to appear there. */
6582 emit_note (NOTE_INSN_DELETED
);
6584 targetm
.expand_to_rtl_hook ();
6585 crtl
->init_stack_alignment ();
6586 fun
->cfg
->max_jumptable_ents
= 0;
6588 /* Resovle the function section. Some targets, like ARM EABI rely on knowledge
6589 of the function section at exapnsion time to predict distance of calls. */
6590 resolve_unique_section (current_function_decl
, 0, flag_function_sections
);
6592 /* Expand the variables recorded during gimple lowering. */
6593 timevar_push (TV_VAR_EXPAND
);
6596 var_ret_seq
= expand_used_vars ();
6598 var_seq
= get_insns ();
6600 timevar_pop (TV_VAR_EXPAND
);
6602 /* Honor stack protection warnings. */
6603 if (warn_stack_protect
)
6605 if (fun
->calls_alloca
)
6606 warning (OPT_Wstack_protector
,
6607 "stack protector not protecting local variables: "
6608 "variable length buffer");
6609 if (has_short_buffer
&& !crtl
->stack_protect_guard
)
6610 warning (OPT_Wstack_protector
,
6611 "stack protector not protecting function: "
6612 "all local arrays are less than %d bytes long",
6613 (int) param_ssp_buffer_size
);
6616 /* Set up parameters and prepare for return, for the function. */
6617 expand_function_start (current_function_decl
);
6619 /* If we emitted any instructions for setting up the variables,
6620 emit them before the FUNCTION_START note. */
6623 emit_insn_before (var_seq
, parm_birth_insn
);
6625 /* In expand_function_end we'll insert the alloca save/restore
6626 before parm_birth_insn. We've just insertted an alloca call.
6627 Adjust the pointer to match. */
6628 parm_birth_insn
= var_seq
;
6631 /* Now propagate the RTL assignment of each partition to the
6632 underlying var of each SSA_NAME. */
6635 FOR_EACH_SSA_NAME (i
, name
, cfun
)
6637 /* We might have generated new SSA names in
6638 update_alias_info_with_stack_vars. They will have a NULL
6639 defining statements, and won't be part of the partitioning,
6641 if (!SSA_NAME_DEF_STMT (name
))
6644 adjust_one_expanded_partition_var (name
);
6647 /* Clean up RTL of variables that straddle across multiple
6648 partitions, and check that the rtl of any PARM_DECLs that are not
6649 cleaned up is that of their default defs. */
6650 FOR_EACH_SSA_NAME (i
, name
, cfun
)
6654 /* We might have generated new SSA names in
6655 update_alias_info_with_stack_vars. They will have a NULL
6656 defining statements, and won't be part of the partitioning,
6658 if (!SSA_NAME_DEF_STMT (name
))
6660 part
= var_to_partition (SA
.map
, name
);
6661 if (part
== NO_PARTITION
)
6664 /* If this decl was marked as living in multiple places, reset
6665 this now to NULL. */
6666 tree var
= SSA_NAME_VAR (name
);
6667 if (var
&& DECL_RTL_IF_SET (var
) == pc_rtx
)
6668 SET_DECL_RTL (var
, NULL
);
6669 /* Check that the pseudos chosen by assign_parms are those of
6670 the corresponding default defs. */
6671 else if (SSA_NAME_IS_DEFAULT_DEF (name
)
6672 && (TREE_CODE (var
) == PARM_DECL
6673 || TREE_CODE (var
) == RESULT_DECL
))
6675 rtx in
= DECL_RTL_IF_SET (var
);
6677 rtx out
= SA
.partition_to_pseudo
[part
];
6678 gcc_assert (in
== out
);
6680 /* Now reset VAR's RTL to IN, so that the _EXPR attrs match
6681 those expected by debug backends for each parm and for
6682 the result. This is particularly important for stabs,
6683 whose register elimination from parm's DECL_RTL may cause
6684 -fcompare-debug differences as SET_DECL_RTL changes reg's
6685 attrs. So, make sure the RTL already has the parm as the
6686 EXPR, so that it won't change. */
6687 SET_DECL_RTL (var
, NULL_RTX
);
6689 set_mem_attributes (in
, var
, true);
6690 SET_DECL_RTL (var
, in
);
6694 /* If this function is `main', emit a call to `__main'
6695 to run global initializers, etc. */
6696 if (DECL_NAME (current_function_decl
)
6697 && MAIN_NAME_P (DECL_NAME (current_function_decl
))
6698 && DECL_FILE_SCOPE_P (current_function_decl
))
6699 expand_main_function ();
6701 /* Initialize the stack_protect_guard field. This must happen after the
6702 call to __main (if any) so that the external decl is initialized. */
6703 if (crtl
->stack_protect_guard
&& targetm
.stack_protect_runtime_enabled_p ())
6704 stack_protect_prologue ();
6706 expand_phi_nodes (&SA
);
6708 /* Release any stale SSA redirection data. */
6709 redirect_edge_var_map_empty ();
6711 /* Register rtl specific functions for cfg. */
6712 rtl_register_cfg_hooks ();
6714 init_block
= construct_init_block ();
6716 /* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
6717 remaining edges later. */
6718 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->succs
)
6719 e
->flags
&= ~EDGE_EXECUTABLE
;
6721 /* If the function has too many markers, drop them while expanding. */
6722 if (cfun
->debug_marker_count
6723 >= param_max_debug_marker_count
)
6724 cfun
->debug_nonbind_markers
= false;
6726 lab_rtx_for_bb
= new hash_map
<basic_block
, rtx_code_label
*>;
6727 FOR_BB_BETWEEN (bb
, init_block
->next_bb
, EXIT_BLOCK_PTR_FOR_FN (fun
),
6729 bb
= expand_gimple_basic_block (bb
, var_ret_seq
!= NULL_RTX
);
6731 if (MAY_HAVE_DEBUG_BIND_INSNS
)
6732 expand_debug_locations ();
6734 if (deep_ter_debug_map
)
6736 delete deep_ter_debug_map
;
6737 deep_ter_debug_map
= NULL
;
6740 /* Free stuff we no longer need after GIMPLE optimizations. */
6741 free_dominance_info (CDI_DOMINATORS
);
6742 free_dominance_info (CDI_POST_DOMINATORS
);
6743 delete_tree_cfg_annotations (fun
);
6745 timevar_push (TV_OUT_OF_SSA
);
6746 finish_out_of_ssa (&SA
);
6747 timevar_pop (TV_OUT_OF_SSA
);
6749 timevar_push (TV_POST_EXPAND
);
6750 /* We are no longer in SSA form. */
6751 fun
->gimple_df
->in_ssa_p
= false;
6752 loops_state_clear (LOOP_CLOSED_SSA
);
6754 /* Expansion is used by optimization passes too, set maybe_hot_insn_p
6755 conservatively to true until they are all profile aware. */
6756 delete lab_rtx_for_bb
;
6757 free_histograms (fun
);
6759 construct_exit_block ();
6760 insn_locations_finalize ();
6764 rtx_insn
*after
= return_label
;
6765 rtx_insn
*next
= NEXT_INSN (after
);
6766 if (next
&& NOTE_INSN_BASIC_BLOCK_P (next
))
6768 emit_insn_after (var_ret_seq
, after
);
6771 if (hwasan_sanitize_stack_p ())
6772 hwasan_maybe_emit_frame_base_init ();
6774 /* Zap the tree EH table. */
6775 set_eh_throw_stmt_table (fun
, NULL
);
6777 /* We need JUMP_LABEL be set in order to redirect jumps, and hence
6778 split edges which edge insertions might do. */
6779 rebuild_jump_labels (get_insns ());
6781 /* If we have a single successor to the entry block, put the pending insns
6782 after parm birth, but before NOTE_INSNS_FUNCTION_BEG. */
6783 if (single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (fun
)))
6785 edge e
= single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (fun
));
6788 rtx_insn
*insns
= e
->insns
.r
;
6790 rebuild_jump_labels_chain (insns
);
6791 if (NOTE_P (parm_birth_insn
)
6792 && NOTE_KIND (parm_birth_insn
) == NOTE_INSN_FUNCTION_BEG
)
6793 emit_insn_before_noloc (insns
, parm_birth_insn
, e
->dest
);
6795 emit_insn_after_noloc (insns
, parm_birth_insn
, e
->dest
);
6799 /* Otherwise, as well as for other edges, take the usual way. */
6800 commit_edge_insertions ();
6802 /* We're done expanding trees to RTL. */
6803 currently_expanding_to_rtl
= 0;
6805 flush_mark_addressable_queue ();
6807 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->next_bb
,
6808 EXIT_BLOCK_PTR_FOR_FN (fun
), next_bb
)
6812 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
6814 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
6815 e
->flags
&= ~EDGE_EXECUTABLE
;
6817 /* At the moment not all abnormal edges match the RTL
6818 representation. It is safe to remove them here as
6819 find_many_sub_basic_blocks will rediscover them.
6820 In the future we should get this fixed properly. */
6821 if ((e
->flags
& EDGE_ABNORMAL
)
6822 && !(e
->flags
& EDGE_SIBCALL
))
6829 auto_sbitmap
blocks (last_basic_block_for_fn (fun
));
6830 bitmap_ones (blocks
);
6831 find_many_sub_basic_blocks (blocks
);
6832 purge_all_dead_edges ();
6834 /* After initial rtl generation, call back to finish generating
6835 exception support code. We need to do this before cleaning up
6836 the CFG as the code does not expect dead landing pads. */
6837 if (fun
->eh
->region_tree
!= NULL
)
6838 finish_eh_generation ();
6840 /* Call expand_stack_alignment after finishing all
6841 updates to crtl->preferred_stack_boundary. */
6842 expand_stack_alignment ();
6844 /* Fixup REG_EQUIV notes in the prologue if there are tailcalls in this
6846 if (crtl
->tail_call_emit
)
6847 fixup_tail_calls ();
6849 HOST_WIDE_INT patch_area_size
, patch_area_entry
;
6850 parse_and_check_patch_area (flag_patchable_function_entry
, false,
6851 &patch_area_size
, &patch_area_entry
);
6853 tree patchable_function_entry_attr
6854 = lookup_attribute ("patchable_function_entry",
6855 DECL_ATTRIBUTES (cfun
->decl
));
6856 if (patchable_function_entry_attr
)
6858 tree pp_val
= TREE_VALUE (patchable_function_entry_attr
);
6859 tree patchable_function_entry_value1
= TREE_VALUE (pp_val
);
6861 patch_area_size
= tree_to_uhwi (patchable_function_entry_value1
);
6862 patch_area_entry
= 0;
6863 if (TREE_CHAIN (pp_val
) != NULL_TREE
)
6865 tree patchable_function_entry_value2
6866 = TREE_VALUE (TREE_CHAIN (pp_val
));
6867 patch_area_entry
= tree_to_uhwi (patchable_function_entry_value2
);
6871 if (patch_area_entry
> patch_area_size
)
6873 if (patch_area_size
> 0)
6874 warning (OPT_Wattributes
,
6875 "patchable function entry %wu exceeds size %wu",
6876 patch_area_entry
, patch_area_size
);
6877 patch_area_entry
= 0;
6880 crtl
->patch_area_size
= patch_area_size
;
6881 crtl
->patch_area_entry
= patch_area_entry
;
6883 /* BB subdivision may have created basic blocks that are only reachable
6884 from unlikely bbs but not marked as such in the profile. */
6886 propagate_unlikely_bbs_forward ();
6888 /* Remove unreachable blocks, otherwise we cannot compute dominators
6889 which are needed for loop state verification. As a side-effect
6890 this also compacts blocks.
6891 ??? We cannot remove trivially dead insns here as for example
6892 the DRAP reg on i?86 is not magically live at this point.
6893 gcc.c-torture/execute/ipa-sra-2.c execution, -Os -m32 fails otherwise. */
6894 cleanup_cfg (CLEANUP_NO_INSN_DEL
);
6896 checking_verify_flow_info ();
6898 /* Initialize pseudos allocated for hard registers. */
6899 emit_initial_value_sets ();
6901 /* And finally unshare all RTL. */
6904 /* There's no need to defer outputting this function any more; we
6905 know we want to output it. */
6906 DECL_DEFER_OUTPUT (current_function_decl
) = 0;
6908 /* Now that we're done expanding trees to RTL, we shouldn't have any
6909 more CONCATs anywhere. */
6910 generating_concat_p
= 0;
6915 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
6916 /* And the pass manager will dump RTL for us. */
6919 /* If we're emitting a nested function, make sure its parent gets
6920 emitted as well. Doing otherwise confuses debug info. */
6923 for (parent
= DECL_CONTEXT (current_function_decl
);
6924 parent
!= NULL_TREE
;
6925 parent
= get_containing_scope (parent
))
6926 if (TREE_CODE (parent
) == FUNCTION_DECL
)
6927 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent
)) = 1;
6930 TREE_ASM_WRITTEN (current_function_decl
) = 1;
6932 /* After expanding, the return labels are no longer needed. */
6933 return_label
= NULL
;
6934 naked_return_label
= NULL
;
6936 /* After expanding, the tm_restart map is no longer needed. */
6937 if (fun
->gimple_df
->tm_restart
)
6938 fun
->gimple_df
->tm_restart
= NULL
;
6940 /* Tag the blocks with a depth number so that change_scope can find
6941 the common parent easily. */
6942 set_block_levels (DECL_INITIAL (fun
->decl
), 0);
6943 default_rtl_profile ();
6945 /* For -dx discard loops now, otherwise IL verify in clean_state will
6947 if (rtl_dump_and_exit
)
6949 cfun
->curr_properties
&= ~PROP_loops
;
6950 loop_optimizer_finalize ();
6953 timevar_pop (TV_POST_EXPAND
);
6961 make_pass_expand (gcc::context
*ctxt
)
6963 return new pass_expand (ctxt
);