1 /* A pass for lowering trees to RTL.
2 Copyright (C) 2004-2018 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"
65 #include "tree-inline.h"
66 #include "value-prof.h"
67 #include "tree-ssa-live.h"
68 #include "tree-outof-ssa.h"
70 #include "insn-attr.h" /* For INSN_SCHEDULING. */
71 #include "stringpool.h"
74 #include "tree-ssa-address.h"
78 /* Some systems use __main in a way incompatible with its use in gcc, in these
79 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
80 give the same symbol without quotes for an alternative entry point. You
81 must define both, or neither. */
83 #define NAME__MAIN "__main"
86 /* This variable holds information helping the rewriting of SSA trees
90 /* This variable holds the currently expanded gimple statement for purposes
91 of comminucating the profile info to the builtin expanders. */
92 gimple
*currently_expanding_gimple_stmt
;
94 static rtx
expand_debug_expr (tree
);
96 static bool defer_stack_allocation (tree
, bool);
98 static void record_alignment_for_reg_var (unsigned int);
100 /* Return an expression tree corresponding to the RHS of GIMPLE
104 gimple_assign_rhs_to_tree (gimple
*stmt
)
107 enum gimple_rhs_class grhs_class
;
109 grhs_class
= get_gimple_rhs_class (gimple_expr_code (stmt
));
111 if (grhs_class
== GIMPLE_TERNARY_RHS
)
112 t
= build3 (gimple_assign_rhs_code (stmt
),
113 TREE_TYPE (gimple_assign_lhs (stmt
)),
114 gimple_assign_rhs1 (stmt
),
115 gimple_assign_rhs2 (stmt
),
116 gimple_assign_rhs3 (stmt
));
117 else if (grhs_class
== GIMPLE_BINARY_RHS
)
118 t
= build2 (gimple_assign_rhs_code (stmt
),
119 TREE_TYPE (gimple_assign_lhs (stmt
)),
120 gimple_assign_rhs1 (stmt
),
121 gimple_assign_rhs2 (stmt
));
122 else if (grhs_class
== GIMPLE_UNARY_RHS
)
123 t
= build1 (gimple_assign_rhs_code (stmt
),
124 TREE_TYPE (gimple_assign_lhs (stmt
)),
125 gimple_assign_rhs1 (stmt
));
126 else if (grhs_class
== GIMPLE_SINGLE_RHS
)
128 t
= gimple_assign_rhs1 (stmt
);
129 /* Avoid modifying this tree in place below. */
130 if ((gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (t
)
131 && gimple_location (stmt
) != EXPR_LOCATION (t
))
132 || (gimple_block (stmt
)
133 && currently_expanding_to_rtl
140 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (t
))
141 SET_EXPR_LOCATION (t
, gimple_location (stmt
));
147 #ifndef STACK_ALIGNMENT_NEEDED
148 #define STACK_ALIGNMENT_NEEDED 1
151 #define SSAVAR(x) (TREE_CODE (x) == SSA_NAME ? SSA_NAME_VAR (x) : x)
153 /* Choose either CUR or NEXT as the leader DECL for a partition.
154 Prefer ignored decls, to simplify debug dumps and reduce ambiguity
155 out of the same user variable being in multiple partitions (this is
156 less likely for compiler-introduced temps). */
159 leader_merge (tree cur
, tree next
)
161 if (cur
== NULL
|| cur
== next
)
164 if (DECL_P (cur
) && DECL_IGNORED_P (cur
))
167 if (DECL_P (next
) && DECL_IGNORED_P (next
))
173 /* Associate declaration T with storage space X. If T is no
174 SSA name this is exactly SET_DECL_RTL, otherwise make the
175 partition of T associated with X. */
177 set_rtl (tree t
, rtx x
)
179 gcc_checking_assert (!x
180 || !(TREE_CODE (t
) == SSA_NAME
|| is_gimple_reg (t
))
181 || (use_register_for_decl (t
)
183 || (GET_CODE (x
) == CONCAT
184 && (REG_P (XEXP (x
, 0))
185 || SUBREG_P (XEXP (x
, 0)))
186 && (REG_P (XEXP (x
, 1))
187 || SUBREG_P (XEXP (x
, 1))))
188 /* We need to accept PARALLELs for RESUT_DECLs
189 because of vector types with BLKmode returned
190 in multiple registers, but they are supposed
191 to be uncoalesced. */
192 || (GET_CODE (x
) == PARALLEL
194 && TREE_CODE (SSAVAR (t
)) == RESULT_DECL
195 && (GET_MODE (x
) == BLKmode
196 || !flag_tree_coalesce_vars
)))
197 : (MEM_P (x
) || x
== pc_rtx
198 || (GET_CODE (x
) == CONCAT
199 && MEM_P (XEXP (x
, 0))
200 && MEM_P (XEXP (x
, 1))))));
201 /* Check that the RTL for SSA_NAMEs and gimple-reg PARM_DECLs and
202 RESULT_DECLs has the expected mode. For memory, we accept
203 unpromoted modes, since that's what we're likely to get. For
204 PARM_DECLs and RESULT_DECLs, we'll have been called by
205 set_parm_rtl, which will give us the default def, so we don't
206 have to compute it ourselves. For RESULT_DECLs, we accept mode
207 mismatches too, as long as we have BLKmode or are not coalescing
208 across variables, so that we don't reject BLKmode PARALLELs or
210 gcc_checking_assert (!x
|| x
== pc_rtx
|| TREE_CODE (t
) != SSA_NAME
212 && TREE_CODE (SSAVAR (t
)) == RESULT_DECL
213 && (promote_ssa_mode (t
, NULL
) == BLKmode
214 || !flag_tree_coalesce_vars
))
215 || !use_register_for_decl (t
)
216 || GET_MODE (x
) == promote_ssa_mode (t
, NULL
));
221 tree cur
= NULL_TREE
;
229 else if (SUBREG_P (xm
))
231 gcc_assert (subreg_lowpart_p (xm
));
232 xm
= SUBREG_REG (xm
);
235 else if (GET_CODE (xm
) == CONCAT
)
240 else if (GET_CODE (xm
) == PARALLEL
)
242 xm
= XVECEXP (xm
, 0, 0);
243 gcc_assert (GET_CODE (xm
) == EXPR_LIST
);
247 else if (xm
== pc_rtx
)
252 tree next
= skip
? cur
: leader_merge (cur
, SSAVAR (t
) ? SSAVAR (t
) : t
);
257 set_mem_attributes (x
,
258 next
&& TREE_CODE (next
) == SSA_NAME
262 set_reg_attrs_for_decl_rtl (next
, x
);
266 if (TREE_CODE (t
) == SSA_NAME
)
268 int part
= var_to_partition (SA
.map
, t
);
269 if (part
!= NO_PARTITION
)
271 if (SA
.partition_to_pseudo
[part
])
272 gcc_assert (SA
.partition_to_pseudo
[part
] == x
);
273 else if (x
!= pc_rtx
)
274 SA
.partition_to_pseudo
[part
] = x
;
276 /* For the benefit of debug information at -O0 (where
277 vartracking doesn't run) record the place also in the base
278 DECL. For PARMs and RESULTs, do so only when setting the
280 if (x
&& x
!= pc_rtx
&& SSA_NAME_VAR (t
)
281 && (VAR_P (SSA_NAME_VAR (t
))
282 || SSA_NAME_IS_DEFAULT_DEF (t
)))
284 tree var
= SSA_NAME_VAR (t
);
285 /* If we don't yet have something recorded, just record it now. */
286 if (!DECL_RTL_SET_P (var
))
287 SET_DECL_RTL (var
, x
);
288 /* If we have it set already to "multiple places" don't
290 else if (DECL_RTL (var
) == pc_rtx
)
292 /* If we have something recorded and it's not the same place
293 as we want to record now, we have multiple partitions for the
294 same base variable, with different places. We can't just
295 randomly chose one, hence we have to say that we don't know.
296 This only happens with optimization, and there var-tracking
297 will figure out the right thing. */
298 else if (DECL_RTL (var
) != x
)
299 SET_DECL_RTL (var
, pc_rtx
);
306 /* This structure holds data relevant to one variable that will be
307 placed in a stack slot. */
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 struct 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
)
368 if (TREE_CODE (decl
) == SSA_NAME
)
369 align
= TYPE_ALIGN (TREE_TYPE (decl
));
372 align
= LOCAL_DECL_ALIGNMENT (decl
);
373 SET_DECL_ALIGN (decl
, align
);
375 return align
/ BITS_PER_UNIT
;
378 /* Align given offset BASE with ALIGN. Truncate up if ALIGN_UP is true,
379 down otherwise. Return truncated BASE value. */
381 static inline unsigned HOST_WIDE_INT
382 align_base (HOST_WIDE_INT base
, unsigned HOST_WIDE_INT align
, bool align_up
)
384 return align_up
? (base
+ align
- 1) & -align
: base
& -align
;
387 /* Allocate SIZE bytes at byte alignment ALIGN from the stack frame.
388 Return the frame offset. */
391 alloc_stack_frame_space (poly_int64 size
, unsigned HOST_WIDE_INT align
)
393 poly_int64 offset
, new_frame_offset
;
395 if (FRAME_GROWS_DOWNWARD
)
398 = aligned_lower_bound (frame_offset
- frame_phase
- size
,
399 align
) + frame_phase
;
400 offset
= new_frame_offset
;
405 = aligned_upper_bound (frame_offset
- frame_phase
,
406 align
) + frame_phase
;
407 offset
= new_frame_offset
;
408 new_frame_offset
+= size
;
410 frame_offset
= new_frame_offset
;
412 if (frame_offset_overflow (frame_offset
, cfun
->decl
))
413 frame_offset
= offset
= 0;
418 /* Accumulate DECL into STACK_VARS. */
421 add_stack_var (tree decl
)
425 if (stack_vars_num
>= stack_vars_alloc
)
427 if (stack_vars_alloc
)
428 stack_vars_alloc
= stack_vars_alloc
* 3 / 2;
430 stack_vars_alloc
= 32;
432 = XRESIZEVEC (struct stack_var
, stack_vars
, stack_vars_alloc
);
434 if (!decl_to_stack_part
)
435 decl_to_stack_part
= new hash_map
<tree
, size_t>;
437 v
= &stack_vars
[stack_vars_num
];
438 decl_to_stack_part
->put (decl
, stack_vars_num
);
441 tree size
= TREE_CODE (decl
) == SSA_NAME
442 ? TYPE_SIZE_UNIT (TREE_TYPE (decl
))
443 : DECL_SIZE_UNIT (decl
);
444 v
->size
= tree_to_poly_uint64 (size
);
445 /* Ensure that all variables have size, so that &a != &b for any two
446 variables that are simultaneously live. */
447 if (known_eq (v
->size
, 0U))
449 v
->alignb
= align_local_variable (decl
);
450 /* An alignment of zero can mightily confuse us later. */
451 gcc_assert (v
->alignb
!= 0);
453 /* All variables are initially in their own partition. */
454 v
->representative
= stack_vars_num
;
457 /* All variables initially conflict with no other. */
460 /* Ensure that this decl doesn't get put onto the list twice. */
461 set_rtl (decl
, pc_rtx
);
466 /* Make the decls associated with luid's X and Y conflict. */
469 add_stack_var_conflict (size_t x
, size_t y
)
471 struct stack_var
*a
= &stack_vars
[x
];
472 struct stack_var
*b
= &stack_vars
[y
];
474 a
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
476 b
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
477 bitmap_set_bit (a
->conflicts
, y
);
478 bitmap_set_bit (b
->conflicts
, x
);
481 /* Check whether the decls associated with luid's X and Y conflict. */
484 stack_var_conflict_p (size_t x
, size_t y
)
486 struct stack_var
*a
= &stack_vars
[x
];
487 struct stack_var
*b
= &stack_vars
[y
];
490 /* Partitions containing an SSA name result from gimple registers
491 with things like unsupported modes. They are top-level and
492 hence conflict with everything else. */
493 if (TREE_CODE (a
->decl
) == SSA_NAME
|| TREE_CODE (b
->decl
) == SSA_NAME
)
496 if (!a
->conflicts
|| !b
->conflicts
)
498 return bitmap_bit_p (a
->conflicts
, y
);
501 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
502 enter its partition number into bitmap DATA. */
505 visit_op (gimple
*, tree op
, tree
, void *data
)
507 bitmap active
= (bitmap
)data
;
508 op
= get_base_address (op
);
511 && DECL_RTL_IF_SET (op
) == pc_rtx
)
513 size_t *v
= decl_to_stack_part
->get (op
);
515 bitmap_set_bit (active
, *v
);
520 /* Callback for walk_stmt_ops. If OP is a decl touched by add_stack_var
521 record conflicts between it and all currently active other partitions
525 visit_conflict (gimple
*, tree op
, tree
, void *data
)
527 bitmap active
= (bitmap
)data
;
528 op
= get_base_address (op
);
531 && DECL_RTL_IF_SET (op
) == pc_rtx
)
533 size_t *v
= decl_to_stack_part
->get (op
);
534 if (v
&& bitmap_set_bit (active
, *v
))
539 gcc_assert (num
< stack_vars_num
);
540 EXECUTE_IF_SET_IN_BITMAP (active
, 0, i
, bi
)
541 add_stack_var_conflict (num
, i
);
547 /* Helper routine for add_scope_conflicts, calculating the active partitions
548 at the end of BB, leaving the result in WORK. We're called to generate
549 conflicts when FOR_CONFLICT is true, otherwise we're just tracking
553 add_scope_conflicts_1 (basic_block bb
, bitmap work
, bool for_conflict
)
557 gimple_stmt_iterator gsi
;
558 walk_stmt_load_store_addr_fn visit
;
561 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
562 bitmap_ior_into (work
, (bitmap
)e
->src
->aux
);
566 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
568 gimple
*stmt
= gsi_stmt (gsi
);
569 walk_stmt_load_store_addr_ops (stmt
, work
, NULL
, NULL
, visit
);
571 for (gsi
= gsi_after_labels (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
573 gimple
*stmt
= gsi_stmt (gsi
);
575 if (gimple_clobber_p (stmt
))
577 tree lhs
= gimple_assign_lhs (stmt
);
579 /* Nested function lowering might introduce LHSs
580 that are COMPONENT_REFs. */
583 if (DECL_RTL_IF_SET (lhs
) == pc_rtx
584 && (v
= decl_to_stack_part
->get (lhs
)))
585 bitmap_clear_bit (work
, *v
);
587 else if (!is_gimple_debug (stmt
))
590 && visit
== visit_op
)
592 /* If this is the first real instruction in this BB we need
593 to add conflicts for everything live at this point now.
594 Unlike classical liveness for named objects we can't
595 rely on seeing a def/use of the names we're interested in.
596 There might merely be indirect loads/stores. We'd not add any
597 conflicts for such partitions. */
600 EXECUTE_IF_SET_IN_BITMAP (work
, 0, i
, bi
)
602 struct stack_var
*a
= &stack_vars
[i
];
604 a
->conflicts
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
605 bitmap_ior_into (a
->conflicts
, work
);
607 visit
= visit_conflict
;
609 walk_stmt_load_store_addr_ops (stmt
, work
, visit
, visit
, visit
);
614 /* Generate stack partition conflicts between all partitions that are
615 simultaneously live. */
618 add_scope_conflicts (void)
622 bitmap work
= BITMAP_ALLOC (NULL
);
626 /* We approximate the live range of a stack variable by taking the first
627 mention of its name as starting point(s), and by the end-of-scope
628 death clobber added by gimplify as ending point(s) of the range.
629 This overapproximates in the case we for instance moved an address-taken
630 operation upward, without also moving a dereference to it upwards.
631 But it's conservatively correct as a variable never can hold values
632 before its name is mentioned at least once.
634 We then do a mostly classical bitmap liveness algorithm. */
636 FOR_ALL_BB_FN (bb
, cfun
)
637 bb
->aux
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
639 rpo
= XNEWVEC (int, last_basic_block_for_fn (cfun
));
640 n_bbs
= pre_and_rev_post_order_compute (NULL
, rpo
, false);
647 for (i
= 0; i
< n_bbs
; i
++)
650 bb
= BASIC_BLOCK_FOR_FN (cfun
, rpo
[i
]);
651 active
= (bitmap
)bb
->aux
;
652 add_scope_conflicts_1 (bb
, work
, false);
653 if (bitmap_ior_into (active
, work
))
658 FOR_EACH_BB_FN (bb
, cfun
)
659 add_scope_conflicts_1 (bb
, work
, true);
663 FOR_ALL_BB_FN (bb
, cfun
)
664 BITMAP_FREE (bb
->aux
);
667 /* A subroutine of partition_stack_vars. A comparison function for qsort,
668 sorting an array of indices by the properties of the object. */
671 stack_var_cmp (const void *a
, const void *b
)
673 size_t ia
= *(const size_t *)a
;
674 size_t ib
= *(const size_t *)b
;
675 unsigned int aligna
= stack_vars
[ia
].alignb
;
676 unsigned int alignb
= stack_vars
[ib
].alignb
;
677 poly_int64 sizea
= stack_vars
[ia
].size
;
678 poly_int64 sizeb
= stack_vars
[ib
].size
;
679 tree decla
= stack_vars
[ia
].decl
;
680 tree declb
= stack_vars
[ib
].decl
;
682 unsigned int uida
, uidb
;
684 /* Primary compare on "large" alignment. Large comes first. */
685 largea
= (aligna
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
686 largeb
= (alignb
* BITS_PER_UNIT
> MAX_SUPPORTED_STACK_ALIGNMENT
);
687 if (largea
!= largeb
)
688 return (int)largeb
- (int)largea
;
690 /* Secondary compare on size, decreasing */
691 int diff
= compare_sizes_for_sort (sizeb
, sizea
);
695 /* Tertiary compare on true alignment, decreasing. */
701 /* Final compare on ID for sort stability, increasing.
702 Two SSA names are compared by their version, SSA names come before
703 non-SSA names, and two normal decls are compared by their DECL_UID. */
704 if (TREE_CODE (decla
) == SSA_NAME
)
706 if (TREE_CODE (declb
) == SSA_NAME
)
707 uida
= SSA_NAME_VERSION (decla
), uidb
= SSA_NAME_VERSION (declb
);
711 else if (TREE_CODE (declb
) == SSA_NAME
)
714 uida
= DECL_UID (decla
), uidb
= DECL_UID (declb
);
722 struct part_traits
: unbounded_int_hashmap_traits
<size_t, bitmap
> {};
723 typedef hash_map
<size_t, bitmap
, part_traits
> part_hashmap
;
725 /* If the points-to solution *PI points to variables that are in a partition
726 together with other variables add all partition members to the pointed-to
730 add_partitioned_vars_to_ptset (struct pt_solution
*pt
,
731 part_hashmap
*decls_to_partitions
,
732 hash_set
<bitmap
> *visited
, bitmap temp
)
740 /* The pointed-to vars bitmap is shared, it is enough to
742 || visited
->add (pt
->vars
))
747 /* By using a temporary bitmap to store all members of the partitions
748 we have to add we make sure to visit each of the partitions only
750 EXECUTE_IF_SET_IN_BITMAP (pt
->vars
, 0, i
, bi
)
752 || !bitmap_bit_p (temp
, i
))
753 && (part
= decls_to_partitions
->get (i
)))
754 bitmap_ior_into (temp
, *part
);
755 if (!bitmap_empty_p (temp
))
756 bitmap_ior_into (pt
->vars
, temp
);
759 /* Update points-to sets based on partition info, so we can use them on RTL.
760 The bitmaps representing stack partitions will be saved until expand,
761 where partitioned decls used as bases in memory expressions will be
765 update_alias_info_with_stack_vars (void)
767 part_hashmap
*decls_to_partitions
= NULL
;
769 tree var
= NULL_TREE
;
771 for (i
= 0; i
< stack_vars_num
; i
++)
775 struct ptr_info_def
*pi
;
777 /* Not interested in partitions with single variable. */
778 if (stack_vars
[i
].representative
!= i
779 || stack_vars
[i
].next
== EOC
)
782 if (!decls_to_partitions
)
784 decls_to_partitions
= new part_hashmap
;
785 cfun
->gimple_df
->decls_to_pointers
= new hash_map
<tree
, tree
>;
788 /* Create an SSA_NAME that points to the partition for use
789 as base during alias-oracle queries on RTL for bases that
790 have been partitioned. */
791 if (var
== NULL_TREE
)
792 var
= create_tmp_var (ptr_type_node
);
793 name
= make_ssa_name (var
);
795 /* Create bitmaps representing partitions. They will be used for
796 points-to sets later, so use GGC alloc. */
797 part
= BITMAP_GGC_ALLOC ();
798 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
800 tree decl
= stack_vars
[j
].decl
;
801 unsigned int uid
= DECL_PT_UID (decl
);
802 bitmap_set_bit (part
, uid
);
803 decls_to_partitions
->put (uid
, part
);
804 cfun
->gimple_df
->decls_to_pointers
->put (decl
, name
);
805 if (TREE_ADDRESSABLE (decl
))
806 TREE_ADDRESSABLE (name
) = 1;
809 /* Make the SSA name point to all partition members. */
810 pi
= get_ptr_info (name
);
811 pt_solution_set (&pi
->pt
, part
, false);
814 /* Make all points-to sets that contain one member of a partition
815 contain all members of the partition. */
816 if (decls_to_partitions
)
820 hash_set
<bitmap
> visited
;
821 bitmap temp
= BITMAP_ALLOC (&stack_var_bitmap_obstack
);
823 FOR_EACH_SSA_NAME (i
, name
, cfun
)
825 struct ptr_info_def
*pi
;
827 if (POINTER_TYPE_P (TREE_TYPE (name
))
828 && ((pi
= SSA_NAME_PTR_INFO (name
)) != NULL
))
829 add_partitioned_vars_to_ptset (&pi
->pt
, decls_to_partitions
,
833 add_partitioned_vars_to_ptset (&cfun
->gimple_df
->escaped
,
834 decls_to_partitions
, &visited
, temp
);
836 delete decls_to_partitions
;
841 /* A subroutine of partition_stack_vars. The UNION portion of a UNION/FIND
842 partitioning algorithm. Partitions A and B are known to be non-conflicting.
843 Merge them into a single partition A. */
846 union_stack_vars (size_t a
, size_t b
)
848 struct stack_var
*vb
= &stack_vars
[b
];
852 gcc_assert (stack_vars
[b
].next
== EOC
);
853 /* Add B to A's partition. */
854 stack_vars
[b
].next
= stack_vars
[a
].next
;
855 stack_vars
[b
].representative
= a
;
856 stack_vars
[a
].next
= b
;
858 /* Update the required alignment of partition A to account for B. */
859 if (stack_vars
[a
].alignb
< stack_vars
[b
].alignb
)
860 stack_vars
[a
].alignb
= stack_vars
[b
].alignb
;
862 /* Update the interference graph and merge the conflicts. */
865 EXECUTE_IF_SET_IN_BITMAP (vb
->conflicts
, 0, u
, bi
)
866 add_stack_var_conflict (a
, stack_vars
[u
].representative
);
867 BITMAP_FREE (vb
->conflicts
);
871 /* A subroutine of expand_used_vars. Binpack the variables into
872 partitions constrained by the interference graph. The overall
873 algorithm used is as follows:
875 Sort the objects by size in descending order.
880 Look for the largest non-conflicting object B with size <= S.
887 partition_stack_vars (void)
889 size_t si
, sj
, n
= stack_vars_num
;
891 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
892 for (si
= 0; si
< n
; ++si
)
893 stack_vars_sorted
[si
] = si
;
898 qsort (stack_vars_sorted
, n
, sizeof (size_t), stack_var_cmp
);
900 for (si
= 0; si
< n
; ++si
)
902 size_t i
= stack_vars_sorted
[si
];
903 unsigned int ialign
= stack_vars
[i
].alignb
;
904 poly_int64 isize
= stack_vars
[i
].size
;
906 /* Ignore objects that aren't partition representatives. If we
907 see a var that is not a partition representative, it must
908 have been merged earlier. */
909 if (stack_vars
[i
].representative
!= i
)
912 for (sj
= si
+ 1; sj
< n
; ++sj
)
914 size_t j
= stack_vars_sorted
[sj
];
915 unsigned int jalign
= stack_vars
[j
].alignb
;
916 poly_int64 jsize
= stack_vars
[j
].size
;
918 /* Ignore objects that aren't partition representatives. */
919 if (stack_vars
[j
].representative
!= j
)
922 /* Do not mix objects of "small" (supported) alignment
923 and "large" (unsupported) alignment. */
924 if ((ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
925 != (jalign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
))
928 /* For Address Sanitizer do not mix objects with different
929 sizes, as the shorter vars wouldn't be adequately protected.
930 Don't do that for "large" (unsupported) alignment objects,
931 those aren't protected anyway. */
932 if (asan_sanitize_stack_p ()
933 && maybe_ne (isize
, jsize
)
934 && ialign
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
937 /* Ignore conflicting objects. */
938 if (stack_var_conflict_p (i
, j
))
941 /* UNION the objects, placing J at OFFSET. */
942 union_stack_vars (i
, j
);
946 update_alias_info_with_stack_vars ();
949 /* A debugging aid for expand_used_vars. Dump the generated partitions. */
952 dump_stack_var_partition (void)
954 size_t si
, i
, j
, n
= stack_vars_num
;
956 for (si
= 0; si
< n
; ++si
)
958 i
= stack_vars_sorted
[si
];
960 /* Skip variables that aren't partition representatives, for now. */
961 if (stack_vars
[i
].representative
!= i
)
964 fprintf (dump_file
, "Partition %lu: size ", (unsigned long) i
);
965 print_dec (stack_vars
[i
].size
, dump_file
);
966 fprintf (dump_file
, " align %u\n", stack_vars
[i
].alignb
);
968 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
970 fputc ('\t', dump_file
);
971 print_generic_expr (dump_file
, stack_vars
[j
].decl
, dump_flags
);
973 fputc ('\n', dump_file
);
977 /* Assign rtl to DECL at BASE + OFFSET. */
980 expand_one_stack_var_at (tree decl
, rtx base
, unsigned base_align
,
986 /* If this fails, we've overflowed the stack frame. Error nicely? */
987 gcc_assert (known_eq (offset
, trunc_int_for_mode (offset
, Pmode
)));
989 x
= plus_constant (Pmode
, base
, offset
);
990 x
= gen_rtx_MEM (TREE_CODE (decl
) == SSA_NAME
991 ? TYPE_MODE (TREE_TYPE (decl
))
992 : DECL_MODE (SSAVAR (decl
)), x
);
994 if (TREE_CODE (decl
) != SSA_NAME
)
996 /* Set alignment we actually gave this decl if it isn't an SSA name.
997 If it is we generate stack slots only accidentally so it isn't as
998 important, we'll simply use the alignment that is already set. */
999 if (base
== virtual_stack_vars_rtx
)
1000 offset
-= frame_phase
;
1001 align
= known_alignment (offset
);
1002 align
*= BITS_PER_UNIT
;
1003 if (align
== 0 || align
> base_align
)
1006 /* One would think that we could assert that we're not decreasing
1007 alignment here, but (at least) the i386 port does exactly this
1008 via the MINIMUM_ALIGNMENT hook. */
1010 SET_DECL_ALIGN (decl
, align
);
1011 DECL_USER_ALIGN (decl
) = 0;
1017 struct stack_vars_data
1019 /* Vector of offset pairs, always end of some padding followed
1020 by start of the padding that needs Address Sanitizer protection.
1021 The vector is in reversed, highest offset pairs come first. */
1022 auto_vec
<HOST_WIDE_INT
> asan_vec
;
1024 /* Vector of partition representative decls in between the paddings. */
1025 auto_vec
<tree
> asan_decl_vec
;
1027 /* Base pseudo register for Address Sanitizer protected automatic vars. */
1030 /* Alignment needed for the Address Sanitizer protected automatic vars. */
1031 unsigned int asan_alignb
;
1034 /* A subroutine of expand_used_vars. Give each partition representative
1035 a unique location within the stack frame. Update each partition member
1036 with that location. */
1039 expand_stack_vars (bool (*pred
) (size_t), struct stack_vars_data
*data
)
1041 size_t si
, i
, j
, n
= stack_vars_num
;
1042 poly_uint64 large_size
= 0, large_alloc
= 0;
1043 rtx large_base
= NULL
;
1044 unsigned large_align
= 0;
1045 bool large_allocation_done
= false;
1048 /* Determine if there are any variables requiring "large" alignment.
1049 Since these are dynamically allocated, we only process these if
1050 no predicate involved. */
1051 large_align
= stack_vars
[stack_vars_sorted
[0]].alignb
* BITS_PER_UNIT
;
1052 if (pred
== NULL
&& large_align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1054 /* Find the total size of these variables. */
1055 for (si
= 0; si
< n
; ++si
)
1059 i
= stack_vars_sorted
[si
];
1060 alignb
= stack_vars
[i
].alignb
;
1062 /* All "large" alignment decls come before all "small" alignment
1063 decls, but "large" alignment decls are not sorted based on
1064 their alignment. Increase large_align to track the largest
1065 required alignment. */
1066 if ((alignb
* BITS_PER_UNIT
) > large_align
)
1067 large_align
= alignb
* BITS_PER_UNIT
;
1069 /* Stop when we get to the first decl with "small" alignment. */
1070 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
1073 /* Skip variables that aren't partition representatives. */
1074 if (stack_vars
[i
].representative
!= i
)
1077 /* Skip variables that have already had rtl assigned. See also
1078 add_stack_var where we perpetrate this pc_rtx hack. */
1079 decl
= stack_vars
[i
].decl
;
1080 if (TREE_CODE (decl
) == SSA_NAME
1081 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)] != NULL_RTX
1082 : DECL_RTL (decl
) != pc_rtx
)
1085 large_size
= aligned_upper_bound (large_size
, alignb
);
1086 large_size
+= stack_vars
[i
].size
;
1090 for (si
= 0; si
< n
; ++si
)
1093 unsigned base_align
, alignb
;
1096 i
= stack_vars_sorted
[si
];
1098 /* Skip variables that aren't partition representatives, for now. */
1099 if (stack_vars
[i
].representative
!= i
)
1102 /* Skip variables that have already had rtl assigned. See also
1103 add_stack_var where we perpetrate this pc_rtx hack. */
1104 decl
= stack_vars
[i
].decl
;
1105 if (TREE_CODE (decl
) == SSA_NAME
1106 ? SA
.partition_to_pseudo
[var_to_partition (SA
.map
, decl
)] != NULL_RTX
1107 : DECL_RTL (decl
) != pc_rtx
)
1110 /* Check the predicate to see whether this variable should be
1111 allocated in this pass. */
1112 if (pred
&& !pred (i
))
1115 alignb
= stack_vars
[i
].alignb
;
1116 if (alignb
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
)
1118 base
= virtual_stack_vars_rtx
;
1119 /* ASAN description strings don't yet have a syntax for expressing
1120 polynomial offsets. */
1121 HOST_WIDE_INT prev_offset
;
1122 if (asan_sanitize_stack_p ()
1124 && frame_offset
.is_constant (&prev_offset
)
1125 && stack_vars
[i
].size
.is_constant ())
1127 prev_offset
= align_base (prev_offset
,
1128 MAX (alignb
, ASAN_RED_ZONE_SIZE
),
1129 !FRAME_GROWS_DOWNWARD
);
1130 tree repr_decl
= NULL_TREE
;
1132 = alloc_stack_frame_space (stack_vars
[i
].size
1133 + ASAN_RED_ZONE_SIZE
,
1134 MAX (alignb
, ASAN_RED_ZONE_SIZE
));
1136 data
->asan_vec
.safe_push (prev_offset
);
1137 /* Allocating a constant amount of space from a constant
1138 starting offset must give a constant result. */
1139 data
->asan_vec
.safe_push ((offset
+ stack_vars
[i
].size
)
1141 /* Find best representative of the partition.
1142 Prefer those with DECL_NAME, even better
1143 satisfying asan_protect_stack_decl predicate. */
1144 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1145 if (asan_protect_stack_decl (stack_vars
[j
].decl
)
1146 && DECL_NAME (stack_vars
[j
].decl
))
1148 repr_decl
= stack_vars
[j
].decl
;
1151 else if (repr_decl
== NULL_TREE
1152 && DECL_P (stack_vars
[j
].decl
)
1153 && DECL_NAME (stack_vars
[j
].decl
))
1154 repr_decl
= stack_vars
[j
].decl
;
1155 if (repr_decl
== NULL_TREE
)
1156 repr_decl
= stack_vars
[i
].decl
;
1157 data
->asan_decl_vec
.safe_push (repr_decl
);
1159 /* Make sure a representative is unpoison if another
1160 variable in the partition is handled by
1161 use-after-scope sanitization. */
1162 if (asan_handled_variables
!= NULL
1163 && !asan_handled_variables
->contains (repr_decl
))
1165 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1166 if (asan_handled_variables
->contains (stack_vars
[j
].decl
))
1169 asan_handled_variables
->add (repr_decl
);
1172 data
->asan_alignb
= MAX (data
->asan_alignb
, alignb
);
1173 if (data
->asan_base
== NULL
)
1174 data
->asan_base
= gen_reg_rtx (Pmode
);
1175 base
= data
->asan_base
;
1177 if (!STRICT_ALIGNMENT
)
1178 base_align
= crtl
->max_used_stack_slot_alignment
;
1180 base_align
= MAX (crtl
->max_used_stack_slot_alignment
,
1181 GET_MODE_ALIGNMENT (SImode
)
1182 << ASAN_SHADOW_SHIFT
);
1186 offset
= alloc_stack_frame_space (stack_vars
[i
].size
, alignb
);
1187 base_align
= crtl
->max_used_stack_slot_alignment
;
1192 /* Large alignment is only processed in the last pass. */
1196 /* If there were any variables requiring "large" alignment, allocate
1198 if (maybe_ne (large_size
, 0U) && ! large_allocation_done
)
1201 rtx large_allocsize
;
1203 large_allocsize
= gen_int_mode (large_size
, Pmode
);
1204 get_dynamic_stack_size (&large_allocsize
, 0, large_align
, NULL
);
1205 loffset
= alloc_stack_frame_space
1206 (rtx_to_poly_int64 (large_allocsize
),
1207 PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
);
1208 large_base
= get_dynamic_stack_base (loffset
, large_align
);
1209 large_allocation_done
= true;
1211 gcc_assert (large_base
!= NULL
);
1213 large_alloc
= aligned_upper_bound (large_alloc
, alignb
);
1214 offset
= large_alloc
;
1215 large_alloc
+= stack_vars
[i
].size
;
1218 base_align
= large_align
;
1221 /* Create rtl for each variable based on their location within the
1223 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1225 expand_one_stack_var_at (stack_vars
[j
].decl
,
1231 gcc_assert (known_eq (large_alloc
, large_size
));
1234 /* Take into account all sizes of partitions and reset DECL_RTLs. */
1236 account_stack_vars (void)
1238 size_t si
, j
, i
, n
= stack_vars_num
;
1239 poly_uint64 size
= 0;
1241 for (si
= 0; si
< n
; ++si
)
1243 i
= stack_vars_sorted
[si
];
1245 /* Skip variables that aren't partition representatives, for now. */
1246 if (stack_vars
[i
].representative
!= i
)
1249 size
+= stack_vars
[i
].size
;
1250 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1251 set_rtl (stack_vars
[j
].decl
, NULL
);
1256 /* Record the RTL assignment X for the default def of PARM. */
1259 set_parm_rtl (tree parm
, rtx x
)
1261 gcc_assert (TREE_CODE (parm
) == PARM_DECL
1262 || TREE_CODE (parm
) == RESULT_DECL
);
1264 if (x
&& !MEM_P (x
))
1266 unsigned int align
= MINIMUM_ALIGNMENT (TREE_TYPE (parm
),
1267 TYPE_MODE (TREE_TYPE (parm
)),
1268 TYPE_ALIGN (TREE_TYPE (parm
)));
1270 /* If the variable alignment is very large we'll dynamicaly
1271 allocate it, which means that in-frame portion is just a
1272 pointer. ??? We've got a pseudo for sure here, do we
1273 actually dynamically allocate its spilling area if needed?
1274 ??? Isn't it a problem when Pmode alignment also exceeds
1275 MAX_SUPPORTED_STACK_ALIGNMENT, as can happen on cris and lm32? */
1276 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1277 align
= GET_MODE_ALIGNMENT (Pmode
);
1279 record_alignment_for_reg_var (align
);
1282 tree ssa
= ssa_default_def (cfun
, parm
);
1284 return set_rtl (parm
, x
);
1286 int part
= var_to_partition (SA
.map
, ssa
);
1287 gcc_assert (part
!= NO_PARTITION
);
1289 bool changed
= bitmap_bit_p (SA
.partitions_for_parm_default_defs
, part
);
1290 gcc_assert (changed
);
1293 gcc_assert (DECL_RTL (parm
) == x
);
1296 /* A subroutine of expand_one_var. Called to immediately assign rtl
1297 to a variable to be allocated in the stack frame. */
1300 expand_one_stack_var_1 (tree var
)
1304 unsigned byte_align
;
1306 if (TREE_CODE (var
) == SSA_NAME
)
1308 tree type
= TREE_TYPE (var
);
1309 size
= tree_to_poly_uint64 (TYPE_SIZE_UNIT (type
));
1310 byte_align
= TYPE_ALIGN_UNIT (type
);
1314 size
= tree_to_poly_uint64 (DECL_SIZE_UNIT (var
));
1315 byte_align
= align_local_variable (var
);
1318 /* We handle highly aligned variables in expand_stack_vars. */
1319 gcc_assert (byte_align
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
);
1321 offset
= alloc_stack_frame_space (size
, byte_align
);
1323 expand_one_stack_var_at (var
, virtual_stack_vars_rtx
,
1324 crtl
->max_used_stack_slot_alignment
, offset
);
1327 /* Wrapper for expand_one_stack_var_1 that checks SSA_NAMEs are
1328 already assigned some MEM. */
1331 expand_one_stack_var (tree var
)
1333 if (TREE_CODE (var
) == SSA_NAME
)
1335 int part
= var_to_partition (SA
.map
, var
);
1336 if (part
!= NO_PARTITION
)
1338 rtx x
= SA
.partition_to_pseudo
[part
];
1340 gcc_assert (MEM_P (x
));
1345 return expand_one_stack_var_1 (var
);
1348 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1349 that will reside in a hard register. */
1352 expand_one_hard_reg_var (tree var
)
1354 rest_of_decl_compilation (var
, 0, 0);
1357 /* Record the alignment requirements of some variable assigned to a
1361 record_alignment_for_reg_var (unsigned int align
)
1363 if (SUPPORTS_STACK_ALIGNMENT
1364 && crtl
->stack_alignment_estimated
< align
)
1366 /* stack_alignment_estimated shouldn't change after stack
1367 realign decision made */
1368 gcc_assert (!crtl
->stack_realign_processed
);
1369 crtl
->stack_alignment_estimated
= align
;
1372 /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
1373 So here we only make sure stack_alignment_needed >= align. */
1374 if (crtl
->stack_alignment_needed
< align
)
1375 crtl
->stack_alignment_needed
= align
;
1376 if (crtl
->max_used_stack_slot_alignment
< align
)
1377 crtl
->max_used_stack_slot_alignment
= align
;
1380 /* Create RTL for an SSA partition. */
1383 expand_one_ssa_partition (tree var
)
1385 int part
= var_to_partition (SA
.map
, var
);
1386 gcc_assert (part
!= NO_PARTITION
);
1388 if (SA
.partition_to_pseudo
[part
])
1391 unsigned int align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1392 TYPE_MODE (TREE_TYPE (var
)),
1393 TYPE_ALIGN (TREE_TYPE (var
)));
1395 /* If the variable alignment is very large we'll dynamicaly allocate
1396 it, which means that in-frame portion is just a pointer. */
1397 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1398 align
= GET_MODE_ALIGNMENT (Pmode
);
1400 record_alignment_for_reg_var (align
);
1402 if (!use_register_for_decl (var
))
1404 if (defer_stack_allocation (var
, true))
1405 add_stack_var (var
);
1407 expand_one_stack_var_1 (var
);
1411 machine_mode reg_mode
= promote_ssa_mode (var
, NULL
);
1412 rtx x
= gen_reg_rtx (reg_mode
);
1416 /* For a promoted variable, X will not be used directly but wrapped in a
1417 SUBREG with SUBREG_PROMOTED_VAR_P set, which means that the RTL land
1418 will assume that its upper bits can be inferred from its lower bits.
1419 Therefore, if X isn't initialized on every path from the entry, then
1420 we must do it manually in order to fulfill the above assumption. */
1421 if (reg_mode
!= TYPE_MODE (TREE_TYPE (var
))
1422 && bitmap_bit_p (SA
.partitions_for_undefined_values
, part
))
1423 emit_move_insn (x
, CONST0_RTX (reg_mode
));
1426 /* Record the association between the RTL generated for partition PART
1427 and the underlying variable of the SSA_NAME VAR. */
1430 adjust_one_expanded_partition_var (tree var
)
1435 tree decl
= SSA_NAME_VAR (var
);
1437 int part
= var_to_partition (SA
.map
, var
);
1438 if (part
== NO_PARTITION
)
1441 rtx x
= SA
.partition_to_pseudo
[part
];
1450 /* Note if the object is a user variable. */
1451 if (decl
&& !DECL_ARTIFICIAL (decl
))
1454 if (POINTER_TYPE_P (decl
? TREE_TYPE (decl
) : TREE_TYPE (var
)))
1455 mark_reg_pointer (x
, get_pointer_alignment (var
));
1458 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1459 that will reside in a pseudo register. */
1462 expand_one_register_var (tree var
)
1464 if (TREE_CODE (var
) == SSA_NAME
)
1466 int part
= var_to_partition (SA
.map
, var
);
1467 if (part
!= NO_PARTITION
)
1469 rtx x
= SA
.partition_to_pseudo
[part
];
1471 gcc_assert (REG_P (x
));
1478 tree type
= TREE_TYPE (decl
);
1479 machine_mode reg_mode
= promote_decl_mode (decl
, NULL
);
1480 rtx x
= gen_reg_rtx (reg_mode
);
1484 /* Note if the object is a user variable. */
1485 if (!DECL_ARTIFICIAL (decl
))
1488 if (POINTER_TYPE_P (type
))
1489 mark_reg_pointer (x
, get_pointer_alignment (var
));
1492 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
1493 has some associated error, e.g. its type is error-mark. We just need
1494 to pick something that won't crash the rest of the compiler. */
1497 expand_one_error_var (tree var
)
1499 machine_mode mode
= DECL_MODE (var
);
1502 if (mode
== BLKmode
)
1503 x
= gen_rtx_MEM (BLKmode
, const0_rtx
);
1504 else if (mode
== VOIDmode
)
1507 x
= gen_reg_rtx (mode
);
1509 SET_DECL_RTL (var
, x
);
1512 /* A subroutine of expand_one_var. VAR is a variable that will be
1513 allocated to the local stack frame. Return true if we wish to
1514 add VAR to STACK_VARS so that it will be coalesced with other
1515 variables. Return false to allocate VAR immediately.
1517 This function is used to reduce the number of variables considered
1518 for coalescing, which reduces the size of the quadratic problem. */
1521 defer_stack_allocation (tree var
, bool toplevel
)
1523 tree size_unit
= TREE_CODE (var
) == SSA_NAME
1524 ? TYPE_SIZE_UNIT (TREE_TYPE (var
))
1525 : DECL_SIZE_UNIT (var
);
1528 /* Whether the variable is small enough for immediate allocation not to be
1529 a problem with regard to the frame size. */
1531 = (poly_int_tree_p (size_unit
, &size
)
1532 && (estimated_poly_value (size
)
1533 < PARAM_VALUE (PARAM_MIN_SIZE_FOR_STACK_SHARING
)));
1535 /* If stack protection is enabled, *all* stack variables must be deferred,
1536 so that we can re-order the strings to the top of the frame.
1537 Similarly for Address Sanitizer. */
1538 if (flag_stack_protect
|| asan_sanitize_stack_p ())
1541 unsigned int align
= TREE_CODE (var
) == SSA_NAME
1542 ? TYPE_ALIGN (TREE_TYPE (var
))
1545 /* We handle "large" alignment via dynamic allocation. We want to handle
1546 this extra complication in only one place, so defer them. */
1547 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1550 bool ignored
= TREE_CODE (var
) == SSA_NAME
1551 ? !SSAVAR (var
) || DECL_IGNORED_P (SSA_NAME_VAR (var
))
1552 : DECL_IGNORED_P (var
);
1554 /* When optimization is enabled, DECL_IGNORED_P variables originally scoped
1555 might be detached from their block and appear at toplevel when we reach
1556 here. We want to coalesce them with variables from other blocks when
1557 the immediate contribution to the frame size would be noticeable. */
1558 if (toplevel
&& optimize
> 0 && ignored
&& !smallish
)
1561 /* Variables declared in the outermost scope automatically conflict
1562 with every other variable. The only reason to want to defer them
1563 at all is that, after sorting, we can more efficiently pack
1564 small variables in the stack frame. Continue to defer at -O2. */
1565 if (toplevel
&& optimize
< 2)
1568 /* Without optimization, *most* variables are allocated from the
1569 stack, which makes the quadratic problem large exactly when we
1570 want compilation to proceed as quickly as possible. On the
1571 other hand, we don't want the function's stack frame size to
1572 get completely out of hand. So we avoid adding scalars and
1573 "small" aggregates to the list at all. */
1574 if (optimize
== 0 && smallish
)
1580 /* A subroutine of expand_used_vars. Expand one variable according to
1581 its flavor. Variables to be placed on the stack are not actually
1582 expanded yet, merely recorded.
1583 When REALLY_EXPAND is false, only add stack values to be allocated.
1584 Return stack usage this variable is supposed to take.
1588 expand_one_var (tree var
, bool toplevel
, bool really_expand
)
1590 unsigned int align
= BITS_PER_UNIT
;
1595 if (TREE_TYPE (var
) != error_mark_node
&& VAR_P (var
))
1597 if (is_global_var (var
))
1600 /* Because we don't know if VAR will be in register or on stack,
1601 we conservatively assume it will be on stack even if VAR is
1602 eventually put into register after RA pass. For non-automatic
1603 variables, which won't be on stack, we collect alignment of
1604 type and ignore user specified alignment. Similarly for
1605 SSA_NAMEs for which use_register_for_decl returns true. */
1606 if (TREE_STATIC (var
)
1607 || DECL_EXTERNAL (var
)
1608 || (TREE_CODE (origvar
) == SSA_NAME
&& use_register_for_decl (var
)))
1609 align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1610 TYPE_MODE (TREE_TYPE (var
)),
1611 TYPE_ALIGN (TREE_TYPE (var
)));
1612 else if (DECL_HAS_VALUE_EXPR_P (var
)
1613 || (DECL_RTL_SET_P (var
) && MEM_P (DECL_RTL (var
))))
1614 /* Don't consider debug only variables with DECL_HAS_VALUE_EXPR_P set
1615 or variables which were assigned a stack slot already by
1616 expand_one_stack_var_at - in the latter case DECL_ALIGN has been
1617 changed from the offset chosen to it. */
1618 align
= crtl
->stack_alignment_estimated
;
1620 align
= MINIMUM_ALIGNMENT (var
, DECL_MODE (var
), DECL_ALIGN (var
));
1622 /* If the variable alignment is very large we'll dynamicaly allocate
1623 it, which means that in-frame portion is just a pointer. */
1624 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1625 align
= GET_MODE_ALIGNMENT (Pmode
);
1628 record_alignment_for_reg_var (align
);
1631 if (TREE_CODE (origvar
) == SSA_NAME
)
1633 gcc_assert (!VAR_P (var
)
1634 || (!DECL_EXTERNAL (var
)
1635 && !DECL_HAS_VALUE_EXPR_P (var
)
1636 && !TREE_STATIC (var
)
1637 && TREE_TYPE (var
) != error_mark_node
1638 && !DECL_HARD_REGISTER (var
)
1641 if (!VAR_P (var
) && TREE_CODE (origvar
) != SSA_NAME
)
1643 else if (DECL_EXTERNAL (var
))
1645 else if (DECL_HAS_VALUE_EXPR_P (var
))
1647 else if (TREE_STATIC (var
))
1649 else if (TREE_CODE (origvar
) != SSA_NAME
&& DECL_RTL_SET_P (var
))
1651 else if (TREE_TYPE (var
) == error_mark_node
)
1654 expand_one_error_var (var
);
1656 else if (VAR_P (var
) && DECL_HARD_REGISTER (var
))
1660 expand_one_hard_reg_var (var
);
1661 if (!DECL_HARD_REGISTER (var
))
1662 /* Invalid register specification. */
1663 expand_one_error_var (var
);
1666 else if (use_register_for_decl (var
))
1669 expand_one_register_var (origvar
);
1671 else if (!poly_int_tree_p (DECL_SIZE_UNIT (var
), &size
)
1672 || !valid_constant_size_p (DECL_SIZE_UNIT (var
)))
1674 /* Reject variables which cover more than half of the address-space. */
1677 error ("size of variable %q+D is too large", var
);
1678 expand_one_error_var (var
);
1681 else if (defer_stack_allocation (var
, toplevel
))
1682 add_stack_var (origvar
);
1687 if (lookup_attribute ("naked",
1688 DECL_ATTRIBUTES (current_function_decl
)))
1689 error ("cannot allocate stack for variable %q+D, naked function.",
1692 expand_one_stack_var (origvar
);
1699 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1700 expanding variables. Those variables that can be put into registers
1701 are allocated pseudos; those that can't are put on the stack.
1703 TOPLEVEL is true if this is the outermost BLOCK. */
1706 expand_used_vars_for_block (tree block
, bool toplevel
)
1710 /* Expand all variables at this level. */
1711 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1713 && ((!VAR_P (t
) && TREE_CODE (t
) != RESULT_DECL
)
1714 || !DECL_NONSHAREABLE (t
)))
1715 expand_one_var (t
, toplevel
, true);
1717 /* Expand all variables at containing levels. */
1718 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1719 expand_used_vars_for_block (t
, false);
1722 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1723 and clear TREE_USED on all local variables. */
1726 clear_tree_used (tree block
)
1730 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1731 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
1732 if ((!VAR_P (t
) && TREE_CODE (t
) != RESULT_DECL
)
1733 || !DECL_NONSHAREABLE (t
))
1736 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1737 clear_tree_used (t
);
1741 SPCT_FLAG_DEFAULT
= 1,
1743 SPCT_FLAG_STRONG
= 3,
1744 SPCT_FLAG_EXPLICIT
= 4
1747 /* Examine TYPE and determine a bit mask of the following features. */
1749 #define SPCT_HAS_LARGE_CHAR_ARRAY 1
1750 #define SPCT_HAS_SMALL_CHAR_ARRAY 2
1751 #define SPCT_HAS_ARRAY 4
1752 #define SPCT_HAS_AGGREGATE 8
1755 stack_protect_classify_type (tree type
)
1757 unsigned int ret
= 0;
1760 switch (TREE_CODE (type
))
1763 t
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1764 if (t
== char_type_node
1765 || t
== signed_char_type_node
1766 || t
== unsigned_char_type_node
)
1768 unsigned HOST_WIDE_INT max
= PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
);
1769 unsigned HOST_WIDE_INT len
;
1771 if (!TYPE_SIZE_UNIT (type
)
1772 || !tree_fits_uhwi_p (TYPE_SIZE_UNIT (type
)))
1775 len
= tree_to_uhwi (TYPE_SIZE_UNIT (type
));
1778 ret
= SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1780 ret
= SPCT_HAS_LARGE_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1783 ret
= SPCT_HAS_ARRAY
;
1787 case QUAL_UNION_TYPE
:
1789 ret
= SPCT_HAS_AGGREGATE
;
1790 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
1791 if (TREE_CODE (t
) == FIELD_DECL
)
1792 ret
|= stack_protect_classify_type (TREE_TYPE (t
));
1802 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
1803 part of the local stack frame. Remember if we ever return nonzero for
1804 any variable in this function. The return value is the phase number in
1805 which the variable should be allocated. */
1808 stack_protect_decl_phase (tree decl
)
1810 unsigned int bits
= stack_protect_classify_type (TREE_TYPE (decl
));
1813 if (bits
& SPCT_HAS_SMALL_CHAR_ARRAY
)
1814 has_short_buffer
= true;
1816 if (flag_stack_protect
== SPCT_FLAG_ALL
1817 || flag_stack_protect
== SPCT_FLAG_STRONG
1818 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
1819 && lookup_attribute ("stack_protect",
1820 DECL_ATTRIBUTES (current_function_decl
))))
1822 if ((bits
& (SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_LARGE_CHAR_ARRAY
))
1823 && !(bits
& SPCT_HAS_AGGREGATE
))
1825 else if (bits
& SPCT_HAS_ARRAY
)
1829 ret
= (bits
& SPCT_HAS_LARGE_CHAR_ARRAY
) != 0;
1832 has_protected_decls
= true;
1837 /* Two helper routines that check for phase 1 and phase 2. These are used
1838 as callbacks for expand_stack_vars. */
1841 stack_protect_decl_phase_1 (size_t i
)
1843 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 1;
1847 stack_protect_decl_phase_2 (size_t i
)
1849 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 2;
1852 /* And helper function that checks for asan phase (with stack protector
1853 it is phase 3). This is used as callback for expand_stack_vars.
1854 Returns true if any of the vars in the partition need to be protected. */
1857 asan_decl_phase_3 (size_t i
)
1861 if (asan_protect_stack_decl (stack_vars
[i
].decl
))
1863 i
= stack_vars
[i
].next
;
1868 /* Ensure that variables in different stack protection phases conflict
1869 so that they are not merged and share the same stack slot. */
1872 add_stack_protection_conflicts (void)
1874 size_t i
, j
, n
= stack_vars_num
;
1875 unsigned char *phase
;
1877 phase
= XNEWVEC (unsigned char, n
);
1878 for (i
= 0; i
< n
; ++i
)
1879 phase
[i
] = stack_protect_decl_phase (stack_vars
[i
].decl
);
1881 for (i
= 0; i
< n
; ++i
)
1883 unsigned char ph_i
= phase
[i
];
1884 for (j
= i
+ 1; j
< n
; ++j
)
1885 if (ph_i
!= phase
[j
])
1886 add_stack_var_conflict (i
, j
);
1892 /* Create a decl for the guard at the top of the stack frame. */
1895 create_stack_guard (void)
1897 tree guard
= build_decl (DECL_SOURCE_LOCATION (current_function_decl
),
1898 VAR_DECL
, NULL
, ptr_type_node
);
1899 TREE_THIS_VOLATILE (guard
) = 1;
1900 TREE_USED (guard
) = 1;
1901 expand_one_stack_var (guard
);
1902 crtl
->stack_protect_guard
= guard
;
1905 /* Prepare for expanding variables. */
1907 init_vars_expansion (void)
1909 /* Conflict bitmaps, and a few related temporary bitmaps, go here. */
1910 bitmap_obstack_initialize (&stack_var_bitmap_obstack
);
1912 /* A map from decl to stack partition. */
1913 decl_to_stack_part
= new hash_map
<tree
, size_t>;
1915 /* Initialize local stack smashing state. */
1916 has_protected_decls
= false;
1917 has_short_buffer
= false;
1920 /* Free up stack variable graph data. */
1922 fini_vars_expansion (void)
1924 bitmap_obstack_release (&stack_var_bitmap_obstack
);
1926 XDELETEVEC (stack_vars
);
1927 if (stack_vars_sorted
)
1928 XDELETEVEC (stack_vars_sorted
);
1930 stack_vars_sorted
= NULL
;
1931 stack_vars_alloc
= stack_vars_num
= 0;
1932 delete decl_to_stack_part
;
1933 decl_to_stack_part
= NULL
;
1936 /* Make a fair guess for the size of the stack frame of the function
1937 in NODE. This doesn't have to be exact, the result is only used in
1938 the inline heuristics. So we don't want to run the full stack var
1939 packing algorithm (which is quadratic in the number of stack vars).
1940 Instead, we calculate the total size of all stack vars. This turns
1941 out to be a pretty fair estimate -- packing of stack vars doesn't
1942 happen very often. */
1945 estimated_stack_frame_size (struct cgraph_node
*node
)
1947 poly_int64 size
= 0;
1950 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
1954 init_vars_expansion ();
1956 FOR_EACH_LOCAL_DECL (fn
, i
, var
)
1957 if (auto_var_in_fn_p (var
, fn
->decl
))
1958 size
+= expand_one_var (var
, true, false);
1960 if (stack_vars_num
> 0)
1962 /* Fake sorting the stack vars for account_stack_vars (). */
1963 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
1964 for (i
= 0; i
< stack_vars_num
; ++i
)
1965 stack_vars_sorted
[i
] = i
;
1966 size
+= account_stack_vars ();
1969 fini_vars_expansion ();
1971 return estimated_poly_value (size
);
1974 /* Helper routine to check if a record or union contains an array field. */
1977 record_or_union_type_has_array_p (const_tree tree_type
)
1979 tree fields
= TYPE_FIELDS (tree_type
);
1982 for (f
= fields
; f
; f
= DECL_CHAIN (f
))
1983 if (TREE_CODE (f
) == FIELD_DECL
)
1985 tree field_type
= TREE_TYPE (f
);
1986 if (RECORD_OR_UNION_TYPE_P (field_type
)
1987 && record_or_union_type_has_array_p (field_type
))
1989 if (TREE_CODE (field_type
) == ARRAY_TYPE
)
1995 /* Check if the current function has local referenced variables that
1996 have their addresses taken, contain an array, or are arrays. */
1999 stack_protect_decl_p ()
2004 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
2005 if (!is_global_var (var
))
2007 tree var_type
= TREE_TYPE (var
);
2009 && (TREE_CODE (var_type
) == ARRAY_TYPE
2010 || TREE_ADDRESSABLE (var
)
2011 || (RECORD_OR_UNION_TYPE_P (var_type
)
2012 && record_or_union_type_has_array_p (var_type
))))
2018 /* Check if the current function has calls that use a return slot. */
2021 stack_protect_return_slot_p ()
2025 FOR_ALL_BB_FN (bb
, cfun
)
2026 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
2027 !gsi_end_p (gsi
); gsi_next (&gsi
))
2029 gimple
*stmt
= gsi_stmt (gsi
);
2030 /* This assumes that calls to internal-only functions never
2031 use a return slot. */
2032 if (is_gimple_call (stmt
)
2033 && !gimple_call_internal_p (stmt
)
2034 && aggregate_value_p (TREE_TYPE (gimple_call_fntype (stmt
)),
2035 gimple_call_fndecl (stmt
)))
2041 /* Expand all variables used in the function. */
2044 expand_used_vars (void)
2046 tree var
, outer_block
= DECL_INITIAL (current_function_decl
);
2047 auto_vec
<tree
> maybe_local_decls
;
2048 rtx_insn
*var_end_seq
= NULL
;
2051 bool gen_stack_protect_signal
= false;
2053 /* Compute the phase of the stack frame for this function. */
2055 int align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
2056 int off
= targetm
.starting_frame_offset () % align
;
2057 frame_phase
= off
? align
- off
: 0;
2060 /* Set TREE_USED on all variables in the local_decls. */
2061 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
2062 TREE_USED (var
) = 1;
2063 /* Clear TREE_USED on all variables associated with a block scope. */
2064 clear_tree_used (DECL_INITIAL (current_function_decl
));
2066 init_vars_expansion ();
2068 if (targetm
.use_pseudo_pic_reg ())
2069 pic_offset_table_rtx
= gen_reg_rtx (Pmode
);
2071 for (i
= 0; i
< SA
.map
->num_partitions
; i
++)
2073 if (bitmap_bit_p (SA
.partitions_for_parm_default_defs
, i
))
2076 tree var
= partition_to_var (SA
.map
, i
);
2078 gcc_assert (!virtual_operand_p (var
));
2080 expand_one_ssa_partition (var
);
2083 if (flag_stack_protect
== SPCT_FLAG_STRONG
)
2084 gen_stack_protect_signal
2085 = stack_protect_decl_p () || stack_protect_return_slot_p ();
2087 /* At this point all variables on the local_decls with TREE_USED
2088 set are not associated with any block scope. Lay them out. */
2090 len
= vec_safe_length (cfun
->local_decls
);
2091 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
2093 bool expand_now
= false;
2095 /* Expanded above already. */
2096 if (is_gimple_reg (var
))
2098 TREE_USED (var
) = 0;
2101 /* We didn't set a block for static or extern because it's hard
2102 to tell the difference between a global variable (re)declared
2103 in a local scope, and one that's really declared there to
2104 begin with. And it doesn't really matter much, since we're
2105 not giving them stack space. Expand them now. */
2106 else if (TREE_STATIC (var
) || DECL_EXTERNAL (var
))
2109 /* Expand variables not associated with any block now. Those created by
2110 the optimizers could be live anywhere in the function. Those that
2111 could possibly have been scoped originally and detached from their
2112 block will have their allocation deferred so we coalesce them with
2113 others when optimization is enabled. */
2114 else if (TREE_USED (var
))
2117 /* Finally, mark all variables on the list as used. We'll use
2118 this in a moment when we expand those associated with scopes. */
2119 TREE_USED (var
) = 1;
2122 expand_one_var (var
, true, true);
2125 if (DECL_ARTIFICIAL (var
) && !DECL_IGNORED_P (var
))
2127 rtx rtl
= DECL_RTL_IF_SET (var
);
2129 /* Keep artificial non-ignored vars in cfun->local_decls
2130 chain until instantiate_decls. */
2131 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
2132 add_local_decl (cfun
, var
);
2133 else if (rtl
== NULL_RTX
)
2134 /* If rtl isn't set yet, which can happen e.g. with
2135 -fstack-protector, retry before returning from this
2137 maybe_local_decls
.safe_push (var
);
2141 /* We duplicated some of the decls in CFUN->LOCAL_DECLS.
2143 +-----------------+-----------------+
2144 | ...processed... | ...duplicates...|
2145 +-----------------+-----------------+
2147 +-- LEN points here.
2149 We just want the duplicates, as those are the artificial
2150 non-ignored vars that we want to keep until instantiate_decls.
2151 Move them down and truncate the array. */
2152 if (!vec_safe_is_empty (cfun
->local_decls
))
2153 cfun
->local_decls
->block_remove (0, len
);
2155 /* At this point, all variables within the block tree with TREE_USED
2156 set are actually used by the optimized function. Lay them out. */
2157 expand_used_vars_for_block (outer_block
, true);
2159 if (stack_vars_num
> 0)
2161 add_scope_conflicts ();
2163 /* If stack protection is enabled, we don't share space between
2164 vulnerable data and non-vulnerable data. */
2165 if (flag_stack_protect
!= 0
2166 && (flag_stack_protect
!= SPCT_FLAG_EXPLICIT
2167 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
2168 && lookup_attribute ("stack_protect",
2169 DECL_ATTRIBUTES (current_function_decl
)))))
2170 add_stack_protection_conflicts ();
2172 /* Now that we have collected all stack variables, and have computed a
2173 minimal interference graph, attempt to save some stack space. */
2174 partition_stack_vars ();
2176 dump_stack_var_partition ();
2179 switch (flag_stack_protect
)
2182 create_stack_guard ();
2185 case SPCT_FLAG_STRONG
:
2186 if (gen_stack_protect_signal
2187 || cfun
->calls_alloca
|| has_protected_decls
2188 || lookup_attribute ("stack_protect",
2189 DECL_ATTRIBUTES (current_function_decl
)))
2190 create_stack_guard ();
2193 case SPCT_FLAG_DEFAULT
:
2194 if (cfun
->calls_alloca
|| has_protected_decls
2195 || lookup_attribute ("stack_protect",
2196 DECL_ATTRIBUTES (current_function_decl
)))
2197 create_stack_guard ();
2200 case SPCT_FLAG_EXPLICIT
:
2201 if (lookup_attribute ("stack_protect",
2202 DECL_ATTRIBUTES (current_function_decl
)))
2203 create_stack_guard ();
2209 /* Assign rtl to each variable based on these partitions. */
2210 if (stack_vars_num
> 0)
2212 struct stack_vars_data data
;
2214 data
.asan_base
= NULL_RTX
;
2215 data
.asan_alignb
= 0;
2217 /* Reorder decls to be protected by iterating over the variables
2218 array multiple times, and allocating out of each phase in turn. */
2219 /* ??? We could probably integrate this into the qsort we did
2220 earlier, such that we naturally see these variables first,
2221 and thus naturally allocate things in the right order. */
2222 if (has_protected_decls
)
2224 /* Phase 1 contains only character arrays. */
2225 expand_stack_vars (stack_protect_decl_phase_1
, &data
);
2227 /* Phase 2 contains other kinds of arrays. */
2228 if (flag_stack_protect
== SPCT_FLAG_ALL
2229 || flag_stack_protect
== SPCT_FLAG_STRONG
2230 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
2231 && lookup_attribute ("stack_protect",
2232 DECL_ATTRIBUTES (current_function_decl
))))
2233 expand_stack_vars (stack_protect_decl_phase_2
, &data
);
2236 if (asan_sanitize_stack_p ())
2237 /* Phase 3, any partitions that need asan protection
2238 in addition to phase 1 and 2. */
2239 expand_stack_vars (asan_decl_phase_3
, &data
);
2241 /* ASAN description strings don't yet have a syntax for expressing
2242 polynomial offsets. */
2243 HOST_WIDE_INT prev_offset
;
2244 if (!data
.asan_vec
.is_empty ()
2245 && frame_offset
.is_constant (&prev_offset
))
2247 HOST_WIDE_INT offset
, sz
, redzonesz
;
2248 redzonesz
= ASAN_RED_ZONE_SIZE
;
2249 sz
= data
.asan_vec
[0] - prev_offset
;
2250 if (data
.asan_alignb
> ASAN_RED_ZONE_SIZE
2251 && data
.asan_alignb
<= 4096
2252 && sz
+ ASAN_RED_ZONE_SIZE
>= (int) data
.asan_alignb
)
2253 redzonesz
= ((sz
+ ASAN_RED_ZONE_SIZE
+ data
.asan_alignb
- 1)
2254 & ~(data
.asan_alignb
- HOST_WIDE_INT_1
)) - sz
;
2255 /* Allocating a constant amount of space from a constant
2256 starting offset must give a constant result. */
2257 offset
= (alloc_stack_frame_space (redzonesz
, ASAN_RED_ZONE_SIZE
)
2259 data
.asan_vec
.safe_push (prev_offset
);
2260 data
.asan_vec
.safe_push (offset
);
2261 /* Leave space for alignment if STRICT_ALIGNMENT. */
2262 if (STRICT_ALIGNMENT
)
2263 alloc_stack_frame_space ((GET_MODE_ALIGNMENT (SImode
)
2264 << ASAN_SHADOW_SHIFT
)
2265 / BITS_PER_UNIT
, 1);
2268 = asan_emit_stack_protection (virtual_stack_vars_rtx
,
2271 data
.asan_vec
.address (),
2272 data
.asan_decl_vec
.address (),
2273 data
.asan_vec
.length ());
2276 expand_stack_vars (NULL
, &data
);
2279 if (asan_sanitize_allocas_p () && cfun
->calls_alloca
)
2280 var_end_seq
= asan_emit_allocas_unpoison (virtual_stack_dynamic_rtx
,
2281 virtual_stack_vars_rtx
,
2284 fini_vars_expansion ();
2286 /* If there were any artificial non-ignored vars without rtl
2287 found earlier, see if deferred stack allocation hasn't assigned
2289 FOR_EACH_VEC_ELT_REVERSE (maybe_local_decls
, i
, var
)
2291 rtx rtl
= DECL_RTL_IF_SET (var
);
2293 /* Keep artificial non-ignored vars in cfun->local_decls
2294 chain until instantiate_decls. */
2295 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
2296 add_local_decl (cfun
, var
);
2299 /* If the target requires that FRAME_OFFSET be aligned, do it. */
2300 if (STACK_ALIGNMENT_NEEDED
)
2302 HOST_WIDE_INT align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
2303 if (FRAME_GROWS_DOWNWARD
)
2304 frame_offset
= aligned_lower_bound (frame_offset
, align
);
2306 frame_offset
= aligned_upper_bound (frame_offset
, align
);
2313 /* If we need to produce a detailed dump, print the tree representation
2314 for STMT to the dump file. SINCE is the last RTX after which the RTL
2315 generated for STMT should have been appended. */
2318 maybe_dump_rtl_for_gimple_stmt (gimple
*stmt
, rtx_insn
*since
)
2320 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2322 fprintf (dump_file
, "\n;; ");
2323 print_gimple_stmt (dump_file
, stmt
, 0,
2324 TDF_SLIM
| (dump_flags
& TDF_LINENO
));
2325 fprintf (dump_file
, "\n");
2327 print_rtl (dump_file
, since
? NEXT_INSN (since
) : since
);
2331 /* Maps the blocks that do not contain tree labels to rtx labels. */
2333 static hash_map
<basic_block
, rtx_code_label
*> *lab_rtx_for_bb
;
2335 /* Returns the label_rtx expression for a label starting basic block BB. */
2337 static rtx_code_label
*
2338 label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED
)
2340 gimple_stmt_iterator gsi
;
2343 if (bb
->flags
& BB_RTL
)
2344 return block_label (bb
);
2346 rtx_code_label
**elt
= lab_rtx_for_bb
->get (bb
);
2350 /* Find the tree label if it is present. */
2352 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2356 lab_stmt
= dyn_cast
<glabel
*> (gsi_stmt (gsi
));
2360 lab
= gimple_label_label (lab_stmt
);
2361 if (DECL_NONLOCAL (lab
))
2364 return jump_target_rtx (lab
);
2367 rtx_code_label
*l
= gen_label_rtx ();
2368 lab_rtx_for_bb
->put (bb
, l
);
2373 /* A subroutine of expand_gimple_cond. Given E, a fallthrough edge
2374 of a basic block where we just expanded the conditional at the end,
2375 possibly clean up the CFG and instruction sequence. LAST is the
2376 last instruction before the just emitted jump sequence. */
2379 maybe_cleanup_end_of_block (edge e
, rtx_insn
*last
)
2381 /* Special case: when jumpif decides that the condition is
2382 trivial it emits an unconditional jump (and the necessary
2383 barrier). But we still have two edges, the fallthru one is
2384 wrong. purge_dead_edges would clean this up later. Unfortunately
2385 we have to insert insns (and split edges) before
2386 find_many_sub_basic_blocks and hence before purge_dead_edges.
2387 But splitting edges might create new blocks which depend on the
2388 fact that if there are two edges there's no barrier. So the
2389 barrier would get lost and verify_flow_info would ICE. Instead
2390 of auditing all edge splitters to care for the barrier (which
2391 normally isn't there in a cleaned CFG), fix it here. */
2392 if (BARRIER_P (get_last_insn ()))
2396 /* Now, we have a single successor block, if we have insns to
2397 insert on the remaining edge we potentially will insert
2398 it at the end of this block (if the dest block isn't feasible)
2399 in order to avoid splitting the edge. This insertion will take
2400 place in front of the last jump. But we might have emitted
2401 multiple jumps (conditional and one unconditional) to the
2402 same destination. Inserting in front of the last one then
2403 is a problem. See PR 40021. We fix this by deleting all
2404 jumps except the last unconditional one. */
2405 insn
= PREV_INSN (get_last_insn ());
2406 /* Make sure we have an unconditional jump. Otherwise we're
2408 gcc_assert (JUMP_P (insn
) && !any_condjump_p (insn
));
2409 for (insn
= PREV_INSN (insn
); insn
!= last
;)
2411 insn
= PREV_INSN (insn
);
2412 if (JUMP_P (NEXT_INSN (insn
)))
2414 if (!any_condjump_p (NEXT_INSN (insn
)))
2416 gcc_assert (BARRIER_P (NEXT_INSN (NEXT_INSN (insn
))));
2417 delete_insn (NEXT_INSN (NEXT_INSN (insn
)));
2419 delete_insn (NEXT_INSN (insn
));
2425 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_COND.
2426 Returns a new basic block if we've terminated the current basic
2427 block and created a new one. */
2430 expand_gimple_cond (basic_block bb
, gcond
*stmt
)
2432 basic_block new_bb
, dest
;
2435 rtx_insn
*last2
, *last
;
2436 enum tree_code code
;
2439 code
= gimple_cond_code (stmt
);
2440 op0
= gimple_cond_lhs (stmt
);
2441 op1
= gimple_cond_rhs (stmt
);
2442 /* We're sometimes presented with such code:
2446 This would expand to two comparisons which then later might
2447 be cleaned up by combine. But some pattern matchers like if-conversion
2448 work better when there's only one compare, so make up for this
2449 here as special exception if TER would have made the same change. */
2451 && TREE_CODE (op0
) == SSA_NAME
2452 && TREE_CODE (TREE_TYPE (op0
)) == BOOLEAN_TYPE
2453 && TREE_CODE (op1
) == INTEGER_CST
2454 && ((gimple_cond_code (stmt
) == NE_EXPR
2455 && integer_zerop (op1
))
2456 || (gimple_cond_code (stmt
) == EQ_EXPR
2457 && integer_onep (op1
)))
2458 && bitmap_bit_p (SA
.values
, SSA_NAME_VERSION (op0
)))
2460 gimple
*second
= SSA_NAME_DEF_STMT (op0
);
2461 if (gimple_code (second
) == GIMPLE_ASSIGN
)
2463 enum tree_code code2
= gimple_assign_rhs_code (second
);
2464 if (TREE_CODE_CLASS (code2
) == tcc_comparison
)
2467 op0
= gimple_assign_rhs1 (second
);
2468 op1
= gimple_assign_rhs2 (second
);
2470 /* If jumps are cheap and the target does not support conditional
2471 compare, turn some more codes into jumpy sequences. */
2472 else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4
2473 && targetm
.gen_ccmp_first
== NULL
)
2475 if ((code2
== BIT_AND_EXPR
2476 && TYPE_PRECISION (TREE_TYPE (op0
)) == 1
2477 && TREE_CODE (gimple_assign_rhs2 (second
)) != INTEGER_CST
)
2478 || code2
== TRUTH_AND_EXPR
)
2480 code
= TRUTH_ANDIF_EXPR
;
2481 op0
= gimple_assign_rhs1 (second
);
2482 op1
= gimple_assign_rhs2 (second
);
2484 else if (code2
== BIT_IOR_EXPR
|| code2
== TRUTH_OR_EXPR
)
2486 code
= TRUTH_ORIF_EXPR
;
2487 op0
= gimple_assign_rhs1 (second
);
2488 op1
= gimple_assign_rhs2 (second
);
2494 /* Optimize (x % C1) == C2 or (x % C1) != C2 if it is beneficial
2495 into (x - C2) * C3 < C4. */
2496 if ((code
== EQ_EXPR
|| code
== NE_EXPR
)
2497 && TREE_CODE (op0
) == SSA_NAME
2498 && TREE_CODE (op1
) == INTEGER_CST
)
2499 code
= maybe_optimize_mod_cmp (code
, &op0
, &op1
);
2501 last2
= last
= get_last_insn ();
2503 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
2504 set_curr_insn_location (gimple_location (stmt
));
2506 /* These flags have no purpose in RTL land. */
2507 true_edge
->flags
&= ~EDGE_TRUE_VALUE
;
2508 false_edge
->flags
&= ~EDGE_FALSE_VALUE
;
2510 /* We can either have a pure conditional jump with one fallthru edge or
2511 two-way jump that needs to be decomposed into two basic blocks. */
2512 if (false_edge
->dest
== bb
->next_bb
)
2514 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2515 true_edge
->probability
);
2516 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2517 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2518 set_curr_insn_location (true_edge
->goto_locus
);
2519 false_edge
->flags
|= EDGE_FALLTHRU
;
2520 maybe_cleanup_end_of_block (false_edge
, last
);
2523 if (true_edge
->dest
== bb
->next_bb
)
2525 jumpifnot_1 (code
, op0
, op1
, label_rtx_for_bb (false_edge
->dest
),
2526 false_edge
->probability
);
2527 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2528 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2529 set_curr_insn_location (false_edge
->goto_locus
);
2530 true_edge
->flags
|= EDGE_FALLTHRU
;
2531 maybe_cleanup_end_of_block (true_edge
, last
);
2535 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2536 true_edge
->probability
);
2537 last
= get_last_insn ();
2538 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2539 set_curr_insn_location (false_edge
->goto_locus
);
2540 emit_jump (label_rtx_for_bb (false_edge
->dest
));
2543 if (BARRIER_P (BB_END (bb
)))
2544 BB_END (bb
) = PREV_INSN (BB_END (bb
));
2545 update_bb_for_insn (bb
);
2547 new_bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
2548 dest
= false_edge
->dest
;
2549 redirect_edge_succ (false_edge
, new_bb
);
2550 false_edge
->flags
|= EDGE_FALLTHRU
;
2551 new_bb
->count
= false_edge
->count ();
2552 loop_p loop
= find_common_loop (bb
->loop_father
, dest
->loop_father
);
2553 add_bb_to_loop (new_bb
, loop
);
2554 if (loop
->latch
== bb
2555 && loop
->header
== dest
)
2556 loop
->latch
= new_bb
;
2557 make_single_succ_edge (new_bb
, dest
, 0);
2558 if (BARRIER_P (BB_END (new_bb
)))
2559 BB_END (new_bb
) = PREV_INSN (BB_END (new_bb
));
2560 update_bb_for_insn (new_bb
);
2562 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
2564 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2566 set_curr_insn_location (true_edge
->goto_locus
);
2567 true_edge
->goto_locus
= curr_insn_location ();
2573 /* Mark all calls that can have a transaction restart. */
2576 mark_transaction_restart_calls (gimple
*stmt
)
2578 struct tm_restart_node dummy
;
2579 tm_restart_node
**slot
;
2581 if (!cfun
->gimple_df
->tm_restart
)
2585 slot
= cfun
->gimple_df
->tm_restart
->find_slot (&dummy
, NO_INSERT
);
2588 struct tm_restart_node
*n
= *slot
;
2589 tree list
= n
->label_or_list
;
2592 for (insn
= next_real_insn (get_last_insn ());
2594 insn
= next_real_insn (insn
))
2597 if (TREE_CODE (list
) == LABEL_DECL
)
2598 add_reg_note (insn
, REG_TM
, label_rtx (list
));
2600 for (; list
; list
= TREE_CHAIN (list
))
2601 add_reg_note (insn
, REG_TM
, label_rtx (TREE_VALUE (list
)));
2605 /* A subroutine of expand_gimple_stmt_1, expanding one GIMPLE_CALL
2609 expand_call_stmt (gcall
*stmt
)
2611 tree exp
, decl
, lhs
;
2615 if (gimple_call_internal_p (stmt
))
2617 expand_internal_call (stmt
);
2621 /* If this is a call to a built-in function and it has no effect other
2622 than setting the lhs, try to implement it using an internal function
2624 decl
= gimple_call_fndecl (stmt
);
2625 if (gimple_call_lhs (stmt
)
2626 && !gimple_has_side_effects (stmt
)
2627 && (optimize
|| (decl
&& called_as_built_in (decl
))))
2629 internal_fn ifn
= replacement_internal_fn (stmt
);
2630 if (ifn
!= IFN_LAST
)
2632 expand_internal_call (ifn
, stmt
);
2637 exp
= build_vl_exp (CALL_EXPR
, gimple_call_num_args (stmt
) + 3);
2639 CALL_EXPR_FN (exp
) = gimple_call_fn (stmt
);
2640 builtin_p
= decl
&& fndecl_built_in_p (decl
);
2642 /* If this is not a builtin function, the function type through which the
2643 call is made may be different from the type of the function. */
2646 = fold_convert (build_pointer_type (gimple_call_fntype (stmt
)),
2647 CALL_EXPR_FN (exp
));
2649 TREE_TYPE (exp
) = gimple_call_return_type (stmt
);
2650 CALL_EXPR_STATIC_CHAIN (exp
) = gimple_call_chain (stmt
);
2652 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2654 tree arg
= gimple_call_arg (stmt
, i
);
2656 /* TER addresses into arguments of builtin functions so we have a
2657 chance to infer more correct alignment information. See PR39954. */
2659 && TREE_CODE (arg
) == SSA_NAME
2660 && (def
= get_gimple_for_ssa_name (arg
))
2661 && gimple_assign_rhs_code (def
) == ADDR_EXPR
)
2662 arg
= gimple_assign_rhs1 (def
);
2663 CALL_EXPR_ARG (exp
, i
) = arg
;
2666 if (gimple_has_side_effects (stmt
))
2667 TREE_SIDE_EFFECTS (exp
) = 1;
2669 if (gimple_call_nothrow_p (stmt
))
2670 TREE_NOTHROW (exp
) = 1;
2672 if (gimple_no_warning_p (stmt
))
2673 TREE_NO_WARNING (exp
) = 1;
2675 CALL_EXPR_TAILCALL (exp
) = gimple_call_tail_p (stmt
);
2676 CALL_EXPR_MUST_TAIL_CALL (exp
) = gimple_call_must_tail_p (stmt
);
2677 CALL_EXPR_RETURN_SLOT_OPT (exp
) = gimple_call_return_slot_opt_p (stmt
);
2679 && fndecl_built_in_p (decl
, BUILT_IN_NORMAL
)
2680 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (decl
)))
2681 CALL_ALLOCA_FOR_VAR_P (exp
) = gimple_call_alloca_for_var_p (stmt
);
2683 CALL_FROM_THUNK_P (exp
) = gimple_call_from_thunk_p (stmt
);
2684 CALL_EXPR_VA_ARG_PACK (exp
) = gimple_call_va_arg_pack_p (stmt
);
2685 CALL_EXPR_BY_DESCRIPTOR (exp
) = gimple_call_by_descriptor_p (stmt
);
2686 SET_EXPR_LOCATION (exp
, gimple_location (stmt
));
2688 /* Ensure RTL is created for debug args. */
2689 if (decl
&& DECL_HAS_DEBUG_ARGS_P (decl
))
2691 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (decl
);
2696 for (ix
= 1; (*debug_args
)->iterate (ix
, &dtemp
); ix
+= 2)
2698 gcc_assert (TREE_CODE (dtemp
) == DEBUG_EXPR_DECL
);
2699 expand_debug_expr (dtemp
);
2703 rtx_insn
*before_call
= get_last_insn ();
2704 lhs
= gimple_call_lhs (stmt
);
2706 expand_assignment (lhs
, exp
, false);
2708 expand_expr (exp
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2710 /* If the gimple call is an indirect call and has 'nocf_check'
2711 attribute find a generated CALL insn to mark it as no
2712 control-flow verification is needed. */
2713 if (gimple_call_nocf_check_p (stmt
)
2714 && !gimple_call_fndecl (stmt
))
2716 rtx_insn
*last
= get_last_insn ();
2717 while (!CALL_P (last
)
2718 && last
!= before_call
)
2719 last
= PREV_INSN (last
);
2721 if (last
!= before_call
)
2722 add_reg_note (last
, REG_CALL_NOCF_CHECK
, const0_rtx
);
2725 mark_transaction_restart_calls (stmt
);
2729 /* Generate RTL for an asm statement (explicit assembler code).
2730 STRING is a STRING_CST node containing the assembler code text,
2731 or an ADDR_EXPR containing a STRING_CST. VOL nonzero means the
2732 insn is volatile; don't optimize it. */
2735 expand_asm_loc (tree string
, int vol
, location_t locus
)
2739 body
= gen_rtx_ASM_INPUT_loc (VOIDmode
,
2740 ggc_strdup (TREE_STRING_POINTER (string
)),
2743 MEM_VOLATILE_P (body
) = vol
;
2745 /* Non-empty basic ASM implicitly clobbers memory. */
2746 if (TREE_STRING_LENGTH (string
) != 0)
2749 unsigned i
, nclobbers
;
2750 auto_vec
<rtx
> input_rvec
, output_rvec
;
2751 auto_vec
<const char *> constraints
;
2752 auto_vec
<rtx
> clobber_rvec
;
2753 HARD_REG_SET clobbered_regs
;
2754 CLEAR_HARD_REG_SET (clobbered_regs
);
2756 clob
= gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
));
2757 clobber_rvec
.safe_push (clob
);
2759 if (targetm
.md_asm_adjust
)
2760 targetm
.md_asm_adjust (output_rvec
, input_rvec
,
2761 constraints
, clobber_rvec
,
2765 nclobbers
= clobber_rvec
.length ();
2766 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (1 + nclobbers
));
2768 XVECEXP (body
, 0, 0) = asm_op
;
2769 for (i
= 0; i
< nclobbers
; i
++)
2770 XVECEXP (body
, 0, i
+ 1) = gen_rtx_CLOBBER (VOIDmode
, clobber_rvec
[i
]);
2776 /* Return the number of times character C occurs in string S. */
2778 n_occurrences (int c
, const char *s
)
2786 /* A subroutine of expand_asm_operands. Check that all operands have
2787 the same number of alternatives. Return true if so. */
2790 check_operand_nalternatives (const vec
<const char *> &constraints
)
2792 unsigned len
= constraints
.length();
2795 int nalternatives
= n_occurrences (',', constraints
[0]);
2797 if (nalternatives
+ 1 > MAX_RECOG_ALTERNATIVES
)
2799 error ("too many alternatives in %<asm%>");
2803 for (unsigned i
= 1; i
< len
; ++i
)
2804 if (n_occurrences (',', constraints
[i
]) != nalternatives
)
2806 error ("operand constraints for %<asm%> differ "
2807 "in number of alternatives");
2814 /* Check for overlap between registers marked in CLOBBERED_REGS and
2815 anything inappropriate in T. Emit error and return the register
2816 variable definition for error, NULL_TREE for ok. */
2819 tree_conflicts_with_clobbers_p (tree t
, HARD_REG_SET
*clobbered_regs
)
2821 /* Conflicts between asm-declared register variables and the clobber
2822 list are not allowed. */
2823 tree overlap
= tree_overlaps_hard_reg_set (t
, clobbered_regs
);
2827 error ("asm-specifier for variable %qE conflicts with asm clobber list",
2828 DECL_NAME (overlap
));
2830 /* Reset registerness to stop multiple errors emitted for a single
2832 DECL_REGISTER (overlap
) = 0;
2839 /* Generate RTL for an asm statement with arguments.
2840 STRING is the instruction template.
2841 OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
2842 Each output or input has an expression in the TREE_VALUE and
2843 a tree list in TREE_PURPOSE which in turn contains a constraint
2844 name in TREE_VALUE (or NULL_TREE) and a constraint string
2846 CLOBBERS is a list of STRING_CST nodes each naming a hard register
2847 that is clobbered by this insn.
2849 LABELS is a list of labels, and if LABELS is non-NULL, FALLTHRU_BB
2850 should be the fallthru basic block of the asm goto.
2852 Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
2853 Some elements of OUTPUTS may be replaced with trees representing temporary
2854 values. The caller should copy those temporary values to the originally
2857 VOL nonzero means the insn is volatile; don't optimize it. */
2860 expand_asm_stmt (gasm
*stmt
)
2862 class save_input_location
2867 explicit save_input_location(location_t where
)
2869 old
= input_location
;
2870 input_location
= where
;
2873 ~save_input_location()
2875 input_location
= old
;
2879 location_t locus
= gimple_location (stmt
);
2881 if (gimple_asm_input_p (stmt
))
2883 const char *s
= gimple_asm_string (stmt
);
2884 tree string
= build_string (strlen (s
), s
);
2885 expand_asm_loc (string
, gimple_asm_volatile_p (stmt
), locus
);
2889 /* There are some legacy diagnostics in here, and also avoids a
2890 sixth parameger to targetm.md_asm_adjust. */
2891 save_input_location
s_i_l(locus
);
2893 unsigned noutputs
= gimple_asm_noutputs (stmt
);
2894 unsigned ninputs
= gimple_asm_ninputs (stmt
);
2895 unsigned nlabels
= gimple_asm_nlabels (stmt
);
2898 /* ??? Diagnose during gimplification? */
2899 if (ninputs
+ noutputs
+ nlabels
> MAX_RECOG_OPERANDS
)
2901 error ("more than %d operands in %<asm%>", MAX_RECOG_OPERANDS
);
2905 auto_vec
<tree
, MAX_RECOG_OPERANDS
> output_tvec
;
2906 auto_vec
<tree
, MAX_RECOG_OPERANDS
> input_tvec
;
2907 auto_vec
<const char *, MAX_RECOG_OPERANDS
> constraints
;
2909 /* Copy the gimple vectors into new vectors that we can manipulate. */
2911 output_tvec
.safe_grow (noutputs
);
2912 input_tvec
.safe_grow (ninputs
);
2913 constraints
.safe_grow (noutputs
+ ninputs
);
2915 for (i
= 0; i
< noutputs
; ++i
)
2917 tree t
= gimple_asm_output_op (stmt
, i
);
2918 output_tvec
[i
] = TREE_VALUE (t
);
2919 constraints
[i
] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
2921 for (i
= 0; i
< ninputs
; i
++)
2923 tree t
= gimple_asm_input_op (stmt
, i
);
2924 input_tvec
[i
] = TREE_VALUE (t
);
2925 constraints
[i
+ noutputs
]
2926 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
2929 /* ??? Diagnose during gimplification? */
2930 if (! check_operand_nalternatives (constraints
))
2933 /* Count the number of meaningful clobbered registers, ignoring what
2934 we would ignore later. */
2935 auto_vec
<rtx
> clobber_rvec
;
2936 HARD_REG_SET clobbered_regs
;
2937 CLEAR_HARD_REG_SET (clobbered_regs
);
2939 if (unsigned n
= gimple_asm_nclobbers (stmt
))
2941 clobber_rvec
.reserve (n
);
2942 for (i
= 0; i
< n
; i
++)
2944 tree t
= gimple_asm_clobber_op (stmt
, i
);
2945 const char *regname
= TREE_STRING_POINTER (TREE_VALUE (t
));
2948 j
= decode_reg_name_and_count (regname
, &nregs
);
2953 /* ??? Diagnose during gimplification? */
2954 error ("unknown register name %qs in %<asm%>", regname
);
2958 rtx x
= gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
));
2959 clobber_rvec
.safe_push (x
);
2963 /* Otherwise we should have -1 == empty string
2964 or -3 == cc, which is not a register. */
2965 gcc_assert (j
== -1 || j
== -3);
2969 for (int reg
= j
; reg
< j
+ nregs
; reg
++)
2971 /* Clobbering the PIC register is an error. */
2972 if (reg
== (int) PIC_OFFSET_TABLE_REGNUM
)
2974 /* ??? Diagnose during gimplification? */
2975 error ("PIC register clobbered by %qs in %<asm%>",
2980 SET_HARD_REG_BIT (clobbered_regs
, reg
);
2981 rtx x
= gen_rtx_REG (reg_raw_mode
[reg
], reg
);
2982 clobber_rvec
.safe_push (x
);
2986 unsigned nclobbers
= clobber_rvec
.length();
2988 /* First pass over inputs and outputs checks validity and sets
2989 mark_addressable if needed. */
2990 /* ??? Diagnose during gimplification? */
2992 for (i
= 0; i
< noutputs
; ++i
)
2994 tree val
= output_tvec
[i
];
2995 tree type
= TREE_TYPE (val
);
2996 const char *constraint
;
3001 /* Try to parse the output constraint. If that fails, there's
3002 no point in going further. */
3003 constraint
= constraints
[i
];
3004 if (!parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
3005 &allows_mem
, &allows_reg
, &is_inout
))
3012 && REG_P (DECL_RTL (val
))
3013 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
))))
3014 mark_addressable (val
);
3017 for (i
= 0; i
< ninputs
; ++i
)
3019 bool allows_reg
, allows_mem
;
3020 const char *constraint
;
3022 constraint
= constraints
[i
+ noutputs
];
3023 if (! parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
3024 constraints
.address (),
3025 &allows_mem
, &allows_reg
))
3028 if (! allows_reg
&& allows_mem
)
3029 mark_addressable (input_tvec
[i
]);
3032 /* Second pass evaluates arguments. */
3034 /* Make sure stack is consistent for asm goto. */
3036 do_pending_stack_adjust ();
3037 int old_generating_concat_p
= generating_concat_p
;
3039 /* Vector of RTX's of evaluated output operands. */
3040 auto_vec
<rtx
, MAX_RECOG_OPERANDS
> output_rvec
;
3041 auto_vec
<int, MAX_RECOG_OPERANDS
> inout_opnum
;
3042 rtx_insn
*after_rtl_seq
= NULL
, *after_rtl_end
= NULL
;
3044 output_rvec
.safe_grow (noutputs
);
3046 for (i
= 0; i
< noutputs
; ++i
)
3048 tree val
= output_tvec
[i
];
3049 tree type
= TREE_TYPE (val
);
3050 bool is_inout
, allows_reg
, allows_mem
, ok
;
3053 ok
= parse_output_constraint (&constraints
[i
], i
, ninputs
,
3054 noutputs
, &allows_mem
, &allows_reg
,
3058 /* If an output operand is not a decl or indirect ref and our constraint
3059 allows a register, make a temporary to act as an intermediate.
3060 Make the asm insn write into that, then we will copy it to
3061 the real output operand. Likewise for promoted variables. */
3063 generating_concat_p
= 0;
3065 if ((TREE_CODE (val
) == INDIRECT_REF
&& allows_mem
)
3067 && (allows_mem
|| REG_P (DECL_RTL (val
)))
3068 && ! (REG_P (DECL_RTL (val
))
3069 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
)))
3072 || TREE_ADDRESSABLE (type
))
3074 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
3075 !allows_reg
? EXPAND_MEMORY
: EXPAND_WRITE
);
3077 op
= validize_mem (op
);
3079 if (! allows_reg
&& !MEM_P (op
))
3080 error ("output number %d not directly addressable", i
);
3081 if ((! allows_mem
&& MEM_P (op
) && GET_MODE (op
) != BLKmode
)
3082 || GET_CODE (op
) == CONCAT
)
3085 op
= gen_reg_rtx (GET_MODE (op
));
3087 generating_concat_p
= old_generating_concat_p
;
3090 emit_move_insn (op
, old_op
);
3092 push_to_sequence2 (after_rtl_seq
, after_rtl_end
);
3093 emit_move_insn (old_op
, op
);
3094 after_rtl_seq
= get_insns ();
3095 after_rtl_end
= get_last_insn ();
3101 op
= assign_temp (type
, 0, 1);
3102 op
= validize_mem (op
);
3103 if (!MEM_P (op
) && TREE_CODE (val
) == SSA_NAME
)
3104 set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (val
), op
);
3106 generating_concat_p
= old_generating_concat_p
;
3108 push_to_sequence2 (after_rtl_seq
, after_rtl_end
);
3109 expand_assignment (val
, make_tree (type
, op
), false);
3110 after_rtl_seq
= get_insns ();
3111 after_rtl_end
= get_last_insn ();
3114 output_rvec
[i
] = op
;
3117 inout_opnum
.safe_push (i
);
3120 auto_vec
<rtx
, MAX_RECOG_OPERANDS
> input_rvec
;
3121 auto_vec
<machine_mode
, MAX_RECOG_OPERANDS
> input_mode
;
3123 input_rvec
.safe_grow (ninputs
);
3124 input_mode
.safe_grow (ninputs
);
3126 generating_concat_p
= 0;
3128 for (i
= 0; i
< ninputs
; ++i
)
3130 tree val
= input_tvec
[i
];
3131 tree type
= TREE_TYPE (val
);
3132 bool allows_reg
, allows_mem
, ok
;
3133 const char *constraint
;
3136 constraint
= constraints
[i
+ noutputs
];
3137 ok
= parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
3138 constraints
.address (),
3139 &allows_mem
, &allows_reg
);
3142 /* EXPAND_INITIALIZER will not generate code for valid initializer
3143 constants, but will still generate code for other types of operand.
3144 This is the behavior we want for constant constraints. */
3145 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
3146 allows_reg
? EXPAND_NORMAL
3147 : allows_mem
? EXPAND_MEMORY
3148 : EXPAND_INITIALIZER
);
3150 /* Never pass a CONCAT to an ASM. */
3151 if (GET_CODE (op
) == CONCAT
)
3152 op
= force_reg (GET_MODE (op
), op
);
3153 else if (MEM_P (op
))
3154 op
= validize_mem (op
);
3156 if (asm_operand_ok (op
, constraint
, NULL
) <= 0)
3158 if (allows_reg
&& TYPE_MODE (type
) != BLKmode
)
3159 op
= force_reg (TYPE_MODE (type
), op
);
3160 else if (!allows_mem
)
3161 warning (0, "asm operand %d probably doesn%'t match constraints",
3163 else if (MEM_P (op
))
3165 /* We won't recognize either volatile memory or memory
3166 with a queued address as available a memory_operand
3167 at this point. Ignore it: clearly this *is* a memory. */
3173 input_mode
[i
] = TYPE_MODE (type
);
3176 /* For in-out operands, copy output rtx to input rtx. */
3177 unsigned ninout
= inout_opnum
.length();
3178 for (i
= 0; i
< ninout
; i
++)
3180 int j
= inout_opnum
[i
];
3181 rtx o
= output_rvec
[j
];
3183 input_rvec
.safe_push (o
);
3184 input_mode
.safe_push (GET_MODE (o
));
3187 sprintf (buffer
, "%d", j
);
3188 constraints
.safe_push (ggc_strdup (buffer
));
3192 /* Sometimes we wish to automatically clobber registers across an asm.
3193 Case in point is when the i386 backend moved from cc0 to a hard reg --
3194 maintaining source-level compatibility means automatically clobbering
3195 the flags register. */
3196 rtx_insn
*after_md_seq
= NULL
;
3197 if (targetm
.md_asm_adjust
)
3198 after_md_seq
= targetm
.md_asm_adjust (output_rvec
, input_rvec
,
3199 constraints
, clobber_rvec
,
3202 /* Do not allow the hook to change the output and input count,
3203 lest it mess up the operand numbering. */
3204 gcc_assert (output_rvec
.length() == noutputs
);
3205 gcc_assert (input_rvec
.length() == ninputs
);
3206 gcc_assert (constraints
.length() == noutputs
+ ninputs
);
3208 /* But it certainly can adjust the clobbers. */
3209 nclobbers
= clobber_rvec
.length();
3211 /* Third pass checks for easy conflicts. */
3212 /* ??? Why are we doing this on trees instead of rtx. */
3214 bool clobber_conflict_found
= 0;
3215 for (i
= 0; i
< noutputs
; ++i
)
3216 if (tree_conflicts_with_clobbers_p (output_tvec
[i
], &clobbered_regs
))
3217 clobber_conflict_found
= 1;
3218 for (i
= 0; i
< ninputs
- ninout
; ++i
)
3219 if (tree_conflicts_with_clobbers_p (input_tvec
[i
], &clobbered_regs
))
3220 clobber_conflict_found
= 1;
3222 /* Make vectors for the expression-rtx, constraint strings,
3223 and named operands. */
3225 rtvec argvec
= rtvec_alloc (ninputs
);
3226 rtvec constraintvec
= rtvec_alloc (ninputs
);
3227 rtvec labelvec
= rtvec_alloc (nlabels
);
3229 rtx body
= gen_rtx_ASM_OPERANDS ((noutputs
== 0 ? VOIDmode
3230 : GET_MODE (output_rvec
[0])),
3231 ggc_strdup (gimple_asm_string (stmt
)),
3232 "", 0, argvec
, constraintvec
,
3234 MEM_VOLATILE_P (body
) = gimple_asm_volatile_p (stmt
);
3236 for (i
= 0; i
< ninputs
; ++i
)
3238 ASM_OPERANDS_INPUT (body
, i
) = input_rvec
[i
];
3239 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body
, i
)
3240 = gen_rtx_ASM_INPUT_loc (input_mode
[i
],
3241 constraints
[i
+ noutputs
],
3245 /* Copy labels to the vector. */
3246 rtx_code_label
*fallthru_label
= NULL
;
3249 basic_block fallthru_bb
= NULL
;
3250 edge fallthru
= find_fallthru_edge (gimple_bb (stmt
)->succs
);
3252 fallthru_bb
= fallthru
->dest
;
3254 for (i
= 0; i
< nlabels
; ++i
)
3256 tree label
= TREE_VALUE (gimple_asm_label_op (stmt
, i
));
3258 /* If asm goto has any labels in the fallthru basic block, use
3259 a label that we emit immediately after the asm goto. Expansion
3260 may insert further instructions into the same basic block after
3261 asm goto and if we don't do this, insertion of instructions on
3262 the fallthru edge might misbehave. See PR58670. */
3263 if (fallthru_bb
&& label_to_block (cfun
, label
) == fallthru_bb
)
3265 if (fallthru_label
== NULL_RTX
)
3266 fallthru_label
= gen_label_rtx ();
3270 r
= label_rtx (label
);
3271 ASM_OPERANDS_LABEL (body
, i
) = gen_rtx_LABEL_REF (Pmode
, r
);
3275 /* Now, for each output, construct an rtx
3276 (set OUTPUT (asm_operands INSN OUTPUTCONSTRAINT OUTPUTNUMBER
3277 ARGVEC CONSTRAINTS OPNAMES))
3278 If there is more than one, put them inside a PARALLEL. */
3280 if (nlabels
> 0 && nclobbers
== 0)
3282 gcc_assert (noutputs
== 0);
3283 emit_jump_insn (body
);
3285 else if (noutputs
== 0 && nclobbers
== 0)
3287 /* No output operands: put in a raw ASM_OPERANDS rtx. */
3290 else if (noutputs
== 1 && nclobbers
== 0)
3292 ASM_OPERANDS_OUTPUT_CONSTRAINT (body
) = constraints
[0];
3293 emit_insn (gen_rtx_SET (output_rvec
[0], body
));
3303 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (num
+ nclobbers
));
3305 /* For each output operand, store a SET. */
3306 for (i
= 0; i
< noutputs
; ++i
)
3308 rtx src
, o
= output_rvec
[i
];
3311 ASM_OPERANDS_OUTPUT_CONSTRAINT (obody
) = constraints
[0];
3316 src
= gen_rtx_ASM_OPERANDS (GET_MODE (o
),
3317 ASM_OPERANDS_TEMPLATE (obody
),
3318 constraints
[i
], i
, argvec
,
3319 constraintvec
, labelvec
, locus
);
3320 MEM_VOLATILE_P (src
) = gimple_asm_volatile_p (stmt
);
3322 XVECEXP (body
, 0, i
) = gen_rtx_SET (o
, src
);
3325 /* If there are no outputs (but there are some clobbers)
3326 store the bare ASM_OPERANDS into the PARALLEL. */
3328 XVECEXP (body
, 0, i
++) = obody
;
3330 /* Store (clobber REG) for each clobbered register specified. */
3331 for (unsigned j
= 0; j
< nclobbers
; ++j
)
3333 rtx clobbered_reg
= clobber_rvec
[j
];
3335 /* Do sanity check for overlap between clobbers and respectively
3336 input and outputs that hasn't been handled. Such overlap
3337 should have been detected and reported above. */
3338 if (!clobber_conflict_found
&& REG_P (clobbered_reg
))
3340 /* We test the old body (obody) contents to avoid
3341 tripping over the under-construction body. */
3342 for (unsigned k
= 0; k
< noutputs
; ++k
)
3343 if (reg_overlap_mentioned_p (clobbered_reg
, output_rvec
[k
]))
3344 internal_error ("asm clobber conflict with output operand");
3346 for (unsigned k
= 0; k
< ninputs
- ninout
; ++k
)
3347 if (reg_overlap_mentioned_p (clobbered_reg
, input_rvec
[k
]))
3348 internal_error ("asm clobber conflict with input operand");
3351 XVECEXP (body
, 0, i
++) = gen_rtx_CLOBBER (VOIDmode
, clobbered_reg
);
3355 emit_jump_insn (body
);
3360 generating_concat_p
= old_generating_concat_p
;
3363 emit_label (fallthru_label
);
3366 emit_insn (after_md_seq
);
3368 emit_insn (after_rtl_seq
);
3371 crtl
->has_asm_statement
= 1;
3374 /* Emit code to jump to the address
3375 specified by the pointer expression EXP. */
3378 expand_computed_goto (tree exp
)
3380 rtx x
= expand_normal (exp
);
3382 do_pending_stack_adjust ();
3383 emit_indirect_jump (x
);
3386 /* Generate RTL code for a `goto' statement with target label LABEL.
3387 LABEL should be a LABEL_DECL tree node that was or will later be
3388 defined with `expand_label'. */
3391 expand_goto (tree label
)
3395 /* Check for a nonlocal goto to a containing function. Should have
3396 gotten translated to __builtin_nonlocal_goto. */
3397 tree context
= decl_function_context (label
);
3398 gcc_assert (!context
|| context
== current_function_decl
);
3401 emit_jump (jump_target_rtx (label
));
3404 /* Output a return with no value. */
3407 expand_null_return_1 (void)
3409 clear_pending_stack_adjust ();
3410 do_pending_stack_adjust ();
3411 emit_jump (return_label
);
3414 /* Generate RTL to return from the current function, with no value.
3415 (That is, we do not do anything about returning any value.) */
3418 expand_null_return (void)
3420 /* If this function was declared to return a value, but we
3421 didn't, clobber the return registers so that they are not
3422 propagated live to the rest of the function. */
3423 clobber_return_register ();
3425 expand_null_return_1 ();
3428 /* Generate RTL to return from the current function, with value VAL. */
3431 expand_value_return (rtx val
)
3433 /* Copy the value to the return location unless it's already there. */
3435 tree decl
= DECL_RESULT (current_function_decl
);
3436 rtx return_reg
= DECL_RTL (decl
);
3437 if (return_reg
!= val
)
3439 tree funtype
= TREE_TYPE (current_function_decl
);
3440 tree type
= TREE_TYPE (decl
);
3441 int unsignedp
= TYPE_UNSIGNED (type
);
3442 machine_mode old_mode
= DECL_MODE (decl
);
3444 if (DECL_BY_REFERENCE (decl
))
3445 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 2);
3447 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 1);
3449 if (mode
!= old_mode
)
3450 val
= convert_modes (mode
, old_mode
, val
, unsignedp
);
3452 if (GET_CODE (return_reg
) == PARALLEL
)
3453 emit_group_load (return_reg
, val
, type
, int_size_in_bytes (type
));
3455 emit_move_insn (return_reg
, val
);
3458 expand_null_return_1 ();
3461 /* Generate RTL to evaluate the expression RETVAL and return it
3462 from the current function. */
3465 expand_return (tree retval
)
3471 /* If function wants no value, give it none. */
3472 if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl
))) == VOID_TYPE
)
3474 expand_normal (retval
);
3475 expand_null_return ();
3479 if (retval
== error_mark_node
)
3481 /* Treat this like a return of no value from a function that
3483 expand_null_return ();
3486 else if ((TREE_CODE (retval
) == MODIFY_EXPR
3487 || TREE_CODE (retval
) == INIT_EXPR
)
3488 && TREE_CODE (TREE_OPERAND (retval
, 0)) == RESULT_DECL
)
3489 retval_rhs
= TREE_OPERAND (retval
, 1);
3491 retval_rhs
= retval
;
3493 result_rtl
= DECL_RTL (DECL_RESULT (current_function_decl
));
3495 /* If we are returning the RESULT_DECL, then the value has already
3496 been stored into it, so we don't have to do anything special. */
3497 if (TREE_CODE (retval_rhs
) == RESULT_DECL
)
3498 expand_value_return (result_rtl
);
3500 /* If the result is an aggregate that is being returned in one (or more)
3501 registers, load the registers here. */
3503 else if (retval_rhs
!= 0
3504 && TYPE_MODE (TREE_TYPE (retval_rhs
)) == BLKmode
3505 && REG_P (result_rtl
))
3507 val
= copy_blkmode_to_reg (GET_MODE (result_rtl
), retval_rhs
);
3510 /* Use the mode of the result value on the return register. */
3511 PUT_MODE (result_rtl
, GET_MODE (val
));
3512 expand_value_return (val
);
3515 expand_null_return ();
3517 else if (retval_rhs
!= 0
3518 && !VOID_TYPE_P (TREE_TYPE (retval_rhs
))
3519 && (REG_P (result_rtl
)
3520 || (GET_CODE (result_rtl
) == PARALLEL
)))
3522 /* Compute the return value into a temporary (usually a pseudo reg). */
3524 = assign_temp (TREE_TYPE (DECL_RESULT (current_function_decl
)), 0, 1);
3525 val
= expand_expr (retval_rhs
, val
, GET_MODE (val
), EXPAND_NORMAL
);
3526 val
= force_not_mem (val
);
3527 expand_value_return (val
);
3531 /* No hard reg used; calculate value into hard return reg. */
3532 expand_expr (retval
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3533 expand_value_return (result_rtl
);
3537 /* Expand a clobber of LHS. If LHS is stored it in a multi-part
3538 register, tell the rtl optimizers that its value is no longer
3542 expand_clobber (tree lhs
)
3546 rtx decl_rtl
= DECL_RTL_IF_SET (lhs
);
3547 if (decl_rtl
&& REG_P (decl_rtl
))
3549 machine_mode decl_mode
= GET_MODE (decl_rtl
);
3550 if (maybe_gt (GET_MODE_SIZE (decl_mode
),
3551 REGMODE_NATURAL_SIZE (decl_mode
)))
3552 emit_clobber (decl_rtl
);
3557 /* A subroutine of expand_gimple_stmt, expanding one gimple statement
3558 STMT that doesn't require special handling for outgoing edges. That
3559 is no tailcalls and no GIMPLE_COND. */
3562 expand_gimple_stmt_1 (gimple
*stmt
)
3566 set_curr_insn_location (gimple_location (stmt
));
3568 switch (gimple_code (stmt
))
3571 op0
= gimple_goto_dest (stmt
);
3572 if (TREE_CODE (op0
) == LABEL_DECL
)
3575 expand_computed_goto (op0
);
3578 expand_label (gimple_label_label (as_a
<glabel
*> (stmt
)));
3581 case GIMPLE_PREDICT
:
3585 gswitch
*swtch
= as_a
<gswitch
*> (stmt
);
3586 if (gimple_switch_num_labels (swtch
) == 1)
3587 expand_goto (CASE_LABEL (gimple_switch_default_label (swtch
)));
3589 expand_case (swtch
);
3593 expand_asm_stmt (as_a
<gasm
*> (stmt
));
3596 expand_call_stmt (as_a
<gcall
*> (stmt
));
3601 op0
= gimple_return_retval (as_a
<greturn
*> (stmt
));
3603 if (op0
&& op0
!= error_mark_node
)
3605 tree result
= DECL_RESULT (current_function_decl
);
3607 /* If we are not returning the current function's RESULT_DECL,
3608 build an assignment to it. */
3611 /* I believe that a function's RESULT_DECL is unique. */
3612 gcc_assert (TREE_CODE (op0
) != RESULT_DECL
);
3614 /* ??? We'd like to use simply expand_assignment here,
3615 but this fails if the value is of BLKmode but the return
3616 decl is a register. expand_return has special handling
3617 for this combination, which eventually should move
3618 to common code. See comments there. Until then, let's
3619 build a modify expression :-/ */
3620 op0
= build2 (MODIFY_EXPR
, TREE_TYPE (result
),
3626 expand_null_return ();
3628 expand_return (op0
);
3634 gassign
*assign_stmt
= as_a
<gassign
*> (stmt
);
3635 tree lhs
= gimple_assign_lhs (assign_stmt
);
3637 /* Tree expand used to fiddle with |= and &= of two bitfield
3638 COMPONENT_REFs here. This can't happen with gimple, the LHS
3639 of binary assigns must be a gimple reg. */
3641 if (TREE_CODE (lhs
) != SSA_NAME
3642 || get_gimple_rhs_class (gimple_expr_code (stmt
))
3643 == GIMPLE_SINGLE_RHS
)
3645 tree rhs
= gimple_assign_rhs1 (assign_stmt
);
3646 gcc_assert (get_gimple_rhs_class (gimple_expr_code (stmt
))
3647 == GIMPLE_SINGLE_RHS
);
3648 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (rhs
)
3649 /* Do not put locations on possibly shared trees. */
3650 && !is_gimple_min_invariant (rhs
))
3651 SET_EXPR_LOCATION (rhs
, gimple_location (stmt
));
3652 if (TREE_CLOBBER_P (rhs
))
3653 /* This is a clobber to mark the going out of scope for
3655 expand_clobber (lhs
);
3657 expand_assignment (lhs
, rhs
,
3658 gimple_assign_nontemporal_move_p (
3664 bool nontemporal
= gimple_assign_nontemporal_move_p (assign_stmt
);
3665 struct separate_ops ops
;
3666 bool promoted
= false;
3668 target
= expand_expr (lhs
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
3669 if (GET_CODE (target
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (target
))
3672 ops
.code
= gimple_assign_rhs_code (assign_stmt
);
3673 ops
.type
= TREE_TYPE (lhs
);
3674 switch (get_gimple_rhs_class (ops
.code
))
3676 case GIMPLE_TERNARY_RHS
:
3677 ops
.op2
= gimple_assign_rhs3 (assign_stmt
);
3679 case GIMPLE_BINARY_RHS
:
3680 ops
.op1
= gimple_assign_rhs2 (assign_stmt
);
3682 case GIMPLE_UNARY_RHS
:
3683 ops
.op0
= gimple_assign_rhs1 (assign_stmt
);
3688 ops
.location
= gimple_location (stmt
);
3690 /* If we want to use a nontemporal store, force the value to
3691 register first. If we store into a promoted register,
3692 don't directly expand to target. */
3693 temp
= nontemporal
|| promoted
? NULL_RTX
: target
;
3694 temp
= expand_expr_real_2 (&ops
, temp
, GET_MODE (target
),
3701 int unsignedp
= SUBREG_PROMOTED_SIGN (target
);
3702 /* If TEMP is a VOIDmode constant, use convert_modes to make
3703 sure that we properly convert it. */
3704 if (CONSTANT_P (temp
) && GET_MODE (temp
) == VOIDmode
)
3706 temp
= convert_modes (GET_MODE (target
),
3707 TYPE_MODE (ops
.type
),
3709 temp
= convert_modes (GET_MODE (SUBREG_REG (target
)),
3710 GET_MODE (target
), temp
, unsignedp
);
3713 convert_move (SUBREG_REG (target
), temp
, unsignedp
);
3715 else if (nontemporal
&& emit_storent_insn (target
, temp
))
3719 temp
= force_operand (temp
, target
);
3721 emit_move_insn (target
, temp
);
3732 /* Expand one gimple statement STMT and return the last RTL instruction
3733 before any of the newly generated ones.
3735 In addition to generating the necessary RTL instructions this also
3736 sets REG_EH_REGION notes if necessary and sets the current source
3737 location for diagnostics. */
3740 expand_gimple_stmt (gimple
*stmt
)
3742 location_t saved_location
= input_location
;
3743 rtx_insn
*last
= get_last_insn ();
3748 /* We need to save and restore the current source location so that errors
3749 discovered during expansion are emitted with the right location. But
3750 it would be better if the diagnostic routines used the source location
3751 embedded in the tree nodes rather than globals. */
3752 if (gimple_has_location (stmt
))
3753 input_location
= gimple_location (stmt
);
3755 expand_gimple_stmt_1 (stmt
);
3757 /* Free any temporaries used to evaluate this statement. */
3760 input_location
= saved_location
;
3762 /* Mark all insns that may trap. */
3763 lp_nr
= lookup_stmt_eh_lp (stmt
);
3767 for (insn
= next_real_insn (last
); insn
;
3768 insn
= next_real_insn (insn
))
3770 if (! find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
3771 /* If we want exceptions for non-call insns, any
3772 may_trap_p instruction may throw. */
3773 && GET_CODE (PATTERN (insn
)) != CLOBBER
3774 && GET_CODE (PATTERN (insn
)) != CLOBBER_HIGH
3775 && GET_CODE (PATTERN (insn
)) != USE
3776 && insn_could_throw_p (insn
))
3777 make_reg_eh_region_note (insn
, 0, lp_nr
);
3784 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_CALL
3785 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
3786 generated a tail call (something that might be denied by the ABI
3787 rules governing the call; see calls.c).
3789 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
3790 can still reach the rest of BB. The case here is __builtin_sqrt,
3791 where the NaN result goes through the external function (with a
3792 tailcall) and the normal result happens via a sqrt instruction. */
3795 expand_gimple_tailcall (basic_block bb
, gcall
*stmt
, bool *can_fallthru
)
3797 rtx_insn
*last2
, *last
;
3800 profile_probability probability
;
3802 last2
= last
= expand_gimple_stmt (stmt
);
3804 for (last
= NEXT_INSN (last
); last
; last
= NEXT_INSN (last
))
3805 if (CALL_P (last
) && SIBLING_CALL_P (last
))
3808 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
3810 *can_fallthru
= true;
3814 /* ??? Wouldn't it be better to just reset any pending stack adjust?
3815 Any instructions emitted here are about to be deleted. */
3816 do_pending_stack_adjust ();
3818 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
3819 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
3820 EH or abnormal edges, we shouldn't have created a tail call in
3821 the first place. So it seems to me we should just be removing
3822 all edges here, or redirecting the existing fallthru edge to
3825 probability
= profile_probability::never ();
3827 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
3829 if (!(e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
)))
3831 if (e
->dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
3832 e
->dest
->count
-= e
->count ();
3833 probability
+= e
->probability
;
3840 /* This is somewhat ugly: the call_expr expander often emits instructions
3841 after the sibcall (to perform the function return). These confuse the
3842 find_many_sub_basic_blocks code, so we need to get rid of these. */
3843 last
= NEXT_INSN (last
);
3844 gcc_assert (BARRIER_P (last
));
3846 *can_fallthru
= false;
3847 while (NEXT_INSN (last
))
3849 /* For instance an sqrt builtin expander expands if with
3850 sibcall in the then and label for `else`. */
3851 if (LABEL_P (NEXT_INSN (last
)))
3853 *can_fallthru
= true;
3856 delete_insn (NEXT_INSN (last
));
3859 e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_ABNORMAL
3861 e
->probability
= probability
;
3863 update_bb_for_insn (bb
);
3865 if (NEXT_INSN (last
))
3867 bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
3870 if (BARRIER_P (last
))
3871 BB_END (bb
) = PREV_INSN (last
);
3874 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
3879 /* Return the difference between the floor and the truncated result of
3880 a signed division by OP1 with remainder MOD. */
3882 floor_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3884 /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
3885 return gen_rtx_IF_THEN_ELSE
3886 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3887 gen_rtx_IF_THEN_ELSE
3888 (mode
, gen_rtx_LT (BImode
,
3889 gen_rtx_DIV (mode
, op1
, mod
),
3891 constm1_rtx
, const0_rtx
),
3895 /* Return the difference between the ceil and the truncated result of
3896 a signed division by OP1 with remainder MOD. */
3898 ceil_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3900 /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
3901 return gen_rtx_IF_THEN_ELSE
3902 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3903 gen_rtx_IF_THEN_ELSE
3904 (mode
, gen_rtx_GT (BImode
,
3905 gen_rtx_DIV (mode
, op1
, mod
),
3907 const1_rtx
, const0_rtx
),
3911 /* Return the difference between the ceil and the truncated result of
3912 an unsigned division by OP1 with remainder MOD. */
3914 ceil_udiv_adjust (machine_mode mode
, rtx mod
, rtx op1 ATTRIBUTE_UNUSED
)
3916 /* (mod != 0 ? 1 : 0) */
3917 return gen_rtx_IF_THEN_ELSE
3918 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3919 const1_rtx
, const0_rtx
);
3922 /* Return the difference between the rounded and the truncated result
3923 of a signed division by OP1 with remainder MOD. Halfway cases are
3924 rounded away from zero, rather than to the nearest even number. */
3926 round_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3928 /* (abs (mod) >= abs (op1) - abs (mod)
3929 ? (op1 / mod > 0 ? 1 : -1)
3931 return gen_rtx_IF_THEN_ELSE
3932 (mode
, gen_rtx_GE (BImode
, gen_rtx_ABS (mode
, mod
),
3933 gen_rtx_MINUS (mode
,
3934 gen_rtx_ABS (mode
, op1
),
3935 gen_rtx_ABS (mode
, mod
))),
3936 gen_rtx_IF_THEN_ELSE
3937 (mode
, gen_rtx_GT (BImode
,
3938 gen_rtx_DIV (mode
, op1
, mod
),
3940 const1_rtx
, constm1_rtx
),
3944 /* Return the difference between the rounded and the truncated result
3945 of a unsigned division by OP1 with remainder MOD. Halfway cases
3946 are rounded away from zero, rather than to the nearest even
3949 round_udiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3951 /* (mod >= op1 - mod ? 1 : 0) */
3952 return gen_rtx_IF_THEN_ELSE
3953 (mode
, gen_rtx_GE (BImode
, mod
,
3954 gen_rtx_MINUS (mode
, op1
, mod
)),
3955 const1_rtx
, const0_rtx
);
3958 /* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
3962 convert_debug_memory_address (scalar_int_mode mode
, rtx x
,
3965 #ifndef POINTERS_EXTEND_UNSIGNED
3966 gcc_assert (mode
== Pmode
3967 || mode
== targetm
.addr_space
.address_mode (as
));
3968 gcc_assert (GET_MODE (x
) == mode
|| GET_MODE (x
) == VOIDmode
);
3972 gcc_assert (targetm
.addr_space
.valid_pointer_mode (mode
, as
));
3974 if (GET_MODE (x
) == mode
|| GET_MODE (x
) == VOIDmode
)
3977 /* X must have some form of address mode already. */
3978 scalar_int_mode xmode
= as_a
<scalar_int_mode
> (GET_MODE (x
));
3979 if (GET_MODE_PRECISION (mode
) < GET_MODE_PRECISION (xmode
))
3980 x
= lowpart_subreg (mode
, x
, xmode
);
3981 else if (POINTERS_EXTEND_UNSIGNED
> 0)
3982 x
= gen_rtx_ZERO_EXTEND (mode
, x
);
3983 else if (!POINTERS_EXTEND_UNSIGNED
)
3984 x
= gen_rtx_SIGN_EXTEND (mode
, x
);
3987 switch (GET_CODE (x
))
3990 if ((SUBREG_PROMOTED_VAR_P (x
)
3991 || (REG_P (SUBREG_REG (x
)) && REG_POINTER (SUBREG_REG (x
)))
3992 || (GET_CODE (SUBREG_REG (x
)) == PLUS
3993 && REG_P (XEXP (SUBREG_REG (x
), 0))
3994 && REG_POINTER (XEXP (SUBREG_REG (x
), 0))
3995 && CONST_INT_P (XEXP (SUBREG_REG (x
), 1))))
3996 && GET_MODE (SUBREG_REG (x
)) == mode
)
3997 return SUBREG_REG (x
);
4000 temp
= gen_rtx_LABEL_REF (mode
, label_ref_label (x
));
4001 LABEL_REF_NONLOCAL_P (temp
) = LABEL_REF_NONLOCAL_P (x
);
4004 temp
= shallow_copy_rtx (x
);
4005 PUT_MODE (temp
, mode
);
4008 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
4010 temp
= gen_rtx_CONST (mode
, temp
);
4014 if (CONST_INT_P (XEXP (x
, 1)))
4016 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
4018 return gen_rtx_fmt_ee (GET_CODE (x
), mode
, temp
, XEXP (x
, 1));
4024 /* Don't know how to express ptr_extend as operation in debug info. */
4027 #endif /* POINTERS_EXTEND_UNSIGNED */
4032 /* Map from SSA_NAMEs to corresponding DEBUG_EXPR_DECLs created
4033 by avoid_deep_ter_for_debug. */
4035 static hash_map
<tree
, tree
> *deep_ter_debug_map
;
4037 /* Split too deep TER chains for debug stmts using debug temporaries. */
4040 avoid_deep_ter_for_debug (gimple
*stmt
, int depth
)
4042 use_operand_p use_p
;
4044 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
4046 tree use
= USE_FROM_PTR (use_p
);
4047 if (TREE_CODE (use
) != SSA_NAME
|| SSA_NAME_IS_DEFAULT_DEF (use
))
4049 gimple
*g
= get_gimple_for_ssa_name (use
);
4052 if (depth
> 6 && !stmt_ends_bb_p (g
))
4054 if (deep_ter_debug_map
== NULL
)
4055 deep_ter_debug_map
= new hash_map
<tree
, tree
>;
4057 tree
&vexpr
= deep_ter_debug_map
->get_or_insert (use
);
4060 vexpr
= make_node (DEBUG_EXPR_DECL
);
4061 gimple
*def_temp
= gimple_build_debug_bind (vexpr
, use
, g
);
4062 DECL_ARTIFICIAL (vexpr
) = 1;
4063 TREE_TYPE (vexpr
) = TREE_TYPE (use
);
4064 SET_DECL_MODE (vexpr
, TYPE_MODE (TREE_TYPE (use
)));
4065 gimple_stmt_iterator gsi
= gsi_for_stmt (g
);
4066 gsi_insert_after (&gsi
, def_temp
, GSI_NEW_STMT
);
4067 avoid_deep_ter_for_debug (def_temp
, 0);
4070 avoid_deep_ter_for_debug (g
, depth
+ 1);
4074 /* Return an RTX equivalent to the value of the parameter DECL. */
4077 expand_debug_parm_decl (tree decl
)
4079 rtx incoming
= DECL_INCOMING_RTL (decl
);
4082 && GET_MODE (incoming
) != BLKmode
4083 && ((REG_P (incoming
) && HARD_REGISTER_P (incoming
))
4084 || (MEM_P (incoming
)
4085 && REG_P (XEXP (incoming
, 0))
4086 && HARD_REGISTER_P (XEXP (incoming
, 0)))))
4088 rtx rtl
= gen_rtx_ENTRY_VALUE (GET_MODE (incoming
));
4090 #ifdef HAVE_window_save
4091 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
4092 If the target machine has an explicit window save instruction, the
4093 actual entry value is the corresponding OUTGOING_REGNO instead. */
4094 if (REG_P (incoming
)
4095 && OUTGOING_REGNO (REGNO (incoming
)) != REGNO (incoming
))
4097 = gen_rtx_REG_offset (incoming
, GET_MODE (incoming
),
4098 OUTGOING_REGNO (REGNO (incoming
)), 0);
4099 else if (MEM_P (incoming
))
4101 rtx reg
= XEXP (incoming
, 0);
4102 if (OUTGOING_REGNO (REGNO (reg
)) != REGNO (reg
))
4104 reg
= gen_raw_REG (GET_MODE (reg
), OUTGOING_REGNO (REGNO (reg
)));
4105 incoming
= replace_equiv_address_nv (incoming
, reg
);
4108 incoming
= copy_rtx (incoming
);
4112 ENTRY_VALUE_EXP (rtl
) = incoming
;
4117 && GET_MODE (incoming
) != BLKmode
4118 && !TREE_ADDRESSABLE (decl
)
4120 && (XEXP (incoming
, 0) == virtual_incoming_args_rtx
4121 || (GET_CODE (XEXP (incoming
, 0)) == PLUS
4122 && XEXP (XEXP (incoming
, 0), 0) == virtual_incoming_args_rtx
4123 && CONST_INT_P (XEXP (XEXP (incoming
, 0), 1)))))
4124 return copy_rtx (incoming
);
4129 /* Return an RTX equivalent to the value of the tree expression EXP. */
4132 expand_debug_expr (tree exp
)
4134 rtx op0
= NULL_RTX
, op1
= NULL_RTX
, op2
= NULL_RTX
;
4135 machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
4136 machine_mode inner_mode
= VOIDmode
;
4137 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (exp
));
4139 scalar_int_mode op0_mode
, op1_mode
, addr_mode
;
4141 switch (TREE_CODE_CLASS (TREE_CODE (exp
)))
4143 case tcc_expression
:
4144 switch (TREE_CODE (exp
))
4149 case WIDEN_MULT_PLUS_EXPR
:
4150 case WIDEN_MULT_MINUS_EXPR
:
4153 case TRUTH_ANDIF_EXPR
:
4154 case TRUTH_ORIF_EXPR
:
4155 case TRUTH_AND_EXPR
:
4157 case TRUTH_XOR_EXPR
:
4160 case TRUTH_NOT_EXPR
:
4169 op2
= expand_debug_expr (TREE_OPERAND (exp
, 2));
4176 if (mode
== BLKmode
)
4178 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
4181 switch (TREE_CODE (exp
))
4187 case WIDEN_LSHIFT_EXPR
:
4188 /* Ensure second operand isn't wider than the first one. */
4189 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 1)));
4190 if (is_a
<scalar_int_mode
> (inner_mode
, &op1_mode
)
4191 && (GET_MODE_UNIT_PRECISION (mode
)
4192 < GET_MODE_PRECISION (op1_mode
)))
4193 op1
= lowpart_subreg (GET_MODE_INNER (mode
), op1
, op1_mode
);
4202 if (mode
== BLKmode
)
4204 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4205 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4210 case tcc_comparison
:
4211 unsignedp
= TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4219 case tcc_exceptional
:
4220 case tcc_declaration
:
4226 switch (TREE_CODE (exp
))
4229 if (!lookup_constant_def (exp
))
4231 if (strlen (TREE_STRING_POINTER (exp
)) + 1
4232 != (size_t) TREE_STRING_LENGTH (exp
))
4234 op0
= gen_rtx_CONST_STRING (Pmode
, TREE_STRING_POINTER (exp
));
4235 op0
= gen_rtx_MEM (BLKmode
, op0
);
4236 set_mem_attributes (op0
, exp
, 0);
4244 op0
= expand_expr (exp
, NULL_RTX
, mode
, EXPAND_INITIALIZER
);
4248 return immed_wide_int_const (poly_int_cst_value (exp
), mode
);
4251 gcc_assert (COMPLEX_MODE_P (mode
));
4252 op0
= expand_debug_expr (TREE_REALPART (exp
));
4253 op1
= expand_debug_expr (TREE_IMAGPART (exp
));
4254 return gen_rtx_CONCAT (mode
, op0
, op1
);
4256 case DEBUG_EXPR_DECL
:
4257 op0
= DECL_RTL_IF_SET (exp
);
4262 op0
= gen_rtx_DEBUG_EXPR (mode
);
4263 DEBUG_EXPR_TREE_DECL (op0
) = exp
;
4264 SET_DECL_RTL (exp
, op0
);
4274 op0
= DECL_RTL_IF_SET (exp
);
4276 /* This decl was probably optimized away. */
4280 || DECL_EXTERNAL (exp
)
4281 || !TREE_STATIC (exp
)
4283 || DECL_HARD_REGISTER (exp
)
4284 || DECL_IN_CONSTANT_POOL (exp
)
4285 || mode
== VOIDmode
)
4288 op0
= make_decl_rtl_for_debug (exp
);
4290 || GET_CODE (XEXP (op0
, 0)) != SYMBOL_REF
4291 || SYMBOL_REF_DECL (XEXP (op0
, 0)) != exp
)
4295 op0
= copy_rtx (op0
);
4297 if (GET_MODE (op0
) == BLKmode
4298 /* If op0 is not BLKmode, but mode is, adjust_mode
4299 below would ICE. While it is likely a FE bug,
4300 try to be robust here. See PR43166. */
4302 || (mode
== VOIDmode
&& GET_MODE (op0
) != VOIDmode
))
4304 gcc_assert (MEM_P (op0
));
4305 op0
= adjust_address_nv (op0
, mode
, 0);
4315 inner_mode
= GET_MODE (op0
);
4317 if (mode
== inner_mode
)
4320 if (inner_mode
== VOIDmode
)
4322 if (TREE_CODE (exp
) == SSA_NAME
)
4323 inner_mode
= TYPE_MODE (TREE_TYPE (exp
));
4325 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4326 if (mode
== inner_mode
)
4330 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
4332 if (GET_MODE_UNIT_BITSIZE (mode
)
4333 == GET_MODE_UNIT_BITSIZE (inner_mode
))
4334 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
4335 else if (GET_MODE_UNIT_BITSIZE (mode
)
4336 < GET_MODE_UNIT_BITSIZE (inner_mode
))
4337 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
4339 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
4341 else if (FLOAT_MODE_P (mode
))
4343 gcc_assert (TREE_CODE (exp
) != SSA_NAME
);
4344 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
4345 op0
= simplify_gen_unary (UNSIGNED_FLOAT
, mode
, op0
, inner_mode
);
4347 op0
= simplify_gen_unary (FLOAT
, mode
, op0
, inner_mode
);
4349 else if (FLOAT_MODE_P (inner_mode
))
4352 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
4354 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
4356 else if (GET_MODE_UNIT_PRECISION (mode
)
4357 == GET_MODE_UNIT_PRECISION (inner_mode
))
4358 op0
= lowpart_subreg (mode
, op0
, inner_mode
);
4359 else if (GET_MODE_UNIT_PRECISION (mode
)
4360 < GET_MODE_UNIT_PRECISION (inner_mode
))
4361 op0
= simplify_gen_unary (TRUNCATE
, mode
, op0
, inner_mode
);
4362 else if (UNARY_CLASS_P (exp
)
4363 ? TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)))
4365 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
4367 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
4373 if (!is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
4375 tree newexp
= fold_binary (MEM_REF
, TREE_TYPE (exp
),
4376 TREE_OPERAND (exp
, 0),
4377 TREE_OPERAND (exp
, 1));
4379 return expand_debug_expr (newexp
);
4383 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4384 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4388 if (TREE_CODE (exp
) == MEM_REF
)
4390 if (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
4391 || (GET_CODE (op0
) == PLUS
4392 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
))
4393 /* (mem (debug_implicit_ptr)) might confuse aliasing.
4394 Instead just use get_inner_reference. */
4397 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
4399 if (!op1
|| !poly_int_rtx_p (op1
, &offset
))
4402 op0
= plus_constant (inner_mode
, op0
, offset
);
4405 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))));
4407 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
4409 if (op0
== NULL_RTX
)
4412 op0
= gen_rtx_MEM (mode
, op0
);
4413 set_mem_attributes (op0
, exp
, 0);
4414 if (TREE_CODE (exp
) == MEM_REF
4415 && !is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
4416 set_mem_expr (op0
, NULL_TREE
);
4417 set_mem_addr_space (op0
, as
);
4421 case TARGET_MEM_REF
:
4422 if (TREE_CODE (TMR_BASE (exp
)) == ADDR_EXPR
4423 && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp
), 0)))
4426 op0
= expand_debug_expr
4427 (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp
)), exp
));
4431 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))));
4432 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
4434 if (op0
== NULL_RTX
)
4437 op0
= gen_rtx_MEM (mode
, op0
);
4439 set_mem_attributes (op0
, exp
, 0);
4440 set_mem_addr_space (op0
, as
);
4446 case ARRAY_RANGE_REF
:
4451 case VIEW_CONVERT_EXPR
:
4454 poly_int64 bitsize
, bitpos
;
4456 int reversep
, volatilep
= 0;
4458 = get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
, &mode1
,
4459 &unsignedp
, &reversep
, &volatilep
);
4462 if (known_eq (bitsize
, 0))
4465 orig_op0
= op0
= expand_debug_expr (tem
);
4472 machine_mode addrmode
, offmode
;
4477 op0
= XEXP (op0
, 0);
4478 addrmode
= GET_MODE (op0
);
4479 if (addrmode
== VOIDmode
)
4482 op1
= expand_debug_expr (offset
);
4486 offmode
= GET_MODE (op1
);
4487 if (offmode
== VOIDmode
)
4488 offmode
= TYPE_MODE (TREE_TYPE (offset
));
4490 if (addrmode
!= offmode
)
4491 op1
= lowpart_subreg (addrmode
, op1
, offmode
);
4493 /* Don't use offset_address here, we don't need a
4494 recognizable address, and we don't want to generate
4496 op0
= gen_rtx_MEM (mode
, simplify_gen_binary (PLUS
, addrmode
,
4502 if (mode1
== VOIDmode
)
4504 if (maybe_gt (bitsize
, MAX_BITSIZE_MODE_ANY_INT
))
4507 mode1
= smallest_int_mode_for_size (bitsize
);
4509 poly_int64 bytepos
= bits_to_bytes_round_down (bitpos
);
4510 if (maybe_ne (bytepos
, 0))
4512 op0
= adjust_address_nv (op0
, mode1
, bytepos
);
4513 bitpos
= num_trailing_bits (bitpos
);
4515 else if (known_eq (bitpos
, 0)
4516 && known_eq (bitsize
, GET_MODE_BITSIZE (mode
)))
4517 op0
= adjust_address_nv (op0
, mode
, 0);
4518 else if (GET_MODE (op0
) != mode1
)
4519 op0
= adjust_address_nv (op0
, mode1
, 0);
4521 op0
= copy_rtx (op0
);
4522 if (op0
== orig_op0
)
4523 op0
= shallow_copy_rtx (op0
);
4524 set_mem_attributes (op0
, exp
, 0);
4527 if (known_eq (bitpos
, 0) && mode
== GET_MODE (op0
))
4530 if (maybe_lt (bitpos
, 0))
4533 if (GET_MODE (op0
) == BLKmode
|| mode
== BLKmode
)
4537 if (multiple_p (bitpos
, BITS_PER_UNIT
, &bytepos
)
4538 && known_eq (bitsize
, GET_MODE_BITSIZE (mode1
)))
4540 machine_mode opmode
= GET_MODE (op0
);
4542 if (opmode
== VOIDmode
)
4543 opmode
= TYPE_MODE (TREE_TYPE (tem
));
4545 /* This condition may hold if we're expanding the address
4546 right past the end of an array that turned out not to
4547 be addressable (i.e., the address was only computed in
4548 debug stmts). The gen_subreg below would rightfully
4549 crash, and the address doesn't really exist, so just
4551 if (known_ge (bitpos
, GET_MODE_BITSIZE (opmode
)))
4554 if (multiple_p (bitpos
, GET_MODE_BITSIZE (mode
)))
4555 return simplify_gen_subreg (mode
, op0
, opmode
, bytepos
);
4558 return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0
))
4559 && TYPE_UNSIGNED (TREE_TYPE (exp
))
4561 : ZERO_EXTRACT
, mode
,
4562 GET_MODE (op0
) != VOIDmode
4564 : TYPE_MODE (TREE_TYPE (tem
)),
4565 op0
, gen_int_mode (bitsize
, word_mode
),
4566 gen_int_mode (bitpos
, word_mode
));
4571 return simplify_gen_unary (ABS
, mode
, op0
, mode
);
4574 return simplify_gen_unary (NEG
, mode
, op0
, mode
);
4577 return simplify_gen_unary (NOT
, mode
, op0
, mode
);
4580 return simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4582 ? UNSIGNED_FLOAT
: FLOAT
, mode
, op0
,
4585 case FIX_TRUNC_EXPR
:
4586 return simplify_gen_unary (unsignedp
? UNSIGNED_FIX
: FIX
, mode
, op0
,
4589 case POINTER_PLUS_EXPR
:
4590 /* For the rare target where pointers are not the same size as
4591 size_t, we need to check for mis-matched modes and correct
4594 && is_a
<scalar_int_mode
> (GET_MODE (op0
), &op0_mode
)
4595 && is_a
<scalar_int_mode
> (GET_MODE (op1
), &op1_mode
)
4596 && op0_mode
!= op1_mode
)
4598 if (GET_MODE_BITSIZE (op0_mode
) < GET_MODE_BITSIZE (op1_mode
)
4599 /* If OP0 is a partial mode, then we must truncate, even
4600 if it has the same bitsize as OP1 as GCC's
4601 representation of partial modes is opaque. */
4602 || (GET_MODE_CLASS (op0_mode
) == MODE_PARTIAL_INT
4603 && (GET_MODE_BITSIZE (op0_mode
)
4604 == GET_MODE_BITSIZE (op1_mode
))))
4605 op1
= simplify_gen_unary (TRUNCATE
, op0_mode
, op1
, op1_mode
);
4607 /* We always sign-extend, regardless of the signedness of
4608 the operand, because the operand is always unsigned
4609 here even if the original C expression is signed. */
4610 op1
= simplify_gen_unary (SIGN_EXTEND
, op0_mode
, op1
, op1_mode
);
4614 return simplify_gen_binary (PLUS
, mode
, op0
, op1
);
4617 case POINTER_DIFF_EXPR
:
4618 return simplify_gen_binary (MINUS
, mode
, op0
, op1
);
4621 return simplify_gen_binary (MULT
, mode
, op0
, op1
);
4624 case TRUNC_DIV_EXPR
:
4625 case EXACT_DIV_EXPR
:
4627 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4629 return simplify_gen_binary (DIV
, mode
, op0
, op1
);
4631 case TRUNC_MOD_EXPR
:
4632 return simplify_gen_binary (unsignedp
? UMOD
: MOD
, mode
, op0
, op1
);
4634 case FLOOR_DIV_EXPR
:
4636 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4639 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4640 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4641 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4642 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4645 case FLOOR_MOD_EXPR
:
4647 return simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4650 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4651 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4652 adj
= simplify_gen_unary (NEG
, mode
,
4653 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4655 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4661 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4662 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4663 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4664 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4668 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4669 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4670 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4671 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4677 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4678 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4679 adj
= simplify_gen_unary (NEG
, mode
,
4680 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4682 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4686 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4687 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4688 adj
= simplify_gen_unary (NEG
, mode
,
4689 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4691 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4694 case ROUND_DIV_EXPR
:
4697 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4698 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4699 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4700 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4704 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4705 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4706 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4707 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4710 case ROUND_MOD_EXPR
:
4713 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4714 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4715 adj
= simplify_gen_unary (NEG
, mode
,
4716 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4718 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4722 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4723 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4724 adj
= simplify_gen_unary (NEG
, mode
,
4725 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4727 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4731 return simplify_gen_binary (ASHIFT
, mode
, op0
, op1
);
4735 return simplify_gen_binary (LSHIFTRT
, mode
, op0
, op1
);
4737 return simplify_gen_binary (ASHIFTRT
, mode
, op0
, op1
);
4740 return simplify_gen_binary (ROTATE
, mode
, op0
, op1
);
4743 return simplify_gen_binary (ROTATERT
, mode
, op0
, op1
);
4746 return simplify_gen_binary (unsignedp
? UMIN
: SMIN
, mode
, op0
, op1
);
4749 return simplify_gen_binary (unsignedp
? UMAX
: SMAX
, mode
, op0
, op1
);
4752 case TRUTH_AND_EXPR
:
4753 return simplify_gen_binary (AND
, mode
, op0
, op1
);
4757 return simplify_gen_binary (IOR
, mode
, op0
, op1
);
4760 case TRUTH_XOR_EXPR
:
4761 return simplify_gen_binary (XOR
, mode
, op0
, op1
);
4763 case TRUTH_ANDIF_EXPR
:
4764 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, const0_rtx
);
4766 case TRUTH_ORIF_EXPR
:
4767 return gen_rtx_IF_THEN_ELSE (mode
, op0
, const_true_rtx
, op1
);
4769 case TRUTH_NOT_EXPR
:
4770 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, const0_rtx
);
4773 return simplify_gen_relational (unsignedp
? LTU
: LT
, mode
, inner_mode
,
4777 return simplify_gen_relational (unsignedp
? LEU
: LE
, mode
, inner_mode
,
4781 return simplify_gen_relational (unsignedp
? GTU
: GT
, mode
, inner_mode
,
4785 return simplify_gen_relational (unsignedp
? GEU
: GE
, mode
, inner_mode
,
4789 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, op1
);
4792 return simplify_gen_relational (NE
, mode
, inner_mode
, op0
, op1
);
4794 case UNORDERED_EXPR
:
4795 return simplify_gen_relational (UNORDERED
, mode
, inner_mode
, op0
, op1
);
4798 return simplify_gen_relational (ORDERED
, mode
, inner_mode
, op0
, op1
);
4801 return simplify_gen_relational (UNLT
, mode
, inner_mode
, op0
, op1
);
4804 return simplify_gen_relational (UNLE
, mode
, inner_mode
, op0
, op1
);
4807 return simplify_gen_relational (UNGT
, mode
, inner_mode
, op0
, op1
);
4810 return simplify_gen_relational (UNGE
, mode
, inner_mode
, op0
, op1
);
4813 return simplify_gen_relational (UNEQ
, mode
, inner_mode
, op0
, op1
);
4816 return simplify_gen_relational (LTGT
, mode
, inner_mode
, op0
, op1
);
4819 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, op2
);
4822 gcc_assert (COMPLEX_MODE_P (mode
));
4823 if (GET_MODE (op0
) == VOIDmode
)
4824 op0
= gen_rtx_CONST (GET_MODE_INNER (mode
), op0
);
4825 if (GET_MODE (op1
) == VOIDmode
)
4826 op1
= gen_rtx_CONST (GET_MODE_INNER (mode
), op1
);
4827 return gen_rtx_CONCAT (mode
, op0
, op1
);
4830 if (GET_CODE (op0
) == CONCAT
)
4831 return gen_rtx_CONCAT (mode
, XEXP (op0
, 0),
4832 simplify_gen_unary (NEG
, GET_MODE_INNER (mode
),
4834 GET_MODE_INNER (mode
)));
4837 scalar_mode imode
= GET_MODE_INNER (mode
);
4842 re
= adjust_address_nv (op0
, imode
, 0);
4843 im
= adjust_address_nv (op0
, imode
, GET_MODE_SIZE (imode
));
4847 scalar_int_mode ifmode
;
4848 scalar_int_mode ihmode
;
4850 if (!int_mode_for_mode (mode
).exists (&ifmode
)
4851 || !int_mode_for_mode (imode
).exists (&ihmode
))
4853 halfsize
= GEN_INT (GET_MODE_BITSIZE (ihmode
));
4856 re
= gen_rtx_SUBREG (ifmode
, re
, 0);
4857 re
= gen_rtx_ZERO_EXTRACT (ihmode
, re
, halfsize
, const0_rtx
);
4858 if (imode
!= ihmode
)
4859 re
= gen_rtx_SUBREG (imode
, re
, 0);
4860 im
= copy_rtx (op0
);
4862 im
= gen_rtx_SUBREG (ifmode
, im
, 0);
4863 im
= gen_rtx_ZERO_EXTRACT (ihmode
, im
, halfsize
, halfsize
);
4864 if (imode
!= ihmode
)
4865 im
= gen_rtx_SUBREG (imode
, im
, 0);
4867 im
= gen_rtx_NEG (imode
, im
);
4868 return gen_rtx_CONCAT (mode
, re
, im
);
4872 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4873 if (!op0
|| !MEM_P (op0
))
4875 if ((TREE_CODE (TREE_OPERAND (exp
, 0)) == VAR_DECL
4876 || TREE_CODE (TREE_OPERAND (exp
, 0)) == PARM_DECL
4877 || TREE_CODE (TREE_OPERAND (exp
, 0)) == RESULT_DECL
)
4878 && (!TREE_ADDRESSABLE (TREE_OPERAND (exp
, 0))
4879 || target_for_debug_bind (TREE_OPERAND (exp
, 0))))
4880 return gen_rtx_DEBUG_IMPLICIT_PTR (mode
, TREE_OPERAND (exp
, 0));
4882 if (handled_component_p (TREE_OPERAND (exp
, 0)))
4884 poly_int64 bitoffset
, bitsize
, maxsize
, byteoffset
;
4887 = get_ref_base_and_extent (TREE_OPERAND (exp
, 0), &bitoffset
,
4888 &bitsize
, &maxsize
, &reverse
);
4890 || TREE_CODE (decl
) == PARM_DECL
4891 || TREE_CODE (decl
) == RESULT_DECL
)
4892 && (!TREE_ADDRESSABLE (decl
)
4893 || target_for_debug_bind (decl
))
4894 && multiple_p (bitoffset
, BITS_PER_UNIT
, &byteoffset
)
4895 && known_gt (bitsize
, 0)
4896 && known_eq (bitsize
, maxsize
))
4898 rtx base
= gen_rtx_DEBUG_IMPLICIT_PTR (mode
, decl
);
4899 return plus_constant (mode
, base
, byteoffset
);
4903 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == MEM_REF
4904 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
4907 op0
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
4910 && (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
4911 || (GET_CODE (op0
) == PLUS
4912 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
4913 && CONST_INT_P (XEXP (op0
, 1)))))
4915 op1
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
4918 if (!op1
|| !poly_int_rtx_p (op1
, &offset
))
4921 return plus_constant (mode
, op0
, offset
);
4928 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)));
4929 addr_mode
= SCALAR_INT_TYPE_MODE (TREE_TYPE (exp
));
4930 op0
= convert_debug_memory_address (addr_mode
, XEXP (op0
, 0), as
);
4936 unsigned HOST_WIDE_INT i
, nelts
;
4938 if (!VECTOR_CST_NELTS (exp
).is_constant (&nelts
))
4941 op0
= gen_rtx_CONCATN (mode
, rtvec_alloc (nelts
));
4943 for (i
= 0; i
< nelts
; ++i
)
4945 op1
= expand_debug_expr (VECTOR_CST_ELT (exp
, i
));
4948 XVECEXP (op0
, 0, i
) = op1
;
4955 if (TREE_CLOBBER_P (exp
))
4957 else if (TREE_CODE (TREE_TYPE (exp
)) == VECTOR_TYPE
)
4960 unsigned HOST_WIDE_INT nelts
;
4963 if (!TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)).is_constant (&nelts
))
4964 goto flag_unsupported
;
4966 op0
= gen_rtx_CONCATN (mode
, rtvec_alloc (nelts
));
4968 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), i
, val
)
4970 op1
= expand_debug_expr (val
);
4973 XVECEXP (op0
, 0, i
) = op1
;
4978 op1
= expand_debug_expr
4979 (build_zero_cst (TREE_TYPE (TREE_TYPE (exp
))));
4984 for (; i
< nelts
; i
++)
4985 XVECEXP (op0
, 0, i
) = op1
;
4991 goto flag_unsupported
;
4994 /* ??? Maybe handle some builtins? */
4999 gimple
*g
= get_gimple_for_ssa_name (exp
);
5003 if (deep_ter_debug_map
)
5005 tree
*slot
= deep_ter_debug_map
->get (exp
);
5010 t
= gimple_assign_rhs_to_tree (g
);
5011 op0
= expand_debug_expr (t
);
5017 /* If this is a reference to an incoming value of
5018 parameter that is never used in the code or where the
5019 incoming value is never used in the code, use
5020 PARM_DECL's DECL_RTL if set. */
5021 if (SSA_NAME_IS_DEFAULT_DEF (exp
)
5022 && SSA_NAME_VAR (exp
)
5023 && TREE_CODE (SSA_NAME_VAR (exp
)) == PARM_DECL
5024 && has_zero_uses (exp
))
5026 op0
= expand_debug_parm_decl (SSA_NAME_VAR (exp
));
5029 op0
= expand_debug_expr (SSA_NAME_VAR (exp
));
5034 int part
= var_to_partition (SA
.map
, exp
);
5036 if (part
== NO_PARTITION
)
5039 gcc_assert (part
>= 0 && (unsigned)part
< SA
.map
->num_partitions
);
5041 op0
= copy_rtx (SA
.partition_to_pseudo
[part
]);
5049 /* Vector stuff. For most of the codes we don't have rtl codes. */
5050 case REALIGN_LOAD_EXPR
:
5052 case VEC_PACK_FIX_TRUNC_EXPR
:
5053 case VEC_PACK_FLOAT_EXPR
:
5054 case VEC_PACK_SAT_EXPR
:
5055 case VEC_PACK_TRUNC_EXPR
:
5056 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
5057 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
5058 case VEC_UNPACK_FLOAT_HI_EXPR
:
5059 case VEC_UNPACK_FLOAT_LO_EXPR
:
5060 case VEC_UNPACK_HI_EXPR
:
5061 case VEC_UNPACK_LO_EXPR
:
5062 case VEC_WIDEN_MULT_HI_EXPR
:
5063 case VEC_WIDEN_MULT_LO_EXPR
:
5064 case VEC_WIDEN_MULT_EVEN_EXPR
:
5065 case VEC_WIDEN_MULT_ODD_EXPR
:
5066 case VEC_WIDEN_LSHIFT_HI_EXPR
:
5067 case VEC_WIDEN_LSHIFT_LO_EXPR
:
5069 case VEC_DUPLICATE_EXPR
:
5070 case VEC_SERIES_EXPR
:
5074 case ADDR_SPACE_CONVERT_EXPR
:
5075 case FIXED_CONVERT_EXPR
:
5077 case WITH_SIZE_EXPR
:
5078 case BIT_INSERT_EXPR
:
5082 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5083 && SCALAR_INT_MODE_P (mode
))
5086 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5088 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
5091 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5093 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op1
,
5095 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
5096 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
5100 case WIDEN_MULT_EXPR
:
5101 case WIDEN_MULT_PLUS_EXPR
:
5102 case WIDEN_MULT_MINUS_EXPR
:
5103 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5104 && SCALAR_INT_MODE_P (mode
))
5106 inner_mode
= GET_MODE (op0
);
5107 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
5108 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
5110 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
5111 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 1))))
5112 op1
= simplify_gen_unary (ZERO_EXTEND
, mode
, op1
, inner_mode
);
5114 op1
= simplify_gen_unary (SIGN_EXTEND
, mode
, op1
, inner_mode
);
5115 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
5116 if (TREE_CODE (exp
) == WIDEN_MULT_EXPR
)
5118 else if (TREE_CODE (exp
) == WIDEN_MULT_PLUS_EXPR
)
5119 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
5121 return simplify_gen_binary (MINUS
, mode
, op2
, op0
);
5125 case MULT_HIGHPART_EXPR
:
5126 /* ??? Similar to the above. */
5129 case WIDEN_SUM_EXPR
:
5130 case WIDEN_LSHIFT_EXPR
:
5131 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5132 && SCALAR_INT_MODE_P (mode
))
5135 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5137 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
5139 return simplify_gen_binary (TREE_CODE (exp
) == WIDEN_LSHIFT_EXPR
5140 ? ASHIFT
: PLUS
, mode
, op0
, op1
);
5155 /* Return an RTX equivalent to the source bind value of the tree expression
5159 expand_debug_source_expr (tree exp
)
5162 machine_mode mode
= VOIDmode
, inner_mode
;
5164 switch (TREE_CODE (exp
))
5167 if (DECL_ABSTRACT_ORIGIN (exp
))
5168 return expand_debug_source_expr (DECL_ABSTRACT_ORIGIN (exp
));
5172 mode
= DECL_MODE (exp
);
5173 op0
= expand_debug_parm_decl (exp
);
5176 /* See if this isn't an argument that has been completely
5178 if (!DECL_RTL_SET_P (exp
)
5179 && !DECL_INCOMING_RTL (exp
)
5180 && DECL_ABSTRACT_ORIGIN (current_function_decl
))
5182 tree aexp
= DECL_ORIGIN (exp
);
5183 if (DECL_CONTEXT (aexp
)
5184 == DECL_ABSTRACT_ORIGIN (current_function_decl
))
5186 vec
<tree
, va_gc
> **debug_args
;
5189 debug_args
= decl_debug_args_lookup (current_function_decl
);
5190 if (debug_args
!= NULL
)
5192 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, &ddecl
);
5195 return gen_rtx_DEBUG_PARAMETER_REF (mode
, aexp
);
5205 if (op0
== NULL_RTX
)
5208 inner_mode
= GET_MODE (op0
);
5209 if (mode
== inner_mode
)
5212 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
5214 if (GET_MODE_UNIT_BITSIZE (mode
)
5215 == GET_MODE_UNIT_BITSIZE (inner_mode
))
5216 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
5217 else if (GET_MODE_UNIT_BITSIZE (mode
)
5218 < GET_MODE_UNIT_BITSIZE (inner_mode
))
5219 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
5221 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
5223 else if (FLOAT_MODE_P (mode
))
5225 else if (FLOAT_MODE_P (inner_mode
))
5227 if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
5228 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
5230 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
5232 else if (GET_MODE_UNIT_PRECISION (mode
)
5233 == GET_MODE_UNIT_PRECISION (inner_mode
))
5234 op0
= lowpart_subreg (mode
, op0
, inner_mode
);
5235 else if (GET_MODE_UNIT_PRECISION (mode
)
5236 < GET_MODE_UNIT_PRECISION (inner_mode
))
5237 op0
= simplify_gen_unary (TRUNCATE
, mode
, op0
, inner_mode
);
5238 else if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
5239 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
5241 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
5246 /* Ensure INSN_VAR_LOCATION_LOC (insn) doesn't have unbound complexity.
5247 Allow 4 levels of rtl nesting for most rtl codes, and if we see anything
5248 deeper than that, create DEBUG_EXPRs and emit DEBUG_INSNs before INSN. */
5251 avoid_complex_debug_insns (rtx_insn
*insn
, rtx
*exp_p
, int depth
)
5255 if (exp
== NULL_RTX
)
5258 if ((OBJECT_P (exp
) && !MEM_P (exp
)) || GET_CODE (exp
) == CLOBBER
)
5263 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
5264 rtx dval
= make_debug_expr_from_rtl (exp
);
5266 /* Emit a debug bind insn before INSN. */
5267 rtx bind
= gen_rtx_VAR_LOCATION (GET_MODE (exp
),
5268 DEBUG_EXPR_TREE_DECL (dval
), exp
,
5269 VAR_INIT_STATUS_INITIALIZED
);
5271 emit_debug_insn_before (bind
, insn
);
5276 const char *format_ptr
= GET_RTX_FORMAT (GET_CODE (exp
));
5278 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
5279 switch (*format_ptr
++)
5282 avoid_complex_debug_insns (insn
, &XEXP (exp
, i
), depth
+ 1);
5287 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
5288 avoid_complex_debug_insns (insn
, &XVECEXP (exp
, i
, j
), depth
+ 1);
5296 /* Expand the _LOCs in debug insns. We run this after expanding all
5297 regular insns, so that any variables referenced in the function
5298 will have their DECL_RTLs set. */
5301 expand_debug_locations (void)
5304 rtx_insn
*last
= get_last_insn ();
5305 int save_strict_alias
= flag_strict_aliasing
;
5307 /* New alias sets while setting up memory attributes cause
5308 -fcompare-debug failures, even though it doesn't bring about any
5310 flag_strict_aliasing
= 0;
5312 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
5313 if (DEBUG_BIND_INSN_P (insn
))
5315 tree value
= (tree
)INSN_VAR_LOCATION_LOC (insn
);
5317 rtx_insn
*prev_insn
, *insn2
;
5320 if (value
== NULL_TREE
)
5324 if (INSN_VAR_LOCATION_STATUS (insn
)
5325 == VAR_INIT_STATUS_UNINITIALIZED
)
5326 val
= expand_debug_source_expr (value
);
5327 /* The avoid_deep_ter_for_debug function inserts
5328 debug bind stmts after SSA_NAME definition, with the
5329 SSA_NAME as the whole bind location. Disable temporarily
5330 expansion of that SSA_NAME into the DEBUG_EXPR_DECL
5331 being defined in this DEBUG_INSN. */
5332 else if (deep_ter_debug_map
&& TREE_CODE (value
) == SSA_NAME
)
5334 tree
*slot
= deep_ter_debug_map
->get (value
);
5337 if (*slot
== INSN_VAR_LOCATION_DECL (insn
))
5342 val
= expand_debug_expr (value
);
5344 *slot
= INSN_VAR_LOCATION_DECL (insn
);
5347 val
= expand_debug_expr (value
);
5348 gcc_assert (last
== get_last_insn ());
5352 val
= gen_rtx_UNKNOWN_VAR_LOC ();
5355 mode
= GET_MODE (INSN_VAR_LOCATION (insn
));
5357 gcc_assert (mode
== GET_MODE (val
)
5358 || (GET_MODE (val
) == VOIDmode
5359 && (CONST_SCALAR_INT_P (val
)
5360 || GET_CODE (val
) == CONST_FIXED
5361 || GET_CODE (val
) == LABEL_REF
)));
5364 INSN_VAR_LOCATION_LOC (insn
) = val
;
5365 prev_insn
= PREV_INSN (insn
);
5366 for (insn2
= insn
; insn2
!= prev_insn
; insn2
= PREV_INSN (insn2
))
5367 avoid_complex_debug_insns (insn2
, &INSN_VAR_LOCATION_LOC (insn2
), 0);
5370 flag_strict_aliasing
= save_strict_alias
;
5373 /* Performs swapping operands of commutative operations to expand
5374 the expensive one first. */
5377 reorder_operands (basic_block bb
)
5379 unsigned int *lattice
; /* Hold cost of each statement. */
5380 unsigned int i
= 0, n
= 0;
5381 gimple_stmt_iterator gsi
;
5387 use_operand_p use_p
;
5388 gimple
*def0
, *def1
;
5390 /* Compute cost of each statement using estimate_num_insns. */
5391 stmts
= bb_seq (bb
);
5392 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5394 stmt
= gsi_stmt (gsi
);
5395 if (!is_gimple_debug (stmt
))
5396 gimple_set_uid (stmt
, n
++);
5398 lattice
= XNEWVEC (unsigned int, n
);
5399 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5402 stmt
= gsi_stmt (gsi
);
5403 if (is_gimple_debug (stmt
))
5405 cost
= estimate_num_insns (stmt
, &eni_size_weights
);
5407 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
5409 tree use
= USE_FROM_PTR (use_p
);
5411 if (TREE_CODE (use
) != SSA_NAME
)
5413 def_stmt
= get_gimple_for_ssa_name (use
);
5416 lattice
[i
] += lattice
[gimple_uid (def_stmt
)];
5419 if (!is_gimple_assign (stmt
)
5420 || !commutative_tree_code (gimple_assign_rhs_code (stmt
)))
5422 op0
= gimple_op (stmt
, 1);
5423 op1
= gimple_op (stmt
, 2);
5424 if (TREE_CODE (op0
) != SSA_NAME
5425 || TREE_CODE (op1
) != SSA_NAME
)
5427 /* Swap operands if the second one is more expensive. */
5428 def0
= get_gimple_for_ssa_name (op0
);
5429 def1
= get_gimple_for_ssa_name (op1
);
5433 if (!def0
|| lattice
[gimple_uid (def1
)] > lattice
[gimple_uid (def0
)])
5437 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5439 fprintf (dump_file
, "Swap operands in stmt:\n");
5440 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
5441 fprintf (dump_file
, "Cost left opnd=%d, right opnd=%d\n",
5442 def0
? lattice
[gimple_uid (def0
)] : 0,
5443 lattice
[gimple_uid (def1
)]);
5445 swap_ssa_operands (stmt
, gimple_assign_rhs1_ptr (stmt
),
5446 gimple_assign_rhs2_ptr (stmt
));
5452 /* Expand basic block BB from GIMPLE trees to RTL. */
5455 expand_gimple_basic_block (basic_block bb
, bool disable_tail_calls
)
5457 gimple_stmt_iterator gsi
;
5459 gimple
*stmt
= NULL
;
5460 rtx_note
*note
= NULL
;
5466 fprintf (dump_file
, "\n;; Generating RTL for gimple basic block %d\n",
5469 /* Note that since we are now transitioning from GIMPLE to RTL, we
5470 cannot use the gsi_*_bb() routines because they expect the basic
5471 block to be in GIMPLE, instead of RTL. Therefore, we need to
5472 access the BB sequence directly. */
5474 reorder_operands (bb
);
5475 stmts
= bb_seq (bb
);
5476 bb
->il
.gimple
.seq
= NULL
;
5477 bb
->il
.gimple
.phi_nodes
= NULL
;
5478 rtl_profile_for_bb (bb
);
5479 init_rtl_bb_info (bb
);
5480 bb
->flags
|= BB_RTL
;
5482 /* Remove the RETURN_EXPR if we may fall though to the exit
5484 gsi
= gsi_last (stmts
);
5485 if (!gsi_end_p (gsi
)
5486 && gimple_code (gsi_stmt (gsi
)) == GIMPLE_RETURN
)
5488 greturn
*ret_stmt
= as_a
<greturn
*> (gsi_stmt (gsi
));
5490 gcc_assert (single_succ_p (bb
));
5491 gcc_assert (single_succ (bb
) == EXIT_BLOCK_PTR_FOR_FN (cfun
));
5493 if (bb
->next_bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
)
5494 && !gimple_return_retval (ret_stmt
))
5496 gsi_remove (&gsi
, false);
5497 single_succ_edge (bb
)->flags
|= EDGE_FALLTHRU
;
5501 gsi
= gsi_start (stmts
);
5502 if (!gsi_end_p (gsi
))
5504 stmt
= gsi_stmt (gsi
);
5505 if (gimple_code (stmt
) != GIMPLE_LABEL
)
5509 rtx_code_label
**elt
= lab_rtx_for_bb
->get (bb
);
5513 gcc_checking_assert (!note
);
5514 last
= get_last_insn ();
5518 expand_gimple_stmt (stmt
);
5525 BB_HEAD (bb
) = NEXT_INSN (last
);
5526 if (NOTE_P (BB_HEAD (bb
)))
5527 BB_HEAD (bb
) = NEXT_INSN (BB_HEAD (bb
));
5528 gcc_assert (LABEL_P (BB_HEAD (bb
)));
5529 note
= emit_note_after (NOTE_INSN_BASIC_BLOCK
, BB_HEAD (bb
));
5531 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5534 BB_HEAD (bb
) = note
= emit_note (NOTE_INSN_BASIC_BLOCK
);
5537 NOTE_BASIC_BLOCK (note
) = bb
;
5539 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
5543 stmt
= gsi_stmt (gsi
);
5545 /* If this statement is a non-debug one, and we generate debug
5546 insns, then this one might be the last real use of a TERed
5547 SSA_NAME, but where there are still some debug uses further
5548 down. Expanding the current SSA name in such further debug
5549 uses by their RHS might lead to wrong debug info, as coalescing
5550 might make the operands of such RHS be placed into the same
5551 pseudo as something else. Like so:
5552 a_1 = a_0 + 1; // Assume a_1 is TERed and a_0 is dead
5556 As a_0 and a_2 don't overlap in lifetime, assume they are coalesced.
5557 If we now would expand a_1 by it's RHS (a_0 + 1) in the debug use,
5558 the write to a_2 would actually have clobbered the place which
5561 So, instead of that, we recognize the situation, and generate
5562 debug temporaries at the last real use of TERed SSA names:
5569 if (MAY_HAVE_DEBUG_BIND_INSNS
5571 && !is_gimple_debug (stmt
))
5577 location_t sloc
= curr_insn_location ();
5579 /* Look for SSA names that have their last use here (TERed
5580 names always have only one real use). */
5581 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
)
5582 if ((def
= get_gimple_for_ssa_name (op
)))
5584 imm_use_iterator imm_iter
;
5585 use_operand_p use_p
;
5586 bool have_debug_uses
= false;
5588 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, op
)
5590 if (gimple_debug_bind_p (USE_STMT (use_p
)))
5592 have_debug_uses
= true;
5597 if (have_debug_uses
)
5599 /* OP is a TERed SSA name, with DEF its defining
5600 statement, and where OP is used in further debug
5601 instructions. Generate a debug temporary, and
5602 replace all uses of OP in debug insns with that
5605 tree value
= gimple_assign_rhs_to_tree (def
);
5606 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
5610 set_curr_insn_location (gimple_location (def
));
5612 DECL_ARTIFICIAL (vexpr
) = 1;
5613 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
5615 mode
= DECL_MODE (value
);
5617 mode
= TYPE_MODE (TREE_TYPE (value
));
5618 SET_DECL_MODE (vexpr
, mode
);
5620 val
= gen_rtx_VAR_LOCATION
5621 (mode
, vexpr
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5623 emit_debug_insn (val
);
5625 FOR_EACH_IMM_USE_STMT (debugstmt
, imm_iter
, op
)
5627 if (!gimple_debug_bind_p (debugstmt
))
5630 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
5631 SET_USE (use_p
, vexpr
);
5633 update_stmt (debugstmt
);
5637 set_curr_insn_location (sloc
);
5640 currently_expanding_gimple_stmt
= stmt
;
5642 /* Expand this statement, then evaluate the resulting RTL and
5643 fixup the CFG accordingly. */
5644 if (gimple_code (stmt
) == GIMPLE_COND
)
5646 new_bb
= expand_gimple_cond (bb
, as_a
<gcond
*> (stmt
));
5650 else if (is_gimple_debug (stmt
))
5652 location_t sloc
= curr_insn_location ();
5653 gimple_stmt_iterator nsi
= gsi
;
5658 tree value
= NULL_TREE
;
5662 if (!gimple_debug_nonbind_marker_p (stmt
))
5664 if (gimple_debug_bind_p (stmt
))
5666 var
= gimple_debug_bind_get_var (stmt
);
5668 if (TREE_CODE (var
) != DEBUG_EXPR_DECL
5669 && TREE_CODE (var
) != LABEL_DECL
5670 && !target_for_debug_bind (var
))
5671 goto delink_debug_stmt
;
5674 mode
= DECL_MODE (var
);
5676 mode
= TYPE_MODE (TREE_TYPE (var
));
5678 if (gimple_debug_bind_has_value_p (stmt
))
5679 value
= gimple_debug_bind_get_value (stmt
);
5681 val
= gen_rtx_VAR_LOCATION
5682 (mode
, var
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5684 else if (gimple_debug_source_bind_p (stmt
))
5686 var
= gimple_debug_source_bind_get_var (stmt
);
5688 value
= gimple_debug_source_bind_get_value (stmt
);
5690 mode
= DECL_MODE (var
);
5692 val
= gen_rtx_VAR_LOCATION (mode
, var
, (rtx
)value
,
5693 VAR_INIT_STATUS_UNINITIALIZED
);
5698 /* If this function was first compiled with markers
5699 enabled, but they're now disable (e.g. LTO), drop
5700 them on the floor. */
5701 else if (gimple_debug_nonbind_marker_p (stmt
)
5702 && !MAY_HAVE_DEBUG_MARKER_INSNS
)
5703 goto delink_debug_stmt
;
5704 else if (gimple_debug_begin_stmt_p (stmt
))
5705 val
= GEN_RTX_DEBUG_MARKER_BEGIN_STMT_PAT ();
5706 else if (gimple_debug_inline_entry_p (stmt
))
5708 tree block
= gimple_block (stmt
);
5711 val
= GEN_RTX_DEBUG_MARKER_INLINE_ENTRY_PAT ();
5713 goto delink_debug_stmt
;
5718 last
= get_last_insn ();
5720 set_curr_insn_location (gimple_location (stmt
));
5722 emit_debug_insn (val
);
5724 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5726 /* We can't dump the insn with a TREE where an RTX
5728 if (GET_CODE (val
) == VAR_LOCATION
)
5730 gcc_checking_assert (PAT_VAR_LOCATION_LOC (val
) == (rtx
)value
);
5731 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
5733 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5734 if (GET_CODE (val
) == VAR_LOCATION
)
5735 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
5739 /* In order not to generate too many debug temporaries,
5740 we delink all uses of debug statements we already expanded.
5741 Therefore debug statements between definition and real
5742 use of TERed SSA names will continue to use the SSA name,
5743 and not be replaced with debug temps. */
5744 delink_stmt_imm_use (stmt
);
5748 if (gsi_end_p (nsi
))
5750 stmt
= gsi_stmt (nsi
);
5751 if (!is_gimple_debug (stmt
))
5755 set_curr_insn_location (sloc
);
5759 gcall
*call_stmt
= dyn_cast
<gcall
*> (stmt
);
5761 && gimple_call_tail_p (call_stmt
)
5762 && disable_tail_calls
)
5763 gimple_call_set_tail (call_stmt
, false);
5765 if (call_stmt
&& gimple_call_tail_p (call_stmt
))
5768 new_bb
= expand_gimple_tailcall (bb
, call_stmt
, &can_fallthru
);
5779 def_operand_p def_p
;
5780 def_p
= SINGLE_SSA_DEF_OPERAND (stmt
, SSA_OP_DEF
);
5784 /* Ignore this stmt if it is in the list of
5785 replaceable expressions. */
5787 && bitmap_bit_p (SA
.values
,
5788 SSA_NAME_VERSION (DEF_FROM_PTR (def_p
))))
5791 last
= expand_gimple_stmt (stmt
);
5792 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5797 currently_expanding_gimple_stmt
= NULL
;
5799 /* Expand implicit goto and convert goto_locus. */
5800 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5802 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
5803 set_curr_insn_location (e
->goto_locus
);
5804 if ((e
->flags
& EDGE_FALLTHRU
) && e
->dest
!= bb
->next_bb
)
5806 emit_jump (label_rtx_for_bb (e
->dest
));
5807 e
->flags
&= ~EDGE_FALLTHRU
;
5811 /* Expanded RTL can create a jump in the last instruction of block.
5812 This later might be assumed to be a jump to successor and break edge insertion.
5813 We need to insert dummy move to prevent this. PR41440. */
5814 if (single_succ_p (bb
)
5815 && (single_succ_edge (bb
)->flags
& EDGE_FALLTHRU
)
5816 && (last
= get_last_insn ())
5818 || (DEBUG_INSN_P (last
)
5819 && JUMP_P (prev_nondebug_insn (last
)))))
5821 rtx dummy
= gen_reg_rtx (SImode
);
5822 emit_insn_after_noloc (gen_move_insn (dummy
, dummy
), last
, NULL
);
5825 do_pending_stack_adjust ();
5827 /* Find the block tail. The last insn in the block is the insn
5828 before a barrier and/or table jump insn. */
5829 last
= get_last_insn ();
5830 if (BARRIER_P (last
))
5831 last
= PREV_INSN (last
);
5832 if (JUMP_TABLE_DATA_P (last
))
5833 last
= PREV_INSN (PREV_INSN (last
));
5834 if (BARRIER_P (last
))
5835 last
= PREV_INSN (last
);
5838 update_bb_for_insn (bb
);
5844 /* Create a basic block for initialization code. */
5847 construct_init_block (void)
5849 basic_block init_block
, first_block
;
5853 /* Multiple entry points not supported yet. */
5854 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
) == 1);
5855 init_rtl_bb_info (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5856 init_rtl_bb_info (EXIT_BLOCK_PTR_FOR_FN (cfun
));
5857 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
5858 EXIT_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
5860 e
= EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun
), 0);
5862 /* When entry edge points to first basic block, we don't need jump,
5863 otherwise we have to jump into proper target. */
5864 if (e
&& e
->dest
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
)
5866 tree label
= gimple_block_label (e
->dest
);
5868 emit_jump (jump_target_rtx (label
));
5872 flags
= EDGE_FALLTHRU
;
5874 init_block
= create_basic_block (NEXT_INSN (get_insns ()),
5876 ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5877 init_block
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
5878 add_bb_to_loop (init_block
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
5881 first_block
= e
->dest
;
5882 redirect_edge_succ (e
, init_block
);
5883 e
= make_single_succ_edge (init_block
, first_block
, flags
);
5886 e
= make_single_succ_edge (init_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
),
5889 update_bb_for_insn (init_block
);
5893 /* For each lexical block, set BLOCK_NUMBER to the depth at which it is
5894 found in the block tree. */
5897 set_block_levels (tree block
, int level
)
5901 BLOCK_NUMBER (block
) = level
;
5902 set_block_levels (BLOCK_SUBBLOCKS (block
), level
+ 1);
5903 block
= BLOCK_CHAIN (block
);
5907 /* Create a block containing landing pads and similar stuff. */
5910 construct_exit_block (void)
5912 rtx_insn
*head
= get_last_insn ();
5914 basic_block exit_block
;
5918 basic_block prev_bb
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
;
5919 rtx_insn
*orig_end
= BB_END (prev_bb
);
5921 rtl_profile_for_bb (EXIT_BLOCK_PTR_FOR_FN (cfun
));
5923 /* Make sure the locus is set to the end of the function, so that
5924 epilogue line numbers and warnings are set properly. */
5925 if (LOCATION_LOCUS (cfun
->function_end_locus
) != UNKNOWN_LOCATION
)
5926 input_location
= cfun
->function_end_locus
;
5928 /* Generate rtl for function exit. */
5929 expand_function_end ();
5931 end
= get_last_insn ();
5934 /* While emitting the function end we could move end of the last basic
5936 BB_END (prev_bb
) = orig_end
;
5937 while (NEXT_INSN (head
) && NOTE_P (NEXT_INSN (head
)))
5938 head
= NEXT_INSN (head
);
5939 /* But make sure exit_block starts with RETURN_LABEL, otherwise the
5940 bb count counting will be confused. Any instructions before that
5941 label are emitted for the case where PREV_BB falls through into the
5942 exit block, so append those instructions to prev_bb in that case. */
5943 if (NEXT_INSN (head
) != return_label
)
5945 while (NEXT_INSN (head
) != return_label
)
5947 if (!NOTE_P (NEXT_INSN (head
)))
5948 BB_END (prev_bb
) = NEXT_INSN (head
);
5949 head
= NEXT_INSN (head
);
5952 exit_block
= create_basic_block (NEXT_INSN (head
), end
, prev_bb
);
5953 exit_block
->count
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
;
5954 add_bb_to_loop (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
5957 while (ix
< EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
))
5959 e
= EDGE_PRED (EXIT_BLOCK_PTR_FOR_FN (cfun
), ix
);
5960 if (!(e
->flags
& EDGE_ABNORMAL
))
5961 redirect_edge_succ (e
, exit_block
);
5966 e
= make_single_succ_edge (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
),
5968 FOR_EACH_EDGE (e2
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
5971 exit_block
->count
-= e2
->count ();
5973 update_bb_for_insn (exit_block
);
5976 /* Helper function for discover_nonconstant_array_refs.
5977 Look for ARRAY_REF nodes with non-constant indexes and mark them
5981 discover_nonconstant_array_refs_r (tree
* tp
, int *walk_subtrees
,
5982 void *data ATTRIBUTE_UNUSED
)
5986 if (IS_TYPE_OR_DECL_P (t
))
5988 else if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5990 while (((TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5991 && is_gimple_min_invariant (TREE_OPERAND (t
, 1))
5992 && (!TREE_OPERAND (t
, 2)
5993 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
5994 || (TREE_CODE (t
) == COMPONENT_REF
5995 && (!TREE_OPERAND (t
,2)
5996 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
5997 || TREE_CODE (t
) == BIT_FIELD_REF
5998 || TREE_CODE (t
) == REALPART_EXPR
5999 || TREE_CODE (t
) == IMAGPART_EXPR
6000 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
6001 || CONVERT_EXPR_P (t
))
6002 t
= TREE_OPERAND (t
, 0);
6004 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
6006 t
= get_base_address (t
);
6008 && DECL_MODE (t
) != BLKmode
)
6009 TREE_ADDRESSABLE (t
) = 1;
6018 /* RTL expansion is not able to compile array references with variable
6019 offsets for arrays stored in single register. Discover such
6020 expressions and mark variables as addressable to avoid this
6024 discover_nonconstant_array_refs (void)
6027 gimple_stmt_iterator gsi
;
6029 FOR_EACH_BB_FN (bb
, cfun
)
6030 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
6032 gimple
*stmt
= gsi_stmt (gsi
);
6033 if (!is_gimple_debug (stmt
))
6034 walk_gimple_op (stmt
, discover_nonconstant_array_refs_r
, NULL
);
6038 /* This function sets crtl->args.internal_arg_pointer to a virtual
6039 register if DRAP is needed. Local register allocator will replace
6040 virtual_incoming_args_rtx with the virtual register. */
6043 expand_stack_alignment (void)
6046 unsigned int preferred_stack_boundary
;
6048 if (! SUPPORTS_STACK_ALIGNMENT
)
6051 if (cfun
->calls_alloca
6052 || cfun
->has_nonlocal_label
6053 || crtl
->has_nonlocal_goto
)
6054 crtl
->need_drap
= true;
6056 /* Call update_stack_boundary here again to update incoming stack
6057 boundary. It may set incoming stack alignment to a different
6058 value after RTL expansion. TARGET_FUNCTION_OK_FOR_SIBCALL may
6059 use the minimum incoming stack alignment to check if it is OK
6060 to perform sibcall optimization since sibcall optimization will
6061 only align the outgoing stack to incoming stack boundary. */
6062 if (targetm
.calls
.update_stack_boundary
)
6063 targetm
.calls
.update_stack_boundary ();
6065 /* The incoming stack frame has to be aligned at least at
6066 parm_stack_boundary. */
6067 gcc_assert (crtl
->parm_stack_boundary
<= INCOMING_STACK_BOUNDARY
);
6069 /* Update crtl->stack_alignment_estimated and use it later to align
6070 stack. We check PREFERRED_STACK_BOUNDARY if there may be non-call
6071 exceptions since callgraph doesn't collect incoming stack alignment
6073 if (cfun
->can_throw_non_call_exceptions
6074 && PREFERRED_STACK_BOUNDARY
> crtl
->preferred_stack_boundary
)
6075 preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
6077 preferred_stack_boundary
= crtl
->preferred_stack_boundary
;
6078 if (preferred_stack_boundary
> crtl
->stack_alignment_estimated
)
6079 crtl
->stack_alignment_estimated
= preferred_stack_boundary
;
6080 if (preferred_stack_boundary
> crtl
->stack_alignment_needed
)
6081 crtl
->stack_alignment_needed
= preferred_stack_boundary
;
6083 gcc_assert (crtl
->stack_alignment_needed
6084 <= crtl
->stack_alignment_estimated
);
6086 crtl
->stack_realign_needed
6087 = INCOMING_STACK_BOUNDARY
< crtl
->stack_alignment_estimated
;
6088 crtl
->stack_realign_tried
= crtl
->stack_realign_needed
;
6090 crtl
->stack_realign_processed
= true;
6092 /* Target has to redefine TARGET_GET_DRAP_RTX to support stack
6094 gcc_assert (targetm
.calls
.get_drap_rtx
!= NULL
);
6095 drap_rtx
= targetm
.calls
.get_drap_rtx ();
6097 /* stack_realign_drap and drap_rtx must match. */
6098 gcc_assert ((stack_realign_drap
!= 0) == (drap_rtx
!= NULL
));
6100 /* Do nothing if NULL is returned, which means DRAP is not needed. */
6101 if (drap_rtx
!= NULL
)
6103 crtl
->args
.internal_arg_pointer
= drap_rtx
;
6105 /* Call fixup_tail_calls to clean up REG_EQUIV note if DRAP is
6107 fixup_tail_calls ();
6113 expand_main_function (void)
6115 #if (defined(INVOKE__main) \
6116 || (!defined(HAS_INIT_SECTION) \
6117 && !defined(INIT_SECTION_ASM_OP) \
6118 && !defined(INIT_ARRAY_SECTION_ASM_OP)))
6119 emit_library_call (init_one_libfunc (NAME__MAIN
), LCT_NORMAL
, VOIDmode
);
6124 /* Expand code to initialize the stack_protect_guard. This is invoked at
6125 the beginning of a function to be protected. */
6128 stack_protect_prologue (void)
6130 tree guard_decl
= targetm
.stack_protect_guard ();
6133 x
= expand_normal (crtl
->stack_protect_guard
);
6135 y
= expand_normal (guard_decl
);
6139 /* Allow the target to copy from Y to X without leaking Y into a
6141 if (targetm
.have_stack_protect_set ())
6142 if (rtx_insn
*insn
= targetm
.gen_stack_protect_set (x
, y
))
6148 /* Otherwise do a straight move. */
6149 emit_move_insn (x
, y
);
6152 /* Translate the intermediate representation contained in the CFG
6153 from GIMPLE trees to RTL.
6155 We do conversion per basic block and preserve/update the tree CFG.
6156 This implies we have to do some magic as the CFG can simultaneously
6157 consist of basic blocks containing RTL and GIMPLE trees. This can
6158 confuse the CFG hooks, so be careful to not manipulate CFG during
6163 const pass_data pass_data_expand
=
6165 RTL_PASS
, /* type */
6166 "expand", /* name */
6167 OPTGROUP_NONE
, /* optinfo_flags */
6168 TV_EXPAND
, /* tv_id */
6169 ( PROP_ssa
| PROP_gimple_leh
| PROP_cfg
6172 | PROP_gimple_lva
), /* properties_required */
6173 PROP_rtl
, /* properties_provided */
6174 ( PROP_ssa
| PROP_trees
), /* properties_destroyed */
6175 0, /* todo_flags_start */
6176 0, /* todo_flags_finish */
6179 class pass_expand
: public rtl_opt_pass
6182 pass_expand (gcc::context
*ctxt
)
6183 : rtl_opt_pass (pass_data_expand
, ctxt
)
6186 /* opt_pass methods: */
6187 virtual unsigned int execute (function
*);
6189 }; // class pass_expand
6192 pass_expand::execute (function
*fun
)
6194 basic_block bb
, init_block
;
6197 rtx_insn
*var_seq
, *var_ret_seq
;
6200 timevar_push (TV_OUT_OF_SSA
);
6201 rewrite_out_of_ssa (&SA
);
6202 timevar_pop (TV_OUT_OF_SSA
);
6203 SA
.partition_to_pseudo
= XCNEWVEC (rtx
, SA
.map
->num_partitions
);
6205 if (MAY_HAVE_DEBUG_BIND_STMTS
&& flag_tree_ter
)
6207 gimple_stmt_iterator gsi
;
6208 FOR_EACH_BB_FN (bb
, cfun
)
6209 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
6210 if (gimple_debug_bind_p (gsi_stmt (gsi
)))
6211 avoid_deep_ter_for_debug (gsi_stmt (gsi
), 0);
6214 /* Make sure all values used by the optimization passes have sane
6218 /* Some backends want to know that we are expanding to RTL. */
6219 currently_expanding_to_rtl
= 1;
6220 /* Dominators are not kept up-to-date as we may create new basic-blocks. */
6221 free_dominance_info (CDI_DOMINATORS
);
6223 rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (fun
));
6225 insn_locations_init ();
6226 if (!DECL_IS_BUILTIN (current_function_decl
))
6228 /* Eventually, all FEs should explicitly set function_start_locus. */
6229 if (LOCATION_LOCUS (fun
->function_start_locus
) == UNKNOWN_LOCATION
)
6230 set_curr_insn_location
6231 (DECL_SOURCE_LOCATION (current_function_decl
));
6233 set_curr_insn_location (fun
->function_start_locus
);
6236 set_curr_insn_location (UNKNOWN_LOCATION
);
6237 prologue_location
= curr_insn_location ();
6239 #ifdef INSN_SCHEDULING
6240 init_sched_attrs ();
6243 /* Make sure first insn is a note even if we don't want linenums.
6244 This makes sure the first insn will never be deleted.
6245 Also, final expects a note to appear there. */
6246 emit_note (NOTE_INSN_DELETED
);
6248 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
6249 discover_nonconstant_array_refs ();
6251 targetm
.expand_to_rtl_hook ();
6252 crtl
->init_stack_alignment ();
6253 fun
->cfg
->max_jumptable_ents
= 0;
6255 /* Resovle the function section. Some targets, like ARM EABI rely on knowledge
6256 of the function section at exapnsion time to predict distance of calls. */
6257 resolve_unique_section (current_function_decl
, 0, flag_function_sections
);
6259 /* Expand the variables recorded during gimple lowering. */
6260 timevar_push (TV_VAR_EXPAND
);
6263 var_ret_seq
= expand_used_vars ();
6265 var_seq
= get_insns ();
6267 timevar_pop (TV_VAR_EXPAND
);
6269 /* Honor stack protection warnings. */
6270 if (warn_stack_protect
)
6272 if (fun
->calls_alloca
)
6273 warning (OPT_Wstack_protector
,
6274 "stack protector not protecting local variables: "
6275 "variable length buffer");
6276 if (has_short_buffer
&& !crtl
->stack_protect_guard
)
6277 warning (OPT_Wstack_protector
,
6278 "stack protector not protecting function: "
6279 "all local arrays are less than %d bytes long",
6280 (int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
));
6283 /* Set up parameters and prepare for return, for the function. */
6284 expand_function_start (current_function_decl
);
6286 /* If we emitted any instructions for setting up the variables,
6287 emit them before the FUNCTION_START note. */
6290 emit_insn_before (var_seq
, parm_birth_insn
);
6292 /* In expand_function_end we'll insert the alloca save/restore
6293 before parm_birth_insn. We've just insertted an alloca call.
6294 Adjust the pointer to match. */
6295 parm_birth_insn
= var_seq
;
6298 /* Now propagate the RTL assignment of each partition to the
6299 underlying var of each SSA_NAME. */
6302 FOR_EACH_SSA_NAME (i
, name
, cfun
)
6304 /* We might have generated new SSA names in
6305 update_alias_info_with_stack_vars. They will have a NULL
6306 defining statements, and won't be part of the partitioning,
6308 if (!SSA_NAME_DEF_STMT (name
))
6311 adjust_one_expanded_partition_var (name
);
6314 /* Clean up RTL of variables that straddle across multiple
6315 partitions, and check that the rtl of any PARM_DECLs that are not
6316 cleaned up is that of their default defs. */
6317 FOR_EACH_SSA_NAME (i
, name
, cfun
)
6321 /* We might have generated new SSA names in
6322 update_alias_info_with_stack_vars. They will have a NULL
6323 defining statements, and won't be part of the partitioning,
6325 if (!SSA_NAME_DEF_STMT (name
))
6327 part
= var_to_partition (SA
.map
, name
);
6328 if (part
== NO_PARTITION
)
6331 /* If this decl was marked as living in multiple places, reset
6332 this now to NULL. */
6333 tree var
= SSA_NAME_VAR (name
);
6334 if (var
&& DECL_RTL_IF_SET (var
) == pc_rtx
)
6335 SET_DECL_RTL (var
, NULL
);
6336 /* Check that the pseudos chosen by assign_parms are those of
6337 the corresponding default defs. */
6338 else if (SSA_NAME_IS_DEFAULT_DEF (name
)
6339 && (TREE_CODE (var
) == PARM_DECL
6340 || TREE_CODE (var
) == RESULT_DECL
))
6342 rtx in
= DECL_RTL_IF_SET (var
);
6344 rtx out
= SA
.partition_to_pseudo
[part
];
6345 gcc_assert (in
== out
);
6347 /* Now reset VAR's RTL to IN, so that the _EXPR attrs match
6348 those expected by debug backends for each parm and for
6349 the result. This is particularly important for stabs,
6350 whose register elimination from parm's DECL_RTL may cause
6351 -fcompare-debug differences as SET_DECL_RTL changes reg's
6352 attrs. So, make sure the RTL already has the parm as the
6353 EXPR, so that it won't change. */
6354 SET_DECL_RTL (var
, NULL_RTX
);
6356 set_mem_attributes (in
, var
, true);
6357 SET_DECL_RTL (var
, in
);
6361 /* If this function is `main', emit a call to `__main'
6362 to run global initializers, etc. */
6363 if (DECL_NAME (current_function_decl
)
6364 && MAIN_NAME_P (DECL_NAME (current_function_decl
))
6365 && DECL_FILE_SCOPE_P (current_function_decl
))
6366 expand_main_function ();
6368 /* Initialize the stack_protect_guard field. This must happen after the
6369 call to __main (if any) so that the external decl is initialized. */
6370 if (crtl
->stack_protect_guard
&& targetm
.stack_protect_runtime_enabled_p ())
6371 stack_protect_prologue ();
6373 expand_phi_nodes (&SA
);
6375 /* Release any stale SSA redirection data. */
6376 redirect_edge_var_map_empty ();
6378 /* Register rtl specific functions for cfg. */
6379 rtl_register_cfg_hooks ();
6381 init_block
= construct_init_block ();
6383 /* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
6384 remaining edges later. */
6385 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->succs
)
6386 e
->flags
&= ~EDGE_EXECUTABLE
;
6388 /* If the function has too many markers, drop them while expanding. */
6389 if (cfun
->debug_marker_count
6390 >= PARAM_VALUE (PARAM_MAX_DEBUG_MARKER_COUNT
))
6391 cfun
->debug_nonbind_markers
= false;
6393 lab_rtx_for_bb
= new hash_map
<basic_block
, rtx_code_label
*>;
6394 FOR_BB_BETWEEN (bb
, init_block
->next_bb
, EXIT_BLOCK_PTR_FOR_FN (fun
),
6396 bb
= expand_gimple_basic_block (bb
, var_ret_seq
!= NULL_RTX
);
6398 if (MAY_HAVE_DEBUG_BIND_INSNS
)
6399 expand_debug_locations ();
6401 if (deep_ter_debug_map
)
6403 delete deep_ter_debug_map
;
6404 deep_ter_debug_map
= NULL
;
6407 /* Free stuff we no longer need after GIMPLE optimizations. */
6408 free_dominance_info (CDI_DOMINATORS
);
6409 free_dominance_info (CDI_POST_DOMINATORS
);
6410 delete_tree_cfg_annotations (fun
);
6412 timevar_push (TV_OUT_OF_SSA
);
6413 finish_out_of_ssa (&SA
);
6414 timevar_pop (TV_OUT_OF_SSA
);
6416 timevar_push (TV_POST_EXPAND
);
6417 /* We are no longer in SSA form. */
6418 fun
->gimple_df
->in_ssa_p
= false;
6419 loops_state_clear (LOOP_CLOSED_SSA
);
6421 /* Expansion is used by optimization passes too, set maybe_hot_insn_p
6422 conservatively to true until they are all profile aware. */
6423 delete lab_rtx_for_bb
;
6424 free_histograms (fun
);
6426 construct_exit_block ();
6427 insn_locations_finalize ();
6431 rtx_insn
*after
= return_label
;
6432 rtx_insn
*next
= NEXT_INSN (after
);
6433 if (next
&& NOTE_INSN_BASIC_BLOCK_P (next
))
6435 emit_insn_after (var_ret_seq
, after
);
6438 /* Zap the tree EH table. */
6439 set_eh_throw_stmt_table (fun
, NULL
);
6441 /* We need JUMP_LABEL be set in order to redirect jumps, and hence
6442 split edges which edge insertions might do. */
6443 rebuild_jump_labels (get_insns ());
6445 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (fun
),
6446 EXIT_BLOCK_PTR_FOR_FN (fun
), next_bb
)
6450 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
6454 rebuild_jump_labels_chain (e
->insns
.r
);
6455 /* Put insns after parm birth, but before
6456 NOTE_INSNS_FUNCTION_BEG. */
6457 if (e
->src
== ENTRY_BLOCK_PTR_FOR_FN (fun
)
6458 && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (fun
)))
6460 rtx_insn
*insns
= e
->insns
.r
;
6462 if (NOTE_P (parm_birth_insn
)
6463 && NOTE_KIND (parm_birth_insn
) == NOTE_INSN_FUNCTION_BEG
)
6464 emit_insn_before_noloc (insns
, parm_birth_insn
, e
->dest
);
6466 emit_insn_after_noloc (insns
, parm_birth_insn
, e
->dest
);
6469 commit_one_edge_insertion (e
);
6476 /* We're done expanding trees to RTL. */
6477 currently_expanding_to_rtl
= 0;
6479 flush_mark_addressable_queue ();
6481 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->next_bb
,
6482 EXIT_BLOCK_PTR_FOR_FN (fun
), next_bb
)
6486 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
6488 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
6489 e
->flags
&= ~EDGE_EXECUTABLE
;
6491 /* At the moment not all abnormal edges match the RTL
6492 representation. It is safe to remove them here as
6493 find_many_sub_basic_blocks will rediscover them.
6494 In the future we should get this fixed properly. */
6495 if ((e
->flags
& EDGE_ABNORMAL
)
6496 && !(e
->flags
& EDGE_SIBCALL
))
6503 auto_sbitmap
blocks (last_basic_block_for_fn (fun
));
6504 bitmap_ones (blocks
);
6505 find_many_sub_basic_blocks (blocks
);
6506 purge_all_dead_edges ();
6508 expand_stack_alignment ();
6510 /* Fixup REG_EQUIV notes in the prologue if there are tailcalls in this
6512 if (crtl
->tail_call_emit
)
6513 fixup_tail_calls ();
6515 /* After initial rtl generation, call back to finish generating
6516 exception support code. We need to do this before cleaning up
6517 the CFG as the code does not expect dead landing pads. */
6518 if (fun
->eh
->region_tree
!= NULL
)
6519 finish_eh_generation ();
6521 /* BB subdivision may have created basic blocks that are are only reachable
6522 from unlikely bbs but not marked as such in the profile. */
6524 propagate_unlikely_bbs_forward ();
6526 /* Remove unreachable blocks, otherwise we cannot compute dominators
6527 which are needed for loop state verification. As a side-effect
6528 this also compacts blocks.
6529 ??? We cannot remove trivially dead insns here as for example
6530 the DRAP reg on i?86 is not magically live at this point.
6531 gcc.c-torture/execute/ipa-sra-2.c execution, -Os -m32 fails otherwise. */
6532 cleanup_cfg (CLEANUP_NO_INSN_DEL
);
6534 checking_verify_flow_info ();
6536 /* Initialize pseudos allocated for hard registers. */
6537 emit_initial_value_sets ();
6539 /* And finally unshare all RTL. */
6542 /* There's no need to defer outputting this function any more; we
6543 know we want to output it. */
6544 DECL_DEFER_OUTPUT (current_function_decl
) = 0;
6546 /* Now that we're done expanding trees to RTL, we shouldn't have any
6547 more CONCATs anywhere. */
6548 generating_concat_p
= 0;
6553 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
6554 /* And the pass manager will dump RTL for us. */
6557 /* If we're emitting a nested function, make sure its parent gets
6558 emitted as well. Doing otherwise confuses debug info. */
6561 for (parent
= DECL_CONTEXT (current_function_decl
);
6562 parent
!= NULL_TREE
;
6563 parent
= get_containing_scope (parent
))
6564 if (TREE_CODE (parent
) == FUNCTION_DECL
)
6565 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent
)) = 1;
6568 TREE_ASM_WRITTEN (current_function_decl
) = 1;
6570 /* After expanding, the return labels are no longer needed. */
6571 return_label
= NULL
;
6572 naked_return_label
= NULL
;
6574 /* After expanding, the tm_restart map is no longer needed. */
6575 if (fun
->gimple_df
->tm_restart
)
6576 fun
->gimple_df
->tm_restart
= NULL
;
6578 /* Tag the blocks with a depth number so that change_scope can find
6579 the common parent easily. */
6580 set_block_levels (DECL_INITIAL (fun
->decl
), 0);
6581 default_rtl_profile ();
6583 /* For -dx discard loops now, otherwise IL verify in clean_state will
6585 if (rtl_dump_and_exit
)
6587 cfun
->curr_properties
&= ~PROP_loops
;
6588 loop_optimizer_finalize ();
6591 timevar_pop (TV_POST_EXPAND
);
6599 make_pass_expand (gcc::context
*ctxt
)
6601 return new pass_expand (ctxt
);