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
)
369 align
= TYPE_ALIGN (TREE_TYPE (decl
));
372 align
= LOCAL_DECL_ALIGNMENT (decl
);
373 /* Don't change DECL_ALIGN when called from estimated_stack_frame_size.
374 That is done before IPA and could bump alignment based on host
375 backend even for offloaded code which wants different
376 LOCAL_DECL_ALIGNMENT. */
378 SET_DECL_ALIGN (decl
, align
);
380 return align
/ BITS_PER_UNIT
;
383 /* Align given offset BASE with ALIGN. Truncate up if ALIGN_UP is true,
384 down otherwise. Return truncated BASE value. */
386 static inline unsigned HOST_WIDE_INT
387 align_base (HOST_WIDE_INT base
, unsigned HOST_WIDE_INT align
, bool align_up
)
389 return align_up
? (base
+ align
- 1) & -align
: base
& -align
;
392 /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
393 Return the frame offset. */
396 alloc_stack_frame_space (poly_int64 size
, unsigned HOST_WIDE_INT align
)
398 poly_int64 offset
, new_frame_offset
;
400 if (FRAME_GROWS_DOWNWARD
)
403 = aligned_lower_bound (frame_offset
- frame_phase
- size
,
404 align
) + frame_phase
;
405 offset
= new_frame_offset
;
410 = aligned_upper_bound (frame_offset
- frame_phase
,
411 align
) + frame_phase
;
412 offset
= new_frame_offset
;
413 new_frame_offset
+= size
;
415 frame_offset
= new_frame_offset
;
417 if (frame_offset_overflow (frame_offset
, cfun
->decl
))
418 frame_offset
= offset
= 0;
423 /* Accumulate DECL into STACK_VARS. */
426 add_stack_var (tree decl
, bool really_expand
)
430 if (stack_vars_num
>= stack_vars_alloc
)
432 if (stack_vars_alloc
)
433 stack_vars_alloc
= stack_vars_alloc
* 3 / 2;
435 stack_vars_alloc
= 32;
437 = XRESIZEVEC (class stack_var
, stack_vars
, stack_vars_alloc
);
439 if (!decl_to_stack_part
)
440 decl_to_stack_part
= new hash_map
<tree
, size_t>;
442 v
= &stack_vars
[stack_vars_num
];
443 decl_to_stack_part
->put (decl
, stack_vars_num
);
446 tree size
= TREE_CODE (decl
) == SSA_NAME
447 ? TYPE_SIZE_UNIT (TREE_TYPE (decl
))
448 : DECL_SIZE_UNIT (decl
);
449 v
->size
= tree_to_poly_uint64 (size
);
450 /* Ensure that all variables have size, so that &a != &b for any two
451 variables that are simultaneously live. */
452 if (known_eq (v
->size
, 0U))
454 v
->alignb
= align_local_variable (decl
, really_expand
);
455 /* An alignment of zero can mightily confuse us later. */
456 gcc_assert (v
->alignb
!= 0);
458 /* All variables are initially in their own partition. */
459 v
->representative
= stack_vars_num
;
462 /* All variables initially conflict with no other. */
465 /* Ensure that this decl doesn't get put onto the list twice. */
466 set_rtl (decl
, pc_rtx
);
471 /* Make the decls associated with luid's X and Y conflict. */
474 add_stack_var_conflict (size_t x
, size_t y
)
476 class stack_var
*a
= &stack_vars
[x
];
477 class stack_var
*b
= &stack_vars
[y
];
481 a
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
483 b
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
484 bitmap_set_bit (a
->conflicts
, y
);
485 bitmap_set_bit (b
->conflicts
, x
);
488 /* Check whether the decls associated with luid's X and Y conflict. */
491 stack_var_conflict_p (size_t x
, size_t y
)
493 class stack_var
*a
= &stack_vars
[x
];
494 class stack_var
*b
= &stack_vars
[y
];
497 /* Partitions containing an SSA name result from gimple registers
498 with things like unsupported modes. They are top-level and
499 hence conflict with everything else. */
500 if (TREE_CODE (a
->decl
) == SSA_NAME
|| TREE_CODE (b
->decl
) == SSA_NAME
)
503 if (!a
->conflicts
|| !b
->conflicts
)
505 return bitmap_bit_p (a
->conflicts
, y
);
508 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
509 enter its partition number into bitmap DATA. */
512 visit_op (gimple
*, tree op
, tree
, void *data
)
514 bitmap active
= (bitmap
)data
;
515 op
= get_base_address (op
);
518 && DECL_RTL_IF_SET (op
) == pc_rtx
)
520 size_t *v
= decl_to_stack_part
->get (op
);
522 bitmap_set_bit (active
, *v
);
527 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
528 record conflicts between it and all currently active other partitions
532 visit_conflict (gimple
*, tree op
, tree
, void *data
)
534 bitmap active
= (bitmap
)data
;
535 op
= get_base_address (op
);
538 && DECL_RTL_IF_SET (op
) == pc_rtx
)
540 size_t *v
= decl_to_stack_part
->get (op
);
541 if (v
&& bitmap_set_bit (active
, *v
))
546 gcc_assert (num
< stack_vars_num
);
547 EXECUTE_IF_SET_IN_BITMAP (active
, 0, i
, bi
)
548 add_stack_var_conflict (num
, i
);
554 /* Helper routine for add_scope_conflicts, calculating the active partitions
555 at the end of BB, leaving the result in WORK. We're called to generate
556 conflicts when FOR_CONFLICT is true, otherwise we're just tracking
560 add_scope_conflicts_1 (basic_block bb
, bitmap work
, bool for_conflict
)
564 gimple_stmt_iterator gsi
;
565 walk_stmt_load_store_addr_fn visit
;
568 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
569 bitmap_ior_into (work
, (bitmap
)e
->src
->aux
);
573 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
575 gimple
*stmt
= gsi_stmt (gsi
);
576 walk_stmt_load_store_addr_ops (stmt
, work
, NULL
, NULL
, visit
);
578 for (gsi
= gsi_after_labels (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
580 gimple
*stmt
= gsi_stmt (gsi
);
582 if (gimple_clobber_p (stmt
))
584 tree lhs
= gimple_assign_lhs (stmt
);
586 /* Nested function lowering might introduce LHSs
587 that are COMPONENT_REFs. */
590 if (DECL_RTL_IF_SET (lhs
) == pc_rtx
591 && (v
= decl_to_stack_part
->get (lhs
)))
592 bitmap_clear_bit (work
, *v
);
594 else if (!is_gimple_debug (stmt
))
597 && visit
== visit_op
)
599 /* If this is the first real instruction in this BB we need
600 to add conflicts for everything live at this point now.
601 Unlike classical liveness for named objects we can't
602 rely on seeing a def/use of the names we're interested in.
603 There might merely be indirect loads/stores. We'd not add any
604 conflicts for such partitions. */
607 EXECUTE_IF_SET_IN_BITMAP (work
, 0, i
, bi
)
609 class stack_var
*a
= &stack_vars
[i
];
611 a
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
612 bitmap_ior_into (a
->conflicts
, work
);
614 visit
= visit_conflict
;
616 walk_stmt_load_store_addr_ops (stmt
, work
, visit
, visit
, visit
);
621 /* Generate stack partition conflicts between all partitions that are
622 simultaneously live. */
625 add_scope_conflicts (void)
629 bitmap work
= BITMAP_ALLOC (NULL
);
633 /* We approximate the live range of a stack variable by taking the first
634 mention of its name as starting point(s), and by the end-of-scope
635 death clobber added by gimplify as ending point(s) of the range.
636 This overapproximates in the case we for instance moved an address-taken
637 operation upward, without also moving a dereference to it upwards.
638 But it's conservatively correct as a variable never can hold values
639 before its name is mentioned at least once.
641 We then do a mostly classical bitmap liveness algorithm. */
643 FOR_ALL_BB_FN (bb
, cfun
)
644 bb
->aux
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
646 rpo
= XNEWVEC (int, last_basic_block_for_fn (cfun
));
647 n_bbs
= pre_and_rev_post_order_compute (NULL
, rpo
, false);
654 for (i
= 0; i
< n_bbs
; i
++)
657 bb
= BASIC_BLOCK_FOR_FN (cfun
, rpo
[i
]);
658 active
= (bitmap
)bb
->aux
;
659 add_scope_conflicts_1 (bb
, work
, false);
660 if (bitmap_ior_into (active
, work
))
665 FOR_EACH_BB_FN (bb
, cfun
)
666 add_scope_conflicts_1 (bb
, work
, true);
670 FOR_ALL_BB_FN (bb
, cfun
)
671 BITMAP_FREE (bb
->aux
);
674 /* A subroutine of partition_stack_vars. A comparison function for qsort,
675 sorting an array of indices by the properties of the object. */
678 stack_var_cmp (const void *a
, const void *b
)
680 size_t ia
= *(const size_t *)a
;
681 size_t ib
= *(const size_t *)b
;
682 unsigned int aligna
= stack_vars
[ia
].alignb
;
683 unsigned int alignb
= stack_vars
[ib
].alignb
;
684 poly_int64 sizea
= stack_vars
[ia
].size
;
685 poly_int64 sizeb
= stack_vars
[ib
].size
;
686 tree decla
= stack_vars
[ia
].decl
;
687 tree declb
= stack_vars
[ib
].decl
;
689 unsigned int uida
, uidb
;
691 /* Primary compare on "large" alignment. Large comes first. */
692 largea
= (aligna
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
693 largeb
= (alignb
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
694 if (largea
!= largeb
)
695 return (int)largeb
- (int)largea
;
697 /* Secondary compare on size, decreasing */
698 int diff
= compare_sizes_for_sort (sizeb
, sizea
);
702 /* Tertiary compare on true alignment, decreasing. */
708 /* Final compare on ID for sort stability, increasing.
709 Two SSA names are compared by their version, SSA names come before
710 non-SSA names, and two normal decls are compared by their DECL_UID. */
711 if (TREE_CODE (decla
) == SSA_NAME
)
713 if (TREE_CODE (declb
) == SSA_NAME
)
714 uida
= SSA_NAME_VERSION (decla
), uidb
= SSA_NAME_VERSION (declb
);
718 else if (TREE_CODE (declb
) == SSA_NAME
)
721 uida
= DECL_UID (decla
), uidb
= DECL_UID (declb
);
729 struct part_traits
: unbounded_int_hashmap_traits
<size_t, bitmap
> {};
730 typedef hash_map
<size_t, bitmap
, part_traits
> part_hashmap
;
732 /* If the points-to solution *PI points to variables that are in a partition
733 together with other variables add all partition members to the pointed-to
737 add_partitioned_vars_to_ptset (struct pt_solution
*pt
,
738 part_hashmap
*decls_to_partitions
,
739 hash_set
<bitmap
> *visited
, bitmap temp
)
747 /* The pointed-to vars bitmap is shared, it is enough to
749 || visited
->add (pt
->vars
))
754 /* By using a temporary bitmap to store all members of the partitions
755 we have to add we make sure to visit each of the partitions only
757 EXECUTE_IF_SET_IN_BITMAP (pt
->vars
, 0, i
, bi
)
759 || !bitmap_bit_p (temp
, i
))
760 && (part
= decls_to_partitions
->get (i
)))
761 bitmap_ior_into (temp
, *part
);
762 if (!bitmap_empty_p (temp
))
763 bitmap_ior_into (pt
->vars
, temp
);
766 /* Update points-to sets based on partition info, so we can use them on RTL.
767 The bitmaps representing stack partitions will be saved until expand,
768 where partitioned decls used as bases in memory expressions will be
772 update_alias_info_with_stack_vars (void)
774 part_hashmap
*decls_to_partitions
= NULL
;
776 tree var
= NULL_TREE
;
778 for (i
= 0; i
< stack_vars_num
; i
++)
782 struct ptr_info_def
*pi
;
784 /* Not interested in partitions with single variable. */
785 if (stack_vars
[i
].representative
!= i
786 || stack_vars
[i
].next
== EOC
)
789 if (!decls_to_partitions
)
791 decls_to_partitions
= new part_hashmap
;
792 cfun
->gimple_df
->decls_to_pointers
= new hash_map
<tree
, tree
>;
795 /* Create an SSA_NAME that points to the partition for use
796 as base during alias-oracle queries on RTL for bases that
797 have been partitioned. */
798 if (var
== NULL_TREE
)
799 var
= create_tmp_var (ptr_type_node
);
800 name
= make_ssa_name (var
);
802 /* Create bitmaps representing partitions. They will be used for
803 points-to sets later, so use GGC alloc. */
804 part
= BITMAP_GGC_ALLOC ();
805 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
807 tree decl
= stack_vars
[j
].decl
;
808 unsigned int uid
= DECL_PT_UID (decl
);
809 bitmap_set_bit (part
, uid
);
810 decls_to_partitions
->put (uid
, part
);
811 cfun
->gimple_df
->decls_to_pointers
->put (decl
, name
);
812 if (TREE_ADDRESSABLE (decl
))
813 TREE_ADDRESSABLE (name
) = 1;
816 /* Make the SSA name point to all partition members. */
817 pi
= get_ptr_info (name
);
818 pt_solution_set (&pi
->pt
, part
, false);
821 /* Make all points-to sets that contain one member of a partition
822 contain all members of the partition. */
823 if (decls_to_partitions
)
827 hash_set
<bitmap
> visited
;
828 bitmap temp
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
830 FOR_EACH_SSA_NAME (i
, name
, cfun
)
832 struct ptr_info_def
*pi
;
834 if (POINTER_TYPE_P (TREE_TYPE (name
))
835 && ((pi
= SSA_NAME_PTR_INFO (name
)) != NULL
))
836 add_partitioned_vars_to_ptset (&pi
->pt
, decls_to_partitions
,
840 add_partitioned_vars_to_ptset (&cfun
->gimple_df
->escaped
,
841 decls_to_partitions
, &visited
, temp
);
843 delete decls_to_partitions
;
848 /* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
849 partitioning algorithm. Partitions A and B are known to be non-conflicting.
850 Merge them into a single partition A. */
853 union_stack_vars (size_t a
, size_t b
)
855 class stack_var
*vb
= &stack_vars
[b
];
859 gcc_assert (stack_vars
[b
].next
== EOC
);
860 /* Add B to A's partition. */
861 stack_vars
[b
].next
= stack_vars
[a
].next
;
862 stack_vars
[b
].representative
= a
;
863 stack_vars
[a
].next
= b
;
865 /* Make sure A is big enough to hold B. */
866 stack_vars
[a
].size
= upper_bound (stack_vars
[a
].size
, stack_vars
[b
].size
);
868 /* Update the required alignment of partition A to account for B. */
869 if (stack_vars
[a
].alignb
< stack_vars
[b
].alignb
)
870 stack_vars
[a
].alignb
= stack_vars
[b
].alignb
;
872 /* Update the interference graph and merge the conflicts. */
875 EXECUTE_IF_SET_IN_BITMAP (vb
->conflicts
, 0, u
, bi
)
876 add_stack_var_conflict (a
, stack_vars
[u
].representative
);
877 BITMAP_FREE (vb
->conflicts
);
881 /* A subroutine of expand_used_vars. Binpack the variables into
882 partitions constrained by the interference graph. The overall
883 algorithm used is as follows:
885 Sort the objects by size in descending order.
890 Look for the largest non-conflicting object B with size <= S.
897 partition_stack_vars (void)
899 size_t si
, sj
, n
= stack_vars_num
;
901 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
902 for (si
= 0; si
< n
; ++si
)
903 stack_vars_sorted
[si
] = si
;
908 qsort (stack_vars_sorted
, n
, sizeof (size_t), stack_var_cmp
);
910 for (si
= 0; si
< n
; ++si
)
912 size_t i
= stack_vars_sorted
[si
];
913 unsigned int ialign
= stack_vars
[i
].alignb
;
914 poly_int64 isize
= stack_vars
[i
].size
;
916 /* Ignore objects that aren't partition representatives. If we
917 see a var that is not a partition representative, it must
918 have been merged earlier. */
919 if (stack_vars
[i
].representative
!= i
)
922 for (sj
= si
+ 1; sj
< n
; ++sj
)
924 size_t j
= stack_vars_sorted
[sj
];
925 unsigned int jalign
= stack_vars
[j
].alignb
;
926 poly_int64 jsize
= stack_vars
[j
].size
;
928 /* Ignore objects that aren't partition representatives. */
929 if (stack_vars
[j
].representative
!= j
)
932 /* Do not mix objects of "small" (supported) alignment
933 and "large" (unsupported) alignment. */
934 if ((ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
935 != (jalign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
))
938 /* For Address Sanitizer do not mix objects with different
939 sizes, as the shorter vars wouldn't be adequately protected.
940 Don't do that for "large" (unsupported) alignment objects,
941 those aren't protected anyway. */
942 if (asan_sanitize_stack_p ()
943 && maybe_ne (isize
, jsize
)
944 && ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
947 /* Ignore conflicting objects. */
948 if (stack_var_conflict_p (i
, j
))
951 /* UNION the objects, placing J at OFFSET. */
952 union_stack_vars (i
, j
);
956 update_alias_info_with_stack_vars ();
959 /* A debugging aid for expand_used_vars. Dump the generated partitions. */
962 dump_stack_var_partition (void)
964 size_t si
, i
, j
, n
= stack_vars_num
;
966 for (si
= 0; si
< n
; ++si
)
968 i
= stack_vars_sorted
[si
];
970 /* Skip variables that aren't partition representatives, for now. */
971 if (stack_vars
[i
].representative
!= i
)
974 fprintf (dump_file
, "Partition %lu: size ", (unsigned long) i
);
975 print_dec (stack_vars
[i
].size
, dump_file
);
976 fprintf (dump_file
, " align %u\n", stack_vars
[i
].alignb
);
978 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
980 fputc ('\t', dump_file
);
981 print_generic_expr (dump_file
, stack_vars
[j
].decl
, dump_flags
);
983 fputc ('\n', dump_file
);
987 /* Assign rtl to DECL at BASE + OFFSET. */
990 expand_one_stack_var_at (tree decl
, rtx base
, unsigned base_align
,
996 /* If this fails, we've overflowed the stack frame. Error nicely? */
997 gcc_assert (known_eq (offset
, trunc_int_for_mode (offset
, Pmode
)));
999 x
= plus_constant (Pmode
, base
, offset
);
1000 x
= gen_rtx_MEM (TREE_CODE (decl
) == SSA_NAME
1001 ? TYPE_MODE (TREE_TYPE (decl
))
1002 : DECL_MODE (SSAVAR (decl
)), x
);
1004 if (TREE_CODE (decl
) != SSA_NAME
)
1006 /* Set alignment we actually gave this decl if it isn't an SSA name.
1007 If it is we generate stack slots only accidentally so it isn't as
1008 important, we'll simply use the alignment that is already set. */
1009 if (base
== virtual_stack_vars_rtx
)
1010 offset
-= frame_phase
;
1011 align
= known_alignment (offset
);
1012 align
*= BITS_PER_UNIT
;
1013 if (align
== 0 || align
> base_align
)
1016 /* One would think that we could assert that we're not decreasing
1017 alignment here, but (at least) the i386 port does exactly this
1018 via the MINIMUM_ALIGNMENT hook. */
1020 SET_DECL_ALIGN (decl
, align
);
1021 DECL_USER_ALIGN (decl
) = 0;
1027 class stack_vars_data
1030 /* Vector of offset pairs, always end of some padding followed
1031 by start of the padding that needs Address Sanitizer protection.
1032 The vector is in reversed, highest offset pairs come first. */
1033 auto_vec
<HOST_WIDE_INT
> asan_vec
;
1035 /* Vector of partition representative decls in between the paddings. */
1036 auto_vec
<tree
> asan_decl_vec
;
1038 /* Base pseudo register for Address Sanitizer protected automatic vars. */
1041 /* Alignment needed for the Address Sanitizer protected automatic vars. */
1042 unsigned int asan_alignb
;
1045 /* A subroutine of expand_used_vars. Give each partition representative
1046 a unique location within the stack frame. Update each partition member
1047 with that location. */
1050 expand_stack_vars (bool (*pred
) (size_t), class stack_vars_data
*data
)
1052 size_t si
, i
, j
, n
= stack_vars_num
;
1053 poly_uint64 large_size
= 0, large_alloc
= 0;
1054 rtx large_base
= NULL
;
1055 unsigned large_align
= 0;
1056 bool large_allocation_done
= false;
1059 /* Determine if there are any variables requiring "large" alignment.
1060 Since these are dynamically allocated, we only process these if
1061 no predicate involved. */
1062 large_align
= stack_vars
[stack_vars_sorted
[0]].alignb
* BITS_PER_UNIT
;
1063 if (pred
== NULL
&& large_align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1065 /* Find the total size of these variables. */
1066 for (si
= 0; si
< n
; ++si
)
1070 i
= stack_vars_sorted
[si
];
1071 alignb
= stack_vars
[i
].alignb
;
1073 /* All "large" alignment decls come before all "small" alignment
1074 decls, but "large" alignment decls are not sorted based on
1075 their alignment. Increase large_align to track the largest
1076 required alignment. */
1077 if ((alignb
* BITS_PER_UNIT
) > large_align
)
1078 large_align
= alignb
* BITS_PER_UNIT
;
1080 /* Stop when we get to the first decl with "small" alignment. */
1081 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
1084 /* Skip variables that aren't partition representatives. */
1085 if (stack_vars
[i
].representative
!= i
)
1088 /* Skip variables that have already had rtl assigned. See also
1089 add_stack_var where we perpetrate this pc_rtx hack. */
1090 decl
= stack_vars
[i
].decl
;
1091 if (TREE_CODE (decl
) == SSA_NAME
1092 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)] != NULL_RTX
1093 : DECL_RTL (decl
) != pc_rtx
)
1096 large_size
= aligned_upper_bound (large_size
, alignb
);
1097 large_size
+= stack_vars
[i
].size
;
1101 for (si
= 0; si
< n
; ++si
)
1104 unsigned base_align
, alignb
;
1107 i
= stack_vars_sorted
[si
];
1109 /* Skip variables that aren't partition representatives, for now. */
1110 if (stack_vars
[i
].representative
!= i
)
1113 /* Skip variables that have already had rtl assigned. See also
1114 add_stack_var where we perpetrate this pc_rtx hack. */
1115 decl
= stack_vars
[i
].decl
;
1116 if (TREE_CODE (decl
) == SSA_NAME
1117 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)] != NULL_RTX
1118 : DECL_RTL (decl
) != pc_rtx
)
1121 /* Check the predicate to see whether this variable should be
1122 allocated in this pass. */
1123 if (pred
&& !pred (i
))
1126 alignb
= stack_vars
[i
].alignb
;
1127 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
1129 base
= virtual_stack_vars_rtx
;
1130 /* ASAN description strings don't yet have a syntax for expressing
1131 polynomial offsets. */
1132 HOST_WIDE_INT prev_offset
;
1133 if (asan_sanitize_stack_p ()
1135 && frame_offset
.is_constant (&prev_offset
)
1136 && stack_vars
[i
].size
.is_constant ())
1138 if (data
->asan_vec
.is_empty ())
1140 alloc_stack_frame_space (0, ASAN_RED_ZONE_SIZE
);
1141 prev_offset
= frame_offset
.to_constant ();
1143 prev_offset
= align_base (prev_offset
,
1144 ASAN_MIN_RED_ZONE_SIZE
,
1145 !FRAME_GROWS_DOWNWARD
);
1146 tree repr_decl
= NULL_TREE
;
1147 unsigned HOST_WIDE_INT size
1148 = asan_var_and_redzone_size (stack_vars
[i
].size
.to_constant ());
1149 if (data
->asan_vec
.is_empty ())
1150 size
= MAX (size
, ASAN_RED_ZONE_SIZE
);
1152 unsigned HOST_WIDE_INT alignment
= MAX (alignb
,
1153 ASAN_MIN_RED_ZONE_SIZE
);
1154 offset
= alloc_stack_frame_space (size
, alignment
);
1156 data
->asan_vec
.safe_push (prev_offset
);
1157 /* Allocating a constant amount of space from a constant
1158 starting offset must give a constant result. */
1159 data
->asan_vec
.safe_push ((offset
+ stack_vars
[i
].size
)
1161 /* Find best representative of the partition.
1162 Prefer those with DECL_NAME, even better
1163 satisfying asan_protect_stack_decl predicate. */
1164 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1165 if (asan_protect_stack_decl (stack_vars
[j
].decl
)
1166 && DECL_NAME (stack_vars
[j
].decl
))
1168 repr_decl
= stack_vars
[j
].decl
;
1171 else if (repr_decl
== NULL_TREE
1172 && DECL_P (stack_vars
[j
].decl
)
1173 && DECL_NAME (stack_vars
[j
].decl
))
1174 repr_decl
= stack_vars
[j
].decl
;
1175 if (repr_decl
== NULL_TREE
)
1176 repr_decl
= stack_vars
[i
].decl
;
1177 data
->asan_decl_vec
.safe_push (repr_decl
);
1179 /* Make sure a representative is unpoison if another
1180 variable in the partition is handled by
1181 use-after-scope sanitization. */
1182 if (asan_handled_variables
!= NULL
1183 && !asan_handled_variables
->contains (repr_decl
))
1185 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1186 if (asan_handled_variables
->contains (stack_vars
[j
].decl
))
1189 asan_handled_variables
->add (repr_decl
);
1192 data
->asan_alignb
= MAX (data
->asan_alignb
, alignb
);
1193 if (data
->asan_base
== NULL
)
1194 data
->asan_base
= gen_reg_rtx (Pmode
);
1195 base
= data
->asan_base
;
1197 if (!STRICT_ALIGNMENT
)
1198 base_align
= crtl
->max_used_stack_slot_alignment
;
1200 base_align
= MAX (crtl
->max_used_stack_slot_alignment
,
1201 GET_MODE_ALIGNMENT (SImode
)
1202 << ASAN_SHADOW_SHIFT
);
1206 offset
= alloc_stack_frame_space (stack_vars
[i
].size
, alignb
);
1207 base_align
= crtl
->max_used_stack_slot_alignment
;
1212 /* Large alignment is only processed in the last pass. */
1216 /* If there were any variables requiring "large" alignment, allocate
1218 if (maybe_ne (large_size
, 0U) && ! large_allocation_done
)
1221 rtx large_allocsize
;
1223 large_allocsize
= gen_int_mode (large_size
, Pmode
);
1224 get_dynamic_stack_size (&large_allocsize
, 0, large_align
, NULL
);
1225 loffset
= alloc_stack_frame_space
1226 (rtx_to_poly_int64 (large_allocsize
),
1227 PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
);
1228 large_base
= get_dynamic_stack_base (loffset
, large_align
);
1229 large_allocation_done
= true;
1231 gcc_assert (large_base
!= NULL
);
1233 large_alloc
= aligned_upper_bound (large_alloc
, alignb
);
1234 offset
= large_alloc
;
1235 large_alloc
+= stack_vars
[i
].size
;
1238 base_align
= large_align
;
1241 /* Create rtl for each variable based on their location within the
1243 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1245 expand_one_stack_var_at (stack_vars
[j
].decl
,
1251 gcc_assert (known_eq (large_alloc
, large_size
));
1254 /* Take into account all sizes of partitions and reset DECL_RTLs. */
1256 account_stack_vars (void)
1258 size_t si
, j
, i
, n
= stack_vars_num
;
1259 poly_uint64 size
= 0;
1261 for (si
= 0; si
< n
; ++si
)
1263 i
= stack_vars_sorted
[si
];
1265 /* Skip variables that aren't partition representatives, for now. */
1266 if (stack_vars
[i
].representative
!= i
)
1269 size
+= stack_vars
[i
].size
;
1270 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1271 set_rtl (stack_vars
[j
].decl
, NULL
);
1276 /* Record the RTL assignment X for the default def of PARM. */
1279 set_parm_rtl (tree parm
, rtx x
)
1281 gcc_assert (TREE_CODE (parm
) == PARM_DECL
1282 || TREE_CODE (parm
) == RESULT_DECL
);
1284 if (x
&& !MEM_P (x
))
1286 unsigned int align
= MINIMUM_ALIGNMENT (TREE_TYPE (parm
),
1287 TYPE_MODE (TREE_TYPE (parm
)),
1288 TYPE_ALIGN (TREE_TYPE (parm
)));
1290 /* If the variable alignment is very large we'll dynamicaly
1291 allocate it, which means that in-frame portion is just a
1292 pointer. ??? We've got a pseudo for sure here, do we
1293 actually dynamically allocate its spilling area if needed?
1294 ??? Isn't it a problem when Pmode alignment also exceeds
1295 MAX_SUPPORTED_STACK_ALIGNMENT, as can happen on cris and lm32? */
1296 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1297 align
= GET_MODE_ALIGNMENT (Pmode
);
1299 record_alignment_for_reg_var (align
);
1302 tree ssa
= ssa_default_def (cfun
, parm
);
1304 return set_rtl (parm
, x
);
1306 int part
= var_to_partition (SA
.map
, ssa
);
1307 gcc_assert (part
!= NO_PARTITION
);
1309 bool changed
= bitmap_bit_p (SA
.partitions_for_parm_default_defs
, part
);
1310 gcc_assert (changed
);
1313 gcc_assert (DECL_RTL (parm
) == x
);
1316 /* A subroutine of expand_one_var. Called to immediately assign rtl
1317 to a variable to be allocated in the stack frame. */
1320 expand_one_stack_var_1 (tree var
)
1324 unsigned byte_align
;
1326 if (TREE_CODE (var
) == SSA_NAME
)
1328 tree type
= TREE_TYPE (var
);
1329 size
= tree_to_poly_uint64 (TYPE_SIZE_UNIT (type
));
1330 byte_align
= TYPE_ALIGN_UNIT (type
);
1334 size
= tree_to_poly_uint64 (DECL_SIZE_UNIT (var
));
1335 byte_align
= align_local_variable (var
, true);
1338 /* We handle highly aligned variables in expand_stack_vars. */
1339 gcc_assert (byte_align
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
);
1341 offset
= alloc_stack_frame_space (size
, byte_align
);
1343 expand_one_stack_var_at (var
, virtual_stack_vars_rtx
,
1344 crtl
->max_used_stack_slot_alignment
, offset
);
1347 /* Wrapper for expand_one_stack_var_1 that checks SSA_NAMEs are
1348 already assigned some MEM. */
1351 expand_one_stack_var (tree var
)
1353 if (TREE_CODE (var
) == SSA_NAME
)
1355 int part
= var_to_partition (SA
.map
, var
);
1356 if (part
!= NO_PARTITION
)
1358 rtx x
= SA
.partition_to_pseudo
[part
];
1360 gcc_assert (MEM_P (x
));
1365 return expand_one_stack_var_1 (var
);
1368 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1369 that will reside in a hard register. */
1372 expand_one_hard_reg_var (tree var
)
1374 rest_of_decl_compilation (var
, 0, 0);
1377 /* Record the alignment requirements of some variable assigned to a
1381 record_alignment_for_reg_var (unsigned int align
)
1383 if (SUPPORTS_STACK_ALIGNMENT
1384 && crtl
->stack_alignment_estimated
< align
)
1386 /* stack_alignment_estimated shouldn't change after stack
1387 realign decision made */
1388 gcc_assert (!crtl
->stack_realign_processed
);
1389 crtl
->stack_alignment_estimated
= align
;
1392 /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
1393 So here we only make sure stack_alignment_needed >= align. */
1394 if (crtl
->stack_alignment_needed
< align
)
1395 crtl
->stack_alignment_needed
= align
;
1396 if (crtl
->max_used_stack_slot_alignment
< align
)
1397 crtl
->max_used_stack_slot_alignment
= align
;
1400 /* Create RTL for an SSA partition. */
1403 expand_one_ssa_partition (tree var
)
1405 int part
= var_to_partition (SA
.map
, var
);
1406 gcc_assert (part
!= NO_PARTITION
);
1408 if (SA
.partition_to_pseudo
[part
])
1411 unsigned int align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1412 TYPE_MODE (TREE_TYPE (var
)),
1413 TYPE_ALIGN (TREE_TYPE (var
)));
1415 /* If the variable alignment is very large we'll dynamicaly allocate
1416 it, which means that in-frame portion is just a pointer. */
1417 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1418 align
= GET_MODE_ALIGNMENT (Pmode
);
1420 record_alignment_for_reg_var (align
);
1422 if (!use_register_for_decl (var
))
1424 if (defer_stack_allocation (var
, true))
1425 add_stack_var (var
, true);
1427 expand_one_stack_var_1 (var
);
1431 machine_mode reg_mode
= promote_ssa_mode (var
, NULL
);
1432 rtx x
= gen_reg_rtx (reg_mode
);
1436 /* For a promoted variable, X will not be used directly but wrapped in a
1437 SUBREG with SUBREG_PROMOTED_VAR_P set, which means that the RTL land
1438 will assume that its upper bits can be inferred from its lower bits.
1439 Therefore, if X isn't initialized on every path from the entry, then
1440 we must do it manually in order to fulfill the above assumption. */
1441 if (reg_mode
!= TYPE_MODE (TREE_TYPE (var
))
1442 && bitmap_bit_p (SA
.partitions_for_undefined_values
, part
))
1443 emit_move_insn (x
, CONST0_RTX (reg_mode
));
1446 /* Record the association between the RTL generated for partition PART
1447 and the underlying variable of the SSA_NAME VAR. */
1450 adjust_one_expanded_partition_var (tree var
)
1455 tree decl
= SSA_NAME_VAR (var
);
1457 int part
= var_to_partition (SA
.map
, var
);
1458 if (part
== NO_PARTITION
)
1461 rtx x
= SA
.partition_to_pseudo
[part
];
1470 /* Note if the object is a user variable. */
1471 if (decl
&& !DECL_ARTIFICIAL (decl
))
1474 if (POINTER_TYPE_P (decl
? TREE_TYPE (decl
) : TREE_TYPE (var
)))
1475 mark_reg_pointer (x
, get_pointer_alignment (var
));
1478 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1479 that will reside in a pseudo register. */
1482 expand_one_register_var (tree var
)
1484 if (TREE_CODE (var
) == SSA_NAME
)
1486 int part
= var_to_partition (SA
.map
, var
);
1487 if (part
!= NO_PARTITION
)
1489 rtx x
= SA
.partition_to_pseudo
[part
];
1491 gcc_assert (REG_P (x
));
1498 tree type
= TREE_TYPE (decl
);
1499 machine_mode reg_mode
= promote_decl_mode (decl
, NULL
);
1500 rtx x
= gen_reg_rtx (reg_mode
);
1504 /* Note if the object is a user variable. */
1505 if (!DECL_ARTIFICIAL (decl
))
1508 if (POINTER_TYPE_P (type
))
1509 mark_reg_pointer (x
, get_pointer_alignment (var
));
1512 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
1513 has some associated error, e.g. its type is error-mark. We just need
1514 to pick something that won't crash the rest of the compiler. */
1517 expand_one_error_var (tree var
)
1519 machine_mode mode
= DECL_MODE (var
);
1522 if (mode
== BLKmode
)
1523 x
= gen_rtx_MEM (BLKmode
, const0_rtx
);
1524 else if (mode
== VOIDmode
)
1527 x
= gen_reg_rtx (mode
);
1529 SET_DECL_RTL (var
, x
);
1532 /* A subroutine of expand_one_var. VAR is a variable that will be
1533 allocated to the local stack frame. Return true if we wish to
1534 add VAR to STACK_VARS so that it will be coalesced with other
1535 variables. Return false to allocate VAR immediately.
1537 This function is used to reduce the number of variables considered
1538 for coalescing, which reduces the size of the quadratic problem. */
1541 defer_stack_allocation (tree var
, bool toplevel
)
1543 tree size_unit
= TREE_CODE (var
) == SSA_NAME
1544 ? TYPE_SIZE_UNIT (TREE_TYPE (var
))
1545 : DECL_SIZE_UNIT (var
);
1548 /* Whether the variable is small enough for immediate allocation not to be
1549 a problem with regard to the frame size. */
1551 = (poly_int_tree_p (size_unit
, &size
)
1552 && (estimated_poly_value (size
)
1553 < param_min_size_for_stack_sharing
));
1555 /* If stack protection is enabled, *all* stack variables must be deferred,
1556 so that we can re-order the strings to the top of the frame.
1557 Similarly for Address Sanitizer. */
1558 if (flag_stack_protect
|| asan_sanitize_stack_p ())
1561 unsigned int align
= TREE_CODE (var
) == SSA_NAME
1562 ? TYPE_ALIGN (TREE_TYPE (var
))
1565 /* We handle "large" alignment via dynamic allocation. We want to handle
1566 this extra complication in only one place, so defer them. */
1567 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1570 bool ignored
= TREE_CODE (var
) == SSA_NAME
1571 ? !SSAVAR (var
) || DECL_IGNORED_P (SSA_NAME_VAR (var
))
1572 : DECL_IGNORED_P (var
);
1574 /* When optimization is enabled, DECL_IGNORED_P variables originally scoped
1575 might be detached from their block and appear at toplevel when we reach
1576 here. We want to coalesce them with variables from other blocks when
1577 the immediate contribution to the frame size would be noticeable. */
1578 if (toplevel
&& optimize
> 0 && ignored
&& !smallish
)
1581 /* Variables declared in the outermost scope automatically conflict
1582 with every other variable. The only reason to want to defer them
1583 at all is that, after sorting, we can more efficiently pack
1584 small variables in the stack frame. Continue to defer at -O2. */
1585 if (toplevel
&& optimize
< 2)
1588 /* Without optimization, *most* variables are allocated from the
1589 stack, which makes the quadratic problem large exactly when we
1590 want compilation to proceed as quickly as possible. On the
1591 other hand, we don't want the function's stack frame size to
1592 get completely out of hand. So we avoid adding scalars and
1593 "small" aggregates to the list at all. */
1594 if (optimize
== 0 && smallish
)
1600 /* A subroutine of expand_used_vars. Expand one variable according to
1601 its flavor. Variables to be placed on the stack are not actually
1602 expanded yet, merely recorded.
1603 When REALLY_EXPAND is false, only add stack values to be allocated.
1604 Return stack usage this variable is supposed to take.
1608 expand_one_var (tree var
, bool toplevel
, bool really_expand
)
1610 unsigned int align
= BITS_PER_UNIT
;
1615 if (TREE_TYPE (var
) != error_mark_node
&& VAR_P (var
))
1617 if (is_global_var (var
))
1620 /* Because we don't know if VAR will be in register or on stack,
1621 we conservatively assume it will be on stack even if VAR is
1622 eventually put into register after RA pass. For non-automatic
1623 variables, which won't be on stack, we collect alignment of
1624 type and ignore user specified alignment. Similarly for
1625 SSA_NAMEs for which use_register_for_decl returns true. */
1626 if (TREE_STATIC (var
)
1627 || DECL_EXTERNAL (var
)
1628 || (TREE_CODE (origvar
) == SSA_NAME
&& use_register_for_decl (var
)))
1629 align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1630 TYPE_MODE (TREE_TYPE (var
)),
1631 TYPE_ALIGN (TREE_TYPE (var
)));
1632 else if (DECL_HAS_VALUE_EXPR_P (var
)
1633 || (DECL_RTL_SET_P (var
) && MEM_P (DECL_RTL (var
))))
1634 /* Don't consider debug only variables with DECL_HAS_VALUE_EXPR_P set
1635 or variables which were assigned a stack slot already by
1636 expand_one_stack_var_at - in the latter case DECL_ALIGN has been
1637 changed from the offset chosen to it. */
1638 align
= crtl
->stack_alignment_estimated
;
1640 align
= MINIMUM_ALIGNMENT (var
, DECL_MODE (var
), DECL_ALIGN (var
));
1642 /* If the variable alignment is very large we'll dynamicaly allocate
1643 it, which means that in-frame portion is just a pointer. */
1644 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1645 align
= GET_MODE_ALIGNMENT (Pmode
);
1648 record_alignment_for_reg_var (align
);
1651 if (TREE_CODE (origvar
) == SSA_NAME
)
1653 gcc_assert (!VAR_P (var
)
1654 || (!DECL_EXTERNAL (var
)
1655 && !DECL_HAS_VALUE_EXPR_P (var
)
1656 && !TREE_STATIC (var
)
1657 && TREE_TYPE (var
) != error_mark_node
1658 && !DECL_HARD_REGISTER (var
)
1661 if (!VAR_P (var
) && TREE_CODE (origvar
) != SSA_NAME
)
1663 else if (DECL_EXTERNAL (var
))
1665 else if (DECL_HAS_VALUE_EXPR_P (var
))
1667 else if (TREE_STATIC (var
))
1669 else if (TREE_CODE (origvar
) != SSA_NAME
&& DECL_RTL_SET_P (var
))
1671 else if (TREE_TYPE (var
) == error_mark_node
)
1674 expand_one_error_var (var
);
1676 else if (VAR_P (var
) && DECL_HARD_REGISTER (var
))
1680 expand_one_hard_reg_var (var
);
1681 if (!DECL_HARD_REGISTER (var
))
1682 /* Invalid register specification. */
1683 expand_one_error_var (var
);
1686 else if (use_register_for_decl (var
))
1689 expand_one_register_var (origvar
);
1691 else if (!poly_int_tree_p (DECL_SIZE_UNIT (var
), &size
)
1692 || !valid_constant_size_p (DECL_SIZE_UNIT (var
)))
1694 /* Reject variables which cover more than half of the address-space. */
1697 if (DECL_NONLOCAL_FRAME (var
))
1698 error_at (DECL_SOURCE_LOCATION (current_function_decl
),
1699 "total size of local objects is too large");
1701 error_at (DECL_SOURCE_LOCATION (var
),
1702 "size of variable %q+D is too large", var
);
1703 expand_one_error_var (var
);
1706 else if (defer_stack_allocation (var
, toplevel
))
1707 add_stack_var (origvar
, really_expand
);
1712 if (lookup_attribute ("naked",
1713 DECL_ATTRIBUTES (current_function_decl
)))
1714 error ("cannot allocate stack for variable %q+D, naked function",
1717 expand_one_stack_var (origvar
);
1724 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1725 expanding variables. Those variables that can be put into registers
1726 are allocated pseudos; those that can't are put on the stack.
1728 TOPLEVEL is true if this is the outermost BLOCK. */
1731 expand_used_vars_for_block (tree block
, bool toplevel
)
1735 /* Expand all variables at this level. */
1736 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1738 && ((!VAR_P (t
) && TREE_CODE (t
) != RESULT_DECL
)
1739 || !DECL_NONSHAREABLE (t
)))
1740 expand_one_var (t
, toplevel
, true);
1742 /* Expand all variables at containing levels. */
1743 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1744 expand_used_vars_for_block (t
, false);
1747 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1748 and clear TREE_USED on all local variables. */
1751 clear_tree_used (tree block
)
1755 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1756 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
1757 if ((!VAR_P (t
) && TREE_CODE (t
) != RESULT_DECL
)
1758 || !DECL_NONSHAREABLE (t
))
1761 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1762 clear_tree_used (t
);
1766 SPCT_FLAG_DEFAULT
= 1,
1768 SPCT_FLAG_STRONG
= 3,
1769 SPCT_FLAG_EXPLICIT
= 4
1772 /* Examine TYPE and determine a bit mask of the following features. */
1774 #define SPCT_HAS_LARGE_CHAR_ARRAY 1
1775 #define SPCT_HAS_SMALL_CHAR_ARRAY 2
1776 #define SPCT_HAS_ARRAY 4
1777 #define SPCT_HAS_AGGREGATE 8
1780 stack_protect_classify_type (tree type
)
1782 unsigned int ret
= 0;
1785 switch (TREE_CODE (type
))
1788 t
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1789 if (t
== char_type_node
1790 || t
== signed_char_type_node
1791 || t
== unsigned_char_type_node
)
1793 unsigned HOST_WIDE_INT max
= param_ssp_buffer_size
;
1794 unsigned HOST_WIDE_INT len
;
1796 if (!TYPE_SIZE_UNIT (type
)
1797 || !tree_fits_uhwi_p (TYPE_SIZE_UNIT (type
)))
1800 len
= tree_to_uhwi (TYPE_SIZE_UNIT (type
));
1803 ret
= SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1805 ret
= SPCT_HAS_LARGE_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1808 ret
= SPCT_HAS_ARRAY
;
1812 case QUAL_UNION_TYPE
:
1814 ret
= SPCT_HAS_AGGREGATE
;
1815 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
1816 if (TREE_CODE (t
) == FIELD_DECL
)
1817 ret
|= stack_protect_classify_type (TREE_TYPE (t
));
1827 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
1828 part of the local stack frame. Remember if we ever return nonzero for
1829 any variable in this function. The return value is the phase number in
1830 which the variable should be allocated. */
1833 stack_protect_decl_phase (tree decl
)
1835 unsigned int bits
= stack_protect_classify_type (TREE_TYPE (decl
));
1838 if (bits
& SPCT_HAS_SMALL_CHAR_ARRAY
)
1839 has_short_buffer
= true;
1841 if (flag_stack_protect
== SPCT_FLAG_ALL
1842 || flag_stack_protect
== SPCT_FLAG_STRONG
1843 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
1844 && lookup_attribute ("stack_protect",
1845 DECL_ATTRIBUTES (current_function_decl
))))
1847 if ((bits
& (SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_LARGE_CHAR_ARRAY
))
1848 && !(bits
& SPCT_HAS_AGGREGATE
))
1850 else if (bits
& SPCT_HAS_ARRAY
)
1854 ret
= (bits
& SPCT_HAS_LARGE_CHAR_ARRAY
) != 0;
1857 has_protected_decls
= true;
1862 /* Two helper routines that check for phase 1 and phase 2. These are used
1863 as callbacks for expand_stack_vars. */
1866 stack_protect_decl_phase_1 (size_t i
)
1868 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 1;
1872 stack_protect_decl_phase_2 (size_t i
)
1874 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 2;
1877 /* And helper function that checks for asan phase (with stack protector
1878 it is phase 3). This is used as callback for expand_stack_vars.
1879 Returns true if any of the vars in the partition need to be protected. */
1882 asan_decl_phase_3 (size_t i
)
1886 if (asan_protect_stack_decl (stack_vars
[i
].decl
))
1888 i
= stack_vars
[i
].next
;
1893 /* Ensure that variables in different stack protection phases conflict
1894 so that they are not merged and share the same stack slot.
1895 Return true if there are any address taken variables. */
1898 add_stack_protection_conflicts (void)
1900 size_t i
, j
, n
= stack_vars_num
;
1901 unsigned char *phase
;
1904 phase
= XNEWVEC (unsigned char, n
);
1905 for (i
= 0; i
< n
; ++i
)
1907 phase
[i
] = stack_protect_decl_phase (stack_vars
[i
].decl
);
1908 if (TREE_ADDRESSABLE (stack_vars
[i
].decl
))
1912 for (i
= 0; i
< n
; ++i
)
1914 unsigned char ph_i
= phase
[i
];
1915 for (j
= i
+ 1; j
< n
; ++j
)
1916 if (ph_i
!= phase
[j
])
1917 add_stack_var_conflict (i
, j
);
1924 /* Create a decl for the guard at the top of the stack frame. */
1927 create_stack_guard (void)
1929 tree guard
= build_decl (DECL_SOURCE_LOCATION (current_function_decl
),
1930 VAR_DECL
, NULL
, ptr_type_node
);
1931 TREE_THIS_VOLATILE (guard
) = 1;
1932 TREE_USED (guard
) = 1;
1933 expand_one_stack_var (guard
);
1934 crtl
->stack_protect_guard
= guard
;
1937 /* Prepare for expanding variables. */
1939 init_vars_expansion (void)
1941 /* Conflict bitmaps, and a few related temporary bitmaps, go here. */
1942 bitmap_obstack_initialize (&stack_var_bitmap_obstack
);
1944 /* A map from decl to stack partition. */
1945 decl_to_stack_part
= new hash_map
<tree
, size_t>;
1947 /* Initialize local stack smashing state. */
1948 has_protected_decls
= false;
1949 has_short_buffer
= false;
1952 /* Free up stack variable graph data. */
1954 fini_vars_expansion (void)
1956 bitmap_obstack_release (&stack_var_bitmap_obstack
);
1958 XDELETEVEC (stack_vars
);
1959 if (stack_vars_sorted
)
1960 XDELETEVEC (stack_vars_sorted
);
1962 stack_vars_sorted
= NULL
;
1963 stack_vars_alloc
= stack_vars_num
= 0;
1964 delete decl_to_stack_part
;
1965 decl_to_stack_part
= NULL
;
1968 /* Make a fair guess for the size of the stack frame of the function
1969 in NODE. This doesn't have to be exact, the result is only used in
1970 the inline heuristics. So we don't want to run the full stack var
1971 packing algorithm (which is quadratic in the number of stack vars).
1972 Instead, we calculate the total size of all stack vars. This turns
1973 out to be a pretty fair estimate -- packing of stack vars doesn't
1974 happen very often. */
1977 estimated_stack_frame_size (struct cgraph_node
*node
)
1979 poly_int64 size
= 0;
1982 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
1986 init_vars_expansion ();
1988 FOR_EACH_LOCAL_DECL (fn
, i
, var
)
1989 if (auto_var_in_fn_p (var
, fn
->decl
))
1990 size
+= expand_one_var (var
, true, false);
1992 if (stack_vars_num
> 0)
1994 /* Fake sorting the stack vars for account_stack_vars (). */
1995 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
1996 for (i
= 0; i
< stack_vars_num
; ++i
)
1997 stack_vars_sorted
[i
] = i
;
1998 size
+= account_stack_vars ();
2001 fini_vars_expansion ();
2003 return estimated_poly_value (size
);
2006 /* Check if the current function has calls that use a return slot. */
2009 stack_protect_return_slot_p ()
2013 FOR_ALL_BB_FN (bb
, cfun
)
2014 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
2015 !gsi_end_p (gsi
); gsi_next (&gsi
))
2017 gimple
*stmt
= gsi_stmt (gsi
);
2018 /* This assumes that calls to internal-only functions never
2019 use a return slot. */
2020 if (is_gimple_call (stmt
)
2021 && !gimple_call_internal_p (stmt
)
2022 && aggregate_value_p (TREE_TYPE (gimple_call_fntype (stmt
)),
2023 gimple_call_fndecl (stmt
)))
2029 /* Expand all variables used in the function. */
2032 expand_used_vars (void)
2034 tree var
, outer_block
= DECL_INITIAL (current_function_decl
);
2035 auto_vec
<tree
> maybe_local_decls
;
2036 rtx_insn
*var_end_seq
= NULL
;
2039 bool gen_stack_protect_signal
= false;
2041 /* Compute the phase of the stack frame for this function. */
2043 int align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
2044 int off
= targetm
.starting_frame_offset () % align
;
2045 frame_phase
= off
? align
- off
: 0;
2048 /* Set TREE_USED on all variables in the local_decls. */
2049 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
2050 TREE_USED (var
) = 1;
2051 /* Clear TREE_USED on all variables associated with a block scope. */
2052 clear_tree_used (DECL_INITIAL (current_function_decl
));
2054 init_vars_expansion ();
2056 if (targetm
.use_pseudo_pic_reg ())
2057 pic_offset_table_rtx
= gen_reg_rtx (Pmode
);
2059 for (i
= 0; i
< SA
.map
->num_partitions
; i
++)
2061 if (bitmap_bit_p (SA
.partitions_for_parm_default_defs
, i
))
2064 tree var
= partition_to_var (SA
.map
, i
);
2066 gcc_assert (!virtual_operand_p (var
));
2068 expand_one_ssa_partition (var
);
2071 if (flag_stack_protect
== SPCT_FLAG_STRONG
)
2072 gen_stack_protect_signal
= stack_protect_return_slot_p ();
2074 /* At this point all variables on the local_decls with TREE_USED
2075 set are not associated with any block scope. Lay them out. */
2077 len
= vec_safe_length (cfun
->local_decls
);
2078 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
2080 bool expand_now
= false;
2082 /* Expanded above already. */
2083 if (is_gimple_reg (var
))
2085 TREE_USED (var
) = 0;
2088 /* We didn't set a block for static or extern because it's hard
2089 to tell the difference between a global variable (re)declared
2090 in a local scope, and one that's really declared there to
2091 begin with. And it doesn't really matter much, since we're
2092 not giving them stack space. Expand them now. */
2093 else if (TREE_STATIC (var
) || DECL_EXTERNAL (var
))
2096 /* Expand variables not associated with any block now. Those created by
2097 the optimizers could be live anywhere in the function. Those that
2098 could possibly have been scoped originally and detached from their
2099 block will have their allocation deferred so we coalesce them with
2100 others when optimization is enabled. */
2101 else if (TREE_USED (var
))
2104 /* Finally, mark all variables on the list as used. We'll use
2105 this in a moment when we expand those associated with scopes. */
2106 TREE_USED (var
) = 1;
2109 expand_one_var (var
, true, true);
2112 if (DECL_ARTIFICIAL (var
) && !DECL_IGNORED_P (var
))
2114 rtx rtl
= DECL_RTL_IF_SET (var
);
2116 /* Keep artificial non-ignored vars in cfun->local_decls
2117 chain until instantiate_decls. */
2118 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
2119 add_local_decl (cfun
, var
);
2120 else if (rtl
== NULL_RTX
)
2121 /* If rtl isn't set yet, which can happen e.g. with
2122 -fstack-protector, retry before returning from this
2124 maybe_local_decls
.safe_push (var
);
2128 /* We duplicated some of the decls in CFUN->LOCAL_DECLS.
2130 +-----------------+-----------------+
2131 | ...processed... | ...duplicates...|
2132 +-----------------+-----------------+
2134 +-- LEN points here.
2136 We just want the duplicates, as those are the artificial
2137 non-ignored vars that we want to keep until instantiate_decls.
2138 Move them down and truncate the array. */
2139 if (!vec_safe_is_empty (cfun
->local_decls
))
2140 cfun
->local_decls
->block_remove (0, len
);
2142 /* At this point, all variables within the block tree with TREE_USED
2143 set are actually used by the optimized function. Lay them out. */
2144 expand_used_vars_for_block (outer_block
, true);
2146 if (stack_vars_num
> 0)
2148 bool has_addressable_vars
= false;
2150 add_scope_conflicts ();
2152 /* If stack protection is enabled, we don't share space between
2153 vulnerable data and non-vulnerable data. */
2154 if (flag_stack_protect
!= 0
2155 && (flag_stack_protect
!= SPCT_FLAG_EXPLICIT
2156 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
2157 && lookup_attribute ("stack_protect",
2158 DECL_ATTRIBUTES (current_function_decl
)))))
2159 has_addressable_vars
= add_stack_protection_conflicts ();
2161 if (flag_stack_protect
== SPCT_FLAG_STRONG
&& has_addressable_vars
)
2162 gen_stack_protect_signal
= true;
2164 /* Now that we have collected all stack variables, and have computed a
2165 minimal interference graph, attempt to save some stack space. */
2166 partition_stack_vars ();
2168 dump_stack_var_partition ();
2171 switch (flag_stack_protect
)
2174 create_stack_guard ();
2177 case SPCT_FLAG_STRONG
:
2178 if (gen_stack_protect_signal
2179 || cfun
->calls_alloca
2180 || has_protected_decls
2181 || lookup_attribute ("stack_protect",
2182 DECL_ATTRIBUTES (current_function_decl
)))
2183 create_stack_guard ();
2186 case SPCT_FLAG_DEFAULT
:
2187 if (cfun
->calls_alloca
2188 || has_protected_decls
2189 || lookup_attribute ("stack_protect",
2190 DECL_ATTRIBUTES (current_function_decl
)))
2191 create_stack_guard ();
2194 case SPCT_FLAG_EXPLICIT
:
2195 if (lookup_attribute ("stack_protect",
2196 DECL_ATTRIBUTES (current_function_decl
)))
2197 create_stack_guard ();
2204 /* Assign rtl to each variable based on these partitions. */
2205 if (stack_vars_num
> 0)
2207 class stack_vars_data data
;
2209 data
.asan_base
= NULL_RTX
;
2210 data
.asan_alignb
= 0;
2212 /* Reorder decls to be protected by iterating over the variables
2213 array multiple times, and allocating out of each phase in turn. */
2214 /* ??? We could probably integrate this into the qsort we did
2215 earlier, such that we naturally see these variables first,
2216 and thus naturally allocate things in the right order. */
2217 if (has_protected_decls
)
2219 /* Phase 1 contains only character arrays. */
2220 expand_stack_vars (stack_protect_decl_phase_1
, &data
);
2222 /* Phase 2 contains other kinds of arrays. */
2223 if (flag_stack_protect
== SPCT_FLAG_ALL
2224 || flag_stack_protect
== SPCT_FLAG_STRONG
2225 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
2226 && lookup_attribute ("stack_protect",
2227 DECL_ATTRIBUTES (current_function_decl
))))
2228 expand_stack_vars (stack_protect_decl_phase_2
, &data
);
2231 if (asan_sanitize_stack_p ())
2232 /* Phase 3, any partitions that need asan protection
2233 in addition to phase 1 and 2. */
2234 expand_stack_vars (asan_decl_phase_3
, &data
);
2236 /* ASAN description strings don't yet have a syntax for expressing
2237 polynomial offsets. */
2238 HOST_WIDE_INT prev_offset
;
2239 if (!data
.asan_vec
.is_empty ()
2240 && frame_offset
.is_constant (&prev_offset
))
2242 HOST_WIDE_INT offset
, sz
, redzonesz
;
2243 redzonesz
= ASAN_RED_ZONE_SIZE
;
2244 sz
= data
.asan_vec
[0] - prev_offset
;
2245 if (data
.asan_alignb
> ASAN_RED_ZONE_SIZE
2246 && data
.asan_alignb
<= 4096
2247 && sz
+ ASAN_RED_ZONE_SIZE
>= (int) data
.asan_alignb
)
2248 redzonesz
= ((sz
+ ASAN_RED_ZONE_SIZE
+ data
.asan_alignb
- 1)
2249 & ~(data
.asan_alignb
- HOST_WIDE_INT_1
)) - sz
;
2250 /* Allocating a constant amount of space from a constant
2251 starting offset must give a constant result. */
2252 offset
= (alloc_stack_frame_space (redzonesz
, ASAN_RED_ZONE_SIZE
)
2254 data
.asan_vec
.safe_push (prev_offset
);
2255 data
.asan_vec
.safe_push (offset
);
2256 /* Leave space for alignment if STRICT_ALIGNMENT. */
2257 if (STRICT_ALIGNMENT
)
2258 alloc_stack_frame_space ((GET_MODE_ALIGNMENT (SImode
)
2259 << ASAN_SHADOW_SHIFT
)
2260 / BITS_PER_UNIT
, 1);
2263 = asan_emit_stack_protection (virtual_stack_vars_rtx
,
2266 data
.asan_vec
.address (),
2267 data
.asan_decl_vec
.address (),
2268 data
.asan_vec
.length ());
2271 expand_stack_vars (NULL
, &data
);
2274 if (asan_sanitize_allocas_p () && cfun
->calls_alloca
)
2275 var_end_seq
= asan_emit_allocas_unpoison (virtual_stack_dynamic_rtx
,
2276 virtual_stack_vars_rtx
,
2279 fini_vars_expansion ();
2281 /* If there were any artificial non-ignored vars without rtl
2282 found earlier, see if deferred stack allocation hasn't assigned
2284 FOR_EACH_VEC_ELT_REVERSE (maybe_local_decls
, i
, var
)
2286 rtx rtl
= DECL_RTL_IF_SET (var
);
2288 /* Keep artificial non-ignored vars in cfun->local_decls
2289 chain until instantiate_decls. */
2290 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
2291 add_local_decl (cfun
, var
);
2294 /* If the target requires that FRAME_OFFSET be aligned, do it. */
2295 if (STACK_ALIGNMENT_NEEDED
)
2297 HOST_WIDE_INT align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
2298 if (FRAME_GROWS_DOWNWARD
)
2299 frame_offset
= aligned_lower_bound (frame_offset
, align
);
2301 frame_offset
= aligned_upper_bound (frame_offset
, align
);
2308 /* If we need to produce a detailed dump, print the tree representation
2309 for STMT to the dump file. SINCE is the last RTX after which the RTL
2310 generated for STMT should have been appended. */
2313 maybe_dump_rtl_for_gimple_stmt (gimple
*stmt
, rtx_insn
*since
)
2315 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2317 fprintf (dump_file
, "\n;; ");
2318 print_gimple_stmt (dump_file
, stmt
, 0,
2319 TDF_SLIM
| (dump_flags
& TDF_LINENO
));
2320 fprintf (dump_file
, "\n");
2322 print_rtl (dump_file
, since
? NEXT_INSN (since
) : since
);
2326 /* Maps the blocks that do not contain tree labels to rtx labels. */
2328 static hash_map
<basic_block
, rtx_code_label
*> *lab_rtx_for_bb
;
2330 /* Returns the label_rtx expression for a label starting basic block BB. */
2332 static rtx_code_label
*
2333 label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED
)
2335 gimple_stmt_iterator gsi
;
2338 if (bb
->flags
& BB_RTL
)
2339 return block_label (bb
);
2341 rtx_code_label
**elt
= lab_rtx_for_bb
->get (bb
);
2345 /* Find the tree label if it is present. */
2347 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2351 lab_stmt
= dyn_cast
<glabel
*> (gsi_stmt (gsi
));
2355 lab
= gimple_label_label (lab_stmt
);
2356 if (DECL_NONLOCAL (lab
))
2359 return jump_target_rtx (lab
);
2362 rtx_code_label
*l
= gen_label_rtx ();
2363 lab_rtx_for_bb
->put (bb
, l
);
2368 /* A subroutine of expand_gimple_cond. Given E, a fallthrough edge
2369 of a basic block where we just expanded the conditional at the end,
2370 possibly clean up the CFG and instruction sequence. LAST is the
2371 last instruction before the just emitted jump sequence. */
2374 maybe_cleanup_end_of_block (edge e
, rtx_insn
*last
)
2376 /* Special case: when jumpif decides that the condition is
2377 trivial it emits an unconditional jump (and the necessary
2378 barrier). But we still have two edges, the fallthru one is
2379 wrong. purge_dead_edges would clean this up later. Unfortunately
2380 we have to insert insns (and split edges) before
2381 find_many_sub_basic_blocks and hence before purge_dead_edges.
2382 But splitting edges might create new blocks which depend on the
2383 fact that if there are two edges there's no barrier. So the
2384 barrier would get lost and verify_flow_info would ICE. Instead
2385 of auditing all edge splitters to care for the barrier (which
2386 normally isn't there in a cleaned CFG), fix it here. */
2387 if (BARRIER_P (get_last_insn ()))
2391 /* Now, we have a single successor block, if we have insns to
2392 insert on the remaining edge we potentially will insert
2393 it at the end of this block (if the dest block isn't feasible)
2394 in order to avoid splitting the edge. This insertion will take
2395 place in front of the last jump. But we might have emitted
2396 multiple jumps (conditional and one unconditional) to the
2397 same destination. Inserting in front of the last one then
2398 is a problem. See PR 40021. We fix this by deleting all
2399 jumps except the last unconditional one. */
2400 insn
= PREV_INSN (get_last_insn ());
2401 /* Make sure we have an unconditional jump. Otherwise we're
2403 gcc_assert (JUMP_P (insn
) && !any_condjump_p (insn
));
2404 for (insn
= PREV_INSN (insn
); insn
!= last
;)
2406 insn
= PREV_INSN (insn
);
2407 if (JUMP_P (NEXT_INSN (insn
)))
2409 if (!any_condjump_p (NEXT_INSN (insn
)))
2411 gcc_assert (BARRIER_P (NEXT_INSN (NEXT_INSN (insn
))));
2412 delete_insn (NEXT_INSN (NEXT_INSN (insn
)));
2414 delete_insn (NEXT_INSN (insn
));
2420 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_COND.
2421 Returns a new basic block if we've terminated the current basic
2422 block and created a new one. */
2425 expand_gimple_cond (basic_block bb
, gcond
*stmt
)
2427 basic_block new_bb
, dest
;
2430 rtx_insn
*last2
, *last
;
2431 enum tree_code code
;
2434 code
= gimple_cond_code (stmt
);
2435 op0
= gimple_cond_lhs (stmt
);
2436 op1
= gimple_cond_rhs (stmt
);
2437 /* We're sometimes presented with such code:
2441 This would expand to two comparisons which then later might
2442 be cleaned up by combine. But some pattern matchers like if-conversion
2443 work better when there's only one compare, so make up for this
2444 here as special exception if TER would have made the same change. */
2446 && TREE_CODE (op0
) == SSA_NAME
2447 && TREE_CODE (TREE_TYPE (op0
)) == BOOLEAN_TYPE
2448 && TREE_CODE (op1
) == INTEGER_CST
2449 && ((gimple_cond_code (stmt
) == NE_EXPR
2450 && integer_zerop (op1
))
2451 || (gimple_cond_code (stmt
) == EQ_EXPR
2452 && integer_onep (op1
)))
2453 && bitmap_bit_p (SA
.values
, SSA_NAME_VERSION (op0
)))
2455 gimple
*second
= SSA_NAME_DEF_STMT (op0
);
2456 if (gimple_code (second
) == GIMPLE_ASSIGN
)
2458 enum tree_code code2
= gimple_assign_rhs_code (second
);
2459 if (TREE_CODE_CLASS (code2
) == tcc_comparison
)
2462 op0
= gimple_assign_rhs1 (second
);
2463 op1
= gimple_assign_rhs2 (second
);
2465 /* If jumps are cheap and the target does not support conditional
2466 compare, turn some more codes into jumpy sequences. */
2467 else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4
2468 && targetm
.gen_ccmp_first
== NULL
)
2470 if ((code2
== BIT_AND_EXPR
2471 && TYPE_PRECISION (TREE_TYPE (op0
)) == 1
2472 && TREE_CODE (gimple_assign_rhs2 (second
)) != INTEGER_CST
)
2473 || code2
== TRUTH_AND_EXPR
)
2475 code
= TRUTH_ANDIF_EXPR
;
2476 op0
= gimple_assign_rhs1 (second
);
2477 op1
= gimple_assign_rhs2 (second
);
2479 else if (code2
== BIT_IOR_EXPR
|| code2
== TRUTH_OR_EXPR
)
2481 code
= TRUTH_ORIF_EXPR
;
2482 op0
= gimple_assign_rhs1 (second
);
2483 op1
= gimple_assign_rhs2 (second
);
2489 /* Optimize (x % C1) == C2 or (x % C1) != C2 if it is beneficial
2490 into (x - C2) * C3 < C4. */
2491 if ((code
== EQ_EXPR
|| code
== NE_EXPR
)
2492 && TREE_CODE (op0
) == SSA_NAME
2493 && TREE_CODE (op1
) == INTEGER_CST
)
2494 code
= maybe_optimize_mod_cmp (code
, &op0
, &op1
);
2496 last2
= last
= get_last_insn ();
2498 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
2499 set_curr_insn_location (gimple_location (stmt
));
2501 /* These flags have no purpose in RTL land. */
2502 true_edge
->flags
&= ~EDGE_TRUE_VALUE
;
2503 false_edge
->flags
&= ~EDGE_FALSE_VALUE
;
2505 /* We can either have a pure conditional jump with one fallthru edge or
2506 two-way jump that needs to be decomposed into two basic blocks. */
2507 if (false_edge
->dest
== bb
->next_bb
)
2509 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2510 true_edge
->probability
);
2511 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2512 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2513 set_curr_insn_location (true_edge
->goto_locus
);
2514 false_edge
->flags
|= EDGE_FALLTHRU
;
2515 maybe_cleanup_end_of_block (false_edge
, last
);
2518 if (true_edge
->dest
== bb
->next_bb
)
2520 jumpifnot_1 (code
, op0
, op1
, label_rtx_for_bb (false_edge
->dest
),
2521 false_edge
->probability
);
2522 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2523 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2524 set_curr_insn_location (false_edge
->goto_locus
);
2525 true_edge
->flags
|= EDGE_FALLTHRU
;
2526 maybe_cleanup_end_of_block (true_edge
, last
);
2530 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2531 true_edge
->probability
);
2532 last
= get_last_insn ();
2533 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2534 set_curr_insn_location (false_edge
->goto_locus
);
2535 emit_jump (label_rtx_for_bb (false_edge
->dest
));
2538 if (BARRIER_P (BB_END (bb
)))
2539 BB_END (bb
) = PREV_INSN (BB_END (bb
));
2540 update_bb_for_insn (bb
);
2542 new_bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
2543 dest
= false_edge
->dest
;
2544 redirect_edge_succ (false_edge
, new_bb
);
2545 false_edge
->flags
|= EDGE_FALLTHRU
;
2546 new_bb
->count
= false_edge
->count ();
2547 loop_p loop
= find_common_loop (bb
->loop_father
, dest
->loop_father
);
2548 add_bb_to_loop (new_bb
, loop
);
2549 if (loop
->latch
== bb
2550 && loop
->header
== dest
)
2551 loop
->latch
= new_bb
;
2552 make_single_succ_edge (new_bb
, dest
, 0);
2553 if (BARRIER_P (BB_END (new_bb
)))
2554 BB_END (new_bb
) = PREV_INSN (BB_END (new_bb
));
2555 update_bb_for_insn (new_bb
);
2557 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
2559 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2561 set_curr_insn_location (true_edge
->goto_locus
);
2562 true_edge
->goto_locus
= curr_insn_location ();
2568 /* Mark all calls that can have a transaction restart. */
2571 mark_transaction_restart_calls (gimple
*stmt
)
2573 struct tm_restart_node dummy
;
2574 tm_restart_node
**slot
;
2576 if (!cfun
->gimple_df
->tm_restart
)
2580 slot
= cfun
->gimple_df
->tm_restart
->find_slot (&dummy
, NO_INSERT
);
2583 struct tm_restart_node
*n
= *slot
;
2584 tree list
= n
->label_or_list
;
2587 for (insn
= next_real_insn (get_last_insn ());
2589 insn
= next_real_insn (insn
))
2592 if (TREE_CODE (list
) == LABEL_DECL
)
2593 add_reg_note (insn
, REG_TM
, label_rtx (list
));
2595 for (; list
; list
= TREE_CHAIN (list
))
2596 add_reg_note (insn
, REG_TM
, label_rtx (TREE_VALUE (list
)));
2600 /* A subroutine of expand_gimple_stmt_1, expanding one GIMPLE_CALL
2604 expand_call_stmt (gcall
*stmt
)
2606 tree exp
, decl
, lhs
;
2610 if (gimple_call_internal_p (stmt
))
2612 expand_internal_call (stmt
);
2616 /* If this is a call to a built-in function and it has no effect other
2617 than setting the lhs, try to implement it using an internal function
2619 decl
= gimple_call_fndecl (stmt
);
2620 if (gimple_call_lhs (stmt
)
2621 && !gimple_has_side_effects (stmt
)
2622 && (optimize
|| (decl
&& called_as_built_in (decl
))))
2624 internal_fn ifn
= replacement_internal_fn (stmt
);
2625 if (ifn
!= IFN_LAST
)
2627 expand_internal_call (ifn
, stmt
);
2632 exp
= build_vl_exp (CALL_EXPR
, gimple_call_num_args (stmt
) + 3);
2634 CALL_EXPR_FN (exp
) = gimple_call_fn (stmt
);
2635 builtin_p
= decl
&& fndecl_built_in_p (decl
);
2637 /* If this is not a builtin function, the function type through which the
2638 call is made may be different from the type of the function. */
2641 = fold_convert (build_pointer_type (gimple_call_fntype (stmt
)),
2642 CALL_EXPR_FN (exp
));
2644 TREE_TYPE (exp
) = gimple_call_return_type (stmt
);
2645 CALL_EXPR_STATIC_CHAIN (exp
) = gimple_call_chain (stmt
);
2647 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2649 tree arg
= gimple_call_arg (stmt
, i
);
2651 /* TER addresses into arguments of builtin functions so we have a
2652 chance to infer more correct alignment information. See PR39954. */
2654 && TREE_CODE (arg
) == SSA_NAME
2655 && (def
= get_gimple_for_ssa_name (arg
))
2656 && gimple_assign_rhs_code (def
) == ADDR_EXPR
)
2657 arg
= gimple_assign_rhs1 (def
);
2658 CALL_EXPR_ARG (exp
, i
) = arg
;
2661 if (gimple_has_side_effects (stmt
))
2662 TREE_SIDE_EFFECTS (exp
) = 1;
2664 if (gimple_call_nothrow_p (stmt
))
2665 TREE_NOTHROW (exp
) = 1;
2667 if (gimple_no_warning_p (stmt
))
2668 TREE_NO_WARNING (exp
) = 1;
2670 CALL_EXPR_TAILCALL (exp
) = gimple_call_tail_p (stmt
);
2671 CALL_EXPR_MUST_TAIL_CALL (exp
) = gimple_call_must_tail_p (stmt
);
2672 CALL_EXPR_RETURN_SLOT_OPT (exp
) = gimple_call_return_slot_opt_p (stmt
);
2674 && fndecl_built_in_p (decl
, BUILT_IN_NORMAL
)
2675 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (decl
)))
2676 CALL_ALLOCA_FOR_VAR_P (exp
) = gimple_call_alloca_for_var_p (stmt
);
2678 CALL_FROM_THUNK_P (exp
) = gimple_call_from_thunk_p (stmt
);
2679 CALL_EXPR_VA_ARG_PACK (exp
) = gimple_call_va_arg_pack_p (stmt
);
2680 CALL_EXPR_BY_DESCRIPTOR (exp
) = gimple_call_by_descriptor_p (stmt
);
2681 SET_EXPR_LOCATION (exp
, gimple_location (stmt
));
2683 /* Ensure RTL is created for debug args. */
2684 if (decl
&& DECL_HAS_DEBUG_ARGS_P (decl
))
2686 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (decl
);
2691 for (ix
= 1; (*debug_args
)->iterate (ix
, &dtemp
); ix
+= 2)
2693 gcc_assert (TREE_CODE (dtemp
) == DEBUG_EXPR_DECL
);
2694 expand_debug_expr (dtemp
);
2698 rtx_insn
*before_call
= get_last_insn ();
2699 lhs
= gimple_call_lhs (stmt
);
2701 expand_assignment (lhs
, exp
, false);
2703 expand_expr (exp
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2705 /* If the gimple call is an indirect call and has 'nocf_check'
2706 attribute find a generated CALL insn to mark it as no
2707 control-flow verification is needed. */
2708 if (gimple_call_nocf_check_p (stmt
)
2709 && !gimple_call_fndecl (stmt
))
2711 rtx_insn
*last
= get_last_insn ();
2712 while (!CALL_P (last
)
2713 && last
!= before_call
)
2714 last
= PREV_INSN (last
);
2716 if (last
!= before_call
)
2717 add_reg_note (last
, REG_CALL_NOCF_CHECK
, const0_rtx
);
2720 mark_transaction_restart_calls (stmt
);
2724 /* Generate RTL for an asm statement (explicit assembler code).
2725 STRING is a STRING_CST node containing the assembler code text,
2726 or an ADDR_EXPR containing a STRING_CST. VOL nonzero means the
2727 insn is volatile; don't optimize it. */
2730 expand_asm_loc (tree string
, int vol
, location_t locus
)
2734 body
= gen_rtx_ASM_INPUT_loc (VOIDmode
,
2735 ggc_strdup (TREE_STRING_POINTER (string
)),
2738 MEM_VOLATILE_P (body
) = vol
;
2740 /* Non-empty basic ASM implicitly clobbers memory. */
2741 if (TREE_STRING_LENGTH (string
) != 0)
2744 unsigned i
, nclobbers
;
2745 auto_vec
<rtx
> input_rvec
, output_rvec
;
2746 auto_vec
<const char *> constraints
;
2747 auto_vec
<rtx
> clobber_rvec
;
2748 HARD_REG_SET clobbered_regs
;
2749 CLEAR_HARD_REG_SET (clobbered_regs
);
2751 clob
= gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
));
2752 clobber_rvec
.safe_push (clob
);
2754 if (targetm
.md_asm_adjust
)
2755 targetm
.md_asm_adjust (output_rvec
, input_rvec
,
2756 constraints
, clobber_rvec
,
2760 nclobbers
= clobber_rvec
.length ();
2761 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (1 + nclobbers
));
2763 XVECEXP (body
, 0, 0) = asm_op
;
2764 for (i
= 0; i
< nclobbers
; i
++)
2765 XVECEXP (body
, 0, i
+ 1) = gen_rtx_CLOBBER (VOIDmode
, clobber_rvec
[i
]);
2771 /* Return the number of times character C occurs in string S. */
2773 n_occurrences (int c
, const char *s
)
2781 /* A subroutine of expand_asm_operands. Check that all operands have
2782 the same number of alternatives. Return true if so. */
2785 check_operand_nalternatives (const vec
<const char *> &constraints
)
2787 unsigned len
= constraints
.length();
2790 int nalternatives
= n_occurrences (',', constraints
[0]);
2792 if (nalternatives
+ 1 > MAX_RECOG_ALTERNATIVES
)
2794 error ("too many alternatives in %<asm%>");
2798 for (unsigned i
= 1; i
< len
; ++i
)
2799 if (n_occurrences (',', constraints
[i
]) != nalternatives
)
2801 error ("operand constraints for %<asm%> differ "
2802 "in number of alternatives");
2809 /* Check for overlap between registers marked in CLOBBERED_REGS and
2810 anything inappropriate in T. Emit error and return the register
2811 variable definition for error, NULL_TREE for ok. */
2814 tree_conflicts_with_clobbers_p (tree t
, HARD_REG_SET
*clobbered_regs
)
2816 /* Conflicts between asm-declared register variables and the clobber
2817 list are not allowed. */
2818 tree overlap
= tree_overlaps_hard_reg_set (t
, clobbered_regs
);
2822 error ("%<asm%> specifier for variable %qE conflicts with "
2823 "%<asm%> clobber list",
2824 DECL_NAME (overlap
));
2826 /* Reset registerness to stop multiple errors emitted for a single
2828 DECL_REGISTER (overlap
) = 0;
2835 /* Check that the given REGNO spanning NREGS is a valid
2836 asm clobber operand. Some HW registers cannot be
2837 saved/restored, hence they should not be clobbered by
2840 asm_clobber_reg_is_valid (int regno
, int nregs
, const char *regname
)
2842 bool is_valid
= true;
2843 HARD_REG_SET regset
;
2845 CLEAR_HARD_REG_SET (regset
);
2847 add_range_to_hard_reg_set (®set
, regno
, nregs
);
2849 /* Clobbering the PIC register is an error. */
2850 if (PIC_OFFSET_TABLE_REGNUM
!= INVALID_REGNUM
2851 && overlaps_hard_reg_set_p (regset
, Pmode
, PIC_OFFSET_TABLE_REGNUM
))
2853 /* ??? Diagnose during gimplification? */
2854 error ("PIC register clobbered by %qs in %<asm%>", regname
);
2857 else if (!in_hard_reg_set_p
2858 (accessible_reg_set
, reg_raw_mode
[regno
], regno
))
2860 /* ??? Diagnose during gimplification? */
2861 error ("the register %qs cannot be clobbered in %<asm%>"
2862 " for the current target", regname
);
2866 /* Clobbering the stack pointer register is deprecated. GCC expects
2867 the value of the stack pointer after an asm statement to be the same
2868 as it was before, so no asm can validly clobber the stack pointer in
2869 the usual sense. Adding the stack pointer to the clobber list has
2870 traditionally had some undocumented and somewhat obscure side-effects. */
2871 if (overlaps_hard_reg_set_p (regset
, Pmode
, STACK_POINTER_REGNUM
)
2872 && warning (OPT_Wdeprecated
, "listing the stack pointer register"
2873 " %qs in a clobber list is deprecated", regname
))
2874 inform (input_location
, "the value of the stack pointer after an %<asm%>"
2875 " statement must be the same as it was before the statement");
2880 /* Generate RTL for an asm statement with arguments.
2881 STRING is the instruction template.
2882 OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
2883 Each output or input has an expression in the TREE_VALUE and
2884 a tree list in TREE_PURPOSE which in turn contains a constraint
2885 name in TREE_VALUE (or NULL_TREE) and a constraint string
2887 CLOBBERS is a list of STRING_CST nodes each naming a hard register
2888 that is clobbered by this insn.
2890 LABELS is a list of labels, and if LABELS is non-NULL, FALLTHRU_BB
2891 should be the fallthru basic block of the asm goto.
2893 Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
2894 Some elements of OUTPUTS may be replaced with trees representing temporary
2895 values. The caller should copy those temporary values to the originally
2898 VOL nonzero means the insn is volatile; don't optimize it. */
2901 expand_asm_stmt (gasm
*stmt
)
2903 class save_input_location
2908 explicit save_input_location(location_t where
)
2910 old
= input_location
;
2911 input_location
= where
;
2914 ~save_input_location()
2916 input_location
= old
;
2920 location_t locus
= gimple_location (stmt
);
2922 if (gimple_asm_input_p (stmt
))
2924 const char *s
= gimple_asm_string (stmt
);
2925 tree string
= build_string (strlen (s
), s
);
2926 expand_asm_loc (string
, gimple_asm_volatile_p (stmt
), locus
);
2930 /* There are some legacy diagnostics in here, and also avoids a
2931 sixth parameger to targetm.md_asm_adjust. */
2932 save_input_location
s_i_l(locus
);
2934 unsigned noutputs
= gimple_asm_noutputs (stmt
);
2935 unsigned ninputs
= gimple_asm_ninputs (stmt
);
2936 unsigned nlabels
= gimple_asm_nlabels (stmt
);
2939 /* ??? Diagnose during gimplification? */
2940 if (ninputs
+ noutputs
+ nlabels
> MAX_RECOG_OPERANDS
)
2942 error ("more than %d operands in %<asm%>", MAX_RECOG_OPERANDS
);
2946 auto_vec
<tree
, MAX_RECOG_OPERANDS
> output_tvec
;
2947 auto_vec
<tree
, MAX_RECOG_OPERANDS
> input_tvec
;
2948 auto_vec
<const char *, MAX_RECOG_OPERANDS
> constraints
;
2950 /* Copy the gimple vectors into new vectors that we can manipulate. */
2952 output_tvec
.safe_grow (noutputs
);
2953 input_tvec
.safe_grow (ninputs
);
2954 constraints
.safe_grow (noutputs
+ ninputs
);
2956 for (i
= 0; i
< noutputs
; ++i
)
2958 tree t
= gimple_asm_output_op (stmt
, i
);
2959 output_tvec
[i
] = TREE_VALUE (t
);
2960 constraints
[i
] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
2962 for (i
= 0; i
< ninputs
; i
++)
2964 tree t
= gimple_asm_input_op (stmt
, i
);
2965 input_tvec
[i
] = TREE_VALUE (t
);
2966 constraints
[i
+ noutputs
]
2967 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
2970 /* ??? Diagnose during gimplification? */
2971 if (! check_operand_nalternatives (constraints
))
2974 /* Count the number of meaningful clobbered registers, ignoring what
2975 we would ignore later. */
2976 auto_vec
<rtx
> clobber_rvec
;
2977 HARD_REG_SET clobbered_regs
;
2978 CLEAR_HARD_REG_SET (clobbered_regs
);
2980 if (unsigned n
= gimple_asm_nclobbers (stmt
))
2982 clobber_rvec
.reserve (n
);
2983 for (i
= 0; i
< n
; i
++)
2985 tree t
= gimple_asm_clobber_op (stmt
, i
);
2986 const char *regname
= TREE_STRING_POINTER (TREE_VALUE (t
));
2989 j
= decode_reg_name_and_count (regname
, &nregs
);
2994 /* ??? Diagnose during gimplification? */
2995 error ("unknown register name %qs in %<asm%>", regname
);
2999 rtx x
= gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
));
3000 clobber_rvec
.safe_push (x
);
3004 /* Otherwise we should have -1 == empty string
3005 or -3 == cc, which is not a register. */
3006 gcc_assert (j
== -1 || j
== -3);
3010 for (int reg
= j
; reg
< j
+ nregs
; reg
++)
3012 if (!asm_clobber_reg_is_valid (reg
, nregs
, regname
))
3015 SET_HARD_REG_BIT (clobbered_regs
, reg
);
3016 rtx x
= gen_rtx_REG (reg_raw_mode
[reg
], reg
);
3017 clobber_rvec
.safe_push (x
);
3022 /* First pass over inputs and outputs checks validity and sets
3023 mark_addressable if needed. */
3024 /* ??? Diagnose during gimplification? */
3026 for (i
= 0; i
< noutputs
; ++i
)
3028 tree val
= output_tvec
[i
];
3029 tree type
= TREE_TYPE (val
);
3030 const char *constraint
;
3035 /* Try to parse the output constraint. If that fails, there's
3036 no point in going further. */
3037 constraint
= constraints
[i
];
3038 if (!parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
3039 &allows_mem
, &allows_reg
, &is_inout
))
3042 /* If the output is a hard register, verify it doesn't conflict with
3043 any other operand's possible hard register use. */
3045 && REG_P (DECL_RTL (val
))
3046 && HARD_REGISTER_P (DECL_RTL (val
)))
3048 unsigned j
, output_hregno
= REGNO (DECL_RTL (val
));
3049 bool early_clobber_p
= strchr (constraints
[i
], '&') != NULL
;
3050 unsigned long match
;
3052 /* Verify the other outputs do not use the same hard register. */
3053 for (j
= i
+ 1; j
< noutputs
; ++j
)
3054 if (DECL_P (output_tvec
[j
])
3055 && REG_P (DECL_RTL (output_tvec
[j
]))
3056 && HARD_REGISTER_P (DECL_RTL (output_tvec
[j
]))
3057 && output_hregno
== REGNO (DECL_RTL (output_tvec
[j
])))
3058 error ("invalid hard register usage between output operands");
3060 /* Verify matching constraint operands use the same hard register
3061 and that the non-matching constraint operands do not use the same
3062 hard register if the output is an early clobber operand. */
3063 for (j
= 0; j
< ninputs
; ++j
)
3064 if (DECL_P (input_tvec
[j
])
3065 && REG_P (DECL_RTL (input_tvec
[j
]))
3066 && HARD_REGISTER_P (DECL_RTL (input_tvec
[j
])))
3068 unsigned input_hregno
= REGNO (DECL_RTL (input_tvec
[j
]));
3069 switch (*constraints
[j
+ noutputs
])
3071 case '0': case '1': case '2': case '3': case '4':
3072 case '5': case '6': case '7': case '8': case '9':
3073 match
= strtoul (constraints
[j
+ noutputs
], NULL
, 10);
3080 && output_hregno
!= input_hregno
)
3081 error ("invalid hard register usage between output operand "
3082 "and matching constraint operand");
3083 else if (early_clobber_p
3085 && output_hregno
== input_hregno
)
3086 error ("invalid hard register usage between earlyclobber "
3087 "operand and input operand");
3095 && REG_P (DECL_RTL (val
))
3096 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
))))
3097 mark_addressable (val
);
3100 for (i
= 0; i
< ninputs
; ++i
)
3102 bool allows_reg
, allows_mem
;
3103 const char *constraint
;
3105 constraint
= constraints
[i
+ noutputs
];
3106 if (! parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
3107 constraints
.address (),
3108 &allows_mem
, &allows_reg
))
3111 if (! allows_reg
&& allows_mem
)
3112 mark_addressable (input_tvec
[i
]);
3115 /* Second pass evaluates arguments. */
3117 /* Make sure stack is consistent for asm goto. */
3119 do_pending_stack_adjust ();
3120 int old_generating_concat_p
= generating_concat_p
;
3122 /* Vector of RTX's of evaluated output operands. */
3123 auto_vec
<rtx
, MAX_RECOG_OPERANDS
> output_rvec
;
3124 auto_vec
<int, MAX_RECOG_OPERANDS
> inout_opnum
;
3125 rtx_insn
*after_rtl_seq
= NULL
, *after_rtl_end
= NULL
;
3127 output_rvec
.safe_grow (noutputs
);
3129 for (i
= 0; i
< noutputs
; ++i
)
3131 tree val
= output_tvec
[i
];
3132 tree type
= TREE_TYPE (val
);
3133 bool is_inout
, allows_reg
, allows_mem
, ok
;
3136 ok
= parse_output_constraint (&constraints
[i
], i
, ninputs
,
3137 noutputs
, &allows_mem
, &allows_reg
,
3141 /* If an output operand is not a decl or indirect ref and our constraint
3142 allows a register, make a temporary to act as an intermediate.
3143 Make the asm insn write into that, then we will copy it to
3144 the real output operand. Likewise for promoted variables. */
3146 generating_concat_p
= 0;
3148 if ((TREE_CODE (val
) == INDIRECT_REF
&& allows_mem
)
3150 && (allows_mem
|| REG_P (DECL_RTL (val
)))
3151 && ! (REG_P (DECL_RTL (val
))
3152 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
)))
3155 || TREE_ADDRESSABLE (type
))
3157 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
3158 !allows_reg
? EXPAND_MEMORY
: EXPAND_WRITE
);
3160 op
= validize_mem (op
);
3162 if (! allows_reg
&& !MEM_P (op
))
3163 error ("output number %d not directly addressable", i
);
3164 if ((! allows_mem
&& MEM_P (op
) && GET_MODE (op
) != BLKmode
)
3165 || GET_CODE (op
) == CONCAT
)
3168 op
= gen_reg_rtx (GET_MODE (op
));
3170 generating_concat_p
= old_generating_concat_p
;
3173 emit_move_insn (op
, old_op
);
3175 push_to_sequence2 (after_rtl_seq
, after_rtl_end
);
3176 emit_move_insn (old_op
, op
);
3177 after_rtl_seq
= get_insns ();
3178 after_rtl_end
= get_last_insn ();
3184 op
= assign_temp (type
, 0, 1);
3185 op
= validize_mem (op
);
3186 if (!MEM_P (op
) && TREE_CODE (val
) == SSA_NAME
)
3187 set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (val
), op
);
3189 generating_concat_p
= old_generating_concat_p
;
3191 push_to_sequence2 (after_rtl_seq
, after_rtl_end
);
3192 expand_assignment (val
, make_tree (type
, op
), false);
3193 after_rtl_seq
= get_insns ();
3194 after_rtl_end
= get_last_insn ();
3197 output_rvec
[i
] = op
;
3200 inout_opnum
.safe_push (i
);
3203 auto_vec
<rtx
, MAX_RECOG_OPERANDS
> input_rvec
;
3204 auto_vec
<machine_mode
, MAX_RECOG_OPERANDS
> input_mode
;
3206 input_rvec
.safe_grow (ninputs
);
3207 input_mode
.safe_grow (ninputs
);
3209 generating_concat_p
= 0;
3211 for (i
= 0; i
< ninputs
; ++i
)
3213 tree val
= input_tvec
[i
];
3214 tree type
= TREE_TYPE (val
);
3215 bool allows_reg
, allows_mem
, ok
;
3216 const char *constraint
;
3219 constraint
= constraints
[i
+ noutputs
];
3220 ok
= parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
3221 constraints
.address (),
3222 &allows_mem
, &allows_reg
);
3225 /* EXPAND_INITIALIZER will not generate code for valid initializer
3226 constants, but will still generate code for other types of operand.
3227 This is the behavior we want for constant constraints. */
3228 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
3229 allows_reg
? EXPAND_NORMAL
3230 : allows_mem
? EXPAND_MEMORY
3231 : EXPAND_INITIALIZER
);
3233 /* Never pass a CONCAT to an ASM. */
3234 if (GET_CODE (op
) == CONCAT
)
3235 op
= force_reg (GET_MODE (op
), op
);
3236 else if (MEM_P (op
))
3237 op
= validize_mem (op
);
3239 if (asm_operand_ok (op
, constraint
, NULL
) <= 0)
3241 if (allows_reg
&& TYPE_MODE (type
) != BLKmode
)
3242 op
= force_reg (TYPE_MODE (type
), op
);
3243 else if (!allows_mem
)
3244 warning (0, "%<asm%> operand %d probably does not match "
3247 else if (MEM_P (op
))
3249 /* We won't recognize either volatile memory or memory
3250 with a queued address as available a memory_operand
3251 at this point. Ignore it: clearly this *is* a memory. */
3257 input_mode
[i
] = TYPE_MODE (type
);
3260 /* For in-out operands, copy output rtx to input rtx. */
3261 unsigned ninout
= inout_opnum
.length();
3262 for (i
= 0; i
< ninout
; i
++)
3264 int j
= inout_opnum
[i
];
3265 rtx o
= output_rvec
[j
];
3267 input_rvec
.safe_push (o
);
3268 input_mode
.safe_push (GET_MODE (o
));
3271 sprintf (buffer
, "%d", j
);
3272 constraints
.safe_push (ggc_strdup (buffer
));
3276 /* Sometimes we wish to automatically clobber registers across an asm.
3277 Case in point is when the i386 backend moved from cc0 to a hard reg --
3278 maintaining source-level compatibility means automatically clobbering
3279 the flags register. */
3280 rtx_insn
*after_md_seq
= NULL
;
3281 if (targetm
.md_asm_adjust
)
3282 after_md_seq
= targetm
.md_asm_adjust (output_rvec
, input_rvec
,
3283 constraints
, clobber_rvec
,
3286 /* Do not allow the hook to change the output and input count,
3287 lest it mess up the operand numbering. */
3288 gcc_assert (output_rvec
.length() == noutputs
);
3289 gcc_assert (input_rvec
.length() == ninputs
);
3290 gcc_assert (constraints
.length() == noutputs
+ ninputs
);
3292 /* But it certainly can adjust the clobbers. */
3293 unsigned nclobbers
= clobber_rvec
.length ();
3295 /* Third pass checks for easy conflicts. */
3296 /* ??? Why are we doing this on trees instead of rtx. */
3298 bool clobber_conflict_found
= 0;
3299 for (i
= 0; i
< noutputs
; ++i
)
3300 if (tree_conflicts_with_clobbers_p (output_tvec
[i
], &clobbered_regs
))
3301 clobber_conflict_found
= 1;
3302 for (i
= 0; i
< ninputs
- ninout
; ++i
)
3303 if (tree_conflicts_with_clobbers_p (input_tvec
[i
], &clobbered_regs
))
3304 clobber_conflict_found
= 1;
3306 /* Make vectors for the expression-rtx, constraint strings,
3307 and named operands. */
3309 rtvec argvec
= rtvec_alloc (ninputs
);
3310 rtvec constraintvec
= rtvec_alloc (ninputs
);
3311 rtvec labelvec
= rtvec_alloc (nlabels
);
3313 rtx body
= gen_rtx_ASM_OPERANDS ((noutputs
== 0 ? VOIDmode
3314 : GET_MODE (output_rvec
[0])),
3315 ggc_strdup (gimple_asm_string (stmt
)),
3316 "", 0, argvec
, constraintvec
,
3318 MEM_VOLATILE_P (body
) = gimple_asm_volatile_p (stmt
);
3320 for (i
= 0; i
< ninputs
; ++i
)
3322 ASM_OPERANDS_INPUT (body
, i
) = input_rvec
[i
];
3323 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body
, i
)
3324 = gen_rtx_ASM_INPUT_loc (input_mode
[i
],
3325 constraints
[i
+ noutputs
],
3329 /* Copy labels to the vector. */
3330 rtx_code_label
*fallthru_label
= NULL
;
3333 basic_block fallthru_bb
= NULL
;
3334 edge fallthru
= find_fallthru_edge (gimple_bb (stmt
)->succs
);
3336 fallthru_bb
= fallthru
->dest
;
3338 for (i
= 0; i
< nlabels
; ++i
)
3340 tree label
= TREE_VALUE (gimple_asm_label_op (stmt
, i
));
3342 /* If asm goto has any labels in the fallthru basic block, use
3343 a label that we emit immediately after the asm goto. Expansion
3344 may insert further instructions into the same basic block after
3345 asm goto and if we don't do this, insertion of instructions on
3346 the fallthru edge might misbehave. See PR58670. */
3347 if (fallthru_bb
&& label_to_block (cfun
, label
) == fallthru_bb
)
3349 if (fallthru_label
== NULL_RTX
)
3350 fallthru_label
= gen_label_rtx ();
3354 r
= label_rtx (label
);
3355 ASM_OPERANDS_LABEL (body
, i
) = gen_rtx_LABEL_REF (Pmode
, r
);
3359 /* Now, for each output, construct an rtx
3360 (set OUTPUT (asm_operands INSN OUTPUTCONSTRAINT OUTPUTNUMBER
3361 ARGVEC CONSTRAINTS OPNAMES))
3362 If there is more than one, put them inside a PARALLEL. */
3364 if (nlabels
> 0 && nclobbers
== 0)
3366 gcc_assert (noutputs
== 0);
3367 emit_jump_insn (body
);
3369 else if (noutputs
== 0 && nclobbers
== 0)
3371 /* No output operands: put in a raw ASM_OPERANDS rtx. */
3374 else if (noutputs
== 1 && nclobbers
== 0)
3376 ASM_OPERANDS_OUTPUT_CONSTRAINT (body
) = constraints
[0];
3377 emit_insn (gen_rtx_SET (output_rvec
[0], body
));
3387 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (num
+ nclobbers
));
3389 /* For each output operand, store a SET. */
3390 for (i
= 0; i
< noutputs
; ++i
)
3392 rtx src
, o
= output_rvec
[i
];
3395 ASM_OPERANDS_OUTPUT_CONSTRAINT (obody
) = constraints
[0];
3400 src
= gen_rtx_ASM_OPERANDS (GET_MODE (o
),
3401 ASM_OPERANDS_TEMPLATE (obody
),
3402 constraints
[i
], i
, argvec
,
3403 constraintvec
, labelvec
, locus
);
3404 MEM_VOLATILE_P (src
) = gimple_asm_volatile_p (stmt
);
3406 XVECEXP (body
, 0, i
) = gen_rtx_SET (o
, src
);
3409 /* If there are no outputs (but there are some clobbers)
3410 store the bare ASM_OPERANDS into the PARALLEL. */
3412 XVECEXP (body
, 0, i
++) = obody
;
3414 /* Store (clobber REG) for each clobbered register specified. */
3415 for (unsigned j
= 0; j
< nclobbers
; ++j
)
3417 rtx clobbered_reg
= clobber_rvec
[j
];
3419 /* Do sanity check for overlap between clobbers and respectively
3420 input and outputs that hasn't been handled. Such overlap
3421 should have been detected and reported above. */
3422 if (!clobber_conflict_found
&& REG_P (clobbered_reg
))
3424 /* We test the old body (obody) contents to avoid
3425 tripping over the under-construction body. */
3426 for (unsigned k
= 0; k
< noutputs
; ++k
)
3427 if (reg_overlap_mentioned_p (clobbered_reg
, output_rvec
[k
]))
3428 internal_error ("%<asm%> clobber conflict with "
3431 for (unsigned k
= 0; k
< ninputs
- ninout
; ++k
)
3432 if (reg_overlap_mentioned_p (clobbered_reg
, input_rvec
[k
]))
3433 internal_error ("%<asm%> clobber conflict with "
3437 XVECEXP (body
, 0, i
++) = gen_rtx_CLOBBER (VOIDmode
, clobbered_reg
);
3441 emit_jump_insn (body
);
3446 generating_concat_p
= old_generating_concat_p
;
3449 emit_label (fallthru_label
);
3452 emit_insn (after_md_seq
);
3454 emit_insn (after_rtl_seq
);
3457 crtl
->has_asm_statement
= 1;
3460 /* Emit code to jump to the address
3461 specified by the pointer expression EXP. */
3464 expand_computed_goto (tree exp
)
3466 rtx x
= expand_normal (exp
);
3468 do_pending_stack_adjust ();
3469 emit_indirect_jump (x
);
3472 /* Generate RTL code for a `goto' statement with target label LABEL.
3473 LABEL should be a LABEL_DECL tree node that was or will later be
3474 defined with `expand_label'. */
3477 expand_goto (tree label
)
3481 /* Check for a nonlocal goto to a containing function. Should have
3482 gotten translated to __builtin_nonlocal_goto. */
3483 tree context
= decl_function_context (label
);
3484 gcc_assert (!context
|| context
== current_function_decl
);
3487 emit_jump (jump_target_rtx (label
));
3490 /* Output a return with no value. */
3493 expand_null_return_1 (void)
3495 clear_pending_stack_adjust ();
3496 do_pending_stack_adjust ();
3497 emit_jump (return_label
);
3500 /* Generate RTL to return from the current function, with no value.
3501 (That is, we do not do anything about returning any value.) */
3504 expand_null_return (void)
3506 /* If this function was declared to return a value, but we
3507 didn't, clobber the return registers so that they are not
3508 propagated live to the rest of the function. */
3509 clobber_return_register ();
3511 expand_null_return_1 ();
3514 /* Generate RTL to return from the current function, with value VAL. */
3517 expand_value_return (rtx val
)
3519 /* Copy the value to the return location unless it's already there. */
3521 tree decl
= DECL_RESULT (current_function_decl
);
3522 rtx return_reg
= DECL_RTL (decl
);
3523 if (return_reg
!= val
)
3525 tree funtype
= TREE_TYPE (current_function_decl
);
3526 tree type
= TREE_TYPE (decl
);
3527 int unsignedp
= TYPE_UNSIGNED (type
);
3528 machine_mode old_mode
= DECL_MODE (decl
);
3530 if (DECL_BY_REFERENCE (decl
))
3531 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 2);
3533 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 1);
3535 if (mode
!= old_mode
)
3536 val
= convert_modes (mode
, old_mode
, val
, unsignedp
);
3538 if (GET_CODE (return_reg
) == PARALLEL
)
3539 emit_group_load (return_reg
, val
, type
, int_size_in_bytes (type
));
3541 emit_move_insn (return_reg
, val
);
3544 expand_null_return_1 ();
3547 /* Generate RTL to evaluate the expression RETVAL and return it
3548 from the current function. */
3551 expand_return (tree retval
)
3557 /* If function wants no value, give it none. */
3558 if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl
))) == VOID_TYPE
)
3560 expand_normal (retval
);
3561 expand_null_return ();
3565 if (retval
== error_mark_node
)
3567 /* Treat this like a return of no value from a function that
3569 expand_null_return ();
3572 else if ((TREE_CODE (retval
) == MODIFY_EXPR
3573 || TREE_CODE (retval
) == INIT_EXPR
)
3574 && TREE_CODE (TREE_OPERAND (retval
, 0)) == RESULT_DECL
)
3575 retval_rhs
= TREE_OPERAND (retval
, 1);
3577 retval_rhs
= retval
;
3579 result_rtl
= DECL_RTL (DECL_RESULT (current_function_decl
));
3581 /* If we are returning the RESULT_DECL, then the value has already
3582 been stored into it, so we don't have to do anything special. */
3583 if (TREE_CODE (retval_rhs
) == RESULT_DECL
)
3584 expand_value_return (result_rtl
);
3586 /* If the result is an aggregate that is being returned in one (or more)
3587 registers, load the registers here. */
3589 else if (retval_rhs
!= 0
3590 && TYPE_MODE (TREE_TYPE (retval_rhs
)) == BLKmode
3591 && REG_P (result_rtl
))
3593 val
= copy_blkmode_to_reg (GET_MODE (result_rtl
), retval_rhs
);
3596 /* Use the mode of the result value on the return register. */
3597 PUT_MODE (result_rtl
, GET_MODE (val
));
3598 expand_value_return (val
);
3601 expand_null_return ();
3603 else if (retval_rhs
!= 0
3604 && !VOID_TYPE_P (TREE_TYPE (retval_rhs
))
3605 && (REG_P (result_rtl
)
3606 || (GET_CODE (result_rtl
) == PARALLEL
)))
3608 /* Compute the return value into a temporary (usually a pseudo reg). */
3610 = assign_temp (TREE_TYPE (DECL_RESULT (current_function_decl
)), 0, 1);
3611 val
= expand_expr (retval_rhs
, val
, GET_MODE (val
), EXPAND_NORMAL
);
3612 val
= force_not_mem (val
);
3613 expand_value_return (val
);
3617 /* No hard reg used; calculate value into hard return reg. */
3618 expand_expr (retval
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3619 expand_value_return (result_rtl
);
3623 /* Expand a clobber of LHS. If LHS is stored it in a multi-part
3624 register, tell the rtl optimizers that its value is no longer
3628 expand_clobber (tree lhs
)
3632 rtx decl_rtl
= DECL_RTL_IF_SET (lhs
);
3633 if (decl_rtl
&& REG_P (decl_rtl
))
3635 machine_mode decl_mode
= GET_MODE (decl_rtl
);
3636 if (maybe_gt (GET_MODE_SIZE (decl_mode
),
3637 REGMODE_NATURAL_SIZE (decl_mode
)))
3638 emit_clobber (decl_rtl
);
3643 /* A subroutine of expand_gimple_stmt, expanding one gimple statement
3644 STMT that doesn't require special handling for outgoing edges. That
3645 is no tailcalls and no GIMPLE_COND. */
3648 expand_gimple_stmt_1 (gimple
*stmt
)
3652 set_curr_insn_location (gimple_location (stmt
));
3654 switch (gimple_code (stmt
))
3657 op0
= gimple_goto_dest (stmt
);
3658 if (TREE_CODE (op0
) == LABEL_DECL
)
3661 expand_computed_goto (op0
);
3664 expand_label (gimple_label_label (as_a
<glabel
*> (stmt
)));
3667 case GIMPLE_PREDICT
:
3671 gswitch
*swtch
= as_a
<gswitch
*> (stmt
);
3672 if (gimple_switch_num_labels (swtch
) == 1)
3673 expand_goto (CASE_LABEL (gimple_switch_default_label (swtch
)));
3675 expand_case (swtch
);
3679 expand_asm_stmt (as_a
<gasm
*> (stmt
));
3682 expand_call_stmt (as_a
<gcall
*> (stmt
));
3687 op0
= gimple_return_retval (as_a
<greturn
*> (stmt
));
3689 /* If a return doesn't have a location, it very likely represents
3690 multiple user returns so we cannot let it inherit the location
3691 of the last statement of the previous basic block in RTL. */
3692 if (!gimple_has_location (stmt
))
3693 set_curr_insn_location (cfun
->function_end_locus
);
3695 if (op0
&& op0
!= error_mark_node
)
3697 tree result
= DECL_RESULT (current_function_decl
);
3699 /* If we are not returning the current function's RESULT_DECL,
3700 build an assignment to it. */
3703 /* I believe that a function's RESULT_DECL is unique. */
3704 gcc_assert (TREE_CODE (op0
) != RESULT_DECL
);
3706 /* ??? We'd like to use simply expand_assignment here,
3707 but this fails if the value is of BLKmode but the return
3708 decl is a register. expand_return has special handling
3709 for this combination, which eventually should move
3710 to common code. See comments there. Until then, let's
3711 build a modify expression :-/ */
3712 op0
= build2 (MODIFY_EXPR
, TREE_TYPE (result
),
3718 expand_null_return ();
3720 expand_return (op0
);
3726 gassign
*assign_stmt
= as_a
<gassign
*> (stmt
);
3727 tree lhs
= gimple_assign_lhs (assign_stmt
);
3729 /* Tree expand used to fiddle with |= and &= of two bitfield
3730 COMPONENT_REFs here. This can't happen with gimple, the LHS
3731 of binary assigns must be a gimple reg. */
3733 if (TREE_CODE (lhs
) != SSA_NAME
3734 || get_gimple_rhs_class (gimple_expr_code (stmt
))
3735 == GIMPLE_SINGLE_RHS
)
3737 tree rhs
= gimple_assign_rhs1 (assign_stmt
);
3738 gcc_assert (get_gimple_rhs_class (gimple_expr_code (stmt
))
3739 == GIMPLE_SINGLE_RHS
);
3740 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (rhs
)
3741 /* Do not put locations on possibly shared trees. */
3742 && !is_gimple_min_invariant (rhs
))
3743 SET_EXPR_LOCATION (rhs
, gimple_location (stmt
));
3744 if (TREE_CLOBBER_P (rhs
))
3745 /* This is a clobber to mark the going out of scope for
3747 expand_clobber (lhs
);
3749 expand_assignment (lhs
, rhs
,
3750 gimple_assign_nontemporal_move_p (
3756 bool nontemporal
= gimple_assign_nontemporal_move_p (assign_stmt
);
3757 struct separate_ops ops
;
3758 bool promoted
= false;
3760 target
= expand_expr (lhs
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
3761 if (GET_CODE (target
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (target
))
3764 ops
.code
= gimple_assign_rhs_code (assign_stmt
);
3765 ops
.type
= TREE_TYPE (lhs
);
3766 switch (get_gimple_rhs_class (ops
.code
))
3768 case GIMPLE_TERNARY_RHS
:
3769 ops
.op2
= gimple_assign_rhs3 (assign_stmt
);
3771 case GIMPLE_BINARY_RHS
:
3772 ops
.op1
= gimple_assign_rhs2 (assign_stmt
);
3774 case GIMPLE_UNARY_RHS
:
3775 ops
.op0
= gimple_assign_rhs1 (assign_stmt
);
3780 ops
.location
= gimple_location (stmt
);
3782 /* If we want to use a nontemporal store, force the value to
3783 register first. If we store into a promoted register,
3784 don't directly expand to target. */
3785 temp
= nontemporal
|| promoted
? NULL_RTX
: target
;
3786 temp
= expand_expr_real_2 (&ops
, temp
, GET_MODE (target
),
3793 int unsignedp
= SUBREG_PROMOTED_SIGN (target
);
3794 /* If TEMP is a VOIDmode constant, use convert_modes to make
3795 sure that we properly convert it. */
3796 if (CONSTANT_P (temp
) && GET_MODE (temp
) == VOIDmode
)
3798 temp
= convert_modes (GET_MODE (target
),
3799 TYPE_MODE (ops
.type
),
3801 temp
= convert_modes (GET_MODE (SUBREG_REG (target
)),
3802 GET_MODE (target
), temp
, unsignedp
);
3805 convert_move (SUBREG_REG (target
), temp
, unsignedp
);
3807 else if (nontemporal
&& emit_storent_insn (target
, temp
))
3811 temp
= force_operand (temp
, target
);
3813 emit_move_insn (target
, temp
);
3824 /* Expand one gimple statement STMT and return the last RTL instruction
3825 before any of the newly generated ones.
3827 In addition to generating the necessary RTL instructions this also
3828 sets REG_EH_REGION notes if necessary and sets the current source
3829 location for diagnostics. */
3832 expand_gimple_stmt (gimple
*stmt
)
3834 location_t saved_location
= input_location
;
3835 rtx_insn
*last
= get_last_insn ();
3840 /* We need to save and restore the current source location so that errors
3841 discovered during expansion are emitted with the right location. But
3842 it would be better if the diagnostic routines used the source location
3843 embedded in the tree nodes rather than globals. */
3844 if (gimple_has_location (stmt
))
3845 input_location
= gimple_location (stmt
);
3847 expand_gimple_stmt_1 (stmt
);
3849 /* Free any temporaries used to evaluate this statement. */
3852 input_location
= saved_location
;
3854 /* Mark all insns that may trap. */
3855 lp_nr
= lookup_stmt_eh_lp (stmt
);
3859 for (insn
= next_real_insn (last
); insn
;
3860 insn
= next_real_insn (insn
))
3862 if (! find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
3863 /* If we want exceptions for non-call insns, any
3864 may_trap_p instruction may throw. */
3865 && GET_CODE (PATTERN (insn
)) != CLOBBER
3866 && GET_CODE (PATTERN (insn
)) != USE
3867 && insn_could_throw_p (insn
))
3868 make_reg_eh_region_note (insn
, 0, lp_nr
);
3875 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_CALL
3876 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
3877 generated a tail call (something that might be denied by the ABI
3878 rules governing the call; see calls.c).
3880 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
3881 can still reach the rest of BB. The case here is __builtin_sqrt,
3882 where the NaN result goes through the external function (with a
3883 tailcall) and the normal result happens via a sqrt instruction. */
3886 expand_gimple_tailcall (basic_block bb
, gcall
*stmt
, bool *can_fallthru
)
3888 rtx_insn
*last2
, *last
;
3891 profile_probability probability
;
3893 last2
= last
= expand_gimple_stmt (stmt
);
3895 for (last
= NEXT_INSN (last
); last
; last
= NEXT_INSN (last
))
3896 if (CALL_P (last
) && SIBLING_CALL_P (last
))
3899 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
3901 *can_fallthru
= true;
3905 /* ??? Wouldn't it be better to just reset any pending stack adjust?
3906 Any instructions emitted here are about to be deleted. */
3907 do_pending_stack_adjust ();
3909 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
3910 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
3911 EH or abnormal edges, we shouldn't have created a tail call in
3912 the first place. So it seems to me we should just be removing
3913 all edges here, or redirecting the existing fallthru edge to
3916 probability
= profile_probability::never ();
3918 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
3920 if (!(e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
)))
3922 if (e
->dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
3923 e
->dest
->count
-= e
->count ();
3924 probability
+= e
->probability
;
3931 /* This is somewhat ugly: the call_expr expander often emits instructions
3932 after the sibcall (to perform the function return). These confuse the
3933 find_many_sub_basic_blocks code, so we need to get rid of these. */
3934 last
= NEXT_INSN (last
);
3935 gcc_assert (BARRIER_P (last
));
3937 *can_fallthru
= false;
3938 while (NEXT_INSN (last
))
3940 /* For instance an sqrt builtin expander expands if with
3941 sibcall in the then and label for `else`. */
3942 if (LABEL_P (NEXT_INSN (last
)))
3944 *can_fallthru
= true;
3947 delete_insn (NEXT_INSN (last
));
3950 e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_ABNORMAL
3952 e
->probability
= probability
;
3954 update_bb_for_insn (bb
);
3956 if (NEXT_INSN (last
))
3958 bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
3961 if (BARRIER_P (last
))
3962 BB_END (bb
) = PREV_INSN (last
);
3965 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
3970 /* Return the difference between the floor and the truncated result of
3971 a signed division by OP1 with remainder MOD. */
3973 floor_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3975 /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
3976 return gen_rtx_IF_THEN_ELSE
3977 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3978 gen_rtx_IF_THEN_ELSE
3979 (mode
, gen_rtx_LT (BImode
,
3980 gen_rtx_DIV (mode
, op1
, mod
),
3982 constm1_rtx
, const0_rtx
),
3986 /* Return the difference between the ceil and the truncated result of
3987 a signed division by OP1 with remainder MOD. */
3989 ceil_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3991 /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
3992 return gen_rtx_IF_THEN_ELSE
3993 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3994 gen_rtx_IF_THEN_ELSE
3995 (mode
, gen_rtx_GT (BImode
,
3996 gen_rtx_DIV (mode
, op1
, mod
),
3998 const1_rtx
, const0_rtx
),
4002 /* Return the difference between the ceil and the truncated result of
4003 an unsigned division by OP1 with remainder MOD. */
4005 ceil_udiv_adjust (machine_mode mode
, rtx mod
, rtx op1 ATTRIBUTE_UNUSED
)
4007 /* (mod != 0 ? 1 : 0) */
4008 return gen_rtx_IF_THEN_ELSE
4009 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
4010 const1_rtx
, const0_rtx
);
4013 /* Return the difference between the rounded and the truncated result
4014 of a signed division by OP1 with remainder MOD. Halfway cases are
4015 rounded away from zero, rather than to the nearest even number. */
4017 round_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
4019 /* (abs (mod) >= abs (op1) - abs (mod)
4020 ? (op1 / mod > 0 ? 1 : -1)
4022 return gen_rtx_IF_THEN_ELSE
4023 (mode
, gen_rtx_GE (BImode
, gen_rtx_ABS (mode
, mod
),
4024 gen_rtx_MINUS (mode
,
4025 gen_rtx_ABS (mode
, op1
),
4026 gen_rtx_ABS (mode
, mod
))),
4027 gen_rtx_IF_THEN_ELSE
4028 (mode
, gen_rtx_GT (BImode
,
4029 gen_rtx_DIV (mode
, op1
, mod
),
4031 const1_rtx
, constm1_rtx
),
4035 /* Return the difference between the rounded and the truncated result
4036 of a unsigned division by OP1 with remainder MOD. Halfway cases
4037 are rounded away from zero, rather than to the nearest even
4040 round_udiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
4042 /* (mod >= op1 - mod ? 1 : 0) */
4043 return gen_rtx_IF_THEN_ELSE
4044 (mode
, gen_rtx_GE (BImode
, mod
,
4045 gen_rtx_MINUS (mode
, op1
, mod
)),
4046 const1_rtx
, const0_rtx
);
4049 /* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
4053 convert_debug_memory_address (scalar_int_mode mode
, rtx x
,
4056 #ifndef POINTERS_EXTEND_UNSIGNED
4057 gcc_assert (mode
== Pmode
4058 || mode
== targetm
.addr_space
.address_mode (as
));
4059 gcc_assert (GET_MODE (x
) == mode
|| GET_MODE (x
) == VOIDmode
);
4063 gcc_assert (targetm
.addr_space
.valid_pointer_mode (mode
, as
));
4065 if (GET_MODE (x
) == mode
|| GET_MODE (x
) == VOIDmode
)
4068 /* X must have some form of address mode already. */
4069 scalar_int_mode xmode
= as_a
<scalar_int_mode
> (GET_MODE (x
));
4070 if (GET_MODE_PRECISION (mode
) < GET_MODE_PRECISION (xmode
))
4071 x
= lowpart_subreg (mode
, x
, xmode
);
4072 else if (POINTERS_EXTEND_UNSIGNED
> 0)
4073 x
= gen_rtx_ZERO_EXTEND (mode
, x
);
4074 else if (!POINTERS_EXTEND_UNSIGNED
)
4075 x
= gen_rtx_SIGN_EXTEND (mode
, x
);
4078 switch (GET_CODE (x
))
4081 if ((SUBREG_PROMOTED_VAR_P (x
)
4082 || (REG_P (SUBREG_REG (x
)) && REG_POINTER (SUBREG_REG (x
)))
4083 || (GET_CODE (SUBREG_REG (x
)) == PLUS
4084 && REG_P (XEXP (SUBREG_REG (x
), 0))
4085 && REG_POINTER (XEXP (SUBREG_REG (x
), 0))
4086 && CONST_INT_P (XEXP (SUBREG_REG (x
), 1))))
4087 && GET_MODE (SUBREG_REG (x
)) == mode
)
4088 return SUBREG_REG (x
);
4091 temp
= gen_rtx_LABEL_REF (mode
, label_ref_label (x
));
4092 LABEL_REF_NONLOCAL_P (temp
) = LABEL_REF_NONLOCAL_P (x
);
4095 temp
= shallow_copy_rtx (x
);
4096 PUT_MODE (temp
, mode
);
4099 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
4101 temp
= gen_rtx_CONST (mode
, temp
);
4105 if (CONST_INT_P (XEXP (x
, 1)))
4107 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
4109 return gen_rtx_fmt_ee (GET_CODE (x
), mode
, temp
, XEXP (x
, 1));
4115 /* Don't know how to express ptr_extend as operation in debug info. */
4118 #endif /* POINTERS_EXTEND_UNSIGNED */
4123 /* Map from SSA_NAMEs to corresponding DEBUG_EXPR_DECLs created
4124 by avoid_deep_ter_for_debug. */
4126 static hash_map
<tree
, tree
> *deep_ter_debug_map
;
4128 /* Split too deep TER chains for debug stmts using debug temporaries. */
4131 avoid_deep_ter_for_debug (gimple
*stmt
, int depth
)
4133 use_operand_p use_p
;
4135 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
4137 tree use
= USE_FROM_PTR (use_p
);
4138 if (TREE_CODE (use
) != SSA_NAME
|| SSA_NAME_IS_DEFAULT_DEF (use
))
4140 gimple
*g
= get_gimple_for_ssa_name (use
);
4143 if (depth
> 6 && !stmt_ends_bb_p (g
))
4145 if (deep_ter_debug_map
== NULL
)
4146 deep_ter_debug_map
= new hash_map
<tree
, tree
>;
4148 tree
&vexpr
= deep_ter_debug_map
->get_or_insert (use
);
4151 vexpr
= make_node (DEBUG_EXPR_DECL
);
4152 gimple
*def_temp
= gimple_build_debug_bind (vexpr
, use
, g
);
4153 DECL_ARTIFICIAL (vexpr
) = 1;
4154 TREE_TYPE (vexpr
) = TREE_TYPE (use
);
4155 SET_DECL_MODE (vexpr
, TYPE_MODE (TREE_TYPE (use
)));
4156 gimple_stmt_iterator gsi
= gsi_for_stmt (g
);
4157 gsi_insert_after (&gsi
, def_temp
, GSI_NEW_STMT
);
4158 avoid_deep_ter_for_debug (def_temp
, 0);
4161 avoid_deep_ter_for_debug (g
, depth
+ 1);
4165 /* Return an RTX equivalent to the value of the parameter DECL. */
4168 expand_debug_parm_decl (tree decl
)
4170 rtx incoming
= DECL_INCOMING_RTL (decl
);
4173 && GET_MODE (incoming
) != BLKmode
4174 && ((REG_P (incoming
) && HARD_REGISTER_P (incoming
))
4175 || (MEM_P (incoming
)
4176 && REG_P (XEXP (incoming
, 0))
4177 && HARD_REGISTER_P (XEXP (incoming
, 0)))))
4179 rtx rtl
= gen_rtx_ENTRY_VALUE (GET_MODE (incoming
));
4181 #ifdef HAVE_window_save
4182 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
4183 If the target machine has an explicit window save instruction, the
4184 actual entry value is the corresponding OUTGOING_REGNO instead. */
4185 if (REG_P (incoming
)
4186 && OUTGOING_REGNO (REGNO (incoming
)) != REGNO (incoming
))
4188 = gen_rtx_REG_offset (incoming
, GET_MODE (incoming
),
4189 OUTGOING_REGNO (REGNO (incoming
)), 0);
4190 else if (MEM_P (incoming
))
4192 rtx reg
= XEXP (incoming
, 0);
4193 if (OUTGOING_REGNO (REGNO (reg
)) != REGNO (reg
))
4195 reg
= gen_raw_REG (GET_MODE (reg
), OUTGOING_REGNO (REGNO (reg
)));
4196 incoming
= replace_equiv_address_nv (incoming
, reg
);
4199 incoming
= copy_rtx (incoming
);
4203 ENTRY_VALUE_EXP (rtl
) = incoming
;
4208 && GET_MODE (incoming
) != BLKmode
4209 && !TREE_ADDRESSABLE (decl
)
4211 && (XEXP (incoming
, 0) == virtual_incoming_args_rtx
4212 || (GET_CODE (XEXP (incoming
, 0)) == PLUS
4213 && XEXP (XEXP (incoming
, 0), 0) == virtual_incoming_args_rtx
4214 && CONST_INT_P (XEXP (XEXP (incoming
, 0), 1)))))
4215 return copy_rtx (incoming
);
4220 /* Return an RTX equivalent to the value of the tree expression EXP. */
4223 expand_debug_expr (tree exp
)
4225 rtx op0
= NULL_RTX
, op1
= NULL_RTX
, op2
= NULL_RTX
;
4226 machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
4227 machine_mode inner_mode
= VOIDmode
;
4228 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (exp
));
4230 scalar_int_mode op0_mode
, op1_mode
, addr_mode
;
4232 switch (TREE_CODE_CLASS (TREE_CODE (exp
)))
4234 case tcc_expression
:
4235 switch (TREE_CODE (exp
))
4240 case WIDEN_MULT_PLUS_EXPR
:
4241 case WIDEN_MULT_MINUS_EXPR
:
4244 case TRUTH_ANDIF_EXPR
:
4245 case TRUTH_ORIF_EXPR
:
4246 case TRUTH_AND_EXPR
:
4248 case TRUTH_XOR_EXPR
:
4251 case TRUTH_NOT_EXPR
:
4260 op2
= expand_debug_expr (TREE_OPERAND (exp
, 2));
4267 if (mode
== BLKmode
)
4269 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
4272 switch (TREE_CODE (exp
))
4278 case WIDEN_LSHIFT_EXPR
:
4279 /* Ensure second operand isn't wider than the first one. */
4280 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 1)));
4281 if (is_a
<scalar_int_mode
> (inner_mode
, &op1_mode
)
4282 && (GET_MODE_UNIT_PRECISION (mode
)
4283 < GET_MODE_PRECISION (op1_mode
)))
4284 op1
= lowpart_subreg (GET_MODE_INNER (mode
), op1
, op1_mode
);
4293 if (mode
== BLKmode
)
4295 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4296 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4301 case tcc_comparison
:
4302 unsignedp
= TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4310 case tcc_exceptional
:
4311 case tcc_declaration
:
4317 switch (TREE_CODE (exp
))
4320 if (!lookup_constant_def (exp
))
4322 if (strlen (TREE_STRING_POINTER (exp
)) + 1
4323 != (size_t) TREE_STRING_LENGTH (exp
))
4325 op0
= gen_rtx_CONST_STRING (Pmode
, TREE_STRING_POINTER (exp
));
4326 op0
= gen_rtx_MEM (BLKmode
, op0
);
4327 set_mem_attributes (op0
, exp
, 0);
4335 op0
= expand_expr (exp
, NULL_RTX
, mode
, EXPAND_INITIALIZER
);
4339 return immed_wide_int_const (poly_int_cst_value (exp
), mode
);
4342 gcc_assert (COMPLEX_MODE_P (mode
));
4343 op0
= expand_debug_expr (TREE_REALPART (exp
));
4344 op1
= expand_debug_expr (TREE_IMAGPART (exp
));
4345 return gen_rtx_CONCAT (mode
, op0
, op1
);
4347 case DEBUG_EXPR_DECL
:
4348 op0
= DECL_RTL_IF_SET (exp
);
4353 op0
= gen_rtx_DEBUG_EXPR (mode
);
4354 DEBUG_EXPR_TREE_DECL (op0
) = exp
;
4355 SET_DECL_RTL (exp
, op0
);
4365 op0
= DECL_RTL_IF_SET (exp
);
4367 /* This decl was probably optimized away. */
4369 /* At least label RTXen are sometimes replaced by
4370 NOTE_INSN_DELETED_LABEL. Any notes here are not
4371 handled by copy_rtx. */
4375 || DECL_EXTERNAL (exp
)
4376 || !TREE_STATIC (exp
)
4378 || DECL_HARD_REGISTER (exp
)
4379 || DECL_IN_CONSTANT_POOL (exp
)
4380 || mode
== VOIDmode
)
4383 op0
= make_decl_rtl_for_debug (exp
);
4385 || GET_CODE (XEXP (op0
, 0)) != SYMBOL_REF
4386 || SYMBOL_REF_DECL (XEXP (op0
, 0)) != exp
)
4390 op0
= copy_rtx (op0
);
4392 if (GET_MODE (op0
) == BLKmode
4393 /* If op0 is not BLKmode, but mode is, adjust_mode
4394 below would ICE. While it is likely a FE bug,
4395 try to be robust here. See PR43166. */
4397 || (mode
== VOIDmode
&& GET_MODE (op0
) != VOIDmode
))
4399 gcc_assert (MEM_P (op0
));
4400 op0
= adjust_address_nv (op0
, mode
, 0);
4410 inner_mode
= GET_MODE (op0
);
4412 if (mode
== inner_mode
)
4415 if (inner_mode
== VOIDmode
)
4417 if (TREE_CODE (exp
) == SSA_NAME
)
4418 inner_mode
= TYPE_MODE (TREE_TYPE (exp
));
4420 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4421 if (mode
== inner_mode
)
4425 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
4427 if (GET_MODE_UNIT_BITSIZE (mode
)
4428 == GET_MODE_UNIT_BITSIZE (inner_mode
))
4429 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
4430 else if (GET_MODE_UNIT_BITSIZE (mode
)
4431 < GET_MODE_UNIT_BITSIZE (inner_mode
))
4432 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
4434 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
4436 else if (FLOAT_MODE_P (mode
))
4438 gcc_assert (TREE_CODE (exp
) != SSA_NAME
);
4439 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
4440 op0
= simplify_gen_unary (UNSIGNED_FLOAT
, mode
, op0
, inner_mode
);
4442 op0
= simplify_gen_unary (FLOAT
, mode
, op0
, inner_mode
);
4444 else if (FLOAT_MODE_P (inner_mode
))
4447 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
4449 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
4451 else if (GET_MODE_UNIT_PRECISION (mode
)
4452 == GET_MODE_UNIT_PRECISION (inner_mode
))
4453 op0
= lowpart_subreg (mode
, op0
, inner_mode
);
4454 else if (GET_MODE_UNIT_PRECISION (mode
)
4455 < GET_MODE_UNIT_PRECISION (inner_mode
))
4456 op0
= simplify_gen_unary (TRUNCATE
, mode
, op0
, inner_mode
);
4457 else if (UNARY_CLASS_P (exp
)
4458 ? TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)))
4460 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
4462 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
4468 if (!is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
4470 tree newexp
= fold_binary (MEM_REF
, TREE_TYPE (exp
),
4471 TREE_OPERAND (exp
, 0),
4472 TREE_OPERAND (exp
, 1));
4474 return expand_debug_expr (newexp
);
4478 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4479 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4483 if (TREE_CODE (exp
) == MEM_REF
)
4485 if (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
4486 || (GET_CODE (op0
) == PLUS
4487 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
))
4488 /* (mem (debug_implicit_ptr)) might confuse aliasing.
4489 Instead just use get_inner_reference. */
4492 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
4494 if (!op1
|| !poly_int_rtx_p (op1
, &offset
))
4497 op0
= plus_constant (inner_mode
, op0
, offset
);
4500 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))));
4502 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
4504 if (op0
== NULL_RTX
)
4507 op0
= gen_rtx_MEM (mode
, op0
);
4508 set_mem_attributes (op0
, exp
, 0);
4509 if (TREE_CODE (exp
) == MEM_REF
4510 && !is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
4511 set_mem_expr (op0
, NULL_TREE
);
4512 set_mem_addr_space (op0
, as
);
4516 case TARGET_MEM_REF
:
4517 if (TREE_CODE (TMR_BASE (exp
)) == ADDR_EXPR
4518 && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp
), 0)))
4521 op0
= expand_debug_expr
4522 (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp
)), exp
));
4526 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))));
4527 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
4529 if (op0
== NULL_RTX
)
4532 op0
= gen_rtx_MEM (mode
, op0
);
4534 set_mem_attributes (op0
, exp
, 0);
4535 set_mem_addr_space (op0
, as
);
4541 case ARRAY_RANGE_REF
:
4546 case VIEW_CONVERT_EXPR
:
4549 poly_int64 bitsize
, bitpos
;
4551 int reversep
, volatilep
= 0;
4553 = get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
, &mode1
,
4554 &unsignedp
, &reversep
, &volatilep
);
4557 if (known_eq (bitsize
, 0))
4560 orig_op0
= op0
= expand_debug_expr (tem
);
4567 machine_mode addrmode
, offmode
;
4572 op0
= XEXP (op0
, 0);
4573 addrmode
= GET_MODE (op0
);
4574 if (addrmode
== VOIDmode
)
4577 op1
= expand_debug_expr (offset
);
4581 offmode
= GET_MODE (op1
);
4582 if (offmode
== VOIDmode
)
4583 offmode
= TYPE_MODE (TREE_TYPE (offset
));
4585 if (addrmode
!= offmode
)
4586 op1
= lowpart_subreg (addrmode
, op1
, offmode
);
4588 /* Don't use offset_address here, we don't need a
4589 recognizable address, and we don't want to generate
4591 op0
= gen_rtx_MEM (mode
, simplify_gen_binary (PLUS
, addrmode
,
4597 if (mode1
== VOIDmode
)
4599 if (maybe_gt (bitsize
, MAX_BITSIZE_MODE_ANY_INT
))
4602 mode1
= smallest_int_mode_for_size (bitsize
);
4604 poly_int64 bytepos
= bits_to_bytes_round_down (bitpos
);
4605 if (maybe_ne (bytepos
, 0))
4607 op0
= adjust_address_nv (op0
, mode1
, bytepos
);
4608 bitpos
= num_trailing_bits (bitpos
);
4610 else if (known_eq (bitpos
, 0)
4611 && known_eq (bitsize
, GET_MODE_BITSIZE (mode
)))
4612 op0
= adjust_address_nv (op0
, mode
, 0);
4613 else if (GET_MODE (op0
) != mode1
)
4614 op0
= adjust_address_nv (op0
, mode1
, 0);
4616 op0
= copy_rtx (op0
);
4617 if (op0
== orig_op0
)
4618 op0
= shallow_copy_rtx (op0
);
4619 set_mem_attributes (op0
, exp
, 0);
4622 if (known_eq (bitpos
, 0) && mode
== GET_MODE (op0
))
4625 if (maybe_lt (bitpos
, 0))
4628 if (GET_MODE (op0
) == BLKmode
|| mode
== BLKmode
)
4632 if (multiple_p (bitpos
, BITS_PER_UNIT
, &bytepos
)
4633 && known_eq (bitsize
, GET_MODE_BITSIZE (mode1
)))
4635 machine_mode opmode
= GET_MODE (op0
);
4637 if (opmode
== VOIDmode
)
4638 opmode
= TYPE_MODE (TREE_TYPE (tem
));
4640 /* This condition may hold if we're expanding the address
4641 right past the end of an array that turned out not to
4642 be addressable (i.e., the address was only computed in
4643 debug stmts). The gen_subreg below would rightfully
4644 crash, and the address doesn't really exist, so just
4646 if (known_ge (bitpos
, GET_MODE_BITSIZE (opmode
)))
4649 if (multiple_p (bitpos
, GET_MODE_BITSIZE (mode
)))
4650 return simplify_gen_subreg (mode
, op0
, opmode
, bytepos
);
4653 return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0
))
4654 && TYPE_UNSIGNED (TREE_TYPE (exp
))
4656 : ZERO_EXTRACT
, mode
,
4657 GET_MODE (op0
) != VOIDmode
4659 : TYPE_MODE (TREE_TYPE (tem
)),
4660 op0
, gen_int_mode (bitsize
, word_mode
),
4661 gen_int_mode (bitpos
, word_mode
));
4666 return simplify_gen_unary (ABS
, mode
, op0
, mode
);
4669 return simplify_gen_unary (NEG
, mode
, op0
, mode
);
4672 return simplify_gen_unary (NOT
, mode
, op0
, mode
);
4675 return simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4677 ? UNSIGNED_FLOAT
: FLOAT
, mode
, op0
,
4680 case FIX_TRUNC_EXPR
:
4681 return simplify_gen_unary (unsignedp
? UNSIGNED_FIX
: FIX
, mode
, op0
,
4684 case POINTER_PLUS_EXPR
:
4685 /* For the rare target where pointers are not the same size as
4686 size_t, we need to check for mis-matched modes and correct
4689 && is_a
<scalar_int_mode
> (GET_MODE (op0
), &op0_mode
)
4690 && is_a
<scalar_int_mode
> (GET_MODE (op1
), &op1_mode
)
4691 && op0_mode
!= op1_mode
)
4693 if (GET_MODE_BITSIZE (op0_mode
) < GET_MODE_BITSIZE (op1_mode
)
4694 /* If OP0 is a partial mode, then we must truncate, even
4695 if it has the same bitsize as OP1 as GCC's
4696 representation of partial modes is opaque. */
4697 || (GET_MODE_CLASS (op0_mode
) == MODE_PARTIAL_INT
4698 && (GET_MODE_BITSIZE (op0_mode
)
4699 == GET_MODE_BITSIZE (op1_mode
))))
4700 op1
= simplify_gen_unary (TRUNCATE
, op0_mode
, op1
, op1_mode
);
4702 /* We always sign-extend, regardless of the signedness of
4703 the operand, because the operand is always unsigned
4704 here even if the original C expression is signed. */
4705 op1
= simplify_gen_unary (SIGN_EXTEND
, op0_mode
, op1
, op1_mode
);
4709 return simplify_gen_binary (PLUS
, mode
, op0
, op1
);
4712 case POINTER_DIFF_EXPR
:
4713 return simplify_gen_binary (MINUS
, mode
, op0
, op1
);
4716 return simplify_gen_binary (MULT
, mode
, op0
, op1
);
4719 case TRUNC_DIV_EXPR
:
4720 case EXACT_DIV_EXPR
:
4722 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4724 return simplify_gen_binary (DIV
, mode
, op0
, op1
);
4726 case TRUNC_MOD_EXPR
:
4727 return simplify_gen_binary (unsignedp
? UMOD
: MOD
, mode
, op0
, op1
);
4729 case FLOOR_DIV_EXPR
:
4731 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4734 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4735 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4736 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4737 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4740 case FLOOR_MOD_EXPR
:
4742 return simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4745 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4746 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4747 adj
= simplify_gen_unary (NEG
, mode
,
4748 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4750 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4756 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4757 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4758 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4759 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4763 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4764 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4765 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4766 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4772 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4773 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4774 adj
= simplify_gen_unary (NEG
, mode
,
4775 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4777 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4781 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4782 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4783 adj
= simplify_gen_unary (NEG
, mode
,
4784 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4786 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4789 case ROUND_DIV_EXPR
:
4792 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4793 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4794 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4795 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4799 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4800 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4801 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4802 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4805 case ROUND_MOD_EXPR
:
4808 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4809 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4810 adj
= simplify_gen_unary (NEG
, mode
,
4811 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4813 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4817 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4818 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4819 adj
= simplify_gen_unary (NEG
, mode
,
4820 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4822 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4826 return simplify_gen_binary (ASHIFT
, mode
, op0
, op1
);
4830 return simplify_gen_binary (LSHIFTRT
, mode
, op0
, op1
);
4832 return simplify_gen_binary (ASHIFTRT
, mode
, op0
, op1
);
4835 return simplify_gen_binary (ROTATE
, mode
, op0
, op1
);
4838 return simplify_gen_binary (ROTATERT
, mode
, op0
, op1
);
4841 return simplify_gen_binary (unsignedp
? UMIN
: SMIN
, mode
, op0
, op1
);
4844 return simplify_gen_binary (unsignedp
? UMAX
: SMAX
, mode
, op0
, op1
);
4847 case TRUTH_AND_EXPR
:
4848 return simplify_gen_binary (AND
, mode
, op0
, op1
);
4852 return simplify_gen_binary (IOR
, mode
, op0
, op1
);
4855 case TRUTH_XOR_EXPR
:
4856 return simplify_gen_binary (XOR
, mode
, op0
, op1
);
4858 case TRUTH_ANDIF_EXPR
:
4859 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, const0_rtx
);
4861 case TRUTH_ORIF_EXPR
:
4862 return gen_rtx_IF_THEN_ELSE (mode
, op0
, const_true_rtx
, op1
);
4864 case TRUTH_NOT_EXPR
:
4865 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, const0_rtx
);
4868 return simplify_gen_relational (unsignedp
? LTU
: LT
, mode
, inner_mode
,
4872 return simplify_gen_relational (unsignedp
? LEU
: LE
, mode
, inner_mode
,
4876 return simplify_gen_relational (unsignedp
? GTU
: GT
, mode
, inner_mode
,
4880 return simplify_gen_relational (unsignedp
? GEU
: GE
, mode
, inner_mode
,
4884 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, op1
);
4887 return simplify_gen_relational (NE
, mode
, inner_mode
, op0
, op1
);
4889 case UNORDERED_EXPR
:
4890 return simplify_gen_relational (UNORDERED
, mode
, inner_mode
, op0
, op1
);
4893 return simplify_gen_relational (ORDERED
, mode
, inner_mode
, op0
, op1
);
4896 return simplify_gen_relational (UNLT
, mode
, inner_mode
, op0
, op1
);
4899 return simplify_gen_relational (UNLE
, mode
, inner_mode
, op0
, op1
);
4902 return simplify_gen_relational (UNGT
, mode
, inner_mode
, op0
, op1
);
4905 return simplify_gen_relational (UNGE
, mode
, inner_mode
, op0
, op1
);
4908 return simplify_gen_relational (UNEQ
, mode
, inner_mode
, op0
, op1
);
4911 return simplify_gen_relational (LTGT
, mode
, inner_mode
, op0
, op1
);
4914 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, op2
);
4917 gcc_assert (COMPLEX_MODE_P (mode
));
4918 if (GET_MODE (op0
) == VOIDmode
)
4919 op0
= gen_rtx_CONST (GET_MODE_INNER (mode
), op0
);
4920 if (GET_MODE (op1
) == VOIDmode
)
4921 op1
= gen_rtx_CONST (GET_MODE_INNER (mode
), op1
);
4922 return gen_rtx_CONCAT (mode
, op0
, op1
);
4925 if (GET_CODE (op0
) == CONCAT
)
4926 return gen_rtx_CONCAT (mode
, XEXP (op0
, 0),
4927 simplify_gen_unary (NEG
, GET_MODE_INNER (mode
),
4929 GET_MODE_INNER (mode
)));
4932 scalar_mode imode
= GET_MODE_INNER (mode
);
4937 re
= adjust_address_nv (op0
, imode
, 0);
4938 im
= adjust_address_nv (op0
, imode
, GET_MODE_SIZE (imode
));
4942 scalar_int_mode ifmode
;
4943 scalar_int_mode ihmode
;
4945 if (!int_mode_for_mode (mode
).exists (&ifmode
)
4946 || !int_mode_for_mode (imode
).exists (&ihmode
))
4948 halfsize
= GEN_INT (GET_MODE_BITSIZE (ihmode
));
4951 re
= gen_rtx_SUBREG (ifmode
, re
, 0);
4952 re
= gen_rtx_ZERO_EXTRACT (ihmode
, re
, halfsize
, const0_rtx
);
4953 if (imode
!= ihmode
)
4954 re
= gen_rtx_SUBREG (imode
, re
, 0);
4955 im
= copy_rtx (op0
);
4957 im
= gen_rtx_SUBREG (ifmode
, im
, 0);
4958 im
= gen_rtx_ZERO_EXTRACT (ihmode
, im
, halfsize
, halfsize
);
4959 if (imode
!= ihmode
)
4960 im
= gen_rtx_SUBREG (imode
, im
, 0);
4962 im
= gen_rtx_NEG (imode
, im
);
4963 return gen_rtx_CONCAT (mode
, re
, im
);
4967 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4968 if (!op0
|| !MEM_P (op0
))
4970 if ((TREE_CODE (TREE_OPERAND (exp
, 0)) == VAR_DECL
4971 || TREE_CODE (TREE_OPERAND (exp
, 0)) == PARM_DECL
4972 || TREE_CODE (TREE_OPERAND (exp
, 0)) == RESULT_DECL
)
4973 && (!TREE_ADDRESSABLE (TREE_OPERAND (exp
, 0))
4974 || target_for_debug_bind (TREE_OPERAND (exp
, 0))))
4975 return gen_rtx_DEBUG_IMPLICIT_PTR (mode
, TREE_OPERAND (exp
, 0));
4977 if (handled_component_p (TREE_OPERAND (exp
, 0)))
4979 poly_int64 bitoffset
, bitsize
, maxsize
, byteoffset
;
4982 = get_ref_base_and_extent (TREE_OPERAND (exp
, 0), &bitoffset
,
4983 &bitsize
, &maxsize
, &reverse
);
4985 || TREE_CODE (decl
) == PARM_DECL
4986 || TREE_CODE (decl
) == RESULT_DECL
)
4987 && (!TREE_ADDRESSABLE (decl
)
4988 || target_for_debug_bind (decl
))
4989 && multiple_p (bitoffset
, BITS_PER_UNIT
, &byteoffset
)
4990 && known_gt (bitsize
, 0)
4991 && known_eq (bitsize
, maxsize
))
4993 rtx base
= gen_rtx_DEBUG_IMPLICIT_PTR (mode
, decl
);
4994 return plus_constant (mode
, base
, byteoffset
);
4998 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == MEM_REF
4999 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
5002 op0
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
5005 && (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
5006 || (GET_CODE (op0
) == PLUS
5007 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
5008 && CONST_INT_P (XEXP (op0
, 1)))))
5010 op1
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
5013 if (!op1
|| !poly_int_rtx_p (op1
, &offset
))
5016 return plus_constant (mode
, op0
, offset
);
5023 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)));
5024 addr_mode
= SCALAR_INT_TYPE_MODE (TREE_TYPE (exp
));
5025 op0
= convert_debug_memory_address (addr_mode
, XEXP (op0
, 0), as
);
5031 unsigned HOST_WIDE_INT i
, nelts
;
5033 if (!VECTOR_CST_NELTS (exp
).is_constant (&nelts
))
5036 op0
= gen_rtx_CONCATN (mode
, rtvec_alloc (nelts
));
5038 for (i
= 0; i
< nelts
; ++i
)
5040 op1
= expand_debug_expr (VECTOR_CST_ELT (exp
, i
));
5043 XVECEXP (op0
, 0, i
) = op1
;
5050 if (TREE_CLOBBER_P (exp
))
5052 else if (TREE_CODE (TREE_TYPE (exp
)) == VECTOR_TYPE
)
5055 unsigned HOST_WIDE_INT nelts
;
5058 if (!TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)).is_constant (&nelts
))
5059 goto flag_unsupported
;
5061 op0
= gen_rtx_CONCATN (mode
, rtvec_alloc (nelts
));
5063 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), i
, val
)
5065 op1
= expand_debug_expr (val
);
5068 XVECEXP (op0
, 0, i
) = op1
;
5073 op1
= expand_debug_expr
5074 (build_zero_cst (TREE_TYPE (TREE_TYPE (exp
))));
5079 for (; i
< nelts
; i
++)
5080 XVECEXP (op0
, 0, i
) = op1
;
5086 goto flag_unsupported
;
5089 /* ??? Maybe handle some builtins? */
5094 gimple
*g
= get_gimple_for_ssa_name (exp
);
5098 if (deep_ter_debug_map
)
5100 tree
*slot
= deep_ter_debug_map
->get (exp
);
5105 t
= gimple_assign_rhs_to_tree (g
);
5106 op0
= expand_debug_expr (t
);
5112 /* If this is a reference to an incoming value of
5113 parameter that is never used in the code or where the
5114 incoming value is never used in the code, use
5115 PARM_DECL's DECL_RTL if set. */
5116 if (SSA_NAME_IS_DEFAULT_DEF (exp
)
5117 && SSA_NAME_VAR (exp
)
5118 && TREE_CODE (SSA_NAME_VAR (exp
)) == PARM_DECL
5119 && has_zero_uses (exp
))
5121 op0
= expand_debug_parm_decl (SSA_NAME_VAR (exp
));
5124 op0
= expand_debug_expr (SSA_NAME_VAR (exp
));
5129 int part
= var_to_partition (SA
.map
, exp
);
5131 if (part
== NO_PARTITION
)
5134 gcc_assert (part
>= 0 && (unsigned)part
< SA
.map
->num_partitions
);
5136 op0
= copy_rtx (SA
.partition_to_pseudo
[part
]);
5144 /* Vector stuff. For most of the codes we don't have rtl codes. */
5145 case REALIGN_LOAD_EXPR
:
5147 case VEC_PACK_FIX_TRUNC_EXPR
:
5148 case VEC_PACK_FLOAT_EXPR
:
5149 case VEC_PACK_SAT_EXPR
:
5150 case VEC_PACK_TRUNC_EXPR
:
5151 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
5152 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
5153 case VEC_UNPACK_FLOAT_HI_EXPR
:
5154 case VEC_UNPACK_FLOAT_LO_EXPR
:
5155 case VEC_UNPACK_HI_EXPR
:
5156 case VEC_UNPACK_LO_EXPR
:
5157 case VEC_WIDEN_MULT_HI_EXPR
:
5158 case VEC_WIDEN_MULT_LO_EXPR
:
5159 case VEC_WIDEN_MULT_EVEN_EXPR
:
5160 case VEC_WIDEN_MULT_ODD_EXPR
:
5161 case VEC_WIDEN_LSHIFT_HI_EXPR
:
5162 case VEC_WIDEN_LSHIFT_LO_EXPR
:
5164 case VEC_DUPLICATE_EXPR
:
5165 case VEC_SERIES_EXPR
:
5170 case ADDR_SPACE_CONVERT_EXPR
:
5171 case FIXED_CONVERT_EXPR
:
5173 case WITH_SIZE_EXPR
:
5174 case BIT_INSERT_EXPR
:
5178 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5179 && SCALAR_INT_MODE_P (mode
))
5182 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5184 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
5187 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5189 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op1
,
5191 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
5192 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
5196 case WIDEN_MULT_EXPR
:
5197 case WIDEN_MULT_PLUS_EXPR
:
5198 case WIDEN_MULT_MINUS_EXPR
:
5199 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5200 && SCALAR_INT_MODE_P (mode
))
5202 inner_mode
= GET_MODE (op0
);
5203 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
5204 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
5206 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
5207 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 1))))
5208 op1
= simplify_gen_unary (ZERO_EXTEND
, mode
, op1
, inner_mode
);
5210 op1
= simplify_gen_unary (SIGN_EXTEND
, mode
, op1
, inner_mode
);
5211 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
5212 if (TREE_CODE (exp
) == WIDEN_MULT_EXPR
)
5214 else if (TREE_CODE (exp
) == WIDEN_MULT_PLUS_EXPR
)
5215 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
5217 return simplify_gen_binary (MINUS
, mode
, op2
, op0
);
5221 case MULT_HIGHPART_EXPR
:
5222 /* ??? Similar to the above. */
5225 case WIDEN_SUM_EXPR
:
5226 case WIDEN_LSHIFT_EXPR
:
5227 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5228 && SCALAR_INT_MODE_P (mode
))
5231 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5233 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
5235 return simplify_gen_binary (TREE_CODE (exp
) == WIDEN_LSHIFT_EXPR
5236 ? ASHIFT
: PLUS
, mode
, op0
, op1
);
5251 /* Return an RTX equivalent to the source bind value of the tree expression
5255 expand_debug_source_expr (tree exp
)
5258 machine_mode mode
= VOIDmode
, inner_mode
;
5260 switch (TREE_CODE (exp
))
5263 if (DECL_ABSTRACT_ORIGIN (exp
))
5264 return expand_debug_source_expr (DECL_ABSTRACT_ORIGIN (exp
));
5268 mode
= DECL_MODE (exp
);
5269 op0
= expand_debug_parm_decl (exp
);
5272 /* See if this isn't an argument that has been completely
5274 if (!DECL_RTL_SET_P (exp
)
5275 && !DECL_INCOMING_RTL (exp
)
5276 && DECL_ABSTRACT_ORIGIN (current_function_decl
))
5278 tree aexp
= DECL_ORIGIN (exp
);
5279 if (DECL_CONTEXT (aexp
)
5280 == DECL_ABSTRACT_ORIGIN (current_function_decl
))
5282 vec
<tree
, va_gc
> **debug_args
;
5285 debug_args
= decl_debug_args_lookup (current_function_decl
);
5286 if (debug_args
!= NULL
)
5288 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, &ddecl
);
5291 return gen_rtx_DEBUG_PARAMETER_REF (mode
, aexp
);
5301 if (op0
== NULL_RTX
)
5304 inner_mode
= GET_MODE (op0
);
5305 if (mode
== inner_mode
)
5308 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
5310 if (GET_MODE_UNIT_BITSIZE (mode
)
5311 == GET_MODE_UNIT_BITSIZE (inner_mode
))
5312 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
5313 else if (GET_MODE_UNIT_BITSIZE (mode
)
5314 < GET_MODE_UNIT_BITSIZE (inner_mode
))
5315 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
5317 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
5319 else if (FLOAT_MODE_P (mode
))
5321 else if (FLOAT_MODE_P (inner_mode
))
5323 if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
5324 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
5326 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
5328 else if (GET_MODE_UNIT_PRECISION (mode
)
5329 == GET_MODE_UNIT_PRECISION (inner_mode
))
5330 op0
= lowpart_subreg (mode
, op0
, inner_mode
);
5331 else if (GET_MODE_UNIT_PRECISION (mode
)
5332 < GET_MODE_UNIT_PRECISION (inner_mode
))
5333 op0
= simplify_gen_unary (TRUNCATE
, mode
, op0
, inner_mode
);
5334 else if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
5335 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
5337 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
5342 /* Ensure INSN_VAR_LOCATION_LOC (insn) doesn't have unbound complexity.
5343 Allow 4 levels of rtl nesting for most rtl codes, and if we see anything
5344 deeper than that, create DEBUG_EXPRs and emit DEBUG_INSNs before INSN. */
5347 avoid_complex_debug_insns (rtx_insn
*insn
, rtx
*exp_p
, int depth
)
5351 if (exp
== NULL_RTX
)
5354 if ((OBJECT_P (exp
) && !MEM_P (exp
)) || GET_CODE (exp
) == CLOBBER
)
5359 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
5360 rtx dval
= make_debug_expr_from_rtl (exp
);
5362 /* Emit a debug bind insn before INSN. */
5363 rtx bind
= gen_rtx_VAR_LOCATION (GET_MODE (exp
),
5364 DEBUG_EXPR_TREE_DECL (dval
), exp
,
5365 VAR_INIT_STATUS_INITIALIZED
);
5367 emit_debug_insn_before (bind
, insn
);
5372 const char *format_ptr
= GET_RTX_FORMAT (GET_CODE (exp
));
5374 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
5375 switch (*format_ptr
++)
5378 avoid_complex_debug_insns (insn
, &XEXP (exp
, i
), depth
+ 1);
5383 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
5384 avoid_complex_debug_insns (insn
, &XVECEXP (exp
, i
, j
), depth
+ 1);
5392 /* Expand the _LOCs in debug insns. We run this after expanding all
5393 regular insns, so that any variables referenced in the function
5394 will have their DECL_RTLs set. */
5397 expand_debug_locations (void)
5400 rtx_insn
*last
= get_last_insn ();
5401 int save_strict_alias
= flag_strict_aliasing
;
5403 /* New alias sets while setting up memory attributes cause
5404 -fcompare-debug failures, even though it doesn't bring about any
5406 flag_strict_aliasing
= 0;
5408 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
5409 if (DEBUG_BIND_INSN_P (insn
))
5411 tree value
= (tree
)INSN_VAR_LOCATION_LOC (insn
);
5413 rtx_insn
*prev_insn
, *insn2
;
5416 if (value
== NULL_TREE
)
5420 if (INSN_VAR_LOCATION_STATUS (insn
)
5421 == VAR_INIT_STATUS_UNINITIALIZED
)
5422 val
= expand_debug_source_expr (value
);
5423 /* The avoid_deep_ter_for_debug function inserts
5424 debug bind stmts after SSA_NAME definition, with the
5425 SSA_NAME as the whole bind location. Disable temporarily
5426 expansion of that SSA_NAME into the DEBUG_EXPR_DECL
5427 being defined in this DEBUG_INSN. */
5428 else if (deep_ter_debug_map
&& TREE_CODE (value
) == SSA_NAME
)
5430 tree
*slot
= deep_ter_debug_map
->get (value
);
5433 if (*slot
== INSN_VAR_LOCATION_DECL (insn
))
5438 val
= expand_debug_expr (value
);
5440 *slot
= INSN_VAR_LOCATION_DECL (insn
);
5443 val
= expand_debug_expr (value
);
5444 gcc_assert (last
== get_last_insn ());
5448 val
= gen_rtx_UNKNOWN_VAR_LOC ();
5451 mode
= GET_MODE (INSN_VAR_LOCATION (insn
));
5453 gcc_assert (mode
== GET_MODE (val
)
5454 || (GET_MODE (val
) == VOIDmode
5455 && (CONST_SCALAR_INT_P (val
)
5456 || GET_CODE (val
) == CONST_FIXED
5457 || GET_CODE (val
) == LABEL_REF
)));
5460 INSN_VAR_LOCATION_LOC (insn
) = val
;
5461 prev_insn
= PREV_INSN (insn
);
5462 for (insn2
= insn
; insn2
!= prev_insn
; insn2
= PREV_INSN (insn2
))
5463 avoid_complex_debug_insns (insn2
, &INSN_VAR_LOCATION_LOC (insn2
), 0);
5466 flag_strict_aliasing
= save_strict_alias
;
5469 /* Performs swapping operands of commutative operations to expand
5470 the expensive one first. */
5473 reorder_operands (basic_block bb
)
5475 unsigned int *lattice
; /* Hold cost of each statement. */
5476 unsigned int i
= 0, n
= 0;
5477 gimple_stmt_iterator gsi
;
5483 use_operand_p use_p
;
5484 gimple
*def0
, *def1
;
5486 /* Compute cost of each statement using estimate_num_insns. */
5487 stmts
= bb_seq (bb
);
5488 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5490 stmt
= gsi_stmt (gsi
);
5491 if (!is_gimple_debug (stmt
))
5492 gimple_set_uid (stmt
, n
++);
5494 lattice
= XNEWVEC (unsigned int, n
);
5495 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5498 stmt
= gsi_stmt (gsi
);
5499 if (is_gimple_debug (stmt
))
5501 cost
= estimate_num_insns (stmt
, &eni_size_weights
);
5503 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
5505 tree use
= USE_FROM_PTR (use_p
);
5507 if (TREE_CODE (use
) != SSA_NAME
)
5509 def_stmt
= get_gimple_for_ssa_name (use
);
5512 lattice
[i
] += lattice
[gimple_uid (def_stmt
)];
5515 if (!is_gimple_assign (stmt
)
5516 || !commutative_tree_code (gimple_assign_rhs_code (stmt
)))
5518 op0
= gimple_op (stmt
, 1);
5519 op1
= gimple_op (stmt
, 2);
5520 if (TREE_CODE (op0
) != SSA_NAME
5521 || TREE_CODE (op1
) != SSA_NAME
)
5523 /* Swap operands if the second one is more expensive. */
5524 def0
= get_gimple_for_ssa_name (op0
);
5525 def1
= get_gimple_for_ssa_name (op1
);
5529 if (!def0
|| lattice
[gimple_uid (def1
)] > lattice
[gimple_uid (def0
)])
5533 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5535 fprintf (dump_file
, "Swap operands in stmt:\n");
5536 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
5537 fprintf (dump_file
, "Cost left opnd=%d, right opnd=%d\n",
5538 def0
? lattice
[gimple_uid (def0
)] : 0,
5539 lattice
[gimple_uid (def1
)]);
5541 swap_ssa_operands (stmt
, gimple_assign_rhs1_ptr (stmt
),
5542 gimple_assign_rhs2_ptr (stmt
));
5548 /* Expand basic block BB from GIMPLE trees to RTL. */
5551 expand_gimple_basic_block (basic_block bb
, bool disable_tail_calls
)
5553 gimple_stmt_iterator gsi
;
5555 gimple
*stmt
= NULL
;
5556 rtx_note
*note
= NULL
;
5562 fprintf (dump_file
, "\n;; Generating RTL for gimple basic block %d\n",
5565 /* Note that since we are now transitioning from GIMPLE to RTL, we
5566 cannot use the gsi_*_bb() routines because they expect the basic
5567 block to be in GIMPLE, instead of RTL. Therefore, we need to
5568 access the BB sequence directly. */
5570 reorder_operands (bb
);
5571 stmts
= bb_seq (bb
);
5572 bb
->il
.gimple
.seq
= NULL
;
5573 bb
->il
.gimple
.phi_nodes
= NULL
;
5574 rtl_profile_for_bb (bb
);
5575 init_rtl_bb_info (bb
);
5576 bb
->flags
|= BB_RTL
;
5578 /* Remove the RETURN_EXPR if we may fall though to the exit
5580 gsi
= gsi_last (stmts
);
5581 if (!gsi_end_p (gsi
)
5582 && gimple_code (gsi_stmt (gsi
)) == GIMPLE_RETURN
)
5584 greturn
*ret_stmt
= as_a
<greturn
*> (gsi_stmt (gsi
));
5586 gcc_assert (single_succ_p (bb
));
5587 gcc_assert (single_succ (bb
) == EXIT_BLOCK_PTR_FOR_FN (cfun
));
5589 if (bb
->next_bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
)
5590 && !gimple_return_retval (ret_stmt
))
5592 gsi_remove (&gsi
, false);
5593 single_succ_edge (bb
)->flags
|= EDGE_FALLTHRU
;
5597 gsi
= gsi_start (stmts
);
5598 if (!gsi_end_p (gsi
))
5600 stmt
= gsi_stmt (gsi
);
5601 if (gimple_code (stmt
) != GIMPLE_LABEL
)
5605 rtx_code_label
**elt
= lab_rtx_for_bb
->get (bb
);
5609 gcc_checking_assert (!note
);
5610 last
= get_last_insn ();
5614 expand_gimple_stmt (stmt
);
5621 BB_HEAD (bb
) = NEXT_INSN (last
);
5622 if (NOTE_P (BB_HEAD (bb
)))
5623 BB_HEAD (bb
) = NEXT_INSN (BB_HEAD (bb
));
5624 gcc_assert (LABEL_P (BB_HEAD (bb
)));
5625 note
= emit_note_after (NOTE_INSN_BASIC_BLOCK
, BB_HEAD (bb
));
5627 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5630 BB_HEAD (bb
) = note
= emit_note (NOTE_INSN_BASIC_BLOCK
);
5633 NOTE_BASIC_BLOCK (note
) = bb
;
5635 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
5639 stmt
= gsi_stmt (gsi
);
5641 /* If this statement is a non-debug one, and we generate debug
5642 insns, then this one might be the last real use of a TERed
5643 SSA_NAME, but where there are still some debug uses further
5644 down. Expanding the current SSA name in such further debug
5645 uses by their RHS might lead to wrong debug info, as coalescing
5646 might make the operands of such RHS be placed into the same
5647 pseudo as something else. Like so:
5648 a_1 = a_0 + 1; // Assume a_1 is TERed and a_0 is dead
5652 As a_0 and a_2 don't overlap in lifetime, assume they are coalesced.
5653 If we now would expand a_1 by it's RHS (a_0 + 1) in the debug use,
5654 the write to a_2 would actually have clobbered the place which
5657 So, instead of that, we recognize the situation, and generate
5658 debug temporaries at the last real use of TERed SSA names:
5665 if (MAY_HAVE_DEBUG_BIND_INSNS
5667 && !is_gimple_debug (stmt
))
5673 location_t sloc
= curr_insn_location ();
5675 /* Look for SSA names that have their last use here (TERed
5676 names always have only one real use). */
5677 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
)
5678 if ((def
= get_gimple_for_ssa_name (op
)))
5680 imm_use_iterator imm_iter
;
5681 use_operand_p use_p
;
5682 bool have_debug_uses
= false;
5684 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, op
)
5686 if (gimple_debug_bind_p (USE_STMT (use_p
)))
5688 have_debug_uses
= true;
5693 if (have_debug_uses
)
5695 /* OP is a TERed SSA name, with DEF its defining
5696 statement, and where OP is used in further debug
5697 instructions. Generate a debug temporary, and
5698 replace all uses of OP in debug insns with that
5701 tree value
= gimple_assign_rhs_to_tree (def
);
5702 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
5706 set_curr_insn_location (gimple_location (def
));
5708 DECL_ARTIFICIAL (vexpr
) = 1;
5709 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
5711 mode
= DECL_MODE (value
);
5713 mode
= TYPE_MODE (TREE_TYPE (value
));
5714 SET_DECL_MODE (vexpr
, mode
);
5716 val
= gen_rtx_VAR_LOCATION
5717 (mode
, vexpr
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5719 emit_debug_insn (val
);
5721 FOR_EACH_IMM_USE_STMT (debugstmt
, imm_iter
, op
)
5723 if (!gimple_debug_bind_p (debugstmt
))
5726 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
5727 SET_USE (use_p
, vexpr
);
5729 update_stmt (debugstmt
);
5733 set_curr_insn_location (sloc
);
5736 currently_expanding_gimple_stmt
= stmt
;
5738 /* Expand this statement, then evaluate the resulting RTL and
5739 fixup the CFG accordingly. */
5740 if (gimple_code (stmt
) == GIMPLE_COND
)
5742 new_bb
= expand_gimple_cond (bb
, as_a
<gcond
*> (stmt
));
5746 else if (is_gimple_debug (stmt
))
5748 location_t sloc
= curr_insn_location ();
5749 gimple_stmt_iterator nsi
= gsi
;
5754 tree value
= NULL_TREE
;
5758 if (!gimple_debug_nonbind_marker_p (stmt
))
5760 if (gimple_debug_bind_p (stmt
))
5762 var
= gimple_debug_bind_get_var (stmt
);
5764 if (TREE_CODE (var
) != DEBUG_EXPR_DECL
5765 && TREE_CODE (var
) != LABEL_DECL
5766 && !target_for_debug_bind (var
))
5767 goto delink_debug_stmt
;
5770 mode
= DECL_MODE (var
);
5772 mode
= TYPE_MODE (TREE_TYPE (var
));
5774 if (gimple_debug_bind_has_value_p (stmt
))
5775 value
= gimple_debug_bind_get_value (stmt
);
5777 val
= gen_rtx_VAR_LOCATION
5778 (mode
, var
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5780 else if (gimple_debug_source_bind_p (stmt
))
5782 var
= gimple_debug_source_bind_get_var (stmt
);
5784 value
= gimple_debug_source_bind_get_value (stmt
);
5786 mode
= DECL_MODE (var
);
5788 val
= gen_rtx_VAR_LOCATION (mode
, var
, (rtx
)value
,
5789 VAR_INIT_STATUS_UNINITIALIZED
);
5794 /* If this function was first compiled with markers
5795 enabled, but they're now disable (e.g. LTO), drop
5796 them on the floor. */
5797 else if (gimple_debug_nonbind_marker_p (stmt
)
5798 && !MAY_HAVE_DEBUG_MARKER_INSNS
)
5799 goto delink_debug_stmt
;
5800 else if (gimple_debug_begin_stmt_p (stmt
))
5801 val
= GEN_RTX_DEBUG_MARKER_BEGIN_STMT_PAT ();
5802 else if (gimple_debug_inline_entry_p (stmt
))
5804 tree block
= gimple_block (stmt
);
5807 val
= GEN_RTX_DEBUG_MARKER_INLINE_ENTRY_PAT ();
5809 goto delink_debug_stmt
;
5814 last
= get_last_insn ();
5816 set_curr_insn_location (gimple_location (stmt
));
5818 emit_debug_insn (val
);
5820 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5822 /* We can't dump the insn with a TREE where an RTX
5824 if (GET_CODE (val
) == VAR_LOCATION
)
5826 gcc_checking_assert (PAT_VAR_LOCATION_LOC (val
) == (rtx
)value
);
5827 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
5829 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5830 if (GET_CODE (val
) == VAR_LOCATION
)
5831 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
5835 /* In order not to generate too many debug temporaries,
5836 we delink all uses of debug statements we already expanded.
5837 Therefore debug statements between definition and real
5838 use of TERed SSA names will continue to use the SSA name,
5839 and not be replaced with debug temps. */
5840 delink_stmt_imm_use (stmt
);
5844 if (gsi_end_p (nsi
))
5846 stmt
= gsi_stmt (nsi
);
5847 if (!is_gimple_debug (stmt
))
5851 set_curr_insn_location (sloc
);
5855 gcall
*call_stmt
= dyn_cast
<gcall
*> (stmt
);
5857 && gimple_call_tail_p (call_stmt
)
5858 && disable_tail_calls
)
5859 gimple_call_set_tail (call_stmt
, false);
5861 if (call_stmt
&& gimple_call_tail_p (call_stmt
))
5864 new_bb
= expand_gimple_tailcall (bb
, call_stmt
, &can_fallthru
);
5875 def_operand_p def_p
;
5876 def_p
= SINGLE_SSA_DEF_OPERAND (stmt
, SSA_OP_DEF
);
5880 /* Ignore this stmt if it is in the list of
5881 replaceable expressions. */
5883 && bitmap_bit_p (SA
.values
,
5884 SSA_NAME_VERSION (DEF_FROM_PTR (def_p
))))
5887 last
= expand_gimple_stmt (stmt
);
5888 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5893 currently_expanding_gimple_stmt
= NULL
;
5895 /* Expand implicit goto and convert goto_locus. */
5896 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5898 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
5899 set_curr_insn_location (e
->goto_locus
);
5900 if ((e
->flags
& EDGE_FALLTHRU
) && e
->dest
!= bb
->next_bb
)
5902 emit_jump (label_rtx_for_bb (e
->dest
));
5903 e
->flags
&= ~EDGE_FALLTHRU
;
5907 /* Expanded RTL can create a jump in the last instruction of block.
5908 This later might be assumed to be a jump to successor and break edge insertion.
5909 We need to insert dummy move to prevent this. PR41440. */
5910 if (single_succ_p (bb
)
5911 && (single_succ_edge (bb
)->flags
& EDGE_FALLTHRU
)
5912 && (last
= get_last_insn ())
5914 || (DEBUG_INSN_P (last
)
5915 && JUMP_P (prev_nondebug_insn (last
)))))
5917 rtx dummy
= gen_reg_rtx (SImode
);
5918 emit_insn_after_noloc (gen_move_insn (dummy
, dummy
), last
, NULL
);
5921 do_pending_stack_adjust ();
5923 /* Find the block tail. The last insn in the block is the insn
5924 before a barrier and/or table jump insn. */
5925 last
= get_last_insn ();
5926 if (BARRIER_P (last
))
5927 last
= PREV_INSN (last
);
5928 if (JUMP_TABLE_DATA_P (last
))
5929 last
= PREV_INSN (PREV_INSN (last
));
5930 if (BARRIER_P (last
))
5931 last
= PREV_INSN (last
);
5934 update_bb_for_insn (bb
);
5940 /* Create a basic block for initialization code. */
5943 construct_init_block (void)
5945 basic_block init_block
, first_block
;
5949 /* Multiple entry points not supported yet. */
5950 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
) == 1);
5951 init_rtl_bb_info (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5952 init_rtl_bb_info (EXIT_BLOCK_PTR_FOR_FN (cfun
));
5953 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
5954 EXIT_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
5956 e
= EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun
), 0);
5958 /* When entry edge points to first basic block, we don't need jump,
5959 otherwise we have to jump into proper target. */
5960 if (e
&& e
->dest
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
)
5962 tree label
= gimple_block_label (e
->dest
);
5964 emit_jump (jump_target_rtx (label
));
5968 flags
= EDGE_FALLTHRU
;
5970 init_block
= create_basic_block (NEXT_INSN (get_insns ()),
5972 ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5973 init_block
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
5974 add_bb_to_loop (init_block
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
5977 first_block
= e
->dest
;
5978 redirect_edge_succ (e
, init_block
);
5979 make_single_succ_edge (init_block
, first_block
, flags
);
5982 make_single_succ_edge (init_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
),
5985 update_bb_for_insn (init_block
);
5989 /* For each lexical block, set BLOCK_NUMBER to the depth at which it is
5990 found in the block tree. */
5993 set_block_levels (tree block
, int level
)
5997 BLOCK_NUMBER (block
) = level
;
5998 set_block_levels (BLOCK_SUBBLOCKS (block
), level
+ 1);
5999 block
= BLOCK_CHAIN (block
);
6003 /* Create a block containing landing pads and similar stuff. */
6006 construct_exit_block (void)
6008 rtx_insn
*head
= get_last_insn ();
6010 basic_block exit_block
;
6014 basic_block prev_bb
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
;
6015 rtx_insn
*orig_end
= BB_END (prev_bb
);
6017 rtl_profile_for_bb (EXIT_BLOCK_PTR_FOR_FN (cfun
));
6019 /* Make sure the locus is set to the end of the function, so that
6020 epilogue line numbers and warnings are set properly. */
6021 if (LOCATION_LOCUS (cfun
->function_end_locus
) != UNKNOWN_LOCATION
)
6022 input_location
= cfun
->function_end_locus
;
6024 /* Generate rtl for function exit. */
6025 expand_function_end ();
6027 end
= get_last_insn ();
6030 /* While emitting the function end we could move end of the last basic
6032 BB_END (prev_bb
) = orig_end
;
6033 while (NEXT_INSN (head
) && NOTE_P (NEXT_INSN (head
)))
6034 head
= NEXT_INSN (head
);
6035 /* But make sure exit_block starts with RETURN_LABEL, otherwise the
6036 bb count counting will be confused. Any instructions before that
6037 label are emitted for the case where PREV_BB falls through into the
6038 exit block, so append those instructions to prev_bb in that case. */
6039 if (NEXT_INSN (head
) != return_label
)
6041 while (NEXT_INSN (head
) != return_label
)
6043 if (!NOTE_P (NEXT_INSN (head
)))
6044 BB_END (prev_bb
) = NEXT_INSN (head
);
6045 head
= NEXT_INSN (head
);
6048 exit_block
= create_basic_block (NEXT_INSN (head
), end
, prev_bb
);
6049 exit_block
->count
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
;
6050 add_bb_to_loop (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
6053 while (ix
< EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
))
6055 e
= EDGE_PRED (EXIT_BLOCK_PTR_FOR_FN (cfun
), ix
);
6056 if (!(e
->flags
& EDGE_ABNORMAL
))
6057 redirect_edge_succ (e
, exit_block
);
6062 e
= make_single_succ_edge (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
),
6064 FOR_EACH_EDGE (e2
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
6067 exit_block
->count
-= e2
->count ();
6069 update_bb_for_insn (exit_block
);
6072 /* Helper function for discover_nonconstant_array_refs.
6073 Look for ARRAY_REF nodes with non-constant indexes and mark them
6077 discover_nonconstant_array_refs_r (tree
* tp
, int *walk_subtrees
,
6078 void *data ATTRIBUTE_UNUSED
)
6082 if (IS_TYPE_OR_DECL_P (t
))
6084 else if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
6086 while (((TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
6087 && is_gimple_min_invariant (TREE_OPERAND (t
, 1))
6088 && (!TREE_OPERAND (t
, 2)
6089 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
6090 || (TREE_CODE (t
) == COMPONENT_REF
6091 && (!TREE_OPERAND (t
,2)
6092 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
6093 || TREE_CODE (t
) == BIT_FIELD_REF
6094 || TREE_CODE (t
) == REALPART_EXPR
6095 || TREE_CODE (t
) == IMAGPART_EXPR
6096 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
6097 || CONVERT_EXPR_P (t
))
6098 t
= TREE_OPERAND (t
, 0);
6100 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
6102 t
= get_base_address (t
);
6104 && DECL_MODE (t
) != BLKmode
)
6105 TREE_ADDRESSABLE (t
) = 1;
6110 /* References of size POLY_INT_CST to a fixed-size object must go
6111 through memory. It's more efficient to force that here than
6112 to create temporary slots on the fly. */
6113 else if ((TREE_CODE (t
) == MEM_REF
|| TREE_CODE (t
) == TARGET_MEM_REF
)
6114 && TYPE_SIZE (TREE_TYPE (t
))
6115 && POLY_INT_CST_P (TYPE_SIZE (TREE_TYPE (t
))))
6117 tree base
= get_base_address (t
);
6120 && DECL_MODE (base
) != BLKmode
6121 && GET_MODE_SIZE (DECL_MODE (base
)).is_constant ())
6122 TREE_ADDRESSABLE (base
) = 1;
6129 /* RTL expansion is not able to compile array references with variable
6130 offsets for arrays stored in single register. Discover such
6131 expressions and mark variables as addressable to avoid this
6135 discover_nonconstant_array_refs (void)
6138 gimple_stmt_iterator gsi
;
6140 FOR_EACH_BB_FN (bb
, cfun
)
6141 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
6143 gimple
*stmt
= gsi_stmt (gsi
);
6144 if (!is_gimple_debug (stmt
))
6146 walk_gimple_op (stmt
, discover_nonconstant_array_refs_r
, NULL
);
6147 gcall
*call
= dyn_cast
<gcall
*> (stmt
);
6148 if (call
&& gimple_call_internal_p (call
))
6149 switch (gimple_call_internal_fn (call
))
6151 case IFN_LOAD_LANES
:
6152 /* The source must be a MEM. */
6153 mark_addressable (gimple_call_arg (call
, 0));
6155 case IFN_STORE_LANES
:
6156 /* The destination must be a MEM. */
6157 mark_addressable (gimple_call_lhs (call
));
6166 /* This function sets crtl->args.internal_arg_pointer to a virtual
6167 register if DRAP is needed. Local register allocator will replace
6168 virtual_incoming_args_rtx with the virtual register. */
6171 expand_stack_alignment (void)
6174 unsigned int preferred_stack_boundary
;
6176 if (! SUPPORTS_STACK_ALIGNMENT
)
6179 if (cfun
->calls_alloca
6180 || cfun
->has_nonlocal_label
6181 || crtl
->has_nonlocal_goto
)
6182 crtl
->need_drap
= true;
6184 /* Call update_stack_boundary here again to update incoming stack
6185 boundary. It may set incoming stack alignment to a different
6186 value after RTL expansion. TARGET_FUNCTION_OK_FOR_SIBCALL may
6187 use the minimum incoming stack alignment to check if it is OK
6188 to perform sibcall optimization since sibcall optimization will
6189 only align the outgoing stack to incoming stack boundary. */
6190 if (targetm
.calls
.update_stack_boundary
)
6191 targetm
.calls
.update_stack_boundary ();
6193 /* The incoming stack frame has to be aligned at least at
6194 parm_stack_boundary. */
6195 gcc_assert (crtl
->parm_stack_boundary
<= INCOMING_STACK_BOUNDARY
);
6197 /* Update crtl->stack_alignment_estimated and use it later to align
6198 stack. We check PREFERRED_STACK_BOUNDARY if there may be non-call
6199 exceptions since callgraph doesn't collect incoming stack alignment
6201 if (cfun
->can_throw_non_call_exceptions
6202 && PREFERRED_STACK_BOUNDARY
> crtl
->preferred_stack_boundary
)
6203 preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
6205 preferred_stack_boundary
= crtl
->preferred_stack_boundary
;
6206 if (preferred_stack_boundary
> crtl
->stack_alignment_estimated
)
6207 crtl
->stack_alignment_estimated
= preferred_stack_boundary
;
6208 if (preferred_stack_boundary
> crtl
->stack_alignment_needed
)
6209 crtl
->stack_alignment_needed
= preferred_stack_boundary
;
6211 gcc_assert (crtl
->stack_alignment_needed
6212 <= crtl
->stack_alignment_estimated
);
6214 crtl
->stack_realign_needed
6215 = INCOMING_STACK_BOUNDARY
< crtl
->stack_alignment_estimated
;
6216 crtl
->stack_realign_tried
= crtl
->stack_realign_needed
;
6218 crtl
->stack_realign_processed
= true;
6220 /* Target has to redefine TARGET_GET_DRAP_RTX to support stack
6222 gcc_assert (targetm
.calls
.get_drap_rtx
!= NULL
);
6223 drap_rtx
= targetm
.calls
.get_drap_rtx ();
6225 /* stack_realign_drap and drap_rtx must match. */
6226 gcc_assert ((stack_realign_drap
!= 0) == (drap_rtx
!= NULL
));
6228 /* Do nothing if NULL is returned, which means DRAP is not needed. */
6229 if (drap_rtx
!= NULL
)
6231 crtl
->args
.internal_arg_pointer
= drap_rtx
;
6233 /* Call fixup_tail_calls to clean up REG_EQUIV note if DRAP is
6235 fixup_tail_calls ();
6241 expand_main_function (void)
6243 #if (defined(INVOKE__main) \
6244 || (!defined(HAS_INIT_SECTION) \
6245 && !defined(INIT_SECTION_ASM_OP) \
6246 && !defined(INIT_ARRAY_SECTION_ASM_OP)))
6247 emit_library_call (init_one_libfunc (NAME__MAIN
), LCT_NORMAL
, VOIDmode
);
6252 /* Expand code to initialize the stack_protect_guard. This is invoked at
6253 the beginning of a function to be protected. */
6256 stack_protect_prologue (void)
6258 tree guard_decl
= targetm
.stack_protect_guard ();
6261 crtl
->stack_protect_guard_decl
= guard_decl
;
6262 x
= expand_normal (crtl
->stack_protect_guard
);
6264 if (targetm
.have_stack_protect_combined_set () && guard_decl
)
6266 gcc_assert (DECL_P (guard_decl
));
6267 y
= DECL_RTL (guard_decl
);
6269 /* Allow the target to compute address of Y and copy it to X without
6270 leaking Y into a register. This combined address + copy pattern
6271 allows the target to prevent spilling of any intermediate results by
6272 splitting it after register allocator. */
6273 if (rtx_insn
*insn
= targetm
.gen_stack_protect_combined_set (x
, y
))
6281 y
= expand_normal (guard_decl
);
6285 /* Allow the target to copy from Y to X without leaking Y into a
6287 if (targetm
.have_stack_protect_set ())
6288 if (rtx_insn
*insn
= targetm
.gen_stack_protect_set (x
, y
))
6294 /* Otherwise do a straight move. */
6295 emit_move_insn (x
, y
);
6298 /* Translate the intermediate representation contained in the CFG
6299 from GIMPLE trees to RTL.
6301 We do conversion per basic block and preserve/update the tree CFG.
6302 This implies we have to do some magic as the CFG can simultaneously
6303 consist of basic blocks containing RTL and GIMPLE trees. This can
6304 confuse the CFG hooks, so be careful to not manipulate CFG during
6309 const pass_data pass_data_expand
=
6311 RTL_PASS
, /* type */
6312 "expand", /* name */
6313 OPTGROUP_NONE
, /* optinfo_flags */
6314 TV_EXPAND
, /* tv_id */
6315 ( PROP_ssa
| PROP_gimple_leh
| PROP_cfg
6318 | PROP_gimple_lva
), /* properties_required */
6319 PROP_rtl
, /* properties_provided */
6320 ( PROP_ssa
| PROP_trees
), /* properties_destroyed */
6321 0, /* todo_flags_start */
6322 0, /* todo_flags_finish */
6325 class pass_expand
: public rtl_opt_pass
6328 pass_expand (gcc::context
*ctxt
)
6329 : rtl_opt_pass (pass_data_expand
, ctxt
)
6332 /* opt_pass methods: */
6333 virtual unsigned int execute (function
*);
6335 }; // class pass_expand
6338 pass_expand::execute (function
*fun
)
6340 basic_block bb
, init_block
;
6343 rtx_insn
*var_seq
, *var_ret_seq
;
6346 timevar_push (TV_OUT_OF_SSA
);
6347 rewrite_out_of_ssa (&SA
);
6348 timevar_pop (TV_OUT_OF_SSA
);
6349 SA
.partition_to_pseudo
= XCNEWVEC (rtx
, SA
.map
->num_partitions
);
6351 if (MAY_HAVE_DEBUG_BIND_STMTS
&& flag_tree_ter
)
6353 gimple_stmt_iterator gsi
;
6354 FOR_EACH_BB_FN (bb
, cfun
)
6355 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
6356 if (gimple_debug_bind_p (gsi_stmt (gsi
)))
6357 avoid_deep_ter_for_debug (gsi_stmt (gsi
), 0);
6360 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
6361 discover_nonconstant_array_refs ();
6363 /* Make sure all values used by the optimization passes have sane
6367 /* Some backends want to know that we are expanding to RTL. */
6368 currently_expanding_to_rtl
= 1;
6369 /* Dominators are not kept up-to-date as we may create new basic-blocks. */
6370 free_dominance_info (CDI_DOMINATORS
);
6372 rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (fun
));
6374 insn_locations_init ();
6375 if (!DECL_IS_BUILTIN (current_function_decl
))
6377 /* Eventually, all FEs should explicitly set function_start_locus. */
6378 if (LOCATION_LOCUS (fun
->function_start_locus
) == UNKNOWN_LOCATION
)
6379 set_curr_insn_location
6380 (DECL_SOURCE_LOCATION (current_function_decl
));
6382 set_curr_insn_location (fun
->function_start_locus
);
6385 set_curr_insn_location (UNKNOWN_LOCATION
);
6386 prologue_location
= curr_insn_location ();
6388 #ifdef INSN_SCHEDULING
6389 init_sched_attrs ();
6392 /* Make sure first insn is a note even if we don't want linenums.
6393 This makes sure the first insn will never be deleted.
6394 Also, final expects a note to appear there. */
6395 emit_note (NOTE_INSN_DELETED
);
6397 targetm
.expand_to_rtl_hook ();
6398 crtl
->init_stack_alignment ();
6399 fun
->cfg
->max_jumptable_ents
= 0;
6401 /* Resovle the function section. Some targets, like ARM EABI rely on knowledge
6402 of the function section at exapnsion time to predict distance of calls. */
6403 resolve_unique_section (current_function_decl
, 0, flag_function_sections
);
6405 /* Expand the variables recorded during gimple lowering. */
6406 timevar_push (TV_VAR_EXPAND
);
6409 var_ret_seq
= expand_used_vars ();
6411 var_seq
= get_insns ();
6413 timevar_pop (TV_VAR_EXPAND
);
6415 /* Honor stack protection warnings. */
6416 if (warn_stack_protect
)
6418 if (fun
->calls_alloca
)
6419 warning (OPT_Wstack_protector
,
6420 "stack protector not protecting local variables: "
6421 "variable length buffer");
6422 if (has_short_buffer
&& !crtl
->stack_protect_guard
)
6423 warning (OPT_Wstack_protector
,
6424 "stack protector not protecting function: "
6425 "all local arrays are less than %d bytes long",
6426 (int) param_ssp_buffer_size
);
6429 /* Set up parameters and prepare for return, for the function. */
6430 expand_function_start (current_function_decl
);
6432 /* If we emitted any instructions for setting up the variables,
6433 emit them before the FUNCTION_START note. */
6436 emit_insn_before (var_seq
, parm_birth_insn
);
6438 /* In expand_function_end we'll insert the alloca save/restore
6439 before parm_birth_insn. We've just insertted an alloca call.
6440 Adjust the pointer to match. */
6441 parm_birth_insn
= var_seq
;
6444 /* Now propagate the RTL assignment of each partition to the
6445 underlying var of each SSA_NAME. */
6448 FOR_EACH_SSA_NAME (i
, name
, cfun
)
6450 /* We might have generated new SSA names in
6451 update_alias_info_with_stack_vars. They will have a NULL
6452 defining statements, and won't be part of the partitioning,
6454 if (!SSA_NAME_DEF_STMT (name
))
6457 adjust_one_expanded_partition_var (name
);
6460 /* Clean up RTL of variables that straddle across multiple
6461 partitions, and check that the rtl of any PARM_DECLs that are not
6462 cleaned up is that of their default defs. */
6463 FOR_EACH_SSA_NAME (i
, name
, cfun
)
6467 /* We might have generated new SSA names in
6468 update_alias_info_with_stack_vars. They will have a NULL
6469 defining statements, and won't be part of the partitioning,
6471 if (!SSA_NAME_DEF_STMT (name
))
6473 part
= var_to_partition (SA
.map
, name
);
6474 if (part
== NO_PARTITION
)
6477 /* If this decl was marked as living in multiple places, reset
6478 this now to NULL. */
6479 tree var
= SSA_NAME_VAR (name
);
6480 if (var
&& DECL_RTL_IF_SET (var
) == pc_rtx
)
6481 SET_DECL_RTL (var
, NULL
);
6482 /* Check that the pseudos chosen by assign_parms are those of
6483 the corresponding default defs. */
6484 else if (SSA_NAME_IS_DEFAULT_DEF (name
)
6485 && (TREE_CODE (var
) == PARM_DECL
6486 || TREE_CODE (var
) == RESULT_DECL
))
6488 rtx in
= DECL_RTL_IF_SET (var
);
6490 rtx out
= SA
.partition_to_pseudo
[part
];
6491 gcc_assert (in
== out
);
6493 /* Now reset VAR's RTL to IN, so that the _EXPR attrs match
6494 those expected by debug backends for each parm and for
6495 the result. This is particularly important for stabs,
6496 whose register elimination from parm's DECL_RTL may cause
6497 -fcompare-debug differences as SET_DECL_RTL changes reg's
6498 attrs. So, make sure the RTL already has the parm as the
6499 EXPR, so that it won't change. */
6500 SET_DECL_RTL (var
, NULL_RTX
);
6502 set_mem_attributes (in
, var
, true);
6503 SET_DECL_RTL (var
, in
);
6507 /* If this function is `main', emit a call to `__main'
6508 to run global initializers, etc. */
6509 if (DECL_NAME (current_function_decl
)
6510 && MAIN_NAME_P (DECL_NAME (current_function_decl
))
6511 && DECL_FILE_SCOPE_P (current_function_decl
))
6512 expand_main_function ();
6514 /* Initialize the stack_protect_guard field. This must happen after the
6515 call to __main (if any) so that the external decl is initialized. */
6516 if (crtl
->stack_protect_guard
&& targetm
.stack_protect_runtime_enabled_p ())
6517 stack_protect_prologue ();
6519 expand_phi_nodes (&SA
);
6521 /* Release any stale SSA redirection data. */
6522 redirect_edge_var_map_empty ();
6524 /* Register rtl specific functions for cfg. */
6525 rtl_register_cfg_hooks ();
6527 init_block
= construct_init_block ();
6529 /* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
6530 remaining edges later. */
6531 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->succs
)
6532 e
->flags
&= ~EDGE_EXECUTABLE
;
6534 /* If the function has too many markers, drop them while expanding. */
6535 if (cfun
->debug_marker_count
6536 >= param_max_debug_marker_count
)
6537 cfun
->debug_nonbind_markers
= false;
6539 lab_rtx_for_bb
= new hash_map
<basic_block
, rtx_code_label
*>;
6540 FOR_BB_BETWEEN (bb
, init_block
->next_bb
, EXIT_BLOCK_PTR_FOR_FN (fun
),
6542 bb
= expand_gimple_basic_block (bb
, var_ret_seq
!= NULL_RTX
);
6544 if (MAY_HAVE_DEBUG_BIND_INSNS
)
6545 expand_debug_locations ();
6547 if (deep_ter_debug_map
)
6549 delete deep_ter_debug_map
;
6550 deep_ter_debug_map
= NULL
;
6553 /* Free stuff we no longer need after GIMPLE optimizations. */
6554 free_dominance_info (CDI_DOMINATORS
);
6555 free_dominance_info (CDI_POST_DOMINATORS
);
6556 delete_tree_cfg_annotations (fun
);
6558 timevar_push (TV_OUT_OF_SSA
);
6559 finish_out_of_ssa (&SA
);
6560 timevar_pop (TV_OUT_OF_SSA
);
6562 timevar_push (TV_POST_EXPAND
);
6563 /* We are no longer in SSA form. */
6564 fun
->gimple_df
->in_ssa_p
= false;
6565 loops_state_clear (LOOP_CLOSED_SSA
);
6567 /* Expansion is used by optimization passes too, set maybe_hot_insn_p
6568 conservatively to true until they are all profile aware. */
6569 delete lab_rtx_for_bb
;
6570 free_histograms (fun
);
6572 construct_exit_block ();
6573 insn_locations_finalize ();
6577 rtx_insn
*after
= return_label
;
6578 rtx_insn
*next
= NEXT_INSN (after
);
6579 if (next
&& NOTE_INSN_BASIC_BLOCK_P (next
))
6581 emit_insn_after (var_ret_seq
, after
);
6584 /* Zap the tree EH table. */
6585 set_eh_throw_stmt_table (fun
, NULL
);
6587 /* We need JUMP_LABEL be set in order to redirect jumps, and hence
6588 split edges which edge insertions might do. */
6589 rebuild_jump_labels (get_insns ());
6591 /* If we have a single successor to the entry block, put the pending insns
6592 after parm birth, but before NOTE_INSNS_FUNCTION_BEG. */
6593 if (single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (fun
)))
6595 edge e
= single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (fun
));
6598 rtx_insn
*insns
= e
->insns
.r
;
6600 rebuild_jump_labels_chain (insns
);
6601 if (NOTE_P (parm_birth_insn
)
6602 && NOTE_KIND (parm_birth_insn
) == NOTE_INSN_FUNCTION_BEG
)
6603 emit_insn_before_noloc (insns
, parm_birth_insn
, e
->dest
);
6605 emit_insn_after_noloc (insns
, parm_birth_insn
, e
->dest
);
6609 /* Otherwise, as well as for other edges, take the usual way. */
6610 commit_edge_insertions ();
6612 /* We're done expanding trees to RTL. */
6613 currently_expanding_to_rtl
= 0;
6615 flush_mark_addressable_queue ();
6617 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->next_bb
,
6618 EXIT_BLOCK_PTR_FOR_FN (fun
), next_bb
)
6622 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
6624 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
6625 e
->flags
&= ~EDGE_EXECUTABLE
;
6627 /* At the moment not all abnormal edges match the RTL
6628 representation. It is safe to remove them here as
6629 find_many_sub_basic_blocks will rediscover them.
6630 In the future we should get this fixed properly. */
6631 if ((e
->flags
& EDGE_ABNORMAL
)
6632 && !(e
->flags
& EDGE_SIBCALL
))
6639 auto_sbitmap
blocks (last_basic_block_for_fn (fun
));
6640 bitmap_ones (blocks
);
6641 find_many_sub_basic_blocks (blocks
);
6642 purge_all_dead_edges ();
6644 /* After initial rtl generation, call back to finish generating
6645 exception support code. We need to do this before cleaning up
6646 the CFG as the code does not expect dead landing pads. */
6647 if (fun
->eh
->region_tree
!= NULL
)
6648 finish_eh_generation ();
6650 /* Call expand_stack_alignment after finishing all
6651 updates to crtl->preferred_stack_boundary. */
6652 expand_stack_alignment ();
6654 /* Fixup REG_EQUIV notes in the prologue if there are tailcalls in this
6656 if (crtl
->tail_call_emit
)
6657 fixup_tail_calls ();
6659 /* BB subdivision may have created basic blocks that are only reachable
6660 from unlikely bbs but not marked as such in the profile. */
6662 propagate_unlikely_bbs_forward ();
6664 /* Remove unreachable blocks, otherwise we cannot compute dominators
6665 which are needed for loop state verification. As a side-effect
6666 this also compacts blocks.
6667 ??? We cannot remove trivially dead insns here as for example
6668 the DRAP reg on i?86 is not magically live at this point.
6669 gcc.c-torture/execute/ipa-sra-2.c execution, -Os -m32 fails otherwise. */
6670 cleanup_cfg (CLEANUP_NO_INSN_DEL
);
6672 checking_verify_flow_info ();
6674 /* Initialize pseudos allocated for hard registers. */
6675 emit_initial_value_sets ();
6677 /* And finally unshare all RTL. */
6680 /* There's no need to defer outputting this function any more; we
6681 know we want to output it. */
6682 DECL_DEFER_OUTPUT (current_function_decl
) = 0;
6684 /* Now that we're done expanding trees to RTL, we shouldn't have any
6685 more CONCATs anywhere. */
6686 generating_concat_p
= 0;
6691 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
6692 /* And the pass manager will dump RTL for us. */
6695 /* If we're emitting a nested function, make sure its parent gets
6696 emitted as well. Doing otherwise confuses debug info. */
6699 for (parent
= DECL_CONTEXT (current_function_decl
);
6700 parent
!= NULL_TREE
;
6701 parent
= get_containing_scope (parent
))
6702 if (TREE_CODE (parent
) == FUNCTION_DECL
)
6703 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent
)) = 1;
6706 TREE_ASM_WRITTEN (current_function_decl
) = 1;
6708 /* After expanding, the return labels are no longer needed. */
6709 return_label
= NULL
;
6710 naked_return_label
= NULL
;
6712 /* After expanding, the tm_restart map is no longer needed. */
6713 if (fun
->gimple_df
->tm_restart
)
6714 fun
->gimple_df
->tm_restart
= NULL
;
6716 /* Tag the blocks with a depth number so that change_scope can find
6717 the common parent easily. */
6718 set_block_levels (DECL_INITIAL (fun
->decl
), 0);
6719 default_rtl_profile ();
6721 /* For -dx discard loops now, otherwise IL verify in clean_state will
6723 if (rtl_dump_and_exit
)
6725 cfun
->curr_properties
&= ~PROP_loops
;
6726 loop_optimizer_finalize ();
6729 timevar_pop (TV_POST_EXPAND
);
6737 make_pass_expand (gcc::context
*ctxt
)
6739 return new pass_expand (ctxt
);