1 /* A pass for lowering trees to RTL.
2 Copyright (C) 2004-2020 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
29 #include "tree-pass.h"
34 #include "regs.h" /* For reg_renumber. */
38 #include "diagnostic.h"
39 #include "fold-const.h"
41 #include "stor-layout.h"
43 #include "print-tree.h"
47 #include "cfgcleanup.h"
52 #include "internal-fn.h"
54 #include "gimple-iterator.h"
55 #include "gimple-expr.h"
56 #include "gimple-walk.h"
61 #include "gimple-pretty-print.h"
64 #include "tree-inline.h"
65 #include "value-prof.h"
66 #include "tree-ssa-live.h"
67 #include "tree-outof-ssa.h"
69 #include "insn-attr.h" /* For INSN_SCHEDULING. */
70 #include "stringpool.h"
73 #include "tree-ssa-address.h"
77 /* Some systems use __main in a way incompatible with its use in gcc, in these
78 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
79 give the same symbol without quotes for an alternative entry point. You
80 must define both, or neither. */
82 #define NAME__MAIN "__main"
85 /* This variable holds information helping the rewriting of SSA trees
89 /* This variable holds the currently expanded gimple statement for purposes
90 of comminucating the profile info to the builtin expanders. */
91 gimple
*currently_expanding_gimple_stmt
;
93 static rtx
expand_debug_expr (tree
);
95 static bool defer_stack_allocation (tree
, bool);
97 static void record_alignment_for_reg_var (unsigned int);
99 /* Return an expression tree corresponding to the RHS of GIMPLE
103 gimple_assign_rhs_to_tree (gimple
*stmt
)
106 switch (get_gimple_rhs_class (gimple_expr_code (stmt
)))
108 case GIMPLE_TERNARY_RHS
:
109 t
= build3 (gimple_assign_rhs_code (stmt
),
110 TREE_TYPE (gimple_assign_lhs (stmt
)),
111 gimple_assign_rhs1 (stmt
), gimple_assign_rhs2 (stmt
),
112 gimple_assign_rhs3 (stmt
));
114 case GIMPLE_BINARY_RHS
:
115 t
= build2 (gimple_assign_rhs_code (stmt
),
116 TREE_TYPE (gimple_assign_lhs (stmt
)),
117 gimple_assign_rhs1 (stmt
), gimple_assign_rhs2 (stmt
));
119 case GIMPLE_UNARY_RHS
:
120 t
= build1 (gimple_assign_rhs_code (stmt
),
121 TREE_TYPE (gimple_assign_lhs (stmt
)),
122 gimple_assign_rhs1 (stmt
));
124 case GIMPLE_SINGLE_RHS
:
126 t
= gimple_assign_rhs1 (stmt
);
127 /* Avoid modifying this tree in place below. */
128 if ((gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (t
)
129 && gimple_location (stmt
) != EXPR_LOCATION (t
))
130 || (gimple_block (stmt
) && currently_expanding_to_rtl
139 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (t
))
140 SET_EXPR_LOCATION (t
, gimple_location (stmt
));
146 #ifndef STACK_ALIGNMENT_NEEDED
147 #define STACK_ALIGNMENT_NEEDED 1
150 #define SSAVAR(x) (TREE_CODE (x) == SSA_NAME ? SSA_NAME_VAR (x) : x)
152 /* Choose either CUR or NEXT as the leader DECL for a partition.
153 Prefer ignored decls, to simplify debug dumps and reduce ambiguity
154 out of the same user variable being in multiple partitions (this is
155 less likely for compiler-introduced temps). */
158 leader_merge (tree cur
, tree next
)
160 if (cur
== NULL
|| cur
== next
)
163 if (DECL_P (cur
) && DECL_IGNORED_P (cur
))
166 if (DECL_P (next
) && DECL_IGNORED_P (next
))
172 /* Associate declaration T with storage space X. If T is no
173 SSA name this is exactly SET_DECL_RTL, otherwise make the
174 partition of T associated with X. */
176 set_rtl (tree t
, rtx x
)
178 gcc_checking_assert (!x
179 || !(TREE_CODE (t
) == SSA_NAME
|| is_gimple_reg (t
))
180 || (use_register_for_decl (t
)
182 || (GET_CODE (x
) == CONCAT
183 && (REG_P (XEXP (x
, 0))
184 || SUBREG_P (XEXP (x
, 0)))
185 && (REG_P (XEXP (x
, 1))
186 || SUBREG_P (XEXP (x
, 1))))
187 /* We need to accept PARALLELs for RESUT_DECLs
188 because of vector types with BLKmode returned
189 in multiple registers, but they are supposed
190 to be uncoalesced. */
191 || (GET_CODE (x
) == PARALLEL
193 && TREE_CODE (SSAVAR (t
)) == RESULT_DECL
194 && (GET_MODE (x
) == BLKmode
195 || !flag_tree_coalesce_vars
)))
196 : (MEM_P (x
) || x
== pc_rtx
197 || (GET_CODE (x
) == CONCAT
198 && MEM_P (XEXP (x
, 0))
199 && MEM_P (XEXP (x
, 1))))));
200 /* Check that the RTL for SSA_NAMEs and gimple-reg PARM_DECLs and
201 RESULT_DECLs has the expected mode. For memory, we accept
202 unpromoted modes, since that's what we're likely to get. For
203 PARM_DECLs and RESULT_DECLs, we'll have been called by
204 set_parm_rtl, which will give us the default def, so we don't
205 have to compute it ourselves. For RESULT_DECLs, we accept mode
206 mismatches too, as long as we have BLKmode or are not coalescing
207 across variables, so that we don't reject BLKmode PARALLELs or
209 gcc_checking_assert (!x
|| x
== pc_rtx
|| TREE_CODE (t
) != SSA_NAME
211 && TREE_CODE (SSAVAR (t
)) == RESULT_DECL
212 && (promote_ssa_mode (t
, NULL
) == BLKmode
213 || !flag_tree_coalesce_vars
))
214 || !use_register_for_decl (t
)
215 || GET_MODE (x
) == promote_ssa_mode (t
, NULL
));
220 tree cur
= NULL_TREE
;
228 else if (SUBREG_P (xm
))
230 gcc_assert (subreg_lowpart_p (xm
));
231 xm
= SUBREG_REG (xm
);
234 else if (GET_CODE (xm
) == CONCAT
)
239 else if (GET_CODE (xm
) == PARALLEL
)
241 xm
= XVECEXP (xm
, 0, 0);
242 gcc_assert (GET_CODE (xm
) == EXPR_LIST
);
246 else if (xm
== pc_rtx
)
251 tree next
= skip
? cur
: leader_merge (cur
, SSAVAR (t
) ? SSAVAR (t
) : t
);
256 set_mem_attributes (x
,
257 next
&& TREE_CODE (next
) == SSA_NAME
261 set_reg_attrs_for_decl_rtl (next
, x
);
265 if (TREE_CODE (t
) == SSA_NAME
)
267 int part
= var_to_partition (SA
.map
, t
);
268 if (part
!= NO_PARTITION
)
270 if (SA
.partition_to_pseudo
[part
])
271 gcc_assert (SA
.partition_to_pseudo
[part
] == x
);
272 else if (x
!= pc_rtx
)
273 SA
.partition_to_pseudo
[part
] = x
;
275 /* For the benefit of debug information at -O0 (where
276 vartracking doesn't run) record the place also in the base
277 DECL. For PARMs and RESULTs, do so only when setting the
279 if (x
&& x
!= pc_rtx
&& SSA_NAME_VAR (t
)
280 && (VAR_P (SSA_NAME_VAR (t
))
281 || SSA_NAME_IS_DEFAULT_DEF (t
)))
283 tree var
= SSA_NAME_VAR (t
);
284 /* If we don't yet have something recorded, just record it now. */
285 if (!DECL_RTL_SET_P (var
))
286 SET_DECL_RTL (var
, x
);
287 /* If we have it set already to "multiple places" don't
289 else if (DECL_RTL (var
) == pc_rtx
)
291 /* If we have something recorded and it's not the same place
292 as we want to record now, we have multiple partitions for the
293 same base variable, with different places. We can't just
294 randomly chose one, hence we have to say that we don't know.
295 This only happens with optimization, and there var-tracking
296 will figure out the right thing. */
297 else if (DECL_RTL (var
) != x
)
298 SET_DECL_RTL (var
, pc_rtx
);
305 /* This structure holds data relevant to one variable that will be
306 placed in a stack slot. */
313 /* Initially, the size of the variable. Later, the size of the partition,
314 if this variable becomes it's partition's representative. */
317 /* The *byte* alignment required for this variable. Or as, with the
318 size, the alignment for this partition. */
321 /* The partition representative. */
322 size_t representative
;
324 /* The next stack variable in the partition, or EOC. */
327 /* The numbers of conflicting stack variables. */
331 #define EOC ((size_t)-1)
333 /* We have an array of such objects while deciding allocation. */
334 static class stack_var
*stack_vars
;
335 static size_t stack_vars_alloc
;
336 static size_t stack_vars_num
;
337 static hash_map
<tree
, size_t> *decl_to_stack_part
;
339 /* Conflict bitmaps go on this obstack. This allows us to destroy
340 all of them in one big sweep. */
341 static bitmap_obstack stack_var_bitmap_obstack
;
343 /* An array of indices such that stack_vars[stack_vars_sorted[i]].size
344 is non-decreasing. */
345 static size_t *stack_vars_sorted
;
347 /* The phase of the stack frame. This is the known misalignment of
348 virtual_stack_vars_rtx from PREFERRED_STACK_BOUNDARY. That is,
349 (frame_offset+frame_phase) % PREFERRED_STACK_BOUNDARY == 0. */
350 static int frame_phase
;
352 /* Used during expand_used_vars to remember if we saw any decls for
353 which we'd like to enable stack smashing protection. */
354 static bool has_protected_decls
;
356 /* Used during expand_used_vars. Remember if we say a character buffer
357 smaller than our cutoff threshold. Used for -Wstack-protector. */
358 static bool has_short_buffer
;
360 /* Compute the byte alignment to use for DECL. Ignore alignment
361 we can't do with expected alignment of the stack boundary. */
364 align_local_variable (tree decl
, bool really_expand
)
368 if (TREE_CODE (decl
) == SSA_NAME
)
370 tree type
= TREE_TYPE (decl
);
371 machine_mode mode
= TYPE_MODE (type
);
373 align
= TYPE_ALIGN (type
);
375 && align
< GET_MODE_ALIGNMENT (mode
))
376 align
= GET_MODE_ALIGNMENT (mode
);
380 align
= LOCAL_DECL_ALIGNMENT (decl
);
381 /* Don't change DECL_ALIGN when called from estimated_stack_frame_size.
382 That is done before IPA and could bump alignment based on host
383 backend even for offloaded code which wants different
384 LOCAL_DECL_ALIGNMENT. */
386 SET_DECL_ALIGN (decl
, align
);
388 return align
/ BITS_PER_UNIT
;
391 /* Align given offset BASE with ALIGN. Truncate up if ALIGN_UP is true,
392 down otherwise. Return truncated BASE value. */
394 static inline unsigned HOST_WIDE_INT
395 align_base (HOST_WIDE_INT base
, unsigned HOST_WIDE_INT align
, bool align_up
)
397 return align_up
? (base
+ align
- 1) & -align
: base
& -align
;
400 /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
401 Return the frame offset. */
404 alloc_stack_frame_space (poly_int64 size
, unsigned HOST_WIDE_INT align
)
406 poly_int64 offset
, new_frame_offset
;
408 if (FRAME_GROWS_DOWNWARD
)
411 = aligned_lower_bound (frame_offset
- frame_phase
- size
,
412 align
) + frame_phase
;
413 offset
= new_frame_offset
;
418 = aligned_upper_bound (frame_offset
- frame_phase
,
419 align
) + frame_phase
;
420 offset
= new_frame_offset
;
421 new_frame_offset
+= size
;
423 frame_offset
= new_frame_offset
;
425 if (frame_offset_overflow (frame_offset
, cfun
->decl
))
426 frame_offset
= offset
= 0;
431 /* Accumulate DECL into STACK_VARS. */
434 add_stack_var (tree decl
, bool really_expand
)
438 if (stack_vars_num
>= stack_vars_alloc
)
440 if (stack_vars_alloc
)
441 stack_vars_alloc
= stack_vars_alloc
* 3 / 2;
443 stack_vars_alloc
= 32;
445 = XRESIZEVEC (class stack_var
, stack_vars
, stack_vars_alloc
);
447 if (!decl_to_stack_part
)
448 decl_to_stack_part
= new hash_map
<tree
, size_t>;
450 v
= &stack_vars
[stack_vars_num
];
451 decl_to_stack_part
->put (decl
, stack_vars_num
);
454 tree size
= TREE_CODE (decl
) == SSA_NAME
455 ? TYPE_SIZE_UNIT (TREE_TYPE (decl
))
456 : DECL_SIZE_UNIT (decl
);
457 v
->size
= tree_to_poly_uint64 (size
);
458 /* Ensure that all variables have size, so that &a != &b for any two
459 variables that are simultaneously live. */
460 if (known_eq (v
->size
, 0U))
462 v
->alignb
= align_local_variable (decl
, really_expand
);
463 /* An alignment of zero can mightily confuse us later. */
464 gcc_assert (v
->alignb
!= 0);
466 /* All variables are initially in their own partition. */
467 v
->representative
= stack_vars_num
;
470 /* All variables initially conflict with no other. */
473 /* Ensure that this decl doesn't get put onto the list twice. */
474 set_rtl (decl
, pc_rtx
);
479 /* Make the decls associated with luid's X and Y conflict. */
482 add_stack_var_conflict (size_t x
, size_t y
)
484 class stack_var
*a
= &stack_vars
[x
];
485 class stack_var
*b
= &stack_vars
[y
];
489 a
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
491 b
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
492 bitmap_set_bit (a
->conflicts
, y
);
493 bitmap_set_bit (b
->conflicts
, x
);
496 /* Check whether the decls associated with luid's X and Y conflict. */
499 stack_var_conflict_p (size_t x
, size_t y
)
501 class stack_var
*a
= &stack_vars
[x
];
502 class stack_var
*b
= &stack_vars
[y
];
505 /* Partitions containing an SSA name result from gimple registers
506 with things like unsupported modes. They are top-level and
507 hence conflict with everything else. */
508 if (TREE_CODE (a
->decl
) == SSA_NAME
|| TREE_CODE (b
->decl
) == SSA_NAME
)
511 if (!a
->conflicts
|| !b
->conflicts
)
513 return bitmap_bit_p (a
->conflicts
, y
);
516 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
517 enter its partition number into bitmap DATA. */
520 visit_op (gimple
*, tree op
, tree
, void *data
)
522 bitmap active
= (bitmap
)data
;
523 op
= get_base_address (op
);
526 && DECL_RTL_IF_SET (op
) == pc_rtx
)
528 size_t *v
= decl_to_stack_part
->get (op
);
530 bitmap_set_bit (active
, *v
);
535 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
536 record conflicts between it and all currently active other partitions
540 visit_conflict (gimple
*, tree op
, tree
, void *data
)
542 bitmap active
= (bitmap
)data
;
543 op
= get_base_address (op
);
546 && DECL_RTL_IF_SET (op
) == pc_rtx
)
548 size_t *v
= decl_to_stack_part
->get (op
);
549 if (v
&& bitmap_set_bit (active
, *v
))
554 gcc_assert (num
< stack_vars_num
);
555 EXECUTE_IF_SET_IN_BITMAP (active
, 0, i
, bi
)
556 add_stack_var_conflict (num
, i
);
562 /* Helper routine for add_scope_conflicts, calculating the active partitions
563 at the end of BB, leaving the result in WORK. We're called to generate
564 conflicts when FOR_CONFLICT is true, otherwise we're just tracking
568 add_scope_conflicts_1 (basic_block bb
, bitmap work
, bool for_conflict
)
572 gimple_stmt_iterator gsi
;
573 walk_stmt_load_store_addr_fn visit
;
576 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
577 bitmap_ior_into (work
, (bitmap
)e
->src
->aux
);
581 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
583 gimple
*stmt
= gsi_stmt (gsi
);
584 walk_stmt_load_store_addr_ops (stmt
, work
, NULL
, NULL
, visit
);
586 for (gsi
= gsi_after_labels (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
588 gimple
*stmt
= gsi_stmt (gsi
);
590 if (gimple_clobber_p (stmt
))
592 tree lhs
= gimple_assign_lhs (stmt
);
594 /* Nested function lowering might introduce LHSs
595 that are COMPONENT_REFs. */
598 if (DECL_RTL_IF_SET (lhs
) == pc_rtx
599 && (v
= decl_to_stack_part
->get (lhs
)))
600 bitmap_clear_bit (work
, *v
);
602 else if (!is_gimple_debug (stmt
))
605 && visit
== visit_op
)
607 /* If this is the first real instruction in this BB we need
608 to add conflicts for everything live at this point now.
609 Unlike classical liveness for named objects we can't
610 rely on seeing a def/use of the names we're interested in.
611 There might merely be indirect loads/stores. We'd not add any
612 conflicts for such partitions. */
615 EXECUTE_IF_SET_IN_BITMAP (work
, 0, i
, bi
)
617 class stack_var
*a
= &stack_vars
[i
];
619 a
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
620 bitmap_ior_into (a
->conflicts
, work
);
622 visit
= visit_conflict
;
624 walk_stmt_load_store_addr_ops (stmt
, work
, visit
, visit
, visit
);
629 /* Generate stack partition conflicts between all partitions that are
630 simultaneously live. */
633 add_scope_conflicts (void)
637 bitmap work
= BITMAP_ALLOC (NULL
);
641 /* We approximate the live range of a stack variable by taking the first
642 mention of its name as starting point(s), and by the end-of-scope
643 death clobber added by gimplify as ending point(s) of the range.
644 This overapproximates in the case we for instance moved an address-taken
645 operation upward, without also moving a dereference to it upwards.
646 But it's conservatively correct as a variable never can hold values
647 before its name is mentioned at least once.
649 We then do a mostly classical bitmap liveness algorithm. */
651 FOR_ALL_BB_FN (bb
, cfun
)
652 bb
->aux
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
654 rpo
= XNEWVEC (int, last_basic_block_for_fn (cfun
));
655 n_bbs
= pre_and_rev_post_order_compute (NULL
, rpo
, false);
662 for (i
= 0; i
< n_bbs
; i
++)
665 bb
= BASIC_BLOCK_FOR_FN (cfun
, rpo
[i
]);
666 active
= (bitmap
)bb
->aux
;
667 add_scope_conflicts_1 (bb
, work
, false);
668 if (bitmap_ior_into (active
, work
))
673 FOR_EACH_BB_FN (bb
, cfun
)
674 add_scope_conflicts_1 (bb
, work
, true);
678 FOR_ALL_BB_FN (bb
, cfun
)
679 BITMAP_FREE (bb
->aux
);
682 /* A subroutine of partition_stack_vars. A comparison function for qsort,
683 sorting an array of indices by the properties of the object. */
686 stack_var_cmp (const void *a
, const void *b
)
688 size_t ia
= *(const size_t *)a
;
689 size_t ib
= *(const size_t *)b
;
690 unsigned int aligna
= stack_vars
[ia
].alignb
;
691 unsigned int alignb
= stack_vars
[ib
].alignb
;
692 poly_int64 sizea
= stack_vars
[ia
].size
;
693 poly_int64 sizeb
= stack_vars
[ib
].size
;
694 tree decla
= stack_vars
[ia
].decl
;
695 tree declb
= stack_vars
[ib
].decl
;
697 unsigned int uida
, uidb
;
699 /* Primary compare on "large" alignment. Large comes first. */
700 largea
= (aligna
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
701 largeb
= (alignb
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
702 if (largea
!= largeb
)
703 return (int)largeb
- (int)largea
;
705 /* Secondary compare on size, decreasing */
706 int diff
= compare_sizes_for_sort (sizeb
, sizea
);
710 /* Tertiary compare on true alignment, decreasing. */
716 /* Final compare on ID for sort stability, increasing.
717 Two SSA names are compared by their version, SSA names come before
718 non-SSA names, and two normal decls are compared by their DECL_UID. */
719 if (TREE_CODE (decla
) == SSA_NAME
)
721 if (TREE_CODE (declb
) == SSA_NAME
)
722 uida
= SSA_NAME_VERSION (decla
), uidb
= SSA_NAME_VERSION (declb
);
726 else if (TREE_CODE (declb
) == SSA_NAME
)
729 uida
= DECL_UID (decla
), uidb
= DECL_UID (declb
);
737 struct part_traits
: unbounded_int_hashmap_traits
<size_t, bitmap
> {};
738 typedef hash_map
<size_t, bitmap
, part_traits
> part_hashmap
;
740 /* If the points-to solution *PI points to variables that are in a partition
741 together with other variables add all partition members to the pointed-to
745 add_partitioned_vars_to_ptset (struct pt_solution
*pt
,
746 part_hashmap
*decls_to_partitions
,
747 hash_set
<bitmap
> *visited
, bitmap temp
)
755 /* The pointed-to vars bitmap is shared, it is enough to
757 || visited
->add (pt
->vars
))
762 /* By using a temporary bitmap to store all members of the partitions
763 we have to add we make sure to visit each of the partitions only
765 EXECUTE_IF_SET_IN_BITMAP (pt
->vars
, 0, i
, bi
)
767 || !bitmap_bit_p (temp
, i
))
768 && (part
= decls_to_partitions
->get (i
)))
769 bitmap_ior_into (temp
, *part
);
770 if (!bitmap_empty_p (temp
))
771 bitmap_ior_into (pt
->vars
, temp
);
774 /* Update points-to sets based on partition info, so we can use them on RTL.
775 The bitmaps representing stack partitions will be saved until expand,
776 where partitioned decls used as bases in memory expressions will be
780 update_alias_info_with_stack_vars (void)
782 part_hashmap
*decls_to_partitions
= NULL
;
784 tree var
= NULL_TREE
;
786 for (i
= 0; i
< stack_vars_num
; i
++)
790 struct ptr_info_def
*pi
;
792 /* Not interested in partitions with single variable. */
793 if (stack_vars
[i
].representative
!= i
794 || stack_vars
[i
].next
== EOC
)
797 if (!decls_to_partitions
)
799 decls_to_partitions
= new part_hashmap
;
800 cfun
->gimple_df
->decls_to_pointers
= new hash_map
<tree
, tree
>;
803 /* Create an SSA_NAME that points to the partition for use
804 as base during alias-oracle queries on RTL for bases that
805 have been partitioned. */
806 if (var
== NULL_TREE
)
807 var
= create_tmp_var (ptr_type_node
);
808 name
= make_ssa_name (var
);
810 /* Create bitmaps representing partitions. They will be used for
811 points-to sets later, so use GGC alloc. */
812 part
= BITMAP_GGC_ALLOC ();
813 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
815 tree decl
= stack_vars
[j
].decl
;
816 unsigned int uid
= DECL_PT_UID (decl
);
817 bitmap_set_bit (part
, uid
);
818 decls_to_partitions
->put (uid
, part
);
819 cfun
->gimple_df
->decls_to_pointers
->put (decl
, name
);
820 if (TREE_ADDRESSABLE (decl
))
821 TREE_ADDRESSABLE (name
) = 1;
824 /* Make the SSA name point to all partition members. */
825 pi
= get_ptr_info (name
);
826 pt_solution_set (&pi
->pt
, part
, false);
829 /* Make all points-to sets that contain one member of a partition
830 contain all members of the partition. */
831 if (decls_to_partitions
)
835 hash_set
<bitmap
> visited
;
836 bitmap temp
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
838 FOR_EACH_SSA_NAME (i
, name
, cfun
)
840 struct ptr_info_def
*pi
;
842 if (POINTER_TYPE_P (TREE_TYPE (name
))
843 && ((pi
= SSA_NAME_PTR_INFO (name
)) != NULL
))
844 add_partitioned_vars_to_ptset (&pi
->pt
, decls_to_partitions
,
848 add_partitioned_vars_to_ptset (&cfun
->gimple_df
->escaped
,
849 decls_to_partitions
, &visited
, temp
);
851 delete decls_to_partitions
;
856 /* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
857 partitioning algorithm. Partitions A and B are known to be non-conflicting.
858 Merge them into a single partition A. */
861 union_stack_vars (size_t a
, size_t b
)
863 class stack_var
*vb
= &stack_vars
[b
];
867 gcc_assert (stack_vars
[b
].next
== EOC
);
868 /* Add B to A's partition. */
869 stack_vars
[b
].next
= stack_vars
[a
].next
;
870 stack_vars
[b
].representative
= a
;
871 stack_vars
[a
].next
= b
;
873 /* Make sure A is big enough to hold B. */
874 stack_vars
[a
].size
= upper_bound (stack_vars
[a
].size
, stack_vars
[b
].size
);
876 /* Update the required alignment of partition A to account for B. */
877 if (stack_vars
[a
].alignb
< stack_vars
[b
].alignb
)
878 stack_vars
[a
].alignb
= stack_vars
[b
].alignb
;
880 /* Update the interference graph and merge the conflicts. */
883 EXECUTE_IF_SET_IN_BITMAP (vb
->conflicts
, 0, u
, bi
)
884 add_stack_var_conflict (a
, stack_vars
[u
].representative
);
885 BITMAP_FREE (vb
->conflicts
);
889 /* A subroutine of expand_used_vars. Binpack the variables into
890 partitions constrained by the interference graph. The overall
891 algorithm used is as follows:
893 Sort the objects by size in descending order.
898 Look for the largest non-conflicting object B with size <= S.
905 partition_stack_vars (void)
907 size_t si
, sj
, n
= stack_vars_num
;
909 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
910 for (si
= 0; si
< n
; ++si
)
911 stack_vars_sorted
[si
] = si
;
916 qsort (stack_vars_sorted
, n
, sizeof (size_t), stack_var_cmp
);
918 for (si
= 0; si
< n
; ++si
)
920 size_t i
= stack_vars_sorted
[si
];
921 unsigned int ialign
= stack_vars
[i
].alignb
;
922 poly_int64 isize
= stack_vars
[i
].size
;
924 /* Ignore objects that aren't partition representatives. If we
925 see a var that is not a partition representative, it must
926 have been merged earlier. */
927 if (stack_vars
[i
].representative
!= i
)
930 for (sj
= si
+ 1; sj
< n
; ++sj
)
932 size_t j
= stack_vars_sorted
[sj
];
933 unsigned int jalign
= stack_vars
[j
].alignb
;
934 poly_int64 jsize
= stack_vars
[j
].size
;
936 /* Ignore objects that aren't partition representatives. */
937 if (stack_vars
[j
].representative
!= j
)
940 /* Do not mix objects of "small" (supported) alignment
941 and "large" (unsupported) alignment. */
942 if ((ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
943 != (jalign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
))
946 /* For Address Sanitizer do not mix objects with different
947 sizes, as the shorter vars wouldn't be adequately protected.
948 Don't do that for "large" (unsupported) alignment objects,
949 those aren't protected anyway. */
950 if (asan_sanitize_stack_p ()
951 && maybe_ne (isize
, jsize
)
952 && ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
955 /* Ignore conflicting objects. */
956 if (stack_var_conflict_p (i
, j
))
959 /* UNION the objects, placing J at OFFSET. */
960 union_stack_vars (i
, j
);
964 update_alias_info_with_stack_vars ();
967 /* A debugging aid for expand_used_vars. Dump the generated partitions. */
970 dump_stack_var_partition (void)
972 size_t si
, i
, j
, n
= stack_vars_num
;
974 for (si
= 0; si
< n
; ++si
)
976 i
= stack_vars_sorted
[si
];
978 /* Skip variables that aren't partition representatives, for now. */
979 if (stack_vars
[i
].representative
!= i
)
982 fprintf (dump_file
, "Partition %lu: size ", (unsigned long) i
);
983 print_dec (stack_vars
[i
].size
, dump_file
);
984 fprintf (dump_file
, " align %u\n", stack_vars
[i
].alignb
);
986 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
988 fputc ('\t', dump_file
);
989 print_generic_expr (dump_file
, stack_vars
[j
].decl
, dump_flags
);
991 fputc ('\n', dump_file
);
995 /* Assign rtl to DECL at BASE + OFFSET. */
998 expand_one_stack_var_at (tree decl
, rtx base
, unsigned base_align
,
1004 /* If this fails, we've overflowed the stack frame. Error nicely? */
1005 gcc_assert (known_eq (offset
, trunc_int_for_mode (offset
, Pmode
)));
1007 x
= plus_constant (Pmode
, base
, offset
);
1008 x
= gen_rtx_MEM (TREE_CODE (decl
) == SSA_NAME
1009 ? TYPE_MODE (TREE_TYPE (decl
))
1010 : DECL_MODE (decl
), x
);
1012 /* Set alignment we actually gave this decl if it isn't an SSA name.
1013 If it is we generate stack slots only accidentally so it isn't as
1014 important, we'll simply set the alignment directly on the MEM. */
1016 if (base
== virtual_stack_vars_rtx
)
1017 offset
-= frame_phase
;
1018 align
= known_alignment (offset
);
1019 align
*= BITS_PER_UNIT
;
1020 if (align
== 0 || align
> base_align
)
1023 if (TREE_CODE (decl
) != SSA_NAME
)
1025 /* One would think that we could assert that we're not decreasing
1026 alignment here, but (at least) the i386 port does exactly this
1027 via the MINIMUM_ALIGNMENT hook. */
1029 SET_DECL_ALIGN (decl
, align
);
1030 DECL_USER_ALIGN (decl
) = 0;
1035 set_mem_align (x
, align
);
1038 class stack_vars_data
1041 /* Vector of offset pairs, always end of some padding followed
1042 by start of the padding that needs Address Sanitizer protection.
1043 The vector is in reversed, highest offset pairs come first. */
1044 auto_vec
<HOST_WIDE_INT
> asan_vec
;
1046 /* Vector of partition representative decls in between the paddings. */
1047 auto_vec
<tree
> asan_decl_vec
;
1049 /* Base pseudo register for Address Sanitizer protected automatic vars. */
1052 /* Alignment needed for the Address Sanitizer protected automatic vars. */
1053 unsigned int asan_alignb
;
1056 /* A subroutine of expand_used_vars. Give each partition representative
1057 a unique location within the stack frame. Update each partition member
1058 with that location. */
1061 expand_stack_vars (bool (*pred
) (size_t), class stack_vars_data
*data
)
1063 size_t si
, i
, j
, n
= stack_vars_num
;
1064 poly_uint64 large_size
= 0, large_alloc
= 0;
1065 rtx large_base
= NULL
;
1066 unsigned large_align
= 0;
1067 bool large_allocation_done
= false;
1070 /* Determine if there are any variables requiring "large" alignment.
1071 Since these are dynamically allocated, we only process these if
1072 no predicate involved. */
1073 large_align
= stack_vars
[stack_vars_sorted
[0]].alignb
* BITS_PER_UNIT
;
1074 if (pred
== NULL
&& large_align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1076 /* Find the total size of these variables. */
1077 for (si
= 0; si
< n
; ++si
)
1081 i
= stack_vars_sorted
[si
];
1082 alignb
= stack_vars
[i
].alignb
;
1084 /* All "large" alignment decls come before all "small" alignment
1085 decls, but "large" alignment decls are not sorted based on
1086 their alignment. Increase large_align to track the largest
1087 required alignment. */
1088 if ((alignb
* BITS_PER_UNIT
) > large_align
)
1089 large_align
= alignb
* BITS_PER_UNIT
;
1091 /* Stop when we get to the first decl with "small" alignment. */
1092 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
1095 /* Skip variables that aren't partition representatives. */
1096 if (stack_vars
[i
].representative
!= i
)
1099 /* Skip variables that have already had rtl assigned. See also
1100 add_stack_var where we perpetrate this pc_rtx hack. */
1101 decl
= stack_vars
[i
].decl
;
1102 if (TREE_CODE (decl
) == SSA_NAME
1103 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)] != NULL_RTX
1104 : DECL_RTL (decl
) != pc_rtx
)
1107 large_size
= aligned_upper_bound (large_size
, alignb
);
1108 large_size
+= stack_vars
[i
].size
;
1112 for (si
= 0; si
< n
; ++si
)
1115 unsigned base_align
, alignb
;
1118 i
= stack_vars_sorted
[si
];
1120 /* Skip variables that aren't partition representatives, for now. */
1121 if (stack_vars
[i
].representative
!= i
)
1124 /* Skip variables that have already had rtl assigned. See also
1125 add_stack_var where we perpetrate this pc_rtx hack. */
1126 decl
= stack_vars
[i
].decl
;
1127 if (TREE_CODE (decl
) == SSA_NAME
1128 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)] != NULL_RTX
1129 : DECL_RTL (decl
) != pc_rtx
)
1132 /* Check the predicate to see whether this variable should be
1133 allocated in this pass. */
1134 if (pred
&& !pred (i
))
1137 alignb
= stack_vars
[i
].alignb
;
1138 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
1140 base
= virtual_stack_vars_rtx
;
1141 /* ASAN description strings don't yet have a syntax for expressing
1142 polynomial offsets. */
1143 HOST_WIDE_INT prev_offset
;
1144 if (asan_sanitize_stack_p ()
1146 && frame_offset
.is_constant (&prev_offset
)
1147 && stack_vars
[i
].size
.is_constant ())
1149 if (data
->asan_vec
.is_empty ())
1151 alloc_stack_frame_space (0, ASAN_RED_ZONE_SIZE
);
1152 prev_offset
= frame_offset
.to_constant ();
1154 prev_offset
= align_base (prev_offset
,
1155 ASAN_MIN_RED_ZONE_SIZE
,
1156 !FRAME_GROWS_DOWNWARD
);
1157 tree repr_decl
= NULL_TREE
;
1158 unsigned HOST_WIDE_INT size
1159 = asan_var_and_redzone_size (stack_vars
[i
].size
.to_constant ());
1160 if (data
->asan_vec
.is_empty ())
1161 size
= MAX (size
, ASAN_RED_ZONE_SIZE
);
1163 unsigned HOST_WIDE_INT alignment
= MAX (alignb
,
1164 ASAN_MIN_RED_ZONE_SIZE
);
1165 offset
= alloc_stack_frame_space (size
, alignment
);
1167 data
->asan_vec
.safe_push (prev_offset
);
1168 /* Allocating a constant amount of space from a constant
1169 starting offset must give a constant result. */
1170 data
->asan_vec
.safe_push ((offset
+ stack_vars
[i
].size
)
1172 /* Find best representative of the partition.
1173 Prefer those with DECL_NAME, even better
1174 satisfying asan_protect_stack_decl predicate. */
1175 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1176 if (asan_protect_stack_decl (stack_vars
[j
].decl
)
1177 && DECL_NAME (stack_vars
[j
].decl
))
1179 repr_decl
= stack_vars
[j
].decl
;
1182 else if (repr_decl
== NULL_TREE
1183 && DECL_P (stack_vars
[j
].decl
)
1184 && DECL_NAME (stack_vars
[j
].decl
))
1185 repr_decl
= stack_vars
[j
].decl
;
1186 if (repr_decl
== NULL_TREE
)
1187 repr_decl
= stack_vars
[i
].decl
;
1188 data
->asan_decl_vec
.safe_push (repr_decl
);
1190 /* Make sure a representative is unpoison if another
1191 variable in the partition is handled by
1192 use-after-scope sanitization. */
1193 if (asan_handled_variables
!= NULL
1194 && !asan_handled_variables
->contains (repr_decl
))
1196 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1197 if (asan_handled_variables
->contains (stack_vars
[j
].decl
))
1200 asan_handled_variables
->add (repr_decl
);
1203 data
->asan_alignb
= MAX (data
->asan_alignb
, alignb
);
1204 if (data
->asan_base
== NULL
)
1205 data
->asan_base
= gen_reg_rtx (Pmode
);
1206 base
= data
->asan_base
;
1208 if (!STRICT_ALIGNMENT
)
1209 base_align
= crtl
->max_used_stack_slot_alignment
;
1211 base_align
= MAX (crtl
->max_used_stack_slot_alignment
,
1212 GET_MODE_ALIGNMENT (SImode
)
1213 << ASAN_SHADOW_SHIFT
);
1217 offset
= alloc_stack_frame_space (stack_vars
[i
].size
, alignb
);
1218 base_align
= crtl
->max_used_stack_slot_alignment
;
1223 /* Large alignment is only processed in the last pass. */
1227 /* If there were any variables requiring "large" alignment, allocate
1229 if (maybe_ne (large_size
, 0U) && ! large_allocation_done
)
1232 rtx large_allocsize
;
1234 large_allocsize
= gen_int_mode (large_size
, Pmode
);
1235 get_dynamic_stack_size (&large_allocsize
, 0, large_align
, NULL
);
1236 loffset
= alloc_stack_frame_space
1237 (rtx_to_poly_int64 (large_allocsize
),
1238 PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
);
1239 large_base
= get_dynamic_stack_base (loffset
, large_align
);
1240 large_allocation_done
= true;
1242 gcc_assert (large_base
!= NULL
);
1244 large_alloc
= aligned_upper_bound (large_alloc
, alignb
);
1245 offset
= large_alloc
;
1246 large_alloc
+= stack_vars
[i
].size
;
1249 base_align
= large_align
;
1252 /* Create rtl for each variable based on their location within the
1254 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1256 expand_one_stack_var_at (stack_vars
[j
].decl
,
1262 gcc_assert (known_eq (large_alloc
, large_size
));
1265 /* Take into account all sizes of partitions and reset DECL_RTLs. */
1267 account_stack_vars (void)
1269 size_t si
, j
, i
, n
= stack_vars_num
;
1270 poly_uint64 size
= 0;
1272 for (si
= 0; si
< n
; ++si
)
1274 i
= stack_vars_sorted
[si
];
1276 /* Skip variables that aren't partition representatives, for now. */
1277 if (stack_vars
[i
].representative
!= i
)
1280 size
+= stack_vars
[i
].size
;
1281 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1282 set_rtl (stack_vars
[j
].decl
, NULL
);
1287 /* Record the RTL assignment X for the default def of PARM. */
1290 set_parm_rtl (tree parm
, rtx x
)
1292 gcc_assert (TREE_CODE (parm
) == PARM_DECL
1293 || TREE_CODE (parm
) == RESULT_DECL
);
1295 if (x
&& !MEM_P (x
))
1297 unsigned int align
= MINIMUM_ALIGNMENT (TREE_TYPE (parm
),
1298 TYPE_MODE (TREE_TYPE (parm
)),
1299 TYPE_ALIGN (TREE_TYPE (parm
)));
1301 /* If the variable alignment is very large we'll dynamicaly
1302 allocate it, which means that in-frame portion is just a
1303 pointer. ??? We've got a pseudo for sure here, do we
1304 actually dynamically allocate its spilling area if needed?
1305 ??? Isn't it a problem when Pmode alignment also exceeds
1306 MAX_SUPPORTED_STACK_ALIGNMENT, as can happen on cris and lm32? */
1307 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1308 align
= GET_MODE_ALIGNMENT (Pmode
);
1310 record_alignment_for_reg_var (align
);
1313 tree ssa
= ssa_default_def (cfun
, parm
);
1315 return set_rtl (parm
, x
);
1317 int part
= var_to_partition (SA
.map
, ssa
);
1318 gcc_assert (part
!= NO_PARTITION
);
1320 bool changed
= bitmap_bit_p (SA
.partitions_for_parm_default_defs
, part
);
1321 gcc_assert (changed
);
1324 gcc_assert (DECL_RTL (parm
) == x
);
1327 /* A subroutine of expand_one_var. Called to immediately assign rtl
1328 to a variable to be allocated in the stack frame. */
1331 expand_one_stack_var_1 (tree var
)
1335 unsigned byte_align
;
1337 if (TREE_CODE (var
) == SSA_NAME
)
1339 tree type
= TREE_TYPE (var
);
1340 size
= tree_to_poly_uint64 (TYPE_SIZE_UNIT (type
));
1343 size
= tree_to_poly_uint64 (DECL_SIZE_UNIT (var
));
1345 byte_align
= align_local_variable (var
, true);
1347 /* We handle highly aligned variables in expand_stack_vars. */
1348 gcc_assert (byte_align
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
);
1350 offset
= alloc_stack_frame_space (size
, byte_align
);
1352 expand_one_stack_var_at (var
, virtual_stack_vars_rtx
,
1353 crtl
->max_used_stack_slot_alignment
, offset
);
1356 /* Wrapper for expand_one_stack_var_1 that checks SSA_NAMEs are
1357 already assigned some MEM. */
1360 expand_one_stack_var (tree var
)
1362 if (TREE_CODE (var
) == SSA_NAME
)
1364 int part
= var_to_partition (SA
.map
, var
);
1365 if (part
!= NO_PARTITION
)
1367 rtx x
= SA
.partition_to_pseudo
[part
];
1369 gcc_assert (MEM_P (x
));
1374 return expand_one_stack_var_1 (var
);
1377 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1378 that will reside in a hard register. */
1381 expand_one_hard_reg_var (tree var
)
1383 rest_of_decl_compilation (var
, 0, 0);
1386 /* Record the alignment requirements of some variable assigned to a
1390 record_alignment_for_reg_var (unsigned int align
)
1392 if (SUPPORTS_STACK_ALIGNMENT
1393 && crtl
->stack_alignment_estimated
< align
)
1395 /* stack_alignment_estimated shouldn't change after stack
1396 realign decision made */
1397 gcc_assert (!crtl
->stack_realign_processed
);
1398 crtl
->stack_alignment_estimated
= align
;
1401 /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
1402 So here we only make sure stack_alignment_needed >= align. */
1403 if (crtl
->stack_alignment_needed
< align
)
1404 crtl
->stack_alignment_needed
= align
;
1405 if (crtl
->max_used_stack_slot_alignment
< align
)
1406 crtl
->max_used_stack_slot_alignment
= align
;
1409 /* Create RTL for an SSA partition. */
1412 expand_one_ssa_partition (tree var
)
1414 int part
= var_to_partition (SA
.map
, var
);
1415 gcc_assert (part
!= NO_PARTITION
);
1417 if (SA
.partition_to_pseudo
[part
])
1420 unsigned int align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1421 TYPE_MODE (TREE_TYPE (var
)),
1422 TYPE_ALIGN (TREE_TYPE (var
)));
1424 /* If the variable alignment is very large we'll dynamicaly allocate
1425 it, which means that in-frame portion is just a pointer. */
1426 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1427 align
= GET_MODE_ALIGNMENT (Pmode
);
1429 record_alignment_for_reg_var (align
);
1431 if (!use_register_for_decl (var
))
1433 if (defer_stack_allocation (var
, true))
1434 add_stack_var (var
, true);
1436 expand_one_stack_var_1 (var
);
1440 machine_mode reg_mode
= promote_ssa_mode (var
, NULL
);
1441 rtx x
= gen_reg_rtx (reg_mode
);
1445 /* For a promoted variable, X will not be used directly but wrapped in a
1446 SUBREG with SUBREG_PROMOTED_VAR_P set, which means that the RTL land
1447 will assume that its upper bits can be inferred from its lower bits.
1448 Therefore, if X isn't initialized on every path from the entry, then
1449 we must do it manually in order to fulfill the above assumption. */
1450 if (reg_mode
!= TYPE_MODE (TREE_TYPE (var
))
1451 && bitmap_bit_p (SA
.partitions_for_undefined_values
, part
))
1452 emit_move_insn (x
, CONST0_RTX (reg_mode
));
1455 /* Record the association between the RTL generated for partition PART
1456 and the underlying variable of the SSA_NAME VAR. */
1459 adjust_one_expanded_partition_var (tree var
)
1464 tree decl
= SSA_NAME_VAR (var
);
1466 int part
= var_to_partition (SA
.map
, var
);
1467 if (part
== NO_PARTITION
)
1470 rtx x
= SA
.partition_to_pseudo
[part
];
1479 /* Note if the object is a user variable. */
1480 if (decl
&& !DECL_ARTIFICIAL (decl
))
1483 if (POINTER_TYPE_P (decl
? TREE_TYPE (decl
) : TREE_TYPE (var
)))
1484 mark_reg_pointer (x
, get_pointer_alignment (var
));
1487 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1488 that will reside in a pseudo register. */
1491 expand_one_register_var (tree var
)
1493 if (TREE_CODE (var
) == SSA_NAME
)
1495 int part
= var_to_partition (SA
.map
, var
);
1496 if (part
!= NO_PARTITION
)
1498 rtx x
= SA
.partition_to_pseudo
[part
];
1500 gcc_assert (REG_P (x
));
1507 tree type
= TREE_TYPE (decl
);
1508 machine_mode reg_mode
= promote_decl_mode (decl
, NULL
);
1509 rtx x
= gen_reg_rtx (reg_mode
);
1513 /* Note if the object is a user variable. */
1514 if (!DECL_ARTIFICIAL (decl
))
1517 if (POINTER_TYPE_P (type
))
1518 mark_reg_pointer (x
, get_pointer_alignment (var
));
1521 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
1522 has some associated error, e.g. its type is error-mark. We just need
1523 to pick something that won't crash the rest of the compiler. */
1526 expand_one_error_var (tree var
)
1528 machine_mode mode
= DECL_MODE (var
);
1531 if (mode
== BLKmode
)
1532 x
= gen_rtx_MEM (BLKmode
, const0_rtx
);
1533 else if (mode
== VOIDmode
)
1536 x
= gen_reg_rtx (mode
);
1538 SET_DECL_RTL (var
, x
);
1541 /* A subroutine of expand_one_var. VAR is a variable that will be
1542 allocated to the local stack frame. Return true if we wish to
1543 add VAR to STACK_VARS so that it will be coalesced with other
1544 variables. Return false to allocate VAR immediately.
1546 This function is used to reduce the number of variables considered
1547 for coalescing, which reduces the size of the quadratic problem. */
1550 defer_stack_allocation (tree var
, bool toplevel
)
1552 tree size_unit
= TREE_CODE (var
) == SSA_NAME
1553 ? TYPE_SIZE_UNIT (TREE_TYPE (var
))
1554 : DECL_SIZE_UNIT (var
);
1557 /* Whether the variable is small enough for immediate allocation not to be
1558 a problem with regard to the frame size. */
1560 = (poly_int_tree_p (size_unit
, &size
)
1561 && (estimated_poly_value (size
)
1562 < param_min_size_for_stack_sharing
));
1564 /* If stack protection is enabled, *all* stack variables must be deferred,
1565 so that we can re-order the strings to the top of the frame.
1566 Similarly for Address Sanitizer. */
1567 if (flag_stack_protect
|| asan_sanitize_stack_p ())
1570 unsigned int align
= TREE_CODE (var
) == SSA_NAME
1571 ? TYPE_ALIGN (TREE_TYPE (var
))
1574 /* We handle "large" alignment via dynamic allocation. We want to handle
1575 this extra complication in only one place, so defer them. */
1576 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1579 bool ignored
= TREE_CODE (var
) == SSA_NAME
1580 ? !SSAVAR (var
) || DECL_IGNORED_P (SSA_NAME_VAR (var
))
1581 : DECL_IGNORED_P (var
);
1583 /* When optimization is enabled, DECL_IGNORED_P variables originally scoped
1584 might be detached from their block and appear at toplevel when we reach
1585 here. We want to coalesce them with variables from other blocks when
1586 the immediate contribution to the frame size would be noticeable. */
1587 if (toplevel
&& optimize
> 0 && ignored
&& !smallish
)
1590 /* Variables declared in the outermost scope automatically conflict
1591 with every other variable. The only reason to want to defer them
1592 at all is that, after sorting, we can more efficiently pack
1593 small variables in the stack frame. Continue to defer at -O2. */
1594 if (toplevel
&& optimize
< 2)
1597 /* Without optimization, *most* variables are allocated from the
1598 stack, which makes the quadratic problem large exactly when we
1599 want compilation to proceed as quickly as possible. On the
1600 other hand, we don't want the function's stack frame size to
1601 get completely out of hand. So we avoid adding scalars and
1602 "small" aggregates to the list at all. */
1603 if (optimize
== 0 && smallish
)
1609 /* A subroutine of expand_used_vars. Expand one variable according to
1610 its flavor. Variables to be placed on the stack are not actually
1611 expanded yet, merely recorded.
1612 When REALLY_EXPAND is false, only add stack values to be allocated.
1613 Return stack usage this variable is supposed to take.
1617 expand_one_var (tree var
, bool toplevel
, bool really_expand
)
1619 unsigned int align
= BITS_PER_UNIT
;
1624 if (TREE_TYPE (var
) != error_mark_node
&& VAR_P (var
))
1626 if (is_global_var (var
))
1629 /* Because we don't know if VAR will be in register or on stack,
1630 we conservatively assume it will be on stack even if VAR is
1631 eventually put into register after RA pass. For non-automatic
1632 variables, which won't be on stack, we collect alignment of
1633 type and ignore user specified alignment. Similarly for
1634 SSA_NAMEs for which use_register_for_decl returns true. */
1635 if (TREE_STATIC (var
)
1636 || DECL_EXTERNAL (var
)
1637 || (TREE_CODE (origvar
) == SSA_NAME
&& use_register_for_decl (var
)))
1638 align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1639 TYPE_MODE (TREE_TYPE (var
)),
1640 TYPE_ALIGN (TREE_TYPE (var
)));
1641 else if (DECL_HAS_VALUE_EXPR_P (var
)
1642 || (DECL_RTL_SET_P (var
) && MEM_P (DECL_RTL (var
))))
1643 /* Don't consider debug only variables with DECL_HAS_VALUE_EXPR_P set
1644 or variables which were assigned a stack slot already by
1645 expand_one_stack_var_at - in the latter case DECL_ALIGN has been
1646 changed from the offset chosen to it. */
1647 align
= crtl
->stack_alignment_estimated
;
1649 align
= MINIMUM_ALIGNMENT (var
, DECL_MODE (var
), DECL_ALIGN (var
));
1651 /* If the variable alignment is very large we'll dynamicaly allocate
1652 it, which means that in-frame portion is just a pointer. */
1653 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1654 align
= GET_MODE_ALIGNMENT (Pmode
);
1657 record_alignment_for_reg_var (align
);
1660 if (TREE_CODE (origvar
) == SSA_NAME
)
1662 gcc_assert (!VAR_P (var
)
1663 || (!DECL_EXTERNAL (var
)
1664 && !DECL_HAS_VALUE_EXPR_P (var
)
1665 && !TREE_STATIC (var
)
1666 && TREE_TYPE (var
) != error_mark_node
1667 && !DECL_HARD_REGISTER (var
)
1670 if (!VAR_P (var
) && TREE_CODE (origvar
) != SSA_NAME
)
1672 else if (DECL_EXTERNAL (var
))
1674 else if (DECL_HAS_VALUE_EXPR_P (var
))
1676 else if (TREE_STATIC (var
))
1678 else if (TREE_CODE (origvar
) != SSA_NAME
&& DECL_RTL_SET_P (var
))
1680 else if (TREE_TYPE (var
) == error_mark_node
)
1683 expand_one_error_var (var
);
1685 else if (VAR_P (var
) && DECL_HARD_REGISTER (var
))
1689 expand_one_hard_reg_var (var
);
1690 if (!DECL_HARD_REGISTER (var
))
1691 /* Invalid register specification. */
1692 expand_one_error_var (var
);
1695 else if (use_register_for_decl (var
))
1698 expand_one_register_var (origvar
);
1700 else if (!poly_int_tree_p (DECL_SIZE_UNIT (var
), &size
)
1701 || !valid_constant_size_p (DECL_SIZE_UNIT (var
)))
1703 /* Reject variables which cover more than half of the address-space. */
1706 if (DECL_NONLOCAL_FRAME (var
))
1707 error_at (DECL_SOURCE_LOCATION (current_function_decl
),
1708 "total size of local objects is too large");
1710 error_at (DECL_SOURCE_LOCATION (var
),
1711 "size of variable %q+D is too large", var
);
1712 expand_one_error_var (var
);
1715 else if (defer_stack_allocation (var
, toplevel
))
1716 add_stack_var (origvar
, really_expand
);
1721 if (lookup_attribute ("naked",
1722 DECL_ATTRIBUTES (current_function_decl
)))
1723 error ("cannot allocate stack for variable %q+D, naked function",
1726 expand_one_stack_var (origvar
);
1733 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1734 expanding variables. Those variables that can be put into registers
1735 are allocated pseudos; those that can't are put on the stack.
1737 TOPLEVEL is true if this is the outermost BLOCK. */
1740 expand_used_vars_for_block (tree block
, bool toplevel
)
1744 /* Expand all variables at this level. */
1745 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1747 && ((!VAR_P (t
) && TREE_CODE (t
) != RESULT_DECL
)
1748 || !DECL_NONSHAREABLE (t
)))
1749 expand_one_var (t
, toplevel
, true);
1751 /* Expand all variables at containing levels. */
1752 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1753 expand_used_vars_for_block (t
, false);
1756 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1757 and clear TREE_USED on all local variables. */
1760 clear_tree_used (tree block
)
1764 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1765 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
1766 if ((!VAR_P (t
) && TREE_CODE (t
) != RESULT_DECL
)
1767 || !DECL_NONSHAREABLE (t
))
1770 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1771 clear_tree_used (t
);
1774 /* Examine TYPE and determine a bit mask of the following features. */
1776 #define SPCT_HAS_LARGE_CHAR_ARRAY 1
1777 #define SPCT_HAS_SMALL_CHAR_ARRAY 2
1778 #define SPCT_HAS_ARRAY 4
1779 #define SPCT_HAS_AGGREGATE 8
1782 stack_protect_classify_type (tree type
)
1784 unsigned int ret
= 0;
1787 switch (TREE_CODE (type
))
1790 t
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1791 if (t
== char_type_node
1792 || t
== signed_char_type_node
1793 || t
== unsigned_char_type_node
)
1795 unsigned HOST_WIDE_INT max
= param_ssp_buffer_size
;
1796 unsigned HOST_WIDE_INT len
;
1798 if (!TYPE_SIZE_UNIT (type
)
1799 || !tree_fits_uhwi_p (TYPE_SIZE_UNIT (type
)))
1802 len
= tree_to_uhwi (TYPE_SIZE_UNIT (type
));
1805 ret
= SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1807 ret
= SPCT_HAS_LARGE_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1810 ret
= SPCT_HAS_ARRAY
;
1814 case QUAL_UNION_TYPE
:
1816 ret
= SPCT_HAS_AGGREGATE
;
1817 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
1818 if (TREE_CODE (t
) == FIELD_DECL
)
1819 ret
|= stack_protect_classify_type (TREE_TYPE (t
));
1829 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
1830 part of the local stack frame. Remember if we ever return nonzero for
1831 any variable in this function. The return value is the phase number in
1832 which the variable should be allocated. */
1835 stack_protect_decl_phase (tree decl
)
1837 unsigned int bits
= stack_protect_classify_type (TREE_TYPE (decl
));
1840 if (bits
& SPCT_HAS_SMALL_CHAR_ARRAY
)
1841 has_short_buffer
= true;
1843 tree attribs
= DECL_ATTRIBUTES (current_function_decl
);
1844 if (!lookup_attribute ("no_stack_protector", attribs
)
1845 && (flag_stack_protect
== SPCT_FLAG_ALL
1846 || flag_stack_protect
== SPCT_FLAG_STRONG
1847 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
1848 && lookup_attribute ("stack_protect", attribs
))))
1850 if ((bits
& (SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_LARGE_CHAR_ARRAY
))
1851 && !(bits
& SPCT_HAS_AGGREGATE
))
1853 else if (bits
& SPCT_HAS_ARRAY
)
1857 ret
= (bits
& SPCT_HAS_LARGE_CHAR_ARRAY
) != 0;
1860 has_protected_decls
= true;
1865 /* Two helper routines that check for phase 1 and phase 2. These are used
1866 as callbacks for expand_stack_vars. */
1869 stack_protect_decl_phase_1 (size_t i
)
1871 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 1;
1875 stack_protect_decl_phase_2 (size_t i
)
1877 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 2;
1880 /* And helper function that checks for asan phase (with stack protector
1881 it is phase 3). This is used as callback for expand_stack_vars.
1882 Returns true if any of the vars in the partition need to be protected. */
1885 asan_decl_phase_3 (size_t i
)
1889 if (asan_protect_stack_decl (stack_vars
[i
].decl
))
1891 i
= stack_vars
[i
].next
;
1896 /* Ensure that variables in different stack protection phases conflict
1897 so that they are not merged and share the same stack slot.
1898 Return true if there are any address taken variables. */
1901 add_stack_protection_conflicts (void)
1903 size_t i
, j
, n
= stack_vars_num
;
1904 unsigned char *phase
;
1907 phase
= XNEWVEC (unsigned char, n
);
1908 for (i
= 0; i
< n
; ++i
)
1910 phase
[i
] = stack_protect_decl_phase (stack_vars
[i
].decl
);
1911 if (TREE_ADDRESSABLE (stack_vars
[i
].decl
))
1915 for (i
= 0; i
< n
; ++i
)
1917 unsigned char ph_i
= phase
[i
];
1918 for (j
= i
+ 1; j
< n
; ++j
)
1919 if (ph_i
!= phase
[j
])
1920 add_stack_var_conflict (i
, j
);
1927 /* Create a decl for the guard at the top of the stack frame. */
1930 create_stack_guard (void)
1932 tree guard
= build_decl (DECL_SOURCE_LOCATION (current_function_decl
),
1933 VAR_DECL
, NULL
, ptr_type_node
);
1934 TREE_THIS_VOLATILE (guard
) = 1;
1935 TREE_USED (guard
) = 1;
1936 expand_one_stack_var (guard
);
1937 crtl
->stack_protect_guard
= guard
;
1940 /* Prepare for expanding variables. */
1942 init_vars_expansion (void)
1944 /* Conflict bitmaps, and a few related temporary bitmaps, go here. */
1945 bitmap_obstack_initialize (&stack_var_bitmap_obstack
);
1947 /* A map from decl to stack partition. */
1948 decl_to_stack_part
= new hash_map
<tree
, size_t>;
1950 /* Initialize local stack smashing state. */
1951 has_protected_decls
= false;
1952 has_short_buffer
= false;
1955 /* Free up stack variable graph data. */
1957 fini_vars_expansion (void)
1959 bitmap_obstack_release (&stack_var_bitmap_obstack
);
1961 XDELETEVEC (stack_vars
);
1962 if (stack_vars_sorted
)
1963 XDELETEVEC (stack_vars_sorted
);
1965 stack_vars_sorted
= NULL
;
1966 stack_vars_alloc
= stack_vars_num
= 0;
1967 delete decl_to_stack_part
;
1968 decl_to_stack_part
= NULL
;
1971 /* Make a fair guess for the size of the stack frame of the function
1972 in NODE. This doesn't have to be exact, the result is only used in
1973 the inline heuristics. So we don't want to run the full stack var
1974 packing algorithm (which is quadratic in the number of stack vars).
1975 Instead, we calculate the total size of all stack vars. This turns
1976 out to be a pretty fair estimate -- packing of stack vars doesn't
1977 happen very often. */
1980 estimated_stack_frame_size (struct cgraph_node
*node
)
1982 poly_int64 size
= 0;
1985 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
1989 init_vars_expansion ();
1991 FOR_EACH_LOCAL_DECL (fn
, i
, var
)
1992 if (auto_var_in_fn_p (var
, fn
->decl
))
1993 size
+= expand_one_var (var
, true, false);
1995 if (stack_vars_num
> 0)
1997 /* Fake sorting the stack vars for account_stack_vars (). */
1998 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
1999 for (i
= 0; i
< stack_vars_num
; ++i
)
2000 stack_vars_sorted
[i
] = i
;
2001 size
+= account_stack_vars ();
2004 fini_vars_expansion ();
2006 return estimated_poly_value (size
);
2009 /* Check if the current function has calls that use a return slot. */
2012 stack_protect_return_slot_p ()
2016 FOR_ALL_BB_FN (bb
, cfun
)
2017 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
2018 !gsi_end_p (gsi
); gsi_next (&gsi
))
2020 gimple
*stmt
= gsi_stmt (gsi
);
2021 /* This assumes that calls to internal-only functions never
2022 use a return slot. */
2023 if (is_gimple_call (stmt
)
2024 && !gimple_call_internal_p (stmt
)
2025 && aggregate_value_p (TREE_TYPE (gimple_call_fntype (stmt
)),
2026 gimple_call_fndecl (stmt
)))
2032 /* Expand all variables used in the function. */
2035 expand_used_vars (void)
2037 tree var
, outer_block
= DECL_INITIAL (current_function_decl
);
2038 auto_vec
<tree
> maybe_local_decls
;
2039 rtx_insn
*var_end_seq
= NULL
;
2042 bool gen_stack_protect_signal
= false;
2044 /* Compute the phase of the stack frame for this function. */
2046 int align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
2047 int off
= targetm
.starting_frame_offset () % align
;
2048 frame_phase
= off
? align
- off
: 0;
2051 /* Set TREE_USED on all variables in the local_decls. */
2052 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
2053 TREE_USED (var
) = 1;
2054 /* Clear TREE_USED on all variables associated with a block scope. */
2055 clear_tree_used (DECL_INITIAL (current_function_decl
));
2057 init_vars_expansion ();
2059 if (targetm
.use_pseudo_pic_reg ())
2060 pic_offset_table_rtx
= gen_reg_rtx (Pmode
);
2062 for (i
= 0; i
< SA
.map
->num_partitions
; i
++)
2064 if (bitmap_bit_p (SA
.partitions_for_parm_default_defs
, i
))
2067 tree var
= partition_to_var (SA
.map
, i
);
2069 gcc_assert (!virtual_operand_p (var
));
2071 expand_one_ssa_partition (var
);
2074 if (flag_stack_protect
== SPCT_FLAG_STRONG
)
2075 gen_stack_protect_signal
= stack_protect_return_slot_p ();
2077 /* At this point all variables on the local_decls with TREE_USED
2078 set are not associated with any block scope. Lay them out. */
2080 len
= vec_safe_length (cfun
->local_decls
);
2081 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
2083 bool expand_now
= false;
2085 /* Expanded above already. */
2086 if (is_gimple_reg (var
))
2088 TREE_USED (var
) = 0;
2091 /* We didn't set a block for static or extern because it's hard
2092 to tell the difference between a global variable (re)declared
2093 in a local scope, and one that's really declared there to
2094 begin with. And it doesn't really matter much, since we're
2095 not giving them stack space. Expand them now. */
2096 else if (TREE_STATIC (var
) || DECL_EXTERNAL (var
))
2099 /* Expand variables not associated with any block now. Those created by
2100 the optimizers could be live anywhere in the function. Those that
2101 could possibly have been scoped originally and detached from their
2102 block will have their allocation deferred so we coalesce them with
2103 others when optimization is enabled. */
2104 else if (TREE_USED (var
))
2107 /* Finally, mark all variables on the list as used. We'll use
2108 this in a moment when we expand those associated with scopes. */
2109 TREE_USED (var
) = 1;
2112 expand_one_var (var
, true, true);
2115 if (DECL_ARTIFICIAL (var
) && !DECL_IGNORED_P (var
))
2117 rtx rtl
= DECL_RTL_IF_SET (var
);
2119 /* Keep artificial non-ignored vars in cfun->local_decls
2120 chain until instantiate_decls. */
2121 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
2122 add_local_decl (cfun
, var
);
2123 else if (rtl
== NULL_RTX
)
2124 /* If rtl isn't set yet, which can happen e.g. with
2125 -fstack-protector, retry before returning from this
2127 maybe_local_decls
.safe_push (var
);
2131 /* We duplicated some of the decls in CFUN->LOCAL_DECLS.
2133 +-----------------+-----------------+
2134 | ...processed... | ...duplicates...|
2135 +-----------------+-----------------+
2137 +-- LEN points here.
2139 We just want the duplicates, as those are the artificial
2140 non-ignored vars that we want to keep until instantiate_decls.
2141 Move them down and truncate the array. */
2142 if (!vec_safe_is_empty (cfun
->local_decls
))
2143 cfun
->local_decls
->block_remove (0, len
);
2145 /* At this point, all variables within the block tree with TREE_USED
2146 set are actually used by the optimized function. Lay them out. */
2147 expand_used_vars_for_block (outer_block
, true);
2149 tree attribs
= DECL_ATTRIBUTES (current_function_decl
);
2150 if (stack_vars_num
> 0)
2152 bool has_addressable_vars
= false;
2154 add_scope_conflicts ();
2156 /* If stack protection is enabled, we don't share space between
2157 vulnerable data and non-vulnerable data. */
2158 if (flag_stack_protect
!= 0
2159 && !lookup_attribute ("no_stack_protector", attribs
)
2160 && (flag_stack_protect
!= SPCT_FLAG_EXPLICIT
2161 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
2162 && lookup_attribute ("stack_protect", attribs
))))
2163 has_addressable_vars
= add_stack_protection_conflicts ();
2165 if (flag_stack_protect
== SPCT_FLAG_STRONG
&& has_addressable_vars
)
2166 gen_stack_protect_signal
= true;
2168 /* Now that we have collected all stack variables, and have computed a
2169 minimal interference graph, attempt to save some stack space. */
2170 partition_stack_vars ();
2172 dump_stack_var_partition ();
2176 if (!lookup_attribute ("no_stack_protector", attribs
))
2177 switch (flag_stack_protect
)
2180 create_stack_guard ();
2183 case SPCT_FLAG_STRONG
:
2184 if (gen_stack_protect_signal
2185 || cfun
->calls_alloca
2186 || has_protected_decls
2187 || lookup_attribute ("stack_protect",
2188 DECL_ATTRIBUTES (current_function_decl
)))
2189 create_stack_guard ();
2192 case SPCT_FLAG_DEFAULT
:
2193 if (cfun
->calls_alloca
2194 || has_protected_decls
2195 || lookup_attribute ("stack_protect",
2196 DECL_ATTRIBUTES (current_function_decl
)))
2197 create_stack_guard ();
2200 case SPCT_FLAG_EXPLICIT
:
2201 if (lookup_attribute ("stack_protect",
2202 DECL_ATTRIBUTES (current_function_decl
)))
2203 create_stack_guard ();
2210 /* Assign rtl to each variable based on these partitions. */
2211 if (stack_vars_num
> 0)
2213 class stack_vars_data data
;
2215 data
.asan_base
= NULL_RTX
;
2216 data
.asan_alignb
= 0;
2218 /* Reorder decls to be protected by iterating over the variables
2219 array multiple times, and allocating out of each phase in turn. */
2220 /* ??? We could probably integrate this into the qsort we did
2221 earlier, such that we naturally see these variables first,
2222 and thus naturally allocate things in the right order. */
2223 if (has_protected_decls
)
2225 /* Phase 1 contains only character arrays. */
2226 expand_stack_vars (stack_protect_decl_phase_1
, &data
);
2228 /* Phase 2 contains other kinds of arrays. */
2229 if (!lookup_attribute ("no_stack_protector", attribs
)
2230 && (flag_stack_protect
== SPCT_FLAG_ALL
2231 || flag_stack_protect
== SPCT_FLAG_STRONG
2232 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
2233 && lookup_attribute ("stack_protect", attribs
))))
2234 expand_stack_vars (stack_protect_decl_phase_2
, &data
);
2237 if (asan_sanitize_stack_p ())
2238 /* Phase 3, any partitions that need asan protection
2239 in addition to phase 1 and 2. */
2240 expand_stack_vars (asan_decl_phase_3
, &data
);
2242 /* ASAN description strings don't yet have a syntax for expressing
2243 polynomial offsets. */
2244 HOST_WIDE_INT prev_offset
;
2245 if (!data
.asan_vec
.is_empty ()
2246 && frame_offset
.is_constant (&prev_offset
))
2248 HOST_WIDE_INT offset
, sz
, redzonesz
;
2249 redzonesz
= ASAN_RED_ZONE_SIZE
;
2250 sz
= data
.asan_vec
[0] - prev_offset
;
2251 if (data
.asan_alignb
> ASAN_RED_ZONE_SIZE
2252 && data
.asan_alignb
<= 4096
2253 && sz
+ ASAN_RED_ZONE_SIZE
>= (int) data
.asan_alignb
)
2254 redzonesz
= ((sz
+ ASAN_RED_ZONE_SIZE
+ data
.asan_alignb
- 1)
2255 & ~(data
.asan_alignb
- HOST_WIDE_INT_1
)) - sz
;
2256 /* Allocating a constant amount of space from a constant
2257 starting offset must give a constant result. */
2258 offset
= (alloc_stack_frame_space (redzonesz
, ASAN_RED_ZONE_SIZE
)
2260 data
.asan_vec
.safe_push (prev_offset
);
2261 data
.asan_vec
.safe_push (offset
);
2262 /* Leave space for alignment if STRICT_ALIGNMENT. */
2263 if (STRICT_ALIGNMENT
)
2264 alloc_stack_frame_space ((GET_MODE_ALIGNMENT (SImode
)
2265 << ASAN_SHADOW_SHIFT
)
2266 / BITS_PER_UNIT
, 1);
2269 = asan_emit_stack_protection (virtual_stack_vars_rtx
,
2272 data
.asan_vec
.address (),
2273 data
.asan_decl_vec
.address (),
2274 data
.asan_vec
.length ());
2277 expand_stack_vars (NULL
, &data
);
2280 if (asan_sanitize_allocas_p () && cfun
->calls_alloca
)
2281 var_end_seq
= asan_emit_allocas_unpoison (virtual_stack_dynamic_rtx
,
2282 virtual_stack_vars_rtx
,
2285 fini_vars_expansion ();
2287 /* If there were any artificial non-ignored vars without rtl
2288 found earlier, see if deferred stack allocation hasn't assigned
2290 FOR_EACH_VEC_ELT_REVERSE (maybe_local_decls
, i
, var
)
2292 rtx rtl
= DECL_RTL_IF_SET (var
);
2294 /* Keep artificial non-ignored vars in cfun->local_decls
2295 chain until instantiate_decls. */
2296 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
2297 add_local_decl (cfun
, var
);
2300 /* If the target requires that FRAME_OFFSET be aligned, do it. */
2301 if (STACK_ALIGNMENT_NEEDED
)
2303 HOST_WIDE_INT align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
2304 if (FRAME_GROWS_DOWNWARD
)
2305 frame_offset
= aligned_lower_bound (frame_offset
, align
);
2307 frame_offset
= aligned_upper_bound (frame_offset
, align
);
2314 /* If we need to produce a detailed dump, print the tree representation
2315 for STMT to the dump file. SINCE is the last RTX after which the RTL
2316 generated for STMT should have been appended. */
2319 maybe_dump_rtl_for_gimple_stmt (gimple
*stmt
, rtx_insn
*since
)
2321 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2323 fprintf (dump_file
, "\n;; ");
2324 print_gimple_stmt (dump_file
, stmt
, 0,
2325 TDF_SLIM
| (dump_flags
& TDF_LINENO
));
2326 fprintf (dump_file
, "\n");
2328 print_rtl (dump_file
, since
? NEXT_INSN (since
) : since
);
2332 /* Maps the blocks that do not contain tree labels to rtx labels. */
2334 static hash_map
<basic_block
, rtx_code_label
*> *lab_rtx_for_bb
;
2336 /* Returns the label_rtx expression for a label starting basic block BB. */
2338 static rtx_code_label
*
2339 label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED
)
2341 gimple_stmt_iterator gsi
;
2344 if (bb
->flags
& BB_RTL
)
2345 return block_label (bb
);
2347 rtx_code_label
**elt
= lab_rtx_for_bb
->get (bb
);
2351 /* Find the tree label if it is present. */
2353 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2357 lab_stmt
= dyn_cast
<glabel
*> (gsi_stmt (gsi
));
2361 lab
= gimple_label_label (lab_stmt
);
2362 if (DECL_NONLOCAL (lab
))
2365 return jump_target_rtx (lab
);
2368 rtx_code_label
*l
= gen_label_rtx ();
2369 lab_rtx_for_bb
->put (bb
, l
);
2374 /* A subroutine of expand_gimple_cond. Given E, a fallthrough edge
2375 of a basic block where we just expanded the conditional at the end,
2376 possibly clean up the CFG and instruction sequence. LAST is the
2377 last instruction before the just emitted jump sequence. */
2380 maybe_cleanup_end_of_block (edge e
, rtx_insn
*last
)
2382 /* Special case: when jumpif decides that the condition is
2383 trivial it emits an unconditional jump (and the necessary
2384 barrier). But we still have two edges, the fallthru one is
2385 wrong. purge_dead_edges would clean this up later. Unfortunately
2386 we have to insert insns (and split edges) before
2387 find_many_sub_basic_blocks and hence before purge_dead_edges.
2388 But splitting edges might create new blocks which depend on the
2389 fact that if there are two edges there's no barrier. So the
2390 barrier would get lost and verify_flow_info would ICE. Instead
2391 of auditing all edge splitters to care for the barrier (which
2392 normally isn't there in a cleaned CFG), fix it here. */
2393 if (BARRIER_P (get_last_insn ()))
2397 /* Now, we have a single successor block, if we have insns to
2398 insert on the remaining edge we potentially will insert
2399 it at the end of this block (if the dest block isn't feasible)
2400 in order to avoid splitting the edge. This insertion will take
2401 place in front of the last jump. But we might have emitted
2402 multiple jumps (conditional and one unconditional) to the
2403 same destination. Inserting in front of the last one then
2404 is a problem. See PR 40021. We fix this by deleting all
2405 jumps except the last unconditional one. */
2406 insn
= PREV_INSN (get_last_insn ());
2407 /* Make sure we have an unconditional jump. Otherwise we're
2409 gcc_assert (JUMP_P (insn
) && !any_condjump_p (insn
));
2410 for (insn
= PREV_INSN (insn
); insn
!= last
;)
2412 insn
= PREV_INSN (insn
);
2413 if (JUMP_P (NEXT_INSN (insn
)))
2415 if (!any_condjump_p (NEXT_INSN (insn
)))
2417 gcc_assert (BARRIER_P (NEXT_INSN (NEXT_INSN (insn
))));
2418 delete_insn (NEXT_INSN (NEXT_INSN (insn
)));
2420 delete_insn (NEXT_INSN (insn
));
2426 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_COND.
2427 Returns a new basic block if we've terminated the current basic
2428 block and created a new one. */
2431 expand_gimple_cond (basic_block bb
, gcond
*stmt
)
2433 basic_block new_bb
, dest
;
2436 rtx_insn
*last2
, *last
;
2437 enum tree_code code
;
2440 code
= gimple_cond_code (stmt
);
2441 op0
= gimple_cond_lhs (stmt
);
2442 op1
= gimple_cond_rhs (stmt
);
2443 /* We're sometimes presented with such code:
2447 This would expand to two comparisons which then later might
2448 be cleaned up by combine. But some pattern matchers like if-conversion
2449 work better when there's only one compare, so make up for this
2450 here as special exception if TER would have made the same change. */
2452 && TREE_CODE (op0
) == SSA_NAME
2453 && TREE_CODE (TREE_TYPE (op0
)) == BOOLEAN_TYPE
2454 && TREE_CODE (op1
) == INTEGER_CST
2455 && ((gimple_cond_code (stmt
) == NE_EXPR
2456 && integer_zerop (op1
))
2457 || (gimple_cond_code (stmt
) == EQ_EXPR
2458 && integer_onep (op1
)))
2459 && bitmap_bit_p (SA
.values
, SSA_NAME_VERSION (op0
)))
2461 gimple
*second
= SSA_NAME_DEF_STMT (op0
);
2462 if (gimple_code (second
) == GIMPLE_ASSIGN
)
2464 enum tree_code code2
= gimple_assign_rhs_code (second
);
2465 if (TREE_CODE_CLASS (code2
) == tcc_comparison
)
2468 op0
= gimple_assign_rhs1 (second
);
2469 op1
= gimple_assign_rhs2 (second
);
2471 /* If jumps are cheap and the target does not support conditional
2472 compare, turn some more codes into jumpy sequences. */
2473 else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4
2474 && targetm
.gen_ccmp_first
== NULL
)
2476 if ((code2
== BIT_AND_EXPR
2477 && TYPE_PRECISION (TREE_TYPE (op0
)) == 1
2478 && TREE_CODE (gimple_assign_rhs2 (second
)) != INTEGER_CST
)
2479 || code2
== TRUTH_AND_EXPR
)
2481 code
= TRUTH_ANDIF_EXPR
;
2482 op0
= gimple_assign_rhs1 (second
);
2483 op1
= gimple_assign_rhs2 (second
);
2485 else if (code2
== BIT_IOR_EXPR
|| code2
== TRUTH_OR_EXPR
)
2487 code
= TRUTH_ORIF_EXPR
;
2488 op0
= gimple_assign_rhs1 (second
);
2489 op1
= gimple_assign_rhs2 (second
);
2495 /* Optimize (x % C1) == C2 or (x % C1) != C2 if it is beneficial
2496 into (x - C2) * C3 < C4. */
2497 if ((code
== EQ_EXPR
|| code
== NE_EXPR
)
2498 && TREE_CODE (op0
) == SSA_NAME
2499 && TREE_CODE (op1
) == INTEGER_CST
)
2500 code
= maybe_optimize_mod_cmp (code
, &op0
, &op1
);
2502 last2
= last
= get_last_insn ();
2504 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
2505 set_curr_insn_location (gimple_location (stmt
));
2507 /* These flags have no purpose in RTL land. */
2508 true_edge
->flags
&= ~EDGE_TRUE_VALUE
;
2509 false_edge
->flags
&= ~EDGE_FALSE_VALUE
;
2511 /* We can either have a pure conditional jump with one fallthru edge or
2512 two-way jump that needs to be decomposed into two basic blocks. */
2513 if (false_edge
->dest
== bb
->next_bb
)
2515 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2516 true_edge
->probability
);
2517 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2518 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2519 set_curr_insn_location (true_edge
->goto_locus
);
2520 false_edge
->flags
|= EDGE_FALLTHRU
;
2521 maybe_cleanup_end_of_block (false_edge
, last
);
2524 if (true_edge
->dest
== bb
->next_bb
)
2526 jumpifnot_1 (code
, op0
, op1
, label_rtx_for_bb (false_edge
->dest
),
2527 false_edge
->probability
);
2528 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2529 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2530 set_curr_insn_location (false_edge
->goto_locus
);
2531 true_edge
->flags
|= EDGE_FALLTHRU
;
2532 maybe_cleanup_end_of_block (true_edge
, last
);
2536 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2537 true_edge
->probability
);
2538 last
= get_last_insn ();
2539 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2540 set_curr_insn_location (false_edge
->goto_locus
);
2541 emit_jump (label_rtx_for_bb (false_edge
->dest
));
2544 if (BARRIER_P (BB_END (bb
)))
2545 BB_END (bb
) = PREV_INSN (BB_END (bb
));
2546 update_bb_for_insn (bb
);
2548 new_bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
2549 dest
= false_edge
->dest
;
2550 redirect_edge_succ (false_edge
, new_bb
);
2551 false_edge
->flags
|= EDGE_FALLTHRU
;
2552 new_bb
->count
= false_edge
->count ();
2553 loop_p loop
= find_common_loop (bb
->loop_father
, dest
->loop_father
);
2554 add_bb_to_loop (new_bb
, loop
);
2555 if (loop
->latch
== bb
2556 && loop
->header
== dest
)
2557 loop
->latch
= new_bb
;
2558 make_single_succ_edge (new_bb
, dest
, 0);
2559 if (BARRIER_P (BB_END (new_bb
)))
2560 BB_END (new_bb
) = PREV_INSN (BB_END (new_bb
));
2561 update_bb_for_insn (new_bb
);
2563 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
2565 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2567 set_curr_insn_location (true_edge
->goto_locus
);
2568 true_edge
->goto_locus
= curr_insn_location ();
2574 /* Mark all calls that can have a transaction restart. */
2577 mark_transaction_restart_calls (gimple
*stmt
)
2579 struct tm_restart_node dummy
;
2580 tm_restart_node
**slot
;
2582 if (!cfun
->gimple_df
->tm_restart
)
2586 slot
= cfun
->gimple_df
->tm_restart
->find_slot (&dummy
, NO_INSERT
);
2589 struct tm_restart_node
*n
= *slot
;
2590 tree list
= n
->label_or_list
;
2593 for (insn
= next_real_insn (get_last_insn ());
2595 insn
= next_real_insn (insn
))
2598 if (TREE_CODE (list
) == LABEL_DECL
)
2599 add_reg_note (insn
, REG_TM
, label_rtx (list
));
2601 for (; list
; list
= TREE_CHAIN (list
))
2602 add_reg_note (insn
, REG_TM
, label_rtx (TREE_VALUE (list
)));
2606 /* A subroutine of expand_gimple_stmt_1, expanding one GIMPLE_CALL
2610 expand_call_stmt (gcall
*stmt
)
2612 tree exp
, decl
, lhs
;
2616 if (gimple_call_internal_p (stmt
))
2618 expand_internal_call (stmt
);
2622 /* If this is a call to a built-in function and it has no effect other
2623 than setting the lhs, try to implement it using an internal function
2625 decl
= gimple_call_fndecl (stmt
);
2626 if (gimple_call_lhs (stmt
)
2627 && !gimple_has_side_effects (stmt
)
2628 && (optimize
|| (decl
&& called_as_built_in (decl
))))
2630 internal_fn ifn
= replacement_internal_fn (stmt
);
2631 if (ifn
!= IFN_LAST
)
2633 expand_internal_call (ifn
, stmt
);
2638 exp
= build_vl_exp (CALL_EXPR
, gimple_call_num_args (stmt
) + 3);
2640 CALL_EXPR_FN (exp
) = gimple_call_fn (stmt
);
2641 builtin_p
= decl
&& fndecl_built_in_p (decl
);
2643 /* If this is not a builtin function, the function type through which the
2644 call is made may be different from the type of the function. */
2647 = fold_convert (build_pointer_type (gimple_call_fntype (stmt
)),
2648 CALL_EXPR_FN (exp
));
2650 TREE_TYPE (exp
) = gimple_call_return_type (stmt
);
2651 CALL_EXPR_STATIC_CHAIN (exp
) = gimple_call_chain (stmt
);
2653 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2655 tree arg
= gimple_call_arg (stmt
, i
);
2657 /* TER addresses into arguments of builtin functions so we have a
2658 chance to infer more correct alignment information. See PR39954. */
2660 && TREE_CODE (arg
) == SSA_NAME
2661 && (def
= get_gimple_for_ssa_name (arg
))
2662 && gimple_assign_rhs_code (def
) == ADDR_EXPR
)
2663 arg
= gimple_assign_rhs1 (def
);
2664 CALL_EXPR_ARG (exp
, i
) = arg
;
2667 if (gimple_has_side_effects (stmt
))
2668 TREE_SIDE_EFFECTS (exp
) = 1;
2670 if (gimple_call_nothrow_p (stmt
))
2671 TREE_NOTHROW (exp
) = 1;
2673 if (gimple_no_warning_p (stmt
))
2674 TREE_NO_WARNING (exp
) = 1;
2676 CALL_EXPR_TAILCALL (exp
) = gimple_call_tail_p (stmt
);
2677 CALL_EXPR_MUST_TAIL_CALL (exp
) = gimple_call_must_tail_p (stmt
);
2678 CALL_EXPR_RETURN_SLOT_OPT (exp
) = gimple_call_return_slot_opt_p (stmt
);
2680 && fndecl_built_in_p (decl
, BUILT_IN_NORMAL
)
2681 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (decl
)))
2682 CALL_ALLOCA_FOR_VAR_P (exp
) = gimple_call_alloca_for_var_p (stmt
);
2684 CALL_FROM_THUNK_P (exp
) = gimple_call_from_thunk_p (stmt
);
2685 CALL_EXPR_VA_ARG_PACK (exp
) = gimple_call_va_arg_pack_p (stmt
);
2686 CALL_EXPR_BY_DESCRIPTOR (exp
) = gimple_call_by_descriptor_p (stmt
);
2687 SET_EXPR_LOCATION (exp
, gimple_location (stmt
));
2689 /* Ensure RTL is created for debug args. */
2690 if (decl
&& DECL_HAS_DEBUG_ARGS_P (decl
))
2692 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (decl
);
2697 for (ix
= 1; (*debug_args
)->iterate (ix
, &dtemp
); ix
+= 2)
2699 gcc_assert (TREE_CODE (dtemp
) == DEBUG_EXPR_DECL
);
2700 expand_debug_expr (dtemp
);
2704 rtx_insn
*before_call
= get_last_insn ();
2705 lhs
= gimple_call_lhs (stmt
);
2707 expand_assignment (lhs
, exp
, false);
2709 expand_expr (exp
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2711 /* If the gimple call is an indirect call and has 'nocf_check'
2712 attribute find a generated CALL insn to mark it as no
2713 control-flow verification is needed. */
2714 if (gimple_call_nocf_check_p (stmt
)
2715 && !gimple_call_fndecl (stmt
))
2717 rtx_insn
*last
= get_last_insn ();
2718 while (!CALL_P (last
)
2719 && last
!= before_call
)
2720 last
= PREV_INSN (last
);
2722 if (last
!= before_call
)
2723 add_reg_note (last
, REG_CALL_NOCF_CHECK
, const0_rtx
);
2726 mark_transaction_restart_calls (stmt
);
2730 /* Generate RTL for an asm statement (explicit assembler code).
2731 STRING is a STRING_CST node containing the assembler code text,
2732 or an ADDR_EXPR containing a STRING_CST. VOL nonzero means the
2733 insn is volatile; don't optimize it. */
2736 expand_asm_loc (tree string
, int vol
, location_t locus
)
2740 body
= gen_rtx_ASM_INPUT_loc (VOIDmode
,
2741 ggc_strdup (TREE_STRING_POINTER (string
)),
2744 MEM_VOLATILE_P (body
) = vol
;
2746 /* Non-empty basic ASM implicitly clobbers memory. */
2747 if (TREE_STRING_LENGTH (string
) != 0)
2750 unsigned i
, nclobbers
;
2751 auto_vec
<rtx
> input_rvec
, output_rvec
;
2752 auto_vec
<const char *> constraints
;
2753 auto_vec
<rtx
> clobber_rvec
;
2754 HARD_REG_SET clobbered_regs
;
2755 CLEAR_HARD_REG_SET (clobbered_regs
);
2757 clob
= gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
));
2758 clobber_rvec
.safe_push (clob
);
2760 if (targetm
.md_asm_adjust
)
2761 targetm
.md_asm_adjust (output_rvec
, input_rvec
,
2762 constraints
, clobber_rvec
,
2766 nclobbers
= clobber_rvec
.length ();
2767 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (1 + nclobbers
));
2769 XVECEXP (body
, 0, 0) = asm_op
;
2770 for (i
= 0; i
< nclobbers
; i
++)
2771 XVECEXP (body
, 0, i
+ 1) = gen_rtx_CLOBBER (VOIDmode
, clobber_rvec
[i
]);
2777 /* Return the number of times character C occurs in string S. */
2779 n_occurrences (int c
, const char *s
)
2787 /* A subroutine of expand_asm_operands. Check that all operands have
2788 the same number of alternatives. Return true if so. */
2791 check_operand_nalternatives (const vec
<const char *> &constraints
)
2793 unsigned len
= constraints
.length();
2796 int nalternatives
= n_occurrences (',', constraints
[0]);
2798 if (nalternatives
+ 1 > MAX_RECOG_ALTERNATIVES
)
2800 error ("too many alternatives in %<asm%>");
2804 for (unsigned i
= 1; i
< len
; ++i
)
2805 if (n_occurrences (',', constraints
[i
]) != nalternatives
)
2807 error ("operand constraints for %<asm%> differ "
2808 "in number of alternatives");
2815 /* Check for overlap between registers marked in CLOBBERED_REGS and
2816 anything inappropriate in T. Emit error and return the register
2817 variable definition for error, NULL_TREE for ok. */
2820 tree_conflicts_with_clobbers_p (tree t
, HARD_REG_SET
*clobbered_regs
)
2822 /* Conflicts between asm-declared register variables and the clobber
2823 list are not allowed. */
2824 tree overlap
= tree_overlaps_hard_reg_set (t
, clobbered_regs
);
2828 error ("%<asm%> specifier for variable %qE conflicts with "
2829 "%<asm%> clobber list",
2830 DECL_NAME (overlap
));
2832 /* Reset registerness to stop multiple errors emitted for a single
2834 DECL_REGISTER (overlap
) = 0;
2841 /* Check that the given REGNO spanning NREGS is a valid
2842 asm clobber operand. Some HW registers cannot be
2843 saved/restored, hence they should not be clobbered by
2846 asm_clobber_reg_is_valid (int regno
, int nregs
, const char *regname
)
2848 bool is_valid
= true;
2849 HARD_REG_SET regset
;
2851 CLEAR_HARD_REG_SET (regset
);
2853 add_range_to_hard_reg_set (®set
, regno
, nregs
);
2855 /* Clobbering the PIC register is an error. */
2856 if (PIC_OFFSET_TABLE_REGNUM
!= INVALID_REGNUM
2857 && overlaps_hard_reg_set_p (regset
, Pmode
, PIC_OFFSET_TABLE_REGNUM
))
2859 /* ??? Diagnose during gimplification? */
2860 error ("PIC register clobbered by %qs in %<asm%>", regname
);
2863 else if (!in_hard_reg_set_p
2864 (accessible_reg_set
, reg_raw_mode
[regno
], regno
))
2866 /* ??? Diagnose during gimplification? */
2867 error ("the register %qs cannot be clobbered in %<asm%>"
2868 " for the current target", regname
);
2872 /* Clobbering the stack pointer register is deprecated. GCC expects
2873 the value of the stack pointer after an asm statement to be the same
2874 as it was before, so no asm can validly clobber the stack pointer in
2875 the usual sense. Adding the stack pointer to the clobber list has
2876 traditionally had some undocumented and somewhat obscure side-effects. */
2877 if (overlaps_hard_reg_set_p (regset
, Pmode
, STACK_POINTER_REGNUM
))
2879 crtl
->sp_is_clobbered_by_asm
= true;
2880 if (warning (OPT_Wdeprecated
, "listing the stack pointer register"
2881 " %qs in a clobber list is deprecated", regname
))
2882 inform (input_location
, "the value of the stack pointer after"
2883 " an %<asm%> statement must be the same as it was before"
2890 /* Generate RTL for an asm statement with arguments.
2891 STRING is the instruction template.
2892 OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
2893 Each output or input has an expression in the TREE_VALUE and
2894 a tree list in TREE_PURPOSE which in turn contains a constraint
2895 name in TREE_VALUE (or NULL_TREE) and a constraint string
2897 CLOBBERS is a list of STRING_CST nodes each naming a hard register
2898 that is clobbered by this insn.
2900 LABELS is a list of labels, and if LABELS is non-NULL, FALLTHRU_BB
2901 should be the fallthru basic block of the asm goto.
2903 Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
2904 Some elements of OUTPUTS may be replaced with trees representing temporary
2905 values. The caller should copy those temporary values to the originally
2908 VOL nonzero means the insn is volatile; don't optimize it. */
2911 expand_asm_stmt (gasm
*stmt
)
2913 class save_input_location
2918 explicit save_input_location(location_t where
)
2920 old
= input_location
;
2921 input_location
= where
;
2924 ~save_input_location()
2926 input_location
= old
;
2930 location_t locus
= gimple_location (stmt
);
2932 if (gimple_asm_input_p (stmt
))
2934 const char *s
= gimple_asm_string (stmt
);
2935 tree string
= build_string (strlen (s
), s
);
2936 expand_asm_loc (string
, gimple_asm_volatile_p (stmt
), locus
);
2940 /* There are some legacy diagnostics in here, and also avoids a
2941 sixth parameger to targetm.md_asm_adjust. */
2942 save_input_location
s_i_l(locus
);
2944 unsigned noutputs
= gimple_asm_noutputs (stmt
);
2945 unsigned ninputs
= gimple_asm_ninputs (stmt
);
2946 unsigned nlabels
= gimple_asm_nlabels (stmt
);
2949 /* ??? Diagnose during gimplification? */
2950 if (ninputs
+ noutputs
+ nlabels
> MAX_RECOG_OPERANDS
)
2952 error ("more than %d operands in %<asm%>", MAX_RECOG_OPERANDS
);
2956 auto_vec
<tree
, MAX_RECOG_OPERANDS
> output_tvec
;
2957 auto_vec
<tree
, MAX_RECOG_OPERANDS
> input_tvec
;
2958 auto_vec
<const char *, MAX_RECOG_OPERANDS
> constraints
;
2960 /* Copy the gimple vectors into new vectors that we can manipulate. */
2962 output_tvec
.safe_grow (noutputs
, true);
2963 input_tvec
.safe_grow (ninputs
, true);
2964 constraints
.safe_grow (noutputs
+ ninputs
, true);
2966 for (i
= 0; i
< noutputs
; ++i
)
2968 tree t
= gimple_asm_output_op (stmt
, i
);
2969 output_tvec
[i
] = TREE_VALUE (t
);
2970 constraints
[i
] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
2972 for (i
= 0; i
< ninputs
; i
++)
2974 tree t
= gimple_asm_input_op (stmt
, i
);
2975 input_tvec
[i
] = TREE_VALUE (t
);
2976 constraints
[i
+ noutputs
]
2977 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
2980 /* ??? Diagnose during gimplification? */
2981 if (! check_operand_nalternatives (constraints
))
2984 /* Count the number of meaningful clobbered registers, ignoring what
2985 we would ignore later. */
2986 auto_vec
<rtx
> clobber_rvec
;
2987 HARD_REG_SET clobbered_regs
;
2988 CLEAR_HARD_REG_SET (clobbered_regs
);
2990 if (unsigned n
= gimple_asm_nclobbers (stmt
))
2992 clobber_rvec
.reserve (n
);
2993 for (i
= 0; i
< n
; i
++)
2995 tree t
= gimple_asm_clobber_op (stmt
, i
);
2996 const char *regname
= TREE_STRING_POINTER (TREE_VALUE (t
));
2999 j
= decode_reg_name_and_count (regname
, &nregs
);
3004 /* ??? Diagnose during gimplification? */
3005 error ("unknown register name %qs in %<asm%>", regname
);
3009 rtx x
= gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
));
3010 clobber_rvec
.safe_push (x
);
3014 /* Otherwise we should have -1 == empty string
3015 or -3 == cc, which is not a register. */
3016 gcc_assert (j
== -1 || j
== -3);
3020 for (int reg
= j
; reg
< j
+ nregs
; reg
++)
3022 if (!asm_clobber_reg_is_valid (reg
, nregs
, regname
))
3025 SET_HARD_REG_BIT (clobbered_regs
, reg
);
3026 rtx x
= gen_rtx_REG (reg_raw_mode
[reg
], reg
);
3027 clobber_rvec
.safe_push (x
);
3032 /* First pass over inputs and outputs checks validity and sets
3033 mark_addressable if needed. */
3034 /* ??? Diagnose during gimplification? */
3036 for (i
= 0; i
< noutputs
; ++i
)
3038 tree val
= output_tvec
[i
];
3039 tree type
= TREE_TYPE (val
);
3040 const char *constraint
;
3045 /* Try to parse the output constraint. If that fails, there's
3046 no point in going further. */
3047 constraint
= constraints
[i
];
3048 if (!parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
3049 &allows_mem
, &allows_reg
, &is_inout
))
3052 /* If the output is a hard register, verify it doesn't conflict with
3053 any other operand's possible hard register use. */
3055 && REG_P (DECL_RTL (val
))
3056 && HARD_REGISTER_P (DECL_RTL (val
)))
3058 unsigned j
, output_hregno
= REGNO (DECL_RTL (val
));
3059 bool early_clobber_p
= strchr (constraints
[i
], '&') != NULL
;
3060 unsigned long match
;
3062 /* Verify the other outputs do not use the same hard register. */
3063 for (j
= i
+ 1; j
< noutputs
; ++j
)
3064 if (DECL_P (output_tvec
[j
])
3065 && REG_P (DECL_RTL (output_tvec
[j
]))
3066 && HARD_REGISTER_P (DECL_RTL (output_tvec
[j
]))
3067 && output_hregno
== REGNO (DECL_RTL (output_tvec
[j
])))
3068 error ("invalid hard register usage between output operands");
3070 /* Verify matching constraint operands use the same hard register
3071 and that the non-matching constraint operands do not use the same
3072 hard register if the output is an early clobber operand. */
3073 for (j
= 0; j
< ninputs
; ++j
)
3074 if (DECL_P (input_tvec
[j
])
3075 && REG_P (DECL_RTL (input_tvec
[j
]))
3076 && HARD_REGISTER_P (DECL_RTL (input_tvec
[j
])))
3078 unsigned input_hregno
= REGNO (DECL_RTL (input_tvec
[j
]));
3079 switch (*constraints
[j
+ noutputs
])
3081 case '0': case '1': case '2': case '3': case '4':
3082 case '5': case '6': case '7': case '8': case '9':
3083 match
= strtoul (constraints
[j
+ noutputs
], NULL
, 10);
3090 && output_hregno
!= input_hregno
)
3091 error ("invalid hard register usage between output operand "
3092 "and matching constraint operand");
3093 else if (early_clobber_p
3095 && output_hregno
== input_hregno
)
3096 error ("invalid hard register usage between earlyclobber "
3097 "operand and input operand");
3105 && REG_P (DECL_RTL (val
))
3106 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
))))
3107 mark_addressable (val
);
3110 for (i
= 0; i
< ninputs
; ++i
)
3112 bool allows_reg
, allows_mem
;
3113 const char *constraint
;
3115 constraint
= constraints
[i
+ noutputs
];
3116 if (! parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
3117 constraints
.address (),
3118 &allows_mem
, &allows_reg
))
3121 if (! allows_reg
&& allows_mem
)
3122 mark_addressable (input_tvec
[i
]);
3125 /* Second pass evaluates arguments. */
3127 /* Make sure stack is consistent for asm goto. */
3129 do_pending_stack_adjust ();
3130 int old_generating_concat_p
= generating_concat_p
;
3132 /* Vector of RTX's of evaluated output operands. */
3133 auto_vec
<rtx
, MAX_RECOG_OPERANDS
> output_rvec
;
3134 auto_vec
<int, MAX_RECOG_OPERANDS
> inout_opnum
;
3135 rtx_insn
*after_rtl_seq
= NULL
, *after_rtl_end
= NULL
;
3137 output_rvec
.safe_grow (noutputs
, true);
3139 for (i
= 0; i
< noutputs
; ++i
)
3141 tree val
= output_tvec
[i
];
3142 tree type
= TREE_TYPE (val
);
3143 bool is_inout
, allows_reg
, allows_mem
, ok
;
3146 ok
= parse_output_constraint (&constraints
[i
], i
, ninputs
,
3147 noutputs
, &allows_mem
, &allows_reg
,
3151 /* If an output operand is not a decl or indirect ref and our constraint
3152 allows a register, make a temporary to act as an intermediate.
3153 Make the asm insn write into that, then we will copy it to
3154 the real output operand. Likewise for promoted variables. */
3156 generating_concat_p
= 0;
3158 if ((TREE_CODE (val
) == INDIRECT_REF
&& allows_mem
)
3160 && (allows_mem
|| REG_P (DECL_RTL (val
)))
3161 && ! (REG_P (DECL_RTL (val
))
3162 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
)))
3165 || TREE_ADDRESSABLE (type
))
3167 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
3168 !allows_reg
? EXPAND_MEMORY
: EXPAND_WRITE
);
3170 op
= validize_mem (op
);
3172 if (! allows_reg
&& !MEM_P (op
))
3173 error ("output number %d not directly addressable", i
);
3174 if ((! allows_mem
&& MEM_P (op
) && GET_MODE (op
) != BLKmode
)
3175 || GET_CODE (op
) == CONCAT
)
3178 op
= gen_reg_rtx (GET_MODE (op
));
3180 generating_concat_p
= old_generating_concat_p
;
3183 emit_move_insn (op
, old_op
);
3185 push_to_sequence2 (after_rtl_seq
, after_rtl_end
);
3186 emit_move_insn (old_op
, op
);
3187 after_rtl_seq
= get_insns ();
3188 after_rtl_end
= get_last_insn ();
3194 op
= assign_temp (type
, 0, 1);
3195 op
= validize_mem (op
);
3196 if (!MEM_P (op
) && TREE_CODE (val
) == SSA_NAME
)
3197 set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (val
), op
);
3199 generating_concat_p
= old_generating_concat_p
;
3201 push_to_sequence2 (after_rtl_seq
, after_rtl_end
);
3202 expand_assignment (val
, make_tree (type
, op
), false);
3203 after_rtl_seq
= get_insns ();
3204 after_rtl_end
= get_last_insn ();
3207 output_rvec
[i
] = op
;
3210 inout_opnum
.safe_push (i
);
3213 auto_vec
<rtx
, MAX_RECOG_OPERANDS
> input_rvec
;
3214 auto_vec
<machine_mode
, MAX_RECOG_OPERANDS
> input_mode
;
3216 input_rvec
.safe_grow (ninputs
, true);
3217 input_mode
.safe_grow (ninputs
, true);
3219 generating_concat_p
= 0;
3221 for (i
= 0; i
< ninputs
; ++i
)
3223 tree val
= input_tvec
[i
];
3224 tree type
= TREE_TYPE (val
);
3225 bool allows_reg
, allows_mem
, ok
;
3226 const char *constraint
;
3229 constraint
= constraints
[i
+ noutputs
];
3230 ok
= parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
3231 constraints
.address (),
3232 &allows_mem
, &allows_reg
);
3235 /* EXPAND_INITIALIZER will not generate code for valid initializer
3236 constants, but will still generate code for other types of operand.
3237 This is the behavior we want for constant constraints. */
3238 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
3239 allows_reg
? EXPAND_NORMAL
3240 : allows_mem
? EXPAND_MEMORY
3241 : EXPAND_INITIALIZER
);
3243 /* Never pass a CONCAT to an ASM. */
3244 if (GET_CODE (op
) == CONCAT
)
3245 op
= force_reg (GET_MODE (op
), op
);
3246 else if (MEM_P (op
))
3247 op
= validize_mem (op
);
3249 if (asm_operand_ok (op
, constraint
, NULL
) <= 0)
3251 if (allows_reg
&& TYPE_MODE (type
) != BLKmode
)
3252 op
= force_reg (TYPE_MODE (type
), op
);
3253 else if (!allows_mem
)
3254 warning (0, "%<asm%> operand %d probably does not match "
3257 else if (MEM_P (op
))
3259 /* We won't recognize either volatile memory or memory
3260 with a queued address as available a memory_operand
3261 at this point. Ignore it: clearly this *is* a memory. */
3267 input_mode
[i
] = TYPE_MODE (type
);
3270 /* For in-out operands, copy output rtx to input rtx. */
3271 unsigned ninout
= inout_opnum
.length();
3272 for (i
= 0; i
< ninout
; i
++)
3274 int j
= inout_opnum
[i
];
3275 rtx o
= output_rvec
[j
];
3277 input_rvec
.safe_push (o
);
3278 input_mode
.safe_push (GET_MODE (o
));
3281 sprintf (buffer
, "%d", j
);
3282 constraints
.safe_push (ggc_strdup (buffer
));
3286 /* Sometimes we wish to automatically clobber registers across an asm.
3287 Case in point is when the i386 backend moved from cc0 to a hard reg --
3288 maintaining source-level compatibility means automatically clobbering
3289 the flags register. */
3290 rtx_insn
*after_md_seq
= NULL
;
3291 if (targetm
.md_asm_adjust
)
3292 after_md_seq
= targetm
.md_asm_adjust (output_rvec
, input_rvec
,
3293 constraints
, clobber_rvec
,
3296 /* Do not allow the hook to change the output and input count,
3297 lest it mess up the operand numbering. */
3298 gcc_assert (output_rvec
.length() == noutputs
);
3299 gcc_assert (input_rvec
.length() == ninputs
);
3300 gcc_assert (constraints
.length() == noutputs
+ ninputs
);
3302 /* But it certainly can adjust the clobbers. */
3303 unsigned nclobbers
= clobber_rvec
.length ();
3305 /* Third pass checks for easy conflicts. */
3306 /* ??? Why are we doing this on trees instead of rtx. */
3308 bool clobber_conflict_found
= 0;
3309 for (i
= 0; i
< noutputs
; ++i
)
3310 if (tree_conflicts_with_clobbers_p (output_tvec
[i
], &clobbered_regs
))
3311 clobber_conflict_found
= 1;
3312 for (i
= 0; i
< ninputs
- ninout
; ++i
)
3313 if (tree_conflicts_with_clobbers_p (input_tvec
[i
], &clobbered_regs
))
3314 clobber_conflict_found
= 1;
3316 /* Make vectors for the expression-rtx, constraint strings,
3317 and named operands. */
3319 rtvec argvec
= rtvec_alloc (ninputs
);
3320 rtvec constraintvec
= rtvec_alloc (ninputs
);
3321 rtvec labelvec
= rtvec_alloc (nlabels
);
3323 rtx body
= gen_rtx_ASM_OPERANDS ((noutputs
== 0 ? VOIDmode
3324 : GET_MODE (output_rvec
[0])),
3325 ggc_strdup (gimple_asm_string (stmt
)),
3326 "", 0, argvec
, constraintvec
,
3328 MEM_VOLATILE_P (body
) = gimple_asm_volatile_p (stmt
);
3330 for (i
= 0; i
< ninputs
; ++i
)
3332 ASM_OPERANDS_INPUT (body
, i
) = input_rvec
[i
];
3333 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body
, i
)
3334 = gen_rtx_ASM_INPUT_loc (input_mode
[i
],
3335 constraints
[i
+ noutputs
],
3339 /* Copy labels to the vector. */
3340 rtx_code_label
*fallthru_label
= NULL
;
3343 basic_block fallthru_bb
= NULL
;
3344 edge fallthru
= find_fallthru_edge (gimple_bb (stmt
)->succs
);
3346 fallthru_bb
= fallthru
->dest
;
3348 for (i
= 0; i
< nlabels
; ++i
)
3350 tree label
= TREE_VALUE (gimple_asm_label_op (stmt
, i
));
3352 /* If asm goto has any labels in the fallthru basic block, use
3353 a label that we emit immediately after the asm goto. Expansion
3354 may insert further instructions into the same basic block after
3355 asm goto and if we don't do this, insertion of instructions on
3356 the fallthru edge might misbehave. See PR58670. */
3357 if (fallthru_bb
&& label_to_block (cfun
, label
) == fallthru_bb
)
3359 if (fallthru_label
== NULL_RTX
)
3360 fallthru_label
= gen_label_rtx ();
3364 r
= label_rtx (label
);
3365 ASM_OPERANDS_LABEL (body
, i
) = gen_rtx_LABEL_REF (Pmode
, r
);
3369 /* Now, for each output, construct an rtx
3370 (set OUTPUT (asm_operands INSN OUTPUTCONSTRAINT OUTPUTNUMBER
3371 ARGVEC CONSTRAINTS OPNAMES))
3372 If there is more than one, put them inside a PARALLEL. */
3374 if (nlabels
> 0 && nclobbers
== 0)
3376 gcc_assert (noutputs
== 0);
3377 emit_jump_insn (body
);
3379 else if (noutputs
== 0 && nclobbers
== 0)
3381 /* No output operands: put in a raw ASM_OPERANDS rtx. */
3384 else if (noutputs
== 1 && nclobbers
== 0)
3386 ASM_OPERANDS_OUTPUT_CONSTRAINT (body
) = constraints
[0];
3387 emit_insn (gen_rtx_SET (output_rvec
[0], body
));
3397 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (num
+ nclobbers
));
3399 /* For each output operand, store a SET. */
3400 for (i
= 0; i
< noutputs
; ++i
)
3402 rtx src
, o
= output_rvec
[i
];
3405 ASM_OPERANDS_OUTPUT_CONSTRAINT (obody
) = constraints
[0];
3410 src
= gen_rtx_ASM_OPERANDS (GET_MODE (o
),
3411 ASM_OPERANDS_TEMPLATE (obody
),
3412 constraints
[i
], i
, argvec
,
3413 constraintvec
, labelvec
, locus
);
3414 MEM_VOLATILE_P (src
) = gimple_asm_volatile_p (stmt
);
3416 XVECEXP (body
, 0, i
) = gen_rtx_SET (o
, src
);
3419 /* If there are no outputs (but there are some clobbers)
3420 store the bare ASM_OPERANDS into the PARALLEL. */
3422 XVECEXP (body
, 0, i
++) = obody
;
3424 /* Store (clobber REG) for each clobbered register specified. */
3425 for (unsigned j
= 0; j
< nclobbers
; ++j
)
3427 rtx clobbered_reg
= clobber_rvec
[j
];
3429 /* Do sanity check for overlap between clobbers and respectively
3430 input and outputs that hasn't been handled. Such overlap
3431 should have been detected and reported above. */
3432 if (!clobber_conflict_found
&& REG_P (clobbered_reg
))
3434 /* We test the old body (obody) contents to avoid
3435 tripping over the under-construction body. */
3436 for (unsigned k
= 0; k
< noutputs
; ++k
)
3437 if (reg_overlap_mentioned_p (clobbered_reg
, output_rvec
[k
]))
3438 internal_error ("%<asm%> clobber conflict with "
3441 for (unsigned k
= 0; k
< ninputs
- ninout
; ++k
)
3442 if (reg_overlap_mentioned_p (clobbered_reg
, input_rvec
[k
]))
3443 internal_error ("%<asm%> clobber conflict with "
3447 XVECEXP (body
, 0, i
++) = gen_rtx_CLOBBER (VOIDmode
, clobbered_reg
);
3451 emit_jump_insn (body
);
3456 generating_concat_p
= old_generating_concat_p
;
3459 emit_label (fallthru_label
);
3462 emit_insn (after_md_seq
);
3464 emit_insn (after_rtl_seq
);
3467 crtl
->has_asm_statement
= 1;
3470 /* Emit code to jump to the address
3471 specified by the pointer expression EXP. */
3474 expand_computed_goto (tree exp
)
3476 rtx x
= expand_normal (exp
);
3478 do_pending_stack_adjust ();
3479 emit_indirect_jump (x
);
3482 /* Generate RTL code for a `goto' statement with target label LABEL.
3483 LABEL should be a LABEL_DECL tree node that was or will later be
3484 defined with `expand_label'. */
3487 expand_goto (tree label
)
3491 /* Check for a nonlocal goto to a containing function. Should have
3492 gotten translated to __builtin_nonlocal_goto. */
3493 tree context
= decl_function_context (label
);
3494 gcc_assert (!context
|| context
== current_function_decl
);
3497 emit_jump (jump_target_rtx (label
));
3500 /* Output a return with no value. */
3503 expand_null_return_1 (void)
3505 clear_pending_stack_adjust ();
3506 do_pending_stack_adjust ();
3507 emit_jump (return_label
);
3510 /* Generate RTL to return from the current function, with no value.
3511 (That is, we do not do anything about returning any value.) */
3514 expand_null_return (void)
3516 /* If this function was declared to return a value, but we
3517 didn't, clobber the return registers so that they are not
3518 propagated live to the rest of the function. */
3519 clobber_return_register ();
3521 expand_null_return_1 ();
3524 /* Generate RTL to return from the current function, with value VAL. */
3527 expand_value_return (rtx val
)
3529 /* Copy the value to the return location unless it's already there. */
3531 tree decl
= DECL_RESULT (current_function_decl
);
3532 rtx return_reg
= DECL_RTL (decl
);
3533 if (return_reg
!= val
)
3535 tree funtype
= TREE_TYPE (current_function_decl
);
3536 tree type
= TREE_TYPE (decl
);
3537 int unsignedp
= TYPE_UNSIGNED (type
);
3538 machine_mode old_mode
= DECL_MODE (decl
);
3540 if (DECL_BY_REFERENCE (decl
))
3541 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 2);
3543 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 1);
3545 if (mode
!= old_mode
)
3546 val
= convert_modes (mode
, old_mode
, val
, unsignedp
);
3548 if (GET_CODE (return_reg
) == PARALLEL
)
3549 emit_group_load (return_reg
, val
, type
, int_size_in_bytes (type
));
3551 emit_move_insn (return_reg
, val
);
3554 expand_null_return_1 ();
3557 /* Generate RTL to evaluate the expression RETVAL and return it
3558 from the current function. */
3561 expand_return (tree retval
)
3567 /* If function wants no value, give it none. */
3568 if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl
))) == VOID_TYPE
)
3570 expand_normal (retval
);
3571 expand_null_return ();
3575 if (retval
== error_mark_node
)
3577 /* Treat this like a return of no value from a function that
3579 expand_null_return ();
3582 else if ((TREE_CODE (retval
) == MODIFY_EXPR
3583 || TREE_CODE (retval
) == INIT_EXPR
)
3584 && TREE_CODE (TREE_OPERAND (retval
, 0)) == RESULT_DECL
)
3585 retval_rhs
= TREE_OPERAND (retval
, 1);
3587 retval_rhs
= retval
;
3589 result_rtl
= DECL_RTL (DECL_RESULT (current_function_decl
));
3591 /* If we are returning the RESULT_DECL, then the value has already
3592 been stored into it, so we don't have to do anything special. */
3593 if (TREE_CODE (retval_rhs
) == RESULT_DECL
)
3594 expand_value_return (result_rtl
);
3596 /* If the result is an aggregate that is being returned in one (or more)
3597 registers, load the registers here. */
3599 else if (retval_rhs
!= 0
3600 && TYPE_MODE (TREE_TYPE (retval_rhs
)) == BLKmode
3601 && REG_P (result_rtl
))
3603 val
= copy_blkmode_to_reg (GET_MODE (result_rtl
), retval_rhs
);
3606 /* Use the mode of the result value on the return register. */
3607 PUT_MODE (result_rtl
, GET_MODE (val
));
3608 expand_value_return (val
);
3611 expand_null_return ();
3613 else if (retval_rhs
!= 0
3614 && !VOID_TYPE_P (TREE_TYPE (retval_rhs
))
3615 && (REG_P (result_rtl
)
3616 || (GET_CODE (result_rtl
) == PARALLEL
)))
3618 /* Compute the return value into a temporary (usually a pseudo reg). */
3620 = assign_temp (TREE_TYPE (DECL_RESULT (current_function_decl
)), 0, 1);
3621 val
= expand_expr (retval_rhs
, val
, GET_MODE (val
), EXPAND_NORMAL
);
3622 val
= force_not_mem (val
);
3623 expand_value_return (val
);
3627 /* No hard reg used; calculate value into hard return reg. */
3628 expand_expr (retval
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3629 expand_value_return (result_rtl
);
3633 /* Expand a clobber of LHS. If LHS is stored it in a multi-part
3634 register, tell the rtl optimizers that its value is no longer
3638 expand_clobber (tree lhs
)
3642 rtx decl_rtl
= DECL_RTL_IF_SET (lhs
);
3643 if (decl_rtl
&& REG_P (decl_rtl
))
3645 machine_mode decl_mode
= GET_MODE (decl_rtl
);
3646 if (maybe_gt (GET_MODE_SIZE (decl_mode
),
3647 REGMODE_NATURAL_SIZE (decl_mode
)))
3648 emit_clobber (decl_rtl
);
3653 /* A subroutine of expand_gimple_stmt, expanding one gimple statement
3654 STMT that doesn't require special handling for outgoing edges. That
3655 is no tailcalls and no GIMPLE_COND. */
3658 expand_gimple_stmt_1 (gimple
*stmt
)
3662 set_curr_insn_location (gimple_location (stmt
));
3664 switch (gimple_code (stmt
))
3667 op0
= gimple_goto_dest (stmt
);
3668 if (TREE_CODE (op0
) == LABEL_DECL
)
3671 expand_computed_goto (op0
);
3674 expand_label (gimple_label_label (as_a
<glabel
*> (stmt
)));
3677 case GIMPLE_PREDICT
:
3681 gswitch
*swtch
= as_a
<gswitch
*> (stmt
);
3682 if (gimple_switch_num_labels (swtch
) == 1)
3683 expand_goto (CASE_LABEL (gimple_switch_default_label (swtch
)));
3685 expand_case (swtch
);
3689 expand_asm_stmt (as_a
<gasm
*> (stmt
));
3692 expand_call_stmt (as_a
<gcall
*> (stmt
));
3697 op0
= gimple_return_retval (as_a
<greturn
*> (stmt
));
3699 /* If a return doesn't have a location, it very likely represents
3700 multiple user returns so we cannot let it inherit the location
3701 of the last statement of the previous basic block in RTL. */
3702 if (!gimple_has_location (stmt
))
3703 set_curr_insn_location (cfun
->function_end_locus
);
3705 if (op0
&& op0
!= error_mark_node
)
3707 tree result
= DECL_RESULT (current_function_decl
);
3709 /* If we are not returning the current function's RESULT_DECL,
3710 build an assignment to it. */
3713 /* I believe that a function's RESULT_DECL is unique. */
3714 gcc_assert (TREE_CODE (op0
) != RESULT_DECL
);
3716 /* ??? We'd like to use simply expand_assignment here,
3717 but this fails if the value is of BLKmode but the return
3718 decl is a register. expand_return has special handling
3719 for this combination, which eventually should move
3720 to common code. See comments there. Until then, let's
3721 build a modify expression :-/ */
3722 op0
= build2 (MODIFY_EXPR
, TREE_TYPE (result
),
3728 expand_null_return ();
3730 expand_return (op0
);
3736 gassign
*assign_stmt
= as_a
<gassign
*> (stmt
);
3737 tree lhs
= gimple_assign_lhs (assign_stmt
);
3739 /* Tree expand used to fiddle with |= and &= of two bitfield
3740 COMPONENT_REFs here. This can't happen with gimple, the LHS
3741 of binary assigns must be a gimple reg. */
3743 if (TREE_CODE (lhs
) != SSA_NAME
3744 || get_gimple_rhs_class (gimple_expr_code (stmt
))
3745 == GIMPLE_SINGLE_RHS
)
3747 tree rhs
= gimple_assign_rhs1 (assign_stmt
);
3748 gcc_assert (get_gimple_rhs_class (gimple_expr_code (stmt
))
3749 == GIMPLE_SINGLE_RHS
);
3750 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (rhs
)
3751 /* Do not put locations on possibly shared trees. */
3752 && !is_gimple_min_invariant (rhs
))
3753 SET_EXPR_LOCATION (rhs
, gimple_location (stmt
));
3754 if (TREE_CLOBBER_P (rhs
))
3755 /* This is a clobber to mark the going out of scope for
3757 expand_clobber (lhs
);
3759 expand_assignment (lhs
, rhs
,
3760 gimple_assign_nontemporal_move_p (
3766 bool nontemporal
= gimple_assign_nontemporal_move_p (assign_stmt
);
3767 struct separate_ops ops
;
3768 bool promoted
= false;
3770 target
= expand_expr (lhs
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
3771 if (GET_CODE (target
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (target
))
3774 ops
.code
= gimple_assign_rhs_code (assign_stmt
);
3775 ops
.type
= TREE_TYPE (lhs
);
3776 switch (get_gimple_rhs_class (ops
.code
))
3778 case GIMPLE_TERNARY_RHS
:
3779 ops
.op2
= gimple_assign_rhs3 (assign_stmt
);
3781 case GIMPLE_BINARY_RHS
:
3782 ops
.op1
= gimple_assign_rhs2 (assign_stmt
);
3784 case GIMPLE_UNARY_RHS
:
3785 ops
.op0
= gimple_assign_rhs1 (assign_stmt
);
3790 ops
.location
= gimple_location (stmt
);
3792 /* If we want to use a nontemporal store, force the value to
3793 register first. If we store into a promoted register,
3794 don't directly expand to target. */
3795 temp
= nontemporal
|| promoted
? NULL_RTX
: target
;
3796 temp
= expand_expr_real_2 (&ops
, temp
, GET_MODE (target
),
3803 int unsignedp
= SUBREG_PROMOTED_SIGN (target
);
3804 /* If TEMP is a VOIDmode constant, use convert_modes to make
3805 sure that we properly convert it. */
3806 if (CONSTANT_P (temp
) && GET_MODE (temp
) == VOIDmode
)
3808 temp
= convert_modes (GET_MODE (target
),
3809 TYPE_MODE (ops
.type
),
3811 temp
= convert_modes (GET_MODE (SUBREG_REG (target
)),
3812 GET_MODE (target
), temp
, unsignedp
);
3815 convert_move (SUBREG_REG (target
), temp
, unsignedp
);
3817 else if (nontemporal
&& emit_storent_insn (target
, temp
))
3821 temp
= force_operand (temp
, target
);
3823 emit_move_insn (target
, temp
);
3834 /* Expand one gimple statement STMT and return the last RTL instruction
3835 before any of the newly generated ones.
3837 In addition to generating the necessary RTL instructions this also
3838 sets REG_EH_REGION notes if necessary and sets the current source
3839 location for diagnostics. */
3842 expand_gimple_stmt (gimple
*stmt
)
3844 location_t saved_location
= input_location
;
3845 rtx_insn
*last
= get_last_insn ();
3850 /* We need to save and restore the current source location so that errors
3851 discovered during expansion are emitted with the right location. But
3852 it would be better if the diagnostic routines used the source location
3853 embedded in the tree nodes rather than globals. */
3854 if (gimple_has_location (stmt
))
3855 input_location
= gimple_location (stmt
);
3857 expand_gimple_stmt_1 (stmt
);
3859 /* Free any temporaries used to evaluate this statement. */
3862 input_location
= saved_location
;
3864 /* Mark all insns that may trap. */
3865 lp_nr
= lookup_stmt_eh_lp (stmt
);
3869 for (insn
= next_real_insn (last
); insn
;
3870 insn
= next_real_insn (insn
))
3872 if (! find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
3873 /* If we want exceptions for non-call insns, any
3874 may_trap_p instruction may throw. */
3875 && GET_CODE (PATTERN (insn
)) != CLOBBER
3876 && GET_CODE (PATTERN (insn
)) != USE
3877 && insn_could_throw_p (insn
))
3878 make_reg_eh_region_note (insn
, 0, lp_nr
);
3885 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_CALL
3886 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
3887 generated a tail call (something that might be denied by the ABI
3888 rules governing the call; see calls.c).
3890 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
3891 can still reach the rest of BB. The case here is __builtin_sqrt,
3892 where the NaN result goes through the external function (with a
3893 tailcall) and the normal result happens via a sqrt instruction. */
3896 expand_gimple_tailcall (basic_block bb
, gcall
*stmt
, bool *can_fallthru
)
3898 rtx_insn
*last2
, *last
;
3901 profile_probability probability
;
3903 last2
= last
= expand_gimple_stmt (stmt
);
3905 for (last
= NEXT_INSN (last
); last
; last
= NEXT_INSN (last
))
3906 if (CALL_P (last
) && SIBLING_CALL_P (last
))
3909 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
3911 *can_fallthru
= true;
3915 /* ??? Wouldn't it be better to just reset any pending stack adjust?
3916 Any instructions emitted here are about to be deleted. */
3917 do_pending_stack_adjust ();
3919 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
3920 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
3921 EH or abnormal edges, we shouldn't have created a tail call in
3922 the first place. So it seems to me we should just be removing
3923 all edges here, or redirecting the existing fallthru edge to
3926 probability
= profile_probability::never ();
3928 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
3930 if (!(e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
)))
3932 if (e
->dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
3933 e
->dest
->count
-= e
->count ();
3934 probability
+= e
->probability
;
3941 /* This is somewhat ugly: the call_expr expander often emits instructions
3942 after the sibcall (to perform the function return). These confuse the
3943 find_many_sub_basic_blocks code, so we need to get rid of these. */
3944 last
= NEXT_INSN (last
);
3945 gcc_assert (BARRIER_P (last
));
3947 *can_fallthru
= false;
3948 while (NEXT_INSN (last
))
3950 /* For instance an sqrt builtin expander expands if with
3951 sibcall in the then and label for `else`. */
3952 if (LABEL_P (NEXT_INSN (last
)))
3954 *can_fallthru
= true;
3957 delete_insn (NEXT_INSN (last
));
3960 e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_ABNORMAL
3962 e
->probability
= probability
;
3964 update_bb_for_insn (bb
);
3966 if (NEXT_INSN (last
))
3968 bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
3971 if (BARRIER_P (last
))
3972 BB_END (bb
) = PREV_INSN (last
);
3975 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
3980 /* Return the difference between the floor and the truncated result of
3981 a signed division by OP1 with remainder MOD. */
3983 floor_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3985 /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
3986 return gen_rtx_IF_THEN_ELSE
3987 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3988 gen_rtx_IF_THEN_ELSE
3989 (mode
, gen_rtx_LT (BImode
,
3990 gen_rtx_DIV (mode
, op1
, mod
),
3992 constm1_rtx
, const0_rtx
),
3996 /* Return the difference between the ceil and the truncated result of
3997 a signed division by OP1 with remainder MOD. */
3999 ceil_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
4001 /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
4002 return gen_rtx_IF_THEN_ELSE
4003 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
4004 gen_rtx_IF_THEN_ELSE
4005 (mode
, gen_rtx_GT (BImode
,
4006 gen_rtx_DIV (mode
, op1
, mod
),
4008 const1_rtx
, const0_rtx
),
4012 /* Return the difference between the ceil and the truncated result of
4013 an unsigned division by OP1 with remainder MOD. */
4015 ceil_udiv_adjust (machine_mode mode
, rtx mod
, rtx op1 ATTRIBUTE_UNUSED
)
4017 /* (mod != 0 ? 1 : 0) */
4018 return gen_rtx_IF_THEN_ELSE
4019 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
4020 const1_rtx
, const0_rtx
);
4023 /* Return the difference between the rounded and the truncated result
4024 of a signed division by OP1 with remainder MOD. Halfway cases are
4025 rounded away from zero, rather than to the nearest even number. */
4027 round_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
4029 /* (abs (mod) >= abs (op1) - abs (mod)
4030 ? (op1 / mod > 0 ? 1 : -1)
4032 return gen_rtx_IF_THEN_ELSE
4033 (mode
, gen_rtx_GE (BImode
, gen_rtx_ABS (mode
, mod
),
4034 gen_rtx_MINUS (mode
,
4035 gen_rtx_ABS (mode
, op1
),
4036 gen_rtx_ABS (mode
, mod
))),
4037 gen_rtx_IF_THEN_ELSE
4038 (mode
, gen_rtx_GT (BImode
,
4039 gen_rtx_DIV (mode
, op1
, mod
),
4041 const1_rtx
, constm1_rtx
),
4045 /* Return the difference between the rounded and the truncated result
4046 of a unsigned division by OP1 with remainder MOD. Halfway cases
4047 are rounded away from zero, rather than to the nearest even
4050 round_udiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
4052 /* (mod >= op1 - mod ? 1 : 0) */
4053 return gen_rtx_IF_THEN_ELSE
4054 (mode
, gen_rtx_GE (BImode
, mod
,
4055 gen_rtx_MINUS (mode
, op1
, mod
)),
4056 const1_rtx
, const0_rtx
);
4059 /* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
4063 convert_debug_memory_address (scalar_int_mode mode
, rtx x
,
4066 #ifndef POINTERS_EXTEND_UNSIGNED
4067 gcc_assert (mode
== Pmode
4068 || mode
== targetm
.addr_space
.address_mode (as
));
4069 gcc_assert (GET_MODE (x
) == mode
|| GET_MODE (x
) == VOIDmode
);
4073 gcc_assert (targetm
.addr_space
.valid_pointer_mode (mode
, as
));
4075 if (GET_MODE (x
) == mode
|| GET_MODE (x
) == VOIDmode
)
4078 /* X must have some form of address mode already. */
4079 scalar_int_mode xmode
= as_a
<scalar_int_mode
> (GET_MODE (x
));
4080 if (GET_MODE_PRECISION (mode
) < GET_MODE_PRECISION (xmode
))
4081 x
= lowpart_subreg (mode
, x
, xmode
);
4082 else if (POINTERS_EXTEND_UNSIGNED
> 0)
4083 x
= gen_rtx_ZERO_EXTEND (mode
, x
);
4084 else if (!POINTERS_EXTEND_UNSIGNED
)
4085 x
= gen_rtx_SIGN_EXTEND (mode
, x
);
4088 switch (GET_CODE (x
))
4091 if ((SUBREG_PROMOTED_VAR_P (x
)
4092 || (REG_P (SUBREG_REG (x
)) && REG_POINTER (SUBREG_REG (x
)))
4093 || (GET_CODE (SUBREG_REG (x
)) == PLUS
4094 && REG_P (XEXP (SUBREG_REG (x
), 0))
4095 && REG_POINTER (XEXP (SUBREG_REG (x
), 0))
4096 && CONST_INT_P (XEXP (SUBREG_REG (x
), 1))))
4097 && GET_MODE (SUBREG_REG (x
)) == mode
)
4098 return SUBREG_REG (x
);
4101 temp
= gen_rtx_LABEL_REF (mode
, label_ref_label (x
));
4102 LABEL_REF_NONLOCAL_P (temp
) = LABEL_REF_NONLOCAL_P (x
);
4105 temp
= shallow_copy_rtx (x
);
4106 PUT_MODE (temp
, mode
);
4109 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
4111 temp
= gen_rtx_CONST (mode
, temp
);
4115 if (CONST_INT_P (XEXP (x
, 1)))
4117 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
4119 return gen_rtx_fmt_ee (GET_CODE (x
), mode
, temp
, XEXP (x
, 1));
4125 /* Don't know how to express ptr_extend as operation in debug info. */
4128 #endif /* POINTERS_EXTEND_UNSIGNED */
4133 /* Map from SSA_NAMEs to corresponding DEBUG_EXPR_DECLs created
4134 by avoid_deep_ter_for_debug. */
4136 static hash_map
<tree
, tree
> *deep_ter_debug_map
;
4138 /* Split too deep TER chains for debug stmts using debug temporaries. */
4141 avoid_deep_ter_for_debug (gimple
*stmt
, int depth
)
4143 use_operand_p use_p
;
4145 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
4147 tree use
= USE_FROM_PTR (use_p
);
4148 if (TREE_CODE (use
) != SSA_NAME
|| SSA_NAME_IS_DEFAULT_DEF (use
))
4150 gimple
*g
= get_gimple_for_ssa_name (use
);
4153 if (depth
> 6 && !stmt_ends_bb_p (g
))
4155 if (deep_ter_debug_map
== NULL
)
4156 deep_ter_debug_map
= new hash_map
<tree
, tree
>;
4158 tree
&vexpr
= deep_ter_debug_map
->get_or_insert (use
);
4161 vexpr
= make_node (DEBUG_EXPR_DECL
);
4162 gimple
*def_temp
= gimple_build_debug_bind (vexpr
, use
, g
);
4163 DECL_ARTIFICIAL (vexpr
) = 1;
4164 TREE_TYPE (vexpr
) = TREE_TYPE (use
);
4165 SET_DECL_MODE (vexpr
, TYPE_MODE (TREE_TYPE (use
)));
4166 gimple_stmt_iterator gsi
= gsi_for_stmt (g
);
4167 gsi_insert_after (&gsi
, def_temp
, GSI_NEW_STMT
);
4168 avoid_deep_ter_for_debug (def_temp
, 0);
4171 avoid_deep_ter_for_debug (g
, depth
+ 1);
4175 /* Return an RTX equivalent to the value of the parameter DECL. */
4178 expand_debug_parm_decl (tree decl
)
4180 rtx incoming
= DECL_INCOMING_RTL (decl
);
4183 && GET_MODE (incoming
) != BLKmode
4184 && ((REG_P (incoming
) && HARD_REGISTER_P (incoming
))
4185 || (MEM_P (incoming
)
4186 && REG_P (XEXP (incoming
, 0))
4187 && HARD_REGISTER_P (XEXP (incoming
, 0)))))
4189 rtx rtl
= gen_rtx_ENTRY_VALUE (GET_MODE (incoming
));
4191 #ifdef HAVE_window_save
4192 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
4193 If the target machine has an explicit window save instruction, the
4194 actual entry value is the corresponding OUTGOING_REGNO instead. */
4195 if (REG_P (incoming
)
4196 && OUTGOING_REGNO (REGNO (incoming
)) != REGNO (incoming
))
4198 = gen_rtx_REG_offset (incoming
, GET_MODE (incoming
),
4199 OUTGOING_REGNO (REGNO (incoming
)), 0);
4200 else if (MEM_P (incoming
))
4202 rtx reg
= XEXP (incoming
, 0);
4203 if (OUTGOING_REGNO (REGNO (reg
)) != REGNO (reg
))
4205 reg
= gen_raw_REG (GET_MODE (reg
), OUTGOING_REGNO (REGNO (reg
)));
4206 incoming
= replace_equiv_address_nv (incoming
, reg
);
4209 incoming
= copy_rtx (incoming
);
4213 ENTRY_VALUE_EXP (rtl
) = incoming
;
4218 && GET_MODE (incoming
) != BLKmode
4219 && !TREE_ADDRESSABLE (decl
)
4221 && (XEXP (incoming
, 0) == virtual_incoming_args_rtx
4222 || (GET_CODE (XEXP (incoming
, 0)) == PLUS
4223 && XEXP (XEXP (incoming
, 0), 0) == virtual_incoming_args_rtx
4224 && CONST_INT_P (XEXP (XEXP (incoming
, 0), 1)))))
4225 return copy_rtx (incoming
);
4230 /* Return an RTX equivalent to the value of the tree expression EXP. */
4233 expand_debug_expr (tree exp
)
4235 rtx op0
= NULL_RTX
, op1
= NULL_RTX
, op2
= NULL_RTX
;
4236 machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
4237 machine_mode inner_mode
= VOIDmode
;
4238 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (exp
));
4240 scalar_int_mode op0_mode
, op1_mode
, addr_mode
;
4242 switch (TREE_CODE_CLASS (TREE_CODE (exp
)))
4244 case tcc_expression
:
4245 switch (TREE_CODE (exp
))
4250 case WIDEN_MULT_PLUS_EXPR
:
4251 case WIDEN_MULT_MINUS_EXPR
:
4254 case TRUTH_ANDIF_EXPR
:
4255 case TRUTH_ORIF_EXPR
:
4256 case TRUTH_AND_EXPR
:
4258 case TRUTH_XOR_EXPR
:
4261 case TRUTH_NOT_EXPR
:
4270 op2
= expand_debug_expr (TREE_OPERAND (exp
, 2));
4277 if (mode
== BLKmode
)
4279 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
4282 switch (TREE_CODE (exp
))
4288 case WIDEN_LSHIFT_EXPR
:
4289 /* Ensure second operand isn't wider than the first one. */
4290 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 1)));
4291 if (is_a
<scalar_int_mode
> (inner_mode
, &op1_mode
)
4292 && (GET_MODE_UNIT_PRECISION (mode
)
4293 < GET_MODE_PRECISION (op1_mode
)))
4294 op1
= lowpart_subreg (GET_MODE_INNER (mode
), op1
, op1_mode
);
4303 if (mode
== BLKmode
)
4305 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4306 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4311 case tcc_comparison
:
4312 unsignedp
= TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4320 case tcc_exceptional
:
4321 case tcc_declaration
:
4327 switch (TREE_CODE (exp
))
4330 if (!lookup_constant_def (exp
))
4332 if (strlen (TREE_STRING_POINTER (exp
)) + 1
4333 != (size_t) TREE_STRING_LENGTH (exp
))
4335 op0
= gen_rtx_CONST_STRING (Pmode
, TREE_STRING_POINTER (exp
));
4336 op0
= gen_rtx_MEM (BLKmode
, op0
);
4337 set_mem_attributes (op0
, exp
, 0);
4345 op0
= expand_expr (exp
, NULL_RTX
, mode
, EXPAND_INITIALIZER
);
4349 return immed_wide_int_const (poly_int_cst_value (exp
), mode
);
4352 gcc_assert (COMPLEX_MODE_P (mode
));
4353 op0
= expand_debug_expr (TREE_REALPART (exp
));
4354 op1
= expand_debug_expr (TREE_IMAGPART (exp
));
4355 return gen_rtx_CONCAT (mode
, op0
, op1
);
4357 case DEBUG_EXPR_DECL
:
4358 op0
= DECL_RTL_IF_SET (exp
);
4363 op0
= gen_rtx_DEBUG_EXPR (mode
);
4364 DEBUG_EXPR_TREE_DECL (op0
) = exp
;
4365 SET_DECL_RTL (exp
, op0
);
4375 op0
= DECL_RTL_IF_SET (exp
);
4377 /* This decl was probably optimized away. */
4379 /* At least label RTXen are sometimes replaced by
4380 NOTE_INSN_DELETED_LABEL. Any notes here are not
4381 handled by copy_rtx. */
4385 || DECL_EXTERNAL (exp
)
4386 || !TREE_STATIC (exp
)
4388 || DECL_HARD_REGISTER (exp
)
4389 || DECL_IN_CONSTANT_POOL (exp
)
4390 || mode
== VOIDmode
)
4393 op0
= make_decl_rtl_for_debug (exp
);
4395 || GET_CODE (XEXP (op0
, 0)) != SYMBOL_REF
4396 || SYMBOL_REF_DECL (XEXP (op0
, 0)) != exp
)
4400 op0
= copy_rtx (op0
);
4402 if (GET_MODE (op0
) == BLKmode
4403 /* If op0 is not BLKmode, but mode is, adjust_mode
4404 below would ICE. While it is likely a FE bug,
4405 try to be robust here. See PR43166. */
4407 || (mode
== VOIDmode
&& GET_MODE (op0
) != VOIDmode
))
4409 gcc_assert (MEM_P (op0
));
4410 op0
= adjust_address_nv (op0
, mode
, 0);
4420 inner_mode
= GET_MODE (op0
);
4422 if (mode
== inner_mode
)
4425 if (inner_mode
== VOIDmode
)
4427 if (TREE_CODE (exp
) == SSA_NAME
)
4428 inner_mode
= TYPE_MODE (TREE_TYPE (exp
));
4430 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4431 if (mode
== inner_mode
)
4435 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
4437 if (GET_MODE_UNIT_BITSIZE (mode
)
4438 == GET_MODE_UNIT_BITSIZE (inner_mode
))
4439 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
4440 else if (GET_MODE_UNIT_BITSIZE (mode
)
4441 < GET_MODE_UNIT_BITSIZE (inner_mode
))
4442 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
4444 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
4446 else if (FLOAT_MODE_P (mode
))
4448 gcc_assert (TREE_CODE (exp
) != SSA_NAME
);
4449 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
4450 op0
= simplify_gen_unary (UNSIGNED_FLOAT
, mode
, op0
, inner_mode
);
4452 op0
= simplify_gen_unary (FLOAT
, mode
, op0
, inner_mode
);
4454 else if (FLOAT_MODE_P (inner_mode
))
4457 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
4459 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
4461 else if (GET_MODE_UNIT_PRECISION (mode
)
4462 == GET_MODE_UNIT_PRECISION (inner_mode
))
4463 op0
= lowpart_subreg (mode
, op0
, inner_mode
);
4464 else if (GET_MODE_UNIT_PRECISION (mode
)
4465 < GET_MODE_UNIT_PRECISION (inner_mode
))
4466 op0
= simplify_gen_unary (TRUNCATE
, mode
, op0
, inner_mode
);
4467 else if (UNARY_CLASS_P (exp
)
4468 ? TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)))
4470 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
4472 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
4478 if (!is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
4480 tree newexp
= fold_binary (MEM_REF
, TREE_TYPE (exp
),
4481 TREE_OPERAND (exp
, 0),
4482 TREE_OPERAND (exp
, 1));
4484 return expand_debug_expr (newexp
);
4488 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4489 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4493 if (TREE_CODE (exp
) == MEM_REF
)
4495 if (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
4496 || (GET_CODE (op0
) == PLUS
4497 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
))
4498 /* (mem (debug_implicit_ptr)) might confuse aliasing.
4499 Instead just use get_inner_reference. */
4502 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
4504 if (!op1
|| !poly_int_rtx_p (op1
, &offset
))
4507 op0
= plus_constant (inner_mode
, op0
, offset
);
4510 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))));
4512 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
4514 if (op0
== NULL_RTX
)
4517 op0
= gen_rtx_MEM (mode
, op0
);
4518 set_mem_attributes (op0
, exp
, 0);
4519 if (TREE_CODE (exp
) == MEM_REF
4520 && !is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
4521 set_mem_expr (op0
, NULL_TREE
);
4522 set_mem_addr_space (op0
, as
);
4526 case TARGET_MEM_REF
:
4527 if (TREE_CODE (TMR_BASE (exp
)) == ADDR_EXPR
4528 && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp
), 0)))
4531 op0
= expand_debug_expr
4532 (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp
)), exp
));
4536 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))));
4537 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
4539 if (op0
== NULL_RTX
)
4542 op0
= gen_rtx_MEM (mode
, op0
);
4544 set_mem_attributes (op0
, exp
, 0);
4545 set_mem_addr_space (op0
, as
);
4551 case ARRAY_RANGE_REF
:
4556 case VIEW_CONVERT_EXPR
:
4559 poly_int64 bitsize
, bitpos
;
4561 int reversep
, volatilep
= 0;
4563 = get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
, &mode1
,
4564 &unsignedp
, &reversep
, &volatilep
);
4567 if (known_eq (bitsize
, 0))
4570 orig_op0
= op0
= expand_debug_expr (tem
);
4577 machine_mode addrmode
, offmode
;
4582 op0
= XEXP (op0
, 0);
4583 addrmode
= GET_MODE (op0
);
4584 if (addrmode
== VOIDmode
)
4587 op1
= expand_debug_expr (offset
);
4591 offmode
= GET_MODE (op1
);
4592 if (offmode
== VOIDmode
)
4593 offmode
= TYPE_MODE (TREE_TYPE (offset
));
4595 if (addrmode
!= offmode
)
4596 op1
= lowpart_subreg (addrmode
, op1
, offmode
);
4598 /* Don't use offset_address here, we don't need a
4599 recognizable address, and we don't want to generate
4601 op0
= gen_rtx_MEM (mode
, simplify_gen_binary (PLUS
, addrmode
,
4607 if (mode1
== VOIDmode
)
4609 if (maybe_gt (bitsize
, MAX_BITSIZE_MODE_ANY_INT
))
4612 mode1
= smallest_int_mode_for_size (bitsize
);
4614 poly_int64 bytepos
= bits_to_bytes_round_down (bitpos
);
4615 if (maybe_ne (bytepos
, 0))
4617 op0
= adjust_address_nv (op0
, mode1
, bytepos
);
4618 bitpos
= num_trailing_bits (bitpos
);
4620 else if (known_eq (bitpos
, 0)
4621 && known_eq (bitsize
, GET_MODE_BITSIZE (mode
)))
4622 op0
= adjust_address_nv (op0
, mode
, 0);
4623 else if (GET_MODE (op0
) != mode1
)
4624 op0
= adjust_address_nv (op0
, mode1
, 0);
4626 op0
= copy_rtx (op0
);
4627 if (op0
== orig_op0
)
4628 op0
= shallow_copy_rtx (op0
);
4629 if (TREE_CODE (tem
) != SSA_NAME
)
4630 set_mem_attributes (op0
, exp
, 0);
4633 if (known_eq (bitpos
, 0) && mode
== GET_MODE (op0
))
4636 if (maybe_lt (bitpos
, 0))
4639 if (GET_MODE (op0
) == BLKmode
|| mode
== BLKmode
)
4643 if (multiple_p (bitpos
, BITS_PER_UNIT
, &bytepos
)
4644 && known_eq (bitsize
, GET_MODE_BITSIZE (mode1
)))
4646 machine_mode opmode
= GET_MODE (op0
);
4648 if (opmode
== VOIDmode
)
4649 opmode
= TYPE_MODE (TREE_TYPE (tem
));
4651 /* This condition may hold if we're expanding the address
4652 right past the end of an array that turned out not to
4653 be addressable (i.e., the address was only computed in
4654 debug stmts). The gen_subreg below would rightfully
4655 crash, and the address doesn't really exist, so just
4657 if (known_ge (bitpos
, GET_MODE_BITSIZE (opmode
)))
4660 if (multiple_p (bitpos
, GET_MODE_BITSIZE (mode
)))
4661 return simplify_gen_subreg (mode
, op0
, opmode
, bytepos
);
4664 return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0
))
4665 && TYPE_UNSIGNED (TREE_TYPE (exp
))
4667 : ZERO_EXTRACT
, mode
,
4668 GET_MODE (op0
) != VOIDmode
4670 : TYPE_MODE (TREE_TYPE (tem
)),
4671 op0
, gen_int_mode (bitsize
, word_mode
),
4672 gen_int_mode (bitpos
, word_mode
));
4677 return simplify_gen_unary (ABS
, mode
, op0
, mode
);
4680 return simplify_gen_unary (NEG
, mode
, op0
, mode
);
4683 return simplify_gen_unary (NOT
, mode
, op0
, mode
);
4686 return simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4688 ? UNSIGNED_FLOAT
: FLOAT
, mode
, op0
,
4691 case FIX_TRUNC_EXPR
:
4692 return simplify_gen_unary (unsignedp
? UNSIGNED_FIX
: FIX
, mode
, op0
,
4695 case POINTER_PLUS_EXPR
:
4696 /* For the rare target where pointers are not the same size as
4697 size_t, we need to check for mis-matched modes and correct
4700 && is_a
<scalar_int_mode
> (GET_MODE (op0
), &op0_mode
)
4701 && is_a
<scalar_int_mode
> (GET_MODE (op1
), &op1_mode
)
4702 && op0_mode
!= op1_mode
)
4704 if (GET_MODE_BITSIZE (op0_mode
) < GET_MODE_BITSIZE (op1_mode
)
4705 /* If OP0 is a partial mode, then we must truncate, even
4706 if it has the same bitsize as OP1 as GCC's
4707 representation of partial modes is opaque. */
4708 || (GET_MODE_CLASS (op0_mode
) == MODE_PARTIAL_INT
4709 && (GET_MODE_BITSIZE (op0_mode
)
4710 == GET_MODE_BITSIZE (op1_mode
))))
4711 op1
= simplify_gen_unary (TRUNCATE
, op0_mode
, op1
, op1_mode
);
4713 /* We always sign-extend, regardless of the signedness of
4714 the operand, because the operand is always unsigned
4715 here even if the original C expression is signed. */
4716 op1
= simplify_gen_unary (SIGN_EXTEND
, op0_mode
, op1
, op1_mode
);
4720 return simplify_gen_binary (PLUS
, mode
, op0
, op1
);
4723 case POINTER_DIFF_EXPR
:
4724 return simplify_gen_binary (MINUS
, mode
, op0
, op1
);
4727 return simplify_gen_binary (MULT
, mode
, op0
, op1
);
4730 case TRUNC_DIV_EXPR
:
4731 case EXACT_DIV_EXPR
:
4733 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4735 return simplify_gen_binary (DIV
, mode
, op0
, op1
);
4737 case TRUNC_MOD_EXPR
:
4738 return simplify_gen_binary (unsignedp
? UMOD
: MOD
, mode
, op0
, op1
);
4740 case FLOOR_DIV_EXPR
:
4742 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4745 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4746 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4747 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4748 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4751 case FLOOR_MOD_EXPR
:
4753 return simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4756 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4757 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4758 adj
= simplify_gen_unary (NEG
, mode
,
4759 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4761 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4767 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4768 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4769 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4770 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4774 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4775 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4776 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4777 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4783 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4784 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4785 adj
= simplify_gen_unary (NEG
, mode
,
4786 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4788 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4792 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4793 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4794 adj
= simplify_gen_unary (NEG
, mode
,
4795 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4797 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4800 case ROUND_DIV_EXPR
:
4803 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4804 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4805 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4806 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4810 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4811 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4812 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4813 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4816 case ROUND_MOD_EXPR
:
4819 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4820 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4821 adj
= simplify_gen_unary (NEG
, mode
,
4822 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4824 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4828 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4829 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4830 adj
= simplify_gen_unary (NEG
, mode
,
4831 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4833 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4837 return simplify_gen_binary (ASHIFT
, mode
, op0
, op1
);
4841 return simplify_gen_binary (LSHIFTRT
, mode
, op0
, op1
);
4843 return simplify_gen_binary (ASHIFTRT
, mode
, op0
, op1
);
4846 return simplify_gen_binary (ROTATE
, mode
, op0
, op1
);
4849 return simplify_gen_binary (ROTATERT
, mode
, op0
, op1
);
4852 return simplify_gen_binary (unsignedp
? UMIN
: SMIN
, mode
, op0
, op1
);
4855 return simplify_gen_binary (unsignedp
? UMAX
: SMAX
, mode
, op0
, op1
);
4858 case TRUTH_AND_EXPR
:
4859 return simplify_gen_binary (AND
, mode
, op0
, op1
);
4863 return simplify_gen_binary (IOR
, mode
, op0
, op1
);
4866 case TRUTH_XOR_EXPR
:
4867 return simplify_gen_binary (XOR
, mode
, op0
, op1
);
4869 case TRUTH_ANDIF_EXPR
:
4870 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, const0_rtx
);
4872 case TRUTH_ORIF_EXPR
:
4873 return gen_rtx_IF_THEN_ELSE (mode
, op0
, const_true_rtx
, op1
);
4875 case TRUTH_NOT_EXPR
:
4876 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, const0_rtx
);
4879 return simplify_gen_relational (unsignedp
? LTU
: LT
, mode
, inner_mode
,
4883 return simplify_gen_relational (unsignedp
? LEU
: LE
, mode
, inner_mode
,
4887 return simplify_gen_relational (unsignedp
? GTU
: GT
, mode
, inner_mode
,
4891 return simplify_gen_relational (unsignedp
? GEU
: GE
, mode
, inner_mode
,
4895 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, op1
);
4898 return simplify_gen_relational (NE
, mode
, inner_mode
, op0
, op1
);
4900 case UNORDERED_EXPR
:
4901 return simplify_gen_relational (UNORDERED
, mode
, inner_mode
, op0
, op1
);
4904 return simplify_gen_relational (ORDERED
, mode
, inner_mode
, op0
, op1
);
4907 return simplify_gen_relational (UNLT
, mode
, inner_mode
, op0
, op1
);
4910 return simplify_gen_relational (UNLE
, mode
, inner_mode
, op0
, op1
);
4913 return simplify_gen_relational (UNGT
, mode
, inner_mode
, op0
, op1
);
4916 return simplify_gen_relational (UNGE
, mode
, inner_mode
, op0
, op1
);
4919 return simplify_gen_relational (UNEQ
, mode
, inner_mode
, op0
, op1
);
4922 return simplify_gen_relational (LTGT
, mode
, inner_mode
, op0
, op1
);
4925 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, op2
);
4928 gcc_assert (COMPLEX_MODE_P (mode
));
4929 if (GET_MODE (op0
) == VOIDmode
)
4930 op0
= gen_rtx_CONST (GET_MODE_INNER (mode
), op0
);
4931 if (GET_MODE (op1
) == VOIDmode
)
4932 op1
= gen_rtx_CONST (GET_MODE_INNER (mode
), op1
);
4933 return gen_rtx_CONCAT (mode
, op0
, op1
);
4936 if (GET_CODE (op0
) == CONCAT
)
4937 return gen_rtx_CONCAT (mode
, XEXP (op0
, 0),
4938 simplify_gen_unary (NEG
, GET_MODE_INNER (mode
),
4940 GET_MODE_INNER (mode
)));
4943 scalar_mode imode
= GET_MODE_INNER (mode
);
4948 re
= adjust_address_nv (op0
, imode
, 0);
4949 im
= adjust_address_nv (op0
, imode
, GET_MODE_SIZE (imode
));
4953 scalar_int_mode ifmode
;
4954 scalar_int_mode ihmode
;
4956 if (!int_mode_for_mode (mode
).exists (&ifmode
)
4957 || !int_mode_for_mode (imode
).exists (&ihmode
))
4959 halfsize
= GEN_INT (GET_MODE_BITSIZE (ihmode
));
4962 re
= gen_rtx_SUBREG (ifmode
, re
, 0);
4963 re
= gen_rtx_ZERO_EXTRACT (ihmode
, re
, halfsize
, const0_rtx
);
4964 if (imode
!= ihmode
)
4965 re
= gen_rtx_SUBREG (imode
, re
, 0);
4966 im
= copy_rtx (op0
);
4968 im
= gen_rtx_SUBREG (ifmode
, im
, 0);
4969 im
= gen_rtx_ZERO_EXTRACT (ihmode
, im
, halfsize
, halfsize
);
4970 if (imode
!= ihmode
)
4971 im
= gen_rtx_SUBREG (imode
, im
, 0);
4973 im
= gen_rtx_NEG (imode
, im
);
4974 return gen_rtx_CONCAT (mode
, re
, im
);
4978 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4979 if (!op0
|| !MEM_P (op0
))
4981 if ((TREE_CODE (TREE_OPERAND (exp
, 0)) == VAR_DECL
4982 || TREE_CODE (TREE_OPERAND (exp
, 0)) == PARM_DECL
4983 || TREE_CODE (TREE_OPERAND (exp
, 0)) == RESULT_DECL
)
4984 && (!TREE_ADDRESSABLE (TREE_OPERAND (exp
, 0))
4985 || target_for_debug_bind (TREE_OPERAND (exp
, 0))))
4986 return gen_rtx_DEBUG_IMPLICIT_PTR (mode
, TREE_OPERAND (exp
, 0));
4988 if (handled_component_p (TREE_OPERAND (exp
, 0)))
4990 poly_int64 bitoffset
, bitsize
, maxsize
, byteoffset
;
4993 = get_ref_base_and_extent (TREE_OPERAND (exp
, 0), &bitoffset
,
4994 &bitsize
, &maxsize
, &reverse
);
4996 || TREE_CODE (decl
) == PARM_DECL
4997 || TREE_CODE (decl
) == RESULT_DECL
)
4998 && (!TREE_ADDRESSABLE (decl
)
4999 || target_for_debug_bind (decl
))
5000 && multiple_p (bitoffset
, BITS_PER_UNIT
, &byteoffset
)
5001 && known_gt (bitsize
, 0)
5002 && known_eq (bitsize
, maxsize
))
5004 rtx base
= gen_rtx_DEBUG_IMPLICIT_PTR (mode
, decl
);
5005 return plus_constant (mode
, base
, byteoffset
);
5009 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == MEM_REF
5010 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
5013 op0
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
5016 && (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
5017 || (GET_CODE (op0
) == PLUS
5018 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
5019 && CONST_INT_P (XEXP (op0
, 1)))))
5021 op1
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
5024 if (!op1
|| !poly_int_rtx_p (op1
, &offset
))
5027 return plus_constant (mode
, op0
, offset
);
5034 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)));
5035 addr_mode
= SCALAR_INT_TYPE_MODE (TREE_TYPE (exp
));
5036 op0
= convert_debug_memory_address (addr_mode
, XEXP (op0
, 0), as
);
5042 unsigned HOST_WIDE_INT i
, nelts
;
5044 if (!VECTOR_CST_NELTS (exp
).is_constant (&nelts
))
5047 op0
= gen_rtx_CONCATN (mode
, rtvec_alloc (nelts
));
5049 for (i
= 0; i
< nelts
; ++i
)
5051 op1
= expand_debug_expr (VECTOR_CST_ELT (exp
, i
));
5054 XVECEXP (op0
, 0, i
) = op1
;
5061 if (TREE_CLOBBER_P (exp
))
5063 else if (TREE_CODE (TREE_TYPE (exp
)) == VECTOR_TYPE
)
5066 unsigned HOST_WIDE_INT nelts
;
5069 if (!TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)).is_constant (&nelts
))
5070 goto flag_unsupported
;
5072 op0
= gen_rtx_CONCATN (mode
, rtvec_alloc (nelts
));
5074 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), i
, val
)
5076 op1
= expand_debug_expr (val
);
5079 XVECEXP (op0
, 0, i
) = op1
;
5084 op1
= expand_debug_expr
5085 (build_zero_cst (TREE_TYPE (TREE_TYPE (exp
))));
5090 for (; i
< nelts
; i
++)
5091 XVECEXP (op0
, 0, i
) = op1
;
5097 goto flag_unsupported
;
5100 /* ??? Maybe handle some builtins? */
5105 gimple
*g
= get_gimple_for_ssa_name (exp
);
5109 if (deep_ter_debug_map
)
5111 tree
*slot
= deep_ter_debug_map
->get (exp
);
5116 t
= gimple_assign_rhs_to_tree (g
);
5117 op0
= expand_debug_expr (t
);
5123 /* If this is a reference to an incoming value of
5124 parameter that is never used in the code or where the
5125 incoming value is never used in the code, use
5126 PARM_DECL's DECL_RTL if set. */
5127 if (SSA_NAME_IS_DEFAULT_DEF (exp
)
5128 && SSA_NAME_VAR (exp
)
5129 && TREE_CODE (SSA_NAME_VAR (exp
)) == PARM_DECL
5130 && has_zero_uses (exp
))
5132 op0
= expand_debug_parm_decl (SSA_NAME_VAR (exp
));
5135 op0
= expand_debug_expr (SSA_NAME_VAR (exp
));
5140 int part
= var_to_partition (SA
.map
, exp
);
5142 if (part
== NO_PARTITION
)
5145 gcc_assert (part
>= 0 && (unsigned)part
< SA
.map
->num_partitions
);
5147 op0
= copy_rtx (SA
.partition_to_pseudo
[part
]);
5155 /* Vector stuff. For most of the codes we don't have rtl codes. */
5156 case REALIGN_LOAD_EXPR
:
5158 case VEC_PACK_FIX_TRUNC_EXPR
:
5159 case VEC_PACK_FLOAT_EXPR
:
5160 case VEC_PACK_SAT_EXPR
:
5161 case VEC_PACK_TRUNC_EXPR
:
5162 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
5163 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
5164 case VEC_UNPACK_FLOAT_HI_EXPR
:
5165 case VEC_UNPACK_FLOAT_LO_EXPR
:
5166 case VEC_UNPACK_HI_EXPR
:
5167 case VEC_UNPACK_LO_EXPR
:
5168 case VEC_WIDEN_MULT_HI_EXPR
:
5169 case VEC_WIDEN_MULT_LO_EXPR
:
5170 case VEC_WIDEN_MULT_EVEN_EXPR
:
5171 case VEC_WIDEN_MULT_ODD_EXPR
:
5172 case VEC_WIDEN_LSHIFT_HI_EXPR
:
5173 case VEC_WIDEN_LSHIFT_LO_EXPR
:
5175 case VEC_DUPLICATE_EXPR
:
5176 case VEC_SERIES_EXPR
:
5181 case ADDR_SPACE_CONVERT_EXPR
:
5182 case FIXED_CONVERT_EXPR
:
5184 case WITH_SIZE_EXPR
:
5185 case BIT_INSERT_EXPR
:
5189 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5190 && SCALAR_INT_MODE_P (mode
))
5193 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5195 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
5198 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5200 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op1
,
5202 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
5203 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
5207 case WIDEN_MULT_EXPR
:
5208 case WIDEN_MULT_PLUS_EXPR
:
5209 case WIDEN_MULT_MINUS_EXPR
:
5210 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5211 && SCALAR_INT_MODE_P (mode
))
5213 inner_mode
= GET_MODE (op0
);
5214 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
5215 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
5217 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
5218 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 1))))
5219 op1
= simplify_gen_unary (ZERO_EXTEND
, mode
, op1
, inner_mode
);
5221 op1
= simplify_gen_unary (SIGN_EXTEND
, mode
, op1
, inner_mode
);
5222 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
5223 if (TREE_CODE (exp
) == WIDEN_MULT_EXPR
)
5225 else if (TREE_CODE (exp
) == WIDEN_MULT_PLUS_EXPR
)
5226 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
5228 return simplify_gen_binary (MINUS
, mode
, op2
, op0
);
5232 case MULT_HIGHPART_EXPR
:
5233 /* ??? Similar to the above. */
5236 case WIDEN_SUM_EXPR
:
5237 case WIDEN_LSHIFT_EXPR
:
5238 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5239 && SCALAR_INT_MODE_P (mode
))
5242 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5244 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
5246 return simplify_gen_binary (TREE_CODE (exp
) == WIDEN_LSHIFT_EXPR
5247 ? ASHIFT
: PLUS
, mode
, op0
, op1
);
5262 /* Return an RTX equivalent to the source bind value of the tree expression
5266 expand_debug_source_expr (tree exp
)
5269 machine_mode mode
= VOIDmode
, inner_mode
;
5271 switch (TREE_CODE (exp
))
5274 if (DECL_ABSTRACT_ORIGIN (exp
))
5275 return expand_debug_source_expr (DECL_ABSTRACT_ORIGIN (exp
));
5279 mode
= DECL_MODE (exp
);
5280 op0
= expand_debug_parm_decl (exp
);
5283 /* See if this isn't an argument that has been completely
5285 if (!DECL_RTL_SET_P (exp
)
5286 && !DECL_INCOMING_RTL (exp
)
5287 && DECL_ABSTRACT_ORIGIN (current_function_decl
))
5289 tree aexp
= DECL_ORIGIN (exp
);
5290 if (DECL_CONTEXT (aexp
)
5291 == DECL_ABSTRACT_ORIGIN (current_function_decl
))
5293 vec
<tree
, va_gc
> **debug_args
;
5296 debug_args
= decl_debug_args_lookup (current_function_decl
);
5297 if (debug_args
!= NULL
)
5299 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, &ddecl
);
5302 return gen_rtx_DEBUG_PARAMETER_REF (mode
, aexp
);
5312 if (op0
== NULL_RTX
)
5315 inner_mode
= GET_MODE (op0
);
5316 if (mode
== inner_mode
)
5319 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
5321 if (GET_MODE_UNIT_BITSIZE (mode
)
5322 == GET_MODE_UNIT_BITSIZE (inner_mode
))
5323 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
5324 else if (GET_MODE_UNIT_BITSIZE (mode
)
5325 < GET_MODE_UNIT_BITSIZE (inner_mode
))
5326 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
5328 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
5330 else if (FLOAT_MODE_P (mode
))
5332 else if (FLOAT_MODE_P (inner_mode
))
5334 if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
5335 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
5337 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
5339 else if (GET_MODE_UNIT_PRECISION (mode
)
5340 == GET_MODE_UNIT_PRECISION (inner_mode
))
5341 op0
= lowpart_subreg (mode
, op0
, inner_mode
);
5342 else if (GET_MODE_UNIT_PRECISION (mode
)
5343 < GET_MODE_UNIT_PRECISION (inner_mode
))
5344 op0
= simplify_gen_unary (TRUNCATE
, mode
, op0
, inner_mode
);
5345 else if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
5346 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
5348 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
5353 /* Ensure INSN_VAR_LOCATION_LOC (insn) doesn't have unbound complexity.
5354 Allow 4 levels of rtl nesting for most rtl codes, and if we see anything
5355 deeper than that, create DEBUG_EXPRs and emit DEBUG_INSNs before INSN. */
5358 avoid_complex_debug_insns (rtx_insn
*insn
, rtx
*exp_p
, int depth
)
5362 if (exp
== NULL_RTX
)
5365 if ((OBJECT_P (exp
) && !MEM_P (exp
)) || GET_CODE (exp
) == CLOBBER
)
5370 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
5371 rtx dval
= make_debug_expr_from_rtl (exp
);
5373 /* Emit a debug bind insn before INSN. */
5374 rtx bind
= gen_rtx_VAR_LOCATION (GET_MODE (exp
),
5375 DEBUG_EXPR_TREE_DECL (dval
), exp
,
5376 VAR_INIT_STATUS_INITIALIZED
);
5378 emit_debug_insn_before (bind
, insn
);
5383 const char *format_ptr
= GET_RTX_FORMAT (GET_CODE (exp
));
5385 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
5386 switch (*format_ptr
++)
5389 avoid_complex_debug_insns (insn
, &XEXP (exp
, i
), depth
+ 1);
5394 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
5395 avoid_complex_debug_insns (insn
, &XVECEXP (exp
, i
, j
), depth
+ 1);
5403 /* Expand the _LOCs in debug insns. We run this after expanding all
5404 regular insns, so that any variables referenced in the function
5405 will have their DECL_RTLs set. */
5408 expand_debug_locations (void)
5411 rtx_insn
*last
= get_last_insn ();
5412 int save_strict_alias
= flag_strict_aliasing
;
5414 /* New alias sets while setting up memory attributes cause
5415 -fcompare-debug failures, even though it doesn't bring about any
5417 flag_strict_aliasing
= 0;
5419 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
5420 if (DEBUG_BIND_INSN_P (insn
))
5422 tree value
= (tree
)INSN_VAR_LOCATION_LOC (insn
);
5424 rtx_insn
*prev_insn
, *insn2
;
5427 if (value
== NULL_TREE
)
5431 if (INSN_VAR_LOCATION_STATUS (insn
)
5432 == VAR_INIT_STATUS_UNINITIALIZED
)
5433 val
= expand_debug_source_expr (value
);
5434 /* The avoid_deep_ter_for_debug function inserts
5435 debug bind stmts after SSA_NAME definition, with the
5436 SSA_NAME as the whole bind location. Disable temporarily
5437 expansion of that SSA_NAME into the DEBUG_EXPR_DECL
5438 being defined in this DEBUG_INSN. */
5439 else if (deep_ter_debug_map
&& TREE_CODE (value
) == SSA_NAME
)
5441 tree
*slot
= deep_ter_debug_map
->get (value
);
5444 if (*slot
== INSN_VAR_LOCATION_DECL (insn
))
5449 val
= expand_debug_expr (value
);
5451 *slot
= INSN_VAR_LOCATION_DECL (insn
);
5454 val
= expand_debug_expr (value
);
5455 gcc_assert (last
== get_last_insn ());
5459 val
= gen_rtx_UNKNOWN_VAR_LOC ();
5462 mode
= GET_MODE (INSN_VAR_LOCATION (insn
));
5464 gcc_assert (mode
== GET_MODE (val
)
5465 || (GET_MODE (val
) == VOIDmode
5466 && (CONST_SCALAR_INT_P (val
)
5467 || GET_CODE (val
) == CONST_FIXED
5468 || GET_CODE (val
) == LABEL_REF
)));
5471 INSN_VAR_LOCATION_LOC (insn
) = val
;
5472 prev_insn
= PREV_INSN (insn
);
5473 for (insn2
= insn
; insn2
!= prev_insn
; insn2
= PREV_INSN (insn2
))
5474 avoid_complex_debug_insns (insn2
, &INSN_VAR_LOCATION_LOC (insn2
), 0);
5477 flag_strict_aliasing
= save_strict_alias
;
5480 /* Performs swapping operands of commutative operations to expand
5481 the expensive one first. */
5484 reorder_operands (basic_block bb
)
5486 unsigned int *lattice
; /* Hold cost of each statement. */
5487 unsigned int i
= 0, n
= 0;
5488 gimple_stmt_iterator gsi
;
5494 use_operand_p use_p
;
5495 gimple
*def0
, *def1
;
5497 /* Compute cost of each statement using estimate_num_insns. */
5498 stmts
= bb_seq (bb
);
5499 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5501 stmt
= gsi_stmt (gsi
);
5502 if (!is_gimple_debug (stmt
))
5503 gimple_set_uid (stmt
, n
++);
5505 lattice
= XNEWVEC (unsigned int, n
);
5506 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5509 stmt
= gsi_stmt (gsi
);
5510 if (is_gimple_debug (stmt
))
5512 cost
= estimate_num_insns (stmt
, &eni_size_weights
);
5514 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
5516 tree use
= USE_FROM_PTR (use_p
);
5518 if (TREE_CODE (use
) != SSA_NAME
)
5520 def_stmt
= get_gimple_for_ssa_name (use
);
5523 lattice
[i
] += lattice
[gimple_uid (def_stmt
)];
5526 if (!is_gimple_assign (stmt
)
5527 || !commutative_tree_code (gimple_assign_rhs_code (stmt
)))
5529 op0
= gimple_op (stmt
, 1);
5530 op1
= gimple_op (stmt
, 2);
5531 if (TREE_CODE (op0
) != SSA_NAME
5532 || TREE_CODE (op1
) != SSA_NAME
)
5534 /* Swap operands if the second one is more expensive. */
5535 def0
= get_gimple_for_ssa_name (op0
);
5536 def1
= get_gimple_for_ssa_name (op1
);
5540 if (!def0
|| lattice
[gimple_uid (def1
)] > lattice
[gimple_uid (def0
)])
5544 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5546 fprintf (dump_file
, "Swap operands in stmt:\n");
5547 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
5548 fprintf (dump_file
, "Cost left opnd=%d, right opnd=%d\n",
5549 def0
? lattice
[gimple_uid (def0
)] : 0,
5550 lattice
[gimple_uid (def1
)]);
5552 swap_ssa_operands (stmt
, gimple_assign_rhs1_ptr (stmt
),
5553 gimple_assign_rhs2_ptr (stmt
));
5559 /* Expand basic block BB from GIMPLE trees to RTL. */
5562 expand_gimple_basic_block (basic_block bb
, bool disable_tail_calls
)
5564 gimple_stmt_iterator gsi
;
5566 gimple
*stmt
= NULL
;
5567 rtx_note
*note
= NULL
;
5573 fprintf (dump_file
, "\n;; Generating RTL for gimple basic block %d\n",
5576 /* Note that since we are now transitioning from GIMPLE to RTL, we
5577 cannot use the gsi_*_bb() routines because they expect the basic
5578 block to be in GIMPLE, instead of RTL. Therefore, we need to
5579 access the BB sequence directly. */
5581 reorder_operands (bb
);
5582 stmts
= bb_seq (bb
);
5583 bb
->il
.gimple
.seq
= NULL
;
5584 bb
->il
.gimple
.phi_nodes
= NULL
;
5585 rtl_profile_for_bb (bb
);
5586 init_rtl_bb_info (bb
);
5587 bb
->flags
|= BB_RTL
;
5589 /* Remove the RETURN_EXPR if we may fall though to the exit
5591 gsi
= gsi_last (stmts
);
5592 if (!gsi_end_p (gsi
)
5593 && gimple_code (gsi_stmt (gsi
)) == GIMPLE_RETURN
)
5595 greturn
*ret_stmt
= as_a
<greturn
*> (gsi_stmt (gsi
));
5597 gcc_assert (single_succ_p (bb
));
5598 gcc_assert (single_succ (bb
) == EXIT_BLOCK_PTR_FOR_FN (cfun
));
5600 if (bb
->next_bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
)
5601 && !gimple_return_retval (ret_stmt
))
5603 gsi_remove (&gsi
, false);
5604 single_succ_edge (bb
)->flags
|= EDGE_FALLTHRU
;
5608 gsi
= gsi_start (stmts
);
5609 if (!gsi_end_p (gsi
))
5611 stmt
= gsi_stmt (gsi
);
5612 if (gimple_code (stmt
) != GIMPLE_LABEL
)
5616 rtx_code_label
**elt
= lab_rtx_for_bb
->get (bb
);
5620 gcc_checking_assert (!note
);
5621 last
= get_last_insn ();
5625 expand_gimple_stmt (stmt
);
5632 BB_HEAD (bb
) = NEXT_INSN (last
);
5633 if (NOTE_P (BB_HEAD (bb
)))
5634 BB_HEAD (bb
) = NEXT_INSN (BB_HEAD (bb
));
5635 gcc_assert (LABEL_P (BB_HEAD (bb
)));
5636 note
= emit_note_after (NOTE_INSN_BASIC_BLOCK
, BB_HEAD (bb
));
5638 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5641 BB_HEAD (bb
) = note
= emit_note (NOTE_INSN_BASIC_BLOCK
);
5644 NOTE_BASIC_BLOCK (note
) = bb
;
5646 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
5650 stmt
= gsi_stmt (gsi
);
5652 /* If this statement is a non-debug one, and we generate debug
5653 insns, then this one might be the last real use of a TERed
5654 SSA_NAME, but where there are still some debug uses further
5655 down. Expanding the current SSA name in such further debug
5656 uses by their RHS might lead to wrong debug info, as coalescing
5657 might make the operands of such RHS be placed into the same
5658 pseudo as something else. Like so:
5659 a_1 = a_0 + 1; // Assume a_1 is TERed and a_0 is dead
5663 As a_0 and a_2 don't overlap in lifetime, assume they are coalesced.
5664 If we now would expand a_1 by it's RHS (a_0 + 1) in the debug use,
5665 the write to a_2 would actually have clobbered the place which
5668 So, instead of that, we recognize the situation, and generate
5669 debug temporaries at the last real use of TERed SSA names:
5676 if (MAY_HAVE_DEBUG_BIND_INSNS
5678 && !is_gimple_debug (stmt
))
5684 location_t sloc
= curr_insn_location ();
5686 /* Look for SSA names that have their last use here (TERed
5687 names always have only one real use). */
5688 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
)
5689 if ((def
= get_gimple_for_ssa_name (op
)))
5691 imm_use_iterator imm_iter
;
5692 use_operand_p use_p
;
5693 bool have_debug_uses
= false;
5695 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, op
)
5697 if (gimple_debug_bind_p (USE_STMT (use_p
)))
5699 have_debug_uses
= true;
5704 if (have_debug_uses
)
5706 /* OP is a TERed SSA name, with DEF its defining
5707 statement, and where OP is used in further debug
5708 instructions. Generate a debug temporary, and
5709 replace all uses of OP in debug insns with that
5712 tree value
= gimple_assign_rhs_to_tree (def
);
5713 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
5717 set_curr_insn_location (gimple_location (def
));
5719 DECL_ARTIFICIAL (vexpr
) = 1;
5720 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
5722 mode
= DECL_MODE (value
);
5724 mode
= TYPE_MODE (TREE_TYPE (value
));
5725 SET_DECL_MODE (vexpr
, mode
);
5727 val
= gen_rtx_VAR_LOCATION
5728 (mode
, vexpr
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5730 emit_debug_insn (val
);
5732 FOR_EACH_IMM_USE_STMT (debugstmt
, imm_iter
, op
)
5734 if (!gimple_debug_bind_p (debugstmt
))
5737 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
5738 SET_USE (use_p
, vexpr
);
5740 update_stmt (debugstmt
);
5744 set_curr_insn_location (sloc
);
5747 currently_expanding_gimple_stmt
= stmt
;
5749 /* Expand this statement, then evaluate the resulting RTL and
5750 fixup the CFG accordingly. */
5751 if (gimple_code (stmt
) == GIMPLE_COND
)
5753 new_bb
= expand_gimple_cond (bb
, as_a
<gcond
*> (stmt
));
5757 else if (is_gimple_debug (stmt
))
5759 location_t sloc
= curr_insn_location ();
5760 gimple_stmt_iterator nsi
= gsi
;
5765 tree value
= NULL_TREE
;
5769 if (!gimple_debug_nonbind_marker_p (stmt
))
5771 if (gimple_debug_bind_p (stmt
))
5773 var
= gimple_debug_bind_get_var (stmt
);
5775 if (TREE_CODE (var
) != DEBUG_EXPR_DECL
5776 && TREE_CODE (var
) != LABEL_DECL
5777 && !target_for_debug_bind (var
))
5778 goto delink_debug_stmt
;
5781 mode
= DECL_MODE (var
);
5783 mode
= TYPE_MODE (TREE_TYPE (var
));
5785 if (gimple_debug_bind_has_value_p (stmt
))
5786 value
= gimple_debug_bind_get_value (stmt
);
5788 val
= gen_rtx_VAR_LOCATION
5789 (mode
, var
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5791 else if (gimple_debug_source_bind_p (stmt
))
5793 var
= gimple_debug_source_bind_get_var (stmt
);
5795 value
= gimple_debug_source_bind_get_value (stmt
);
5797 mode
= DECL_MODE (var
);
5799 val
= gen_rtx_VAR_LOCATION (mode
, var
, (rtx
)value
,
5800 VAR_INIT_STATUS_UNINITIALIZED
);
5805 /* If this function was first compiled with markers
5806 enabled, but they're now disable (e.g. LTO), drop
5807 them on the floor. */
5808 else if (gimple_debug_nonbind_marker_p (stmt
)
5809 && !MAY_HAVE_DEBUG_MARKER_INSNS
)
5810 goto delink_debug_stmt
;
5811 else if (gimple_debug_begin_stmt_p (stmt
))
5812 val
= GEN_RTX_DEBUG_MARKER_BEGIN_STMT_PAT ();
5813 else if (gimple_debug_inline_entry_p (stmt
))
5815 tree block
= gimple_block (stmt
);
5818 val
= GEN_RTX_DEBUG_MARKER_INLINE_ENTRY_PAT ();
5820 goto delink_debug_stmt
;
5825 last
= get_last_insn ();
5827 set_curr_insn_location (gimple_location (stmt
));
5829 emit_debug_insn (val
);
5831 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5833 /* We can't dump the insn with a TREE where an RTX
5835 if (GET_CODE (val
) == VAR_LOCATION
)
5837 gcc_checking_assert (PAT_VAR_LOCATION_LOC (val
) == (rtx
)value
);
5838 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
5840 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5841 if (GET_CODE (val
) == VAR_LOCATION
)
5842 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
5846 /* In order not to generate too many debug temporaries,
5847 we delink all uses of debug statements we already expanded.
5848 Therefore debug statements between definition and real
5849 use of TERed SSA names will continue to use the SSA name,
5850 and not be replaced with debug temps. */
5851 delink_stmt_imm_use (stmt
);
5855 if (gsi_end_p (nsi
))
5857 stmt
= gsi_stmt (nsi
);
5858 if (!is_gimple_debug (stmt
))
5862 set_curr_insn_location (sloc
);
5866 gcall
*call_stmt
= dyn_cast
<gcall
*> (stmt
);
5868 && gimple_call_tail_p (call_stmt
)
5869 && disable_tail_calls
)
5870 gimple_call_set_tail (call_stmt
, false);
5872 if (call_stmt
&& gimple_call_tail_p (call_stmt
))
5875 new_bb
= expand_gimple_tailcall (bb
, call_stmt
, &can_fallthru
);
5886 def_operand_p def_p
;
5887 def_p
= SINGLE_SSA_DEF_OPERAND (stmt
, SSA_OP_DEF
);
5891 /* Ignore this stmt if it is in the list of
5892 replaceable expressions. */
5894 && bitmap_bit_p (SA
.values
,
5895 SSA_NAME_VERSION (DEF_FROM_PTR (def_p
))))
5898 last
= expand_gimple_stmt (stmt
);
5899 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5904 currently_expanding_gimple_stmt
= NULL
;
5906 /* Expand implicit goto and convert goto_locus. */
5907 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5909 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
5910 set_curr_insn_location (e
->goto_locus
);
5911 if ((e
->flags
& EDGE_FALLTHRU
) && e
->dest
!= bb
->next_bb
)
5913 emit_jump (label_rtx_for_bb (e
->dest
));
5914 e
->flags
&= ~EDGE_FALLTHRU
;
5918 /* Expanded RTL can create a jump in the last instruction of block.
5919 This later might be assumed to be a jump to successor and break edge insertion.
5920 We need to insert dummy move to prevent this. PR41440. */
5921 if (single_succ_p (bb
)
5922 && (single_succ_edge (bb
)->flags
& EDGE_FALLTHRU
)
5923 && (last
= get_last_insn ())
5925 || (DEBUG_INSN_P (last
)
5926 && JUMP_P (prev_nondebug_insn (last
)))))
5928 rtx dummy
= gen_reg_rtx (SImode
);
5929 emit_insn_after_noloc (gen_move_insn (dummy
, dummy
), last
, NULL
);
5932 do_pending_stack_adjust ();
5934 /* Find the block tail. The last insn in the block is the insn
5935 before a barrier and/or table jump insn. */
5936 last
= get_last_insn ();
5937 if (BARRIER_P (last
))
5938 last
= PREV_INSN (last
);
5939 if (JUMP_TABLE_DATA_P (last
))
5940 last
= PREV_INSN (PREV_INSN (last
));
5941 if (BARRIER_P (last
))
5942 last
= PREV_INSN (last
);
5945 update_bb_for_insn (bb
);
5951 /* Create a basic block for initialization code. */
5954 construct_init_block (void)
5956 basic_block init_block
, first_block
;
5960 /* Multiple entry points not supported yet. */
5961 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
) == 1);
5962 init_rtl_bb_info (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5963 init_rtl_bb_info (EXIT_BLOCK_PTR_FOR_FN (cfun
));
5964 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
5965 EXIT_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
5967 e
= EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun
), 0);
5969 /* When entry edge points to first basic block, we don't need jump,
5970 otherwise we have to jump into proper target. */
5971 if (e
&& e
->dest
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
)
5973 tree label
= gimple_block_label (e
->dest
);
5975 emit_jump (jump_target_rtx (label
));
5979 flags
= EDGE_FALLTHRU
;
5981 init_block
= create_basic_block (NEXT_INSN (get_insns ()),
5983 ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5984 init_block
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
5985 add_bb_to_loop (init_block
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
5988 first_block
= e
->dest
;
5989 redirect_edge_succ (e
, init_block
);
5990 make_single_succ_edge (init_block
, first_block
, flags
);
5993 make_single_succ_edge (init_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
),
5996 update_bb_for_insn (init_block
);
6000 /* For each lexical block, set BLOCK_NUMBER to the depth at which it is
6001 found in the block tree. */
6004 set_block_levels (tree block
, int level
)
6008 BLOCK_NUMBER (block
) = level
;
6009 set_block_levels (BLOCK_SUBBLOCKS (block
), level
+ 1);
6010 block
= BLOCK_CHAIN (block
);
6014 /* Create a block containing landing pads and similar stuff. */
6017 construct_exit_block (void)
6019 rtx_insn
*head
= get_last_insn ();
6021 basic_block exit_block
;
6025 basic_block prev_bb
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
;
6026 rtx_insn
*orig_end
= BB_END (prev_bb
);
6028 rtl_profile_for_bb (EXIT_BLOCK_PTR_FOR_FN (cfun
));
6030 /* Make sure the locus is set to the end of the function, so that
6031 epilogue line numbers and warnings are set properly. */
6032 if (LOCATION_LOCUS (cfun
->function_end_locus
) != UNKNOWN_LOCATION
)
6033 input_location
= cfun
->function_end_locus
;
6035 /* Generate rtl for function exit. */
6036 expand_function_end ();
6038 end
= get_last_insn ();
6041 /* While emitting the function end we could move end of the last basic
6043 BB_END (prev_bb
) = orig_end
;
6044 while (NEXT_INSN (head
) && NOTE_P (NEXT_INSN (head
)))
6045 head
= NEXT_INSN (head
);
6046 /* But make sure exit_block starts with RETURN_LABEL, otherwise the
6047 bb count counting will be confused. Any instructions before that
6048 label are emitted for the case where PREV_BB falls through into the
6049 exit block, so append those instructions to prev_bb in that case. */
6050 if (NEXT_INSN (head
) != return_label
)
6052 while (NEXT_INSN (head
) != return_label
)
6054 if (!NOTE_P (NEXT_INSN (head
)))
6055 BB_END (prev_bb
) = NEXT_INSN (head
);
6056 head
= NEXT_INSN (head
);
6059 exit_block
= create_basic_block (NEXT_INSN (head
), end
, prev_bb
);
6060 exit_block
->count
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
;
6061 add_bb_to_loop (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
6064 while (ix
< EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
))
6066 e
= EDGE_PRED (EXIT_BLOCK_PTR_FOR_FN (cfun
), ix
);
6067 if (!(e
->flags
& EDGE_ABNORMAL
))
6068 redirect_edge_succ (e
, exit_block
);
6073 e
= make_single_succ_edge (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
),
6075 FOR_EACH_EDGE (e2
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
6078 exit_block
->count
-= e2
->count ();
6080 update_bb_for_insn (exit_block
);
6083 /* Helper function for discover_nonconstant_array_refs.
6084 Look for ARRAY_REF nodes with non-constant indexes and mark them
6088 discover_nonconstant_array_refs_r (tree
* tp
, int *walk_subtrees
,
6089 void *data ATTRIBUTE_UNUSED
)
6093 if (IS_TYPE_OR_DECL_P (t
))
6095 else if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
6097 while (((TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
6098 && is_gimple_min_invariant (TREE_OPERAND (t
, 1))
6099 && (!TREE_OPERAND (t
, 2)
6100 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
6101 || (TREE_CODE (t
) == COMPONENT_REF
6102 && (!TREE_OPERAND (t
,2)
6103 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
6104 || TREE_CODE (t
) == BIT_FIELD_REF
6105 || TREE_CODE (t
) == REALPART_EXPR
6106 || TREE_CODE (t
) == IMAGPART_EXPR
6107 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
6108 || CONVERT_EXPR_P (t
))
6109 t
= TREE_OPERAND (t
, 0);
6111 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
6113 t
= get_base_address (t
);
6115 && DECL_MODE (t
) != BLKmode
)
6116 TREE_ADDRESSABLE (t
) = 1;
6121 /* References of size POLY_INT_CST to a fixed-size object must go
6122 through memory. It's more efficient to force that here than
6123 to create temporary slots on the fly. */
6124 else if ((TREE_CODE (t
) == MEM_REF
|| TREE_CODE (t
) == TARGET_MEM_REF
)
6125 && TYPE_SIZE (TREE_TYPE (t
))
6126 && POLY_INT_CST_P (TYPE_SIZE (TREE_TYPE (t
))))
6128 tree base
= get_base_address (t
);
6131 && DECL_MODE (base
) != BLKmode
6132 && GET_MODE_SIZE (DECL_MODE (base
)).is_constant ())
6133 TREE_ADDRESSABLE (base
) = 1;
6140 /* If there's a chance to get a pseudo for t then if it would be of float mode
6141 and the actual access is via an integer mode (lowered memcpy or similar
6142 access) then avoid the register expansion if the mode likely is not storage
6143 suitable for raw bits processing (like XFmode on i?86). */
6146 avoid_type_punning_on_regs (tree t
)
6148 machine_mode access_mode
= TYPE_MODE (TREE_TYPE (t
));
6149 if (access_mode
!= BLKmode
6150 && !SCALAR_INT_MODE_P (access_mode
))
6152 tree base
= get_base_address (t
);
6154 && !TREE_ADDRESSABLE (base
)
6155 && FLOAT_MODE_P (DECL_MODE (base
))
6156 && maybe_lt (GET_MODE_PRECISION (DECL_MODE (base
)),
6157 GET_MODE_BITSIZE (GET_MODE_INNER (DECL_MODE (base
))))
6158 /* Double check in the expensive way we really would get a pseudo. */
6159 && use_register_for_decl (base
))
6160 TREE_ADDRESSABLE (base
) = 1;
6163 /* RTL expansion is not able to compile array references with variable
6164 offsets for arrays stored in single register. Discover such
6165 expressions and mark variables as addressable to avoid this
6169 discover_nonconstant_array_refs (void)
6172 gimple_stmt_iterator gsi
;
6174 FOR_EACH_BB_FN (bb
, cfun
)
6175 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
6177 gimple
*stmt
= gsi_stmt (gsi
);
6178 if (!is_gimple_debug (stmt
))
6180 walk_gimple_op (stmt
, discover_nonconstant_array_refs_r
, NULL
);
6181 gcall
*call
= dyn_cast
<gcall
*> (stmt
);
6182 if (call
&& gimple_call_internal_p (call
))
6183 switch (gimple_call_internal_fn (call
))
6185 case IFN_LOAD_LANES
:
6186 /* The source must be a MEM. */
6187 mark_addressable (gimple_call_arg (call
, 0));
6189 case IFN_STORE_LANES
:
6190 /* The destination must be a MEM. */
6191 mark_addressable (gimple_call_lhs (call
));
6196 if (gimple_vdef (stmt
))
6198 tree t
= gimple_get_lhs (stmt
);
6199 if (t
&& REFERENCE_CLASS_P (t
))
6200 avoid_type_punning_on_regs (t
);
6206 /* This function sets crtl->args.internal_arg_pointer to a virtual
6207 register if DRAP is needed. Local register allocator will replace
6208 virtual_incoming_args_rtx with the virtual register. */
6211 expand_stack_alignment (void)
6214 unsigned int preferred_stack_boundary
;
6216 if (! SUPPORTS_STACK_ALIGNMENT
)
6219 if (cfun
->calls_alloca
6220 || cfun
->has_nonlocal_label
6221 || crtl
->has_nonlocal_goto
)
6222 crtl
->need_drap
= true;
6224 /* Call update_stack_boundary here again to update incoming stack
6225 boundary. It may set incoming stack alignment to a different
6226 value after RTL expansion. TARGET_FUNCTION_OK_FOR_SIBCALL may
6227 use the minimum incoming stack alignment to check if it is OK
6228 to perform sibcall optimization since sibcall optimization will
6229 only align the outgoing stack to incoming stack boundary. */
6230 if (targetm
.calls
.update_stack_boundary
)
6231 targetm
.calls
.update_stack_boundary ();
6233 /* The incoming stack frame has to be aligned at least at
6234 parm_stack_boundary. */
6235 gcc_assert (crtl
->parm_stack_boundary
<= INCOMING_STACK_BOUNDARY
);
6237 /* Update crtl->stack_alignment_estimated and use it later to align
6238 stack. We check PREFERRED_STACK_BOUNDARY if there may be non-call
6239 exceptions since callgraph doesn't collect incoming stack alignment
6241 if (cfun
->can_throw_non_call_exceptions
6242 && PREFERRED_STACK_BOUNDARY
> crtl
->preferred_stack_boundary
)
6243 preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
6245 preferred_stack_boundary
= crtl
->preferred_stack_boundary
;
6246 if (preferred_stack_boundary
> crtl
->stack_alignment_estimated
)
6247 crtl
->stack_alignment_estimated
= preferred_stack_boundary
;
6248 if (preferred_stack_boundary
> crtl
->stack_alignment_needed
)
6249 crtl
->stack_alignment_needed
= preferred_stack_boundary
;
6251 gcc_assert (crtl
->stack_alignment_needed
6252 <= crtl
->stack_alignment_estimated
);
6254 crtl
->stack_realign_needed
6255 = INCOMING_STACK_BOUNDARY
< crtl
->stack_alignment_estimated
;
6256 crtl
->stack_realign_tried
= crtl
->stack_realign_needed
;
6258 crtl
->stack_realign_processed
= true;
6260 /* Target has to redefine TARGET_GET_DRAP_RTX to support stack
6262 gcc_assert (targetm
.calls
.get_drap_rtx
!= NULL
);
6263 drap_rtx
= targetm
.calls
.get_drap_rtx ();
6265 /* stack_realign_drap and drap_rtx must match. */
6266 gcc_assert ((stack_realign_drap
!= 0) == (drap_rtx
!= NULL
));
6268 /* Do nothing if NULL is returned, which means DRAP is not needed. */
6269 if (drap_rtx
!= NULL
)
6271 crtl
->args
.internal_arg_pointer
= drap_rtx
;
6273 /* Call fixup_tail_calls to clean up REG_EQUIV note if DRAP is
6275 fixup_tail_calls ();
6281 expand_main_function (void)
6283 #if (defined(INVOKE__main) \
6284 || (!defined(HAS_INIT_SECTION) \
6285 && !defined(INIT_SECTION_ASM_OP) \
6286 && !defined(INIT_ARRAY_SECTION_ASM_OP)))
6287 emit_library_call (init_one_libfunc (NAME__MAIN
), LCT_NORMAL
, VOIDmode
);
6292 /* Expand code to initialize the stack_protect_guard. This is invoked at
6293 the beginning of a function to be protected. */
6296 stack_protect_prologue (void)
6298 tree guard_decl
= targetm
.stack_protect_guard ();
6301 crtl
->stack_protect_guard_decl
= guard_decl
;
6302 x
= expand_normal (crtl
->stack_protect_guard
);
6304 if (targetm
.have_stack_protect_combined_set () && guard_decl
)
6306 gcc_assert (DECL_P (guard_decl
));
6307 y
= DECL_RTL (guard_decl
);
6309 /* Allow the target to compute address of Y and copy it to X without
6310 leaking Y into a register. This combined address + copy pattern
6311 allows the target to prevent spilling of any intermediate results by
6312 splitting it after register allocator. */
6313 if (rtx_insn
*insn
= targetm
.gen_stack_protect_combined_set (x
, y
))
6321 y
= expand_normal (guard_decl
);
6325 /* Allow the target to copy from Y to X without leaking Y into a
6327 if (targetm
.have_stack_protect_set ())
6328 if (rtx_insn
*insn
= targetm
.gen_stack_protect_set (x
, y
))
6334 /* Otherwise do a straight move. */
6335 emit_move_insn (x
, y
);
6338 /* Translate the intermediate representation contained in the CFG
6339 from GIMPLE trees to RTL.
6341 We do conversion per basic block and preserve/update the tree CFG.
6342 This implies we have to do some magic as the CFG can simultaneously
6343 consist of basic blocks containing RTL and GIMPLE trees. This can
6344 confuse the CFG hooks, so be careful to not manipulate CFG during
6349 const pass_data pass_data_expand
=
6351 RTL_PASS
, /* type */
6352 "expand", /* name */
6353 OPTGROUP_NONE
, /* optinfo_flags */
6354 TV_EXPAND
, /* tv_id */
6355 ( PROP_ssa
| PROP_gimple_leh
| PROP_cfg
6358 | PROP_gimple_lva
), /* properties_required */
6359 PROP_rtl
, /* properties_provided */
6360 ( PROP_ssa
| PROP_trees
), /* properties_destroyed */
6361 0, /* todo_flags_start */
6362 0, /* todo_flags_finish */
6365 class pass_expand
: public rtl_opt_pass
6368 pass_expand (gcc::context
*ctxt
)
6369 : rtl_opt_pass (pass_data_expand
, ctxt
)
6372 /* opt_pass methods: */
6373 virtual unsigned int execute (function
*);
6375 }; // class pass_expand
6378 pass_expand::execute (function
*fun
)
6380 basic_block bb
, init_block
;
6383 rtx_insn
*var_seq
, *var_ret_seq
;
6386 timevar_push (TV_OUT_OF_SSA
);
6387 rewrite_out_of_ssa (&SA
);
6388 timevar_pop (TV_OUT_OF_SSA
);
6389 SA
.partition_to_pseudo
= XCNEWVEC (rtx
, SA
.map
->num_partitions
);
6391 if (MAY_HAVE_DEBUG_BIND_STMTS
&& flag_tree_ter
)
6393 gimple_stmt_iterator gsi
;
6394 FOR_EACH_BB_FN (bb
, cfun
)
6395 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
6396 if (gimple_debug_bind_p (gsi_stmt (gsi
)))
6397 avoid_deep_ter_for_debug (gsi_stmt (gsi
), 0);
6400 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
6401 discover_nonconstant_array_refs ();
6403 /* Make sure all values used by the optimization passes have sane
6407 /* Some backends want to know that we are expanding to RTL. */
6408 currently_expanding_to_rtl
= 1;
6409 /* Dominators are not kept up-to-date as we may create new basic-blocks. */
6410 free_dominance_info (CDI_DOMINATORS
);
6412 rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (fun
));
6414 insn_locations_init ();
6415 if (!DECL_IS_UNDECLARED_BUILTIN (current_function_decl
))
6417 /* Eventually, all FEs should explicitly set function_start_locus. */
6418 if (LOCATION_LOCUS (fun
->function_start_locus
) == UNKNOWN_LOCATION
)
6419 set_curr_insn_location
6420 (DECL_SOURCE_LOCATION (current_function_decl
));
6422 set_curr_insn_location (fun
->function_start_locus
);
6425 set_curr_insn_location (UNKNOWN_LOCATION
);
6426 prologue_location
= curr_insn_location ();
6428 #ifdef INSN_SCHEDULING
6429 init_sched_attrs ();
6432 /* Make sure first insn is a note even if we don't want linenums.
6433 This makes sure the first insn will never be deleted.
6434 Also, final expects a note to appear there. */
6435 emit_note (NOTE_INSN_DELETED
);
6437 targetm
.expand_to_rtl_hook ();
6438 crtl
->init_stack_alignment ();
6439 fun
->cfg
->max_jumptable_ents
= 0;
6441 /* Resovle the function section. Some targets, like ARM EABI rely on knowledge
6442 of the function section at exapnsion time to predict distance of calls. */
6443 resolve_unique_section (current_function_decl
, 0, flag_function_sections
);
6445 /* Expand the variables recorded during gimple lowering. */
6446 timevar_push (TV_VAR_EXPAND
);
6449 var_ret_seq
= expand_used_vars ();
6451 var_seq
= get_insns ();
6453 timevar_pop (TV_VAR_EXPAND
);
6455 /* Honor stack protection warnings. */
6456 if (warn_stack_protect
)
6458 if (fun
->calls_alloca
)
6459 warning (OPT_Wstack_protector
,
6460 "stack protector not protecting local variables: "
6461 "variable length buffer");
6462 if (has_short_buffer
&& !crtl
->stack_protect_guard
)
6463 warning (OPT_Wstack_protector
,
6464 "stack protector not protecting function: "
6465 "all local arrays are less than %d bytes long",
6466 (int) param_ssp_buffer_size
);
6469 /* Set up parameters and prepare for return, for the function. */
6470 expand_function_start (current_function_decl
);
6472 /* If we emitted any instructions for setting up the variables,
6473 emit them before the FUNCTION_START note. */
6476 emit_insn_before (var_seq
, parm_birth_insn
);
6478 /* In expand_function_end we'll insert the alloca save/restore
6479 before parm_birth_insn. We've just insertted an alloca call.
6480 Adjust the pointer to match. */
6481 parm_birth_insn
= var_seq
;
6484 /* Now propagate the RTL assignment of each partition to the
6485 underlying var of each SSA_NAME. */
6488 FOR_EACH_SSA_NAME (i
, name
, cfun
)
6490 /* We might have generated new SSA names in
6491 update_alias_info_with_stack_vars. They will have a NULL
6492 defining statements, and won't be part of the partitioning,
6494 if (!SSA_NAME_DEF_STMT (name
))
6497 adjust_one_expanded_partition_var (name
);
6500 /* Clean up RTL of variables that straddle across multiple
6501 partitions, and check that the rtl of any PARM_DECLs that are not
6502 cleaned up is that of their default defs. */
6503 FOR_EACH_SSA_NAME (i
, name
, cfun
)
6507 /* We might have generated new SSA names in
6508 update_alias_info_with_stack_vars. They will have a NULL
6509 defining statements, and won't be part of the partitioning,
6511 if (!SSA_NAME_DEF_STMT (name
))
6513 part
= var_to_partition (SA
.map
, name
);
6514 if (part
== NO_PARTITION
)
6517 /* If this decl was marked as living in multiple places, reset
6518 this now to NULL. */
6519 tree var
= SSA_NAME_VAR (name
);
6520 if (var
&& DECL_RTL_IF_SET (var
) == pc_rtx
)
6521 SET_DECL_RTL (var
, NULL
);
6522 /* Check that the pseudos chosen by assign_parms are those of
6523 the corresponding default defs. */
6524 else if (SSA_NAME_IS_DEFAULT_DEF (name
)
6525 && (TREE_CODE (var
) == PARM_DECL
6526 || TREE_CODE (var
) == RESULT_DECL
))
6528 rtx in
= DECL_RTL_IF_SET (var
);
6530 rtx out
= SA
.partition_to_pseudo
[part
];
6531 gcc_assert (in
== out
);
6533 /* Now reset VAR's RTL to IN, so that the _EXPR attrs match
6534 those expected by debug backends for each parm and for
6535 the result. This is particularly important for stabs,
6536 whose register elimination from parm's DECL_RTL may cause
6537 -fcompare-debug differences as SET_DECL_RTL changes reg's
6538 attrs. So, make sure the RTL already has the parm as the
6539 EXPR, so that it won't change. */
6540 SET_DECL_RTL (var
, NULL_RTX
);
6542 set_mem_attributes (in
, var
, true);
6543 SET_DECL_RTL (var
, in
);
6547 /* If this function is `main', emit a call to `__main'
6548 to run global initializers, etc. */
6549 if (DECL_NAME (current_function_decl
)
6550 && MAIN_NAME_P (DECL_NAME (current_function_decl
))
6551 && DECL_FILE_SCOPE_P (current_function_decl
))
6552 expand_main_function ();
6554 /* Initialize the stack_protect_guard field. This must happen after the
6555 call to __main (if any) so that the external decl is initialized. */
6556 if (crtl
->stack_protect_guard
&& targetm
.stack_protect_runtime_enabled_p ())
6557 stack_protect_prologue ();
6559 expand_phi_nodes (&SA
);
6561 /* Release any stale SSA redirection data. */
6562 redirect_edge_var_map_empty ();
6564 /* Register rtl specific functions for cfg. */
6565 rtl_register_cfg_hooks ();
6567 init_block
= construct_init_block ();
6569 /* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
6570 remaining edges later. */
6571 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->succs
)
6572 e
->flags
&= ~EDGE_EXECUTABLE
;
6574 /* If the function has too many markers, drop them while expanding. */
6575 if (cfun
->debug_marker_count
6576 >= param_max_debug_marker_count
)
6577 cfun
->debug_nonbind_markers
= false;
6579 lab_rtx_for_bb
= new hash_map
<basic_block
, rtx_code_label
*>;
6580 FOR_BB_BETWEEN (bb
, init_block
->next_bb
, EXIT_BLOCK_PTR_FOR_FN (fun
),
6582 bb
= expand_gimple_basic_block (bb
, var_ret_seq
!= NULL_RTX
);
6584 if (MAY_HAVE_DEBUG_BIND_INSNS
)
6585 expand_debug_locations ();
6587 if (deep_ter_debug_map
)
6589 delete deep_ter_debug_map
;
6590 deep_ter_debug_map
= NULL
;
6593 /* Free stuff we no longer need after GIMPLE optimizations. */
6594 free_dominance_info (CDI_DOMINATORS
);
6595 free_dominance_info (CDI_POST_DOMINATORS
);
6596 delete_tree_cfg_annotations (fun
);
6598 timevar_push (TV_OUT_OF_SSA
);
6599 finish_out_of_ssa (&SA
);
6600 timevar_pop (TV_OUT_OF_SSA
);
6602 timevar_push (TV_POST_EXPAND
);
6603 /* We are no longer in SSA form. */
6604 fun
->gimple_df
->in_ssa_p
= false;
6605 loops_state_clear (LOOP_CLOSED_SSA
);
6607 /* Expansion is used by optimization passes too, set maybe_hot_insn_p
6608 conservatively to true until they are all profile aware. */
6609 delete lab_rtx_for_bb
;
6610 free_histograms (fun
);
6612 construct_exit_block ();
6613 insn_locations_finalize ();
6617 rtx_insn
*after
= return_label
;
6618 rtx_insn
*next
= NEXT_INSN (after
);
6619 if (next
&& NOTE_INSN_BASIC_BLOCK_P (next
))
6621 emit_insn_after (var_ret_seq
, after
);
6624 /* Zap the tree EH table. */
6625 set_eh_throw_stmt_table (fun
, NULL
);
6627 /* We need JUMP_LABEL be set in order to redirect jumps, and hence
6628 split edges which edge insertions might do. */
6629 rebuild_jump_labels (get_insns ());
6631 /* If we have a single successor to the entry block, put the pending insns
6632 after parm birth, but before NOTE_INSNS_FUNCTION_BEG. */
6633 if (single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (fun
)))
6635 edge e
= single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (fun
));
6638 rtx_insn
*insns
= e
->insns
.r
;
6640 rebuild_jump_labels_chain (insns
);
6641 if (NOTE_P (parm_birth_insn
)
6642 && NOTE_KIND (parm_birth_insn
) == NOTE_INSN_FUNCTION_BEG
)
6643 emit_insn_before_noloc (insns
, parm_birth_insn
, e
->dest
);
6645 emit_insn_after_noloc (insns
, parm_birth_insn
, e
->dest
);
6649 /* Otherwise, as well as for other edges, take the usual way. */
6650 commit_edge_insertions ();
6652 /* We're done expanding trees to RTL. */
6653 currently_expanding_to_rtl
= 0;
6655 flush_mark_addressable_queue ();
6657 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->next_bb
,
6658 EXIT_BLOCK_PTR_FOR_FN (fun
), next_bb
)
6662 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
6664 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
6665 e
->flags
&= ~EDGE_EXECUTABLE
;
6667 /* At the moment not all abnormal edges match the RTL
6668 representation. It is safe to remove them here as
6669 find_many_sub_basic_blocks will rediscover them.
6670 In the future we should get this fixed properly. */
6671 if ((e
->flags
& EDGE_ABNORMAL
)
6672 && !(e
->flags
& EDGE_SIBCALL
))
6679 auto_sbitmap
blocks (last_basic_block_for_fn (fun
));
6680 bitmap_ones (blocks
);
6681 find_many_sub_basic_blocks (blocks
);
6682 purge_all_dead_edges ();
6684 /* After initial rtl generation, call back to finish generating
6685 exception support code. We need to do this before cleaning up
6686 the CFG as the code does not expect dead landing pads. */
6687 if (fun
->eh
->region_tree
!= NULL
)
6688 finish_eh_generation ();
6690 /* Call expand_stack_alignment after finishing all
6691 updates to crtl->preferred_stack_boundary. */
6692 expand_stack_alignment ();
6694 /* Fixup REG_EQUIV notes in the prologue if there are tailcalls in this
6696 if (crtl
->tail_call_emit
)
6697 fixup_tail_calls ();
6699 unsigned HOST_WIDE_INT patch_area_size
= function_entry_patch_area_size
;
6700 unsigned HOST_WIDE_INT patch_area_entry
= function_entry_patch_area_start
;
6702 tree patchable_function_entry_attr
6703 = lookup_attribute ("patchable_function_entry",
6704 DECL_ATTRIBUTES (cfun
->decl
));
6705 if (patchable_function_entry_attr
)
6707 tree pp_val
= TREE_VALUE (patchable_function_entry_attr
);
6708 tree patchable_function_entry_value1
= TREE_VALUE (pp_val
);
6710 patch_area_size
= tree_to_uhwi (patchable_function_entry_value1
);
6711 patch_area_entry
= 0;
6712 if (TREE_CHAIN (pp_val
) != NULL_TREE
)
6714 tree patchable_function_entry_value2
6715 = TREE_VALUE (TREE_CHAIN (pp_val
));
6716 patch_area_entry
= tree_to_uhwi (patchable_function_entry_value2
);
6720 if (patch_area_entry
> patch_area_size
)
6722 if (patch_area_size
> 0)
6723 warning (OPT_Wattributes
,
6724 "patchable function entry %wu exceeds size %wu",
6725 patch_area_entry
, patch_area_size
);
6726 patch_area_entry
= 0;
6729 crtl
->patch_area_size
= patch_area_size
;
6730 crtl
->patch_area_entry
= patch_area_entry
;
6732 /* BB subdivision may have created basic blocks that are only reachable
6733 from unlikely bbs but not marked as such in the profile. */
6735 propagate_unlikely_bbs_forward ();
6737 /* Remove unreachable blocks, otherwise we cannot compute dominators
6738 which are needed for loop state verification. As a side-effect
6739 this also compacts blocks.
6740 ??? We cannot remove trivially dead insns here as for example
6741 the DRAP reg on i?86 is not magically live at this point.
6742 gcc.c-torture/execute/ipa-sra-2.c execution, -Os -m32 fails otherwise. */
6743 cleanup_cfg (CLEANUP_NO_INSN_DEL
);
6745 checking_verify_flow_info ();
6747 /* Initialize pseudos allocated for hard registers. */
6748 emit_initial_value_sets ();
6750 /* And finally unshare all RTL. */
6753 /* There's no need to defer outputting this function any more; we
6754 know we want to output it. */
6755 DECL_DEFER_OUTPUT (current_function_decl
) = 0;
6757 /* Now that we're done expanding trees to RTL, we shouldn't have any
6758 more CONCATs anywhere. */
6759 generating_concat_p
= 0;
6764 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
6765 /* And the pass manager will dump RTL for us. */
6768 /* If we're emitting a nested function, make sure its parent gets
6769 emitted as well. Doing otherwise confuses debug info. */
6772 for (parent
= DECL_CONTEXT (current_function_decl
);
6773 parent
!= NULL_TREE
;
6774 parent
= get_containing_scope (parent
))
6775 if (TREE_CODE (parent
) == FUNCTION_DECL
)
6776 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent
)) = 1;
6779 TREE_ASM_WRITTEN (current_function_decl
) = 1;
6781 /* After expanding, the return labels are no longer needed. */
6782 return_label
= NULL
;
6783 naked_return_label
= NULL
;
6785 /* After expanding, the tm_restart map is no longer needed. */
6786 if (fun
->gimple_df
->tm_restart
)
6787 fun
->gimple_df
->tm_restart
= NULL
;
6789 /* Tag the blocks with a depth number so that change_scope can find
6790 the common parent easily. */
6791 set_block_levels (DECL_INITIAL (fun
->decl
), 0);
6792 default_rtl_profile ();
6794 /* For -dx discard loops now, otherwise IL verify in clean_state will
6796 if (rtl_dump_and_exit
)
6798 cfun
->curr_properties
&= ~PROP_loops
;
6799 loop_optimizer_finalize ();
6802 timevar_pop (TV_POST_EXPAND
);
6810 make_pass_expand (gcc::context
*ctxt
)
6812 return new pass_expand (ctxt
);