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
);
1158 data
->asan_alignb
= MAX (data
->asan_alignb
, alignb
);
1159 if (data
->asan_base
== NULL
)
1160 data
->asan_base
= gen_reg_rtx (Pmode
);
1161 base
= data
->asan_base
;
1163 if (!STRICT_ALIGNMENT
)
1164 base_align
= crtl
->max_used_stack_slot_alignment
;
1166 base_align
= MAX (crtl
->max_used_stack_slot_alignment
,
1167 GET_MODE_ALIGNMENT (SImode
)
1168 << ASAN_SHADOW_SHIFT
);
1172 offset
= alloc_stack_frame_space (stack_vars
[i
].size
, alignb
);
1173 base_align
= crtl
->max_used_stack_slot_alignment
;
1178 /* Large alignment is only processed in the last pass. */
1182 /* If there were any variables requiring "large" alignment, allocate
1184 if (maybe_ne (large_size
, 0U) && ! large_allocation_done
)
1187 rtx large_allocsize
;
1189 large_allocsize
= gen_int_mode (large_size
, Pmode
);
1190 get_dynamic_stack_size (&large_allocsize
, 0, large_align
, NULL
);
1191 loffset
= alloc_stack_frame_space
1192 (rtx_to_poly_int64 (large_allocsize
),
1193 PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
);
1194 large_base
= get_dynamic_stack_base (loffset
, large_align
);
1195 large_allocation_done
= true;
1197 gcc_assert (large_base
!= NULL
);
1199 large_alloc
= aligned_upper_bound (large_alloc
, alignb
);
1200 offset
= large_alloc
;
1201 large_alloc
+= stack_vars
[i
].size
;
1204 base_align
= large_align
;
1207 /* Create rtl for each variable based on their location within the
1209 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1211 expand_one_stack_var_at (stack_vars
[j
].decl
,
1217 gcc_assert (known_eq (large_alloc
, large_size
));
1220 /* Take into account all sizes of partitions and reset DECL_RTLs. */
1222 account_stack_vars (void)
1224 size_t si
, j
, i
, n
= stack_vars_num
;
1225 poly_uint64 size
= 0;
1227 for (si
= 0; si
< n
; ++si
)
1229 i
= stack_vars_sorted
[si
];
1231 /* Skip variables that aren't partition representatives, for now. */
1232 if (stack_vars
[i
].representative
!= i
)
1235 size
+= stack_vars
[i
].size
;
1236 for (j
= i
; j
!= EOC
; j
= stack_vars
[j
].next
)
1237 set_rtl (stack_vars
[j
].decl
, NULL
);
1242 /* Record the RTL assignment X for the default def of PARM. */
1245 set_parm_rtl (tree parm
, rtx x
)
1247 gcc_assert (TREE_CODE (parm
) == PARM_DECL
1248 || TREE_CODE (parm
) == RESULT_DECL
);
1250 if (x
&& !MEM_P (x
))
1252 unsigned int align
= MINIMUM_ALIGNMENT (TREE_TYPE (parm
),
1253 TYPE_MODE (TREE_TYPE (parm
)),
1254 TYPE_ALIGN (TREE_TYPE (parm
)));
1256 /* If the variable alignment is very large we'll dynamicaly
1257 allocate it, which means that in-frame portion is just a
1258 pointer. ??? We've got a pseudo for sure here, do we
1259 actually dynamically allocate its spilling area if needed?
1260 ??? Isn't it a problem when POINTER_SIZE also exceeds
1261 MAX_SUPPORTED_STACK_ALIGNMENT, as on cris and lm32? */
1262 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1263 align
= POINTER_SIZE
;
1265 record_alignment_for_reg_var (align
);
1268 tree ssa
= ssa_default_def (cfun
, parm
);
1270 return set_rtl (parm
, x
);
1272 int part
= var_to_partition (SA
.map
, ssa
);
1273 gcc_assert (part
!= NO_PARTITION
);
1275 bool changed
= bitmap_bit_p (SA
.partitions_for_parm_default_defs
, part
);
1276 gcc_assert (changed
);
1279 gcc_assert (DECL_RTL (parm
) == x
);
1282 /* A subroutine of expand_one_var. Called to immediately assign rtl
1283 to a variable to be allocated in the stack frame. */
1286 expand_one_stack_var_1 (tree var
)
1290 unsigned byte_align
;
1292 if (TREE_CODE (var
) == SSA_NAME
)
1294 tree type
= TREE_TYPE (var
);
1295 size
= tree_to_poly_uint64 (TYPE_SIZE_UNIT (type
));
1296 byte_align
= TYPE_ALIGN_UNIT (type
);
1300 size
= tree_to_poly_uint64 (DECL_SIZE_UNIT (var
));
1301 byte_align
= align_local_variable (var
);
1304 /* We handle highly aligned variables in expand_stack_vars. */
1305 gcc_assert (byte_align
* BITS_PER_UNIT
<= MAX_SUPPORTED_STACK_ALIGNMENT
);
1307 offset
= alloc_stack_frame_space (size
, byte_align
);
1309 expand_one_stack_var_at (var
, virtual_stack_vars_rtx
,
1310 crtl
->max_used_stack_slot_alignment
, offset
);
1313 /* Wrapper for expand_one_stack_var_1 that checks SSA_NAMEs are
1314 already assigned some MEM. */
1317 expand_one_stack_var (tree var
)
1319 if (TREE_CODE (var
) == SSA_NAME
)
1321 int part
= var_to_partition (SA
.map
, var
);
1322 if (part
!= NO_PARTITION
)
1324 rtx x
= SA
.partition_to_pseudo
[part
];
1326 gcc_assert (MEM_P (x
));
1331 return expand_one_stack_var_1 (var
);
1334 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1335 that will reside in a hard register. */
1338 expand_one_hard_reg_var (tree var
)
1340 rest_of_decl_compilation (var
, 0, 0);
1343 /* Record the alignment requirements of some variable assigned to a
1347 record_alignment_for_reg_var (unsigned int align
)
1349 if (SUPPORTS_STACK_ALIGNMENT
1350 && crtl
->stack_alignment_estimated
< align
)
1352 /* stack_alignment_estimated shouldn't change after stack
1353 realign decision made */
1354 gcc_assert (!crtl
->stack_realign_processed
);
1355 crtl
->stack_alignment_estimated
= align
;
1358 /* stack_alignment_needed > PREFERRED_STACK_BOUNDARY is permitted.
1359 So here we only make sure stack_alignment_needed >= align. */
1360 if (crtl
->stack_alignment_needed
< align
)
1361 crtl
->stack_alignment_needed
= align
;
1362 if (crtl
->max_used_stack_slot_alignment
< align
)
1363 crtl
->max_used_stack_slot_alignment
= align
;
1366 /* Create RTL for an SSA partition. */
1369 expand_one_ssa_partition (tree var
)
1371 int part
= var_to_partition (SA
.map
, var
);
1372 gcc_assert (part
!= NO_PARTITION
);
1374 if (SA
.partition_to_pseudo
[part
])
1377 unsigned int align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1378 TYPE_MODE (TREE_TYPE (var
)),
1379 TYPE_ALIGN (TREE_TYPE (var
)));
1381 /* If the variable alignment is very large we'll dynamicaly allocate
1382 it, which means that in-frame portion is just a pointer. */
1383 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1384 align
= POINTER_SIZE
;
1386 record_alignment_for_reg_var (align
);
1388 if (!use_register_for_decl (var
))
1390 if (defer_stack_allocation (var
, true))
1391 add_stack_var (var
);
1393 expand_one_stack_var_1 (var
);
1397 machine_mode reg_mode
= promote_ssa_mode (var
, NULL
);
1398 rtx x
= gen_reg_rtx (reg_mode
);
1402 /* For a promoted variable, X will not be used directly but wrapped in a
1403 SUBREG with SUBREG_PROMOTED_VAR_P set, which means that the RTL land
1404 will assume that its upper bits can be inferred from its lower bits.
1405 Therefore, if X isn't initialized on every path from the entry, then
1406 we must do it manually in order to fulfill the above assumption. */
1407 if (reg_mode
!= TYPE_MODE (TREE_TYPE (var
))
1408 && bitmap_bit_p (SA
.partitions_for_undefined_values
, part
))
1409 emit_move_insn (x
, CONST0_RTX (reg_mode
));
1412 /* Record the association between the RTL generated for partition PART
1413 and the underlying variable of the SSA_NAME VAR. */
1416 adjust_one_expanded_partition_var (tree var
)
1421 tree decl
= SSA_NAME_VAR (var
);
1423 int part
= var_to_partition (SA
.map
, var
);
1424 if (part
== NO_PARTITION
)
1427 rtx x
= SA
.partition_to_pseudo
[part
];
1436 /* Note if the object is a user variable. */
1437 if (decl
&& !DECL_ARTIFICIAL (decl
))
1440 if (POINTER_TYPE_P (decl
? TREE_TYPE (decl
) : TREE_TYPE (var
)))
1441 mark_reg_pointer (x
, get_pointer_alignment (var
));
1444 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL
1445 that will reside in a pseudo register. */
1448 expand_one_register_var (tree var
)
1450 if (TREE_CODE (var
) == SSA_NAME
)
1452 int part
= var_to_partition (SA
.map
, var
);
1453 if (part
!= NO_PARTITION
)
1455 rtx x
= SA
.partition_to_pseudo
[part
];
1457 gcc_assert (REG_P (x
));
1464 tree type
= TREE_TYPE (decl
);
1465 machine_mode reg_mode
= promote_decl_mode (decl
, NULL
);
1466 rtx x
= gen_reg_rtx (reg_mode
);
1470 /* Note if the object is a user variable. */
1471 if (!DECL_ARTIFICIAL (decl
))
1474 if (POINTER_TYPE_P (type
))
1475 mark_reg_pointer (x
, get_pointer_alignment (var
));
1478 /* A subroutine of expand_one_var. Called to assign rtl to a VAR_DECL that
1479 has some associated error, e.g. its type is error-mark. We just need
1480 to pick something that won't crash the rest of the compiler. */
1483 expand_one_error_var (tree var
)
1485 machine_mode mode
= DECL_MODE (var
);
1488 if (mode
== BLKmode
)
1489 x
= gen_rtx_MEM (BLKmode
, const0_rtx
);
1490 else if (mode
== VOIDmode
)
1493 x
= gen_reg_rtx (mode
);
1495 SET_DECL_RTL (var
, x
);
1498 /* A subroutine of expand_one_var. VAR is a variable that will be
1499 allocated to the local stack frame. Return true if we wish to
1500 add VAR to STACK_VARS so that it will be coalesced with other
1501 variables. Return false to allocate VAR immediately.
1503 This function is used to reduce the number of variables considered
1504 for coalescing, which reduces the size of the quadratic problem. */
1507 defer_stack_allocation (tree var
, bool toplevel
)
1509 tree size_unit
= TREE_CODE (var
) == SSA_NAME
1510 ? TYPE_SIZE_UNIT (TREE_TYPE (var
))
1511 : DECL_SIZE_UNIT (var
);
1514 /* Whether the variable is small enough for immediate allocation not to be
1515 a problem with regard to the frame size. */
1517 = (poly_int_tree_p (size_unit
, &size
)
1518 && (estimated_poly_value (size
)
1519 < PARAM_VALUE (PARAM_MIN_SIZE_FOR_STACK_SHARING
)));
1521 /* If stack protection is enabled, *all* stack variables must be deferred,
1522 so that we can re-order the strings to the top of the frame.
1523 Similarly for Address Sanitizer. */
1524 if (flag_stack_protect
|| asan_sanitize_stack_p ())
1527 unsigned int align
= TREE_CODE (var
) == SSA_NAME
1528 ? TYPE_ALIGN (TREE_TYPE (var
))
1531 /* We handle "large" alignment via dynamic allocation. We want to handle
1532 this extra complication in only one place, so defer them. */
1533 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1536 bool ignored
= TREE_CODE (var
) == SSA_NAME
1537 ? !SSAVAR (var
) || DECL_IGNORED_P (SSA_NAME_VAR (var
))
1538 : DECL_IGNORED_P (var
);
1540 /* When optimization is enabled, DECL_IGNORED_P variables originally scoped
1541 might be detached from their block and appear at toplevel when we reach
1542 here. We want to coalesce them with variables from other blocks when
1543 the immediate contribution to the frame size would be noticeable. */
1544 if (toplevel
&& optimize
> 0 && ignored
&& !smallish
)
1547 /* Variables declared in the outermost scope automatically conflict
1548 with every other variable. The only reason to want to defer them
1549 at all is that, after sorting, we can more efficiently pack
1550 small variables in the stack frame. Continue to defer at -O2. */
1551 if (toplevel
&& optimize
< 2)
1554 /* Without optimization, *most* variables are allocated from the
1555 stack, which makes the quadratic problem large exactly when we
1556 want compilation to proceed as quickly as possible. On the
1557 other hand, we don't want the function's stack frame size to
1558 get completely out of hand. So we avoid adding scalars and
1559 "small" aggregates to the list at all. */
1560 if (optimize
== 0 && smallish
)
1566 /* A subroutine of expand_used_vars. Expand one variable according to
1567 its flavor. Variables to be placed on the stack are not actually
1568 expanded yet, merely recorded.
1569 When REALLY_EXPAND is false, only add stack values to be allocated.
1570 Return stack usage this variable is supposed to take.
1574 expand_one_var (tree var
, bool toplevel
, bool really_expand
)
1576 unsigned int align
= BITS_PER_UNIT
;
1581 if (TREE_TYPE (var
) != error_mark_node
&& VAR_P (var
))
1583 if (is_global_var (var
))
1586 /* Because we don't know if VAR will be in register or on stack,
1587 we conservatively assume it will be on stack even if VAR is
1588 eventually put into register after RA pass. For non-automatic
1589 variables, which won't be on stack, we collect alignment of
1590 type and ignore user specified alignment. Similarly for
1591 SSA_NAMEs for which use_register_for_decl returns true. */
1592 if (TREE_STATIC (var
)
1593 || DECL_EXTERNAL (var
)
1594 || (TREE_CODE (origvar
) == SSA_NAME
&& use_register_for_decl (var
)))
1595 align
= MINIMUM_ALIGNMENT (TREE_TYPE (var
),
1596 TYPE_MODE (TREE_TYPE (var
)),
1597 TYPE_ALIGN (TREE_TYPE (var
)));
1598 else if (DECL_HAS_VALUE_EXPR_P (var
)
1599 || (DECL_RTL_SET_P (var
) && MEM_P (DECL_RTL (var
))))
1600 /* Don't consider debug only variables with DECL_HAS_VALUE_EXPR_P set
1601 or variables which were assigned a stack slot already by
1602 expand_one_stack_var_at - in the latter case DECL_ALIGN has been
1603 changed from the offset chosen to it. */
1604 align
= crtl
->stack_alignment_estimated
;
1606 align
= MINIMUM_ALIGNMENT (var
, DECL_MODE (var
), DECL_ALIGN (var
));
1608 /* If the variable alignment is very large we'll dynamicaly allocate
1609 it, which means that in-frame portion is just a pointer. */
1610 if (align
> MAX_SUPPORTED_STACK_ALIGNMENT
)
1611 align
= POINTER_SIZE
;
1614 record_alignment_for_reg_var (align
);
1617 if (TREE_CODE (origvar
) == SSA_NAME
)
1619 gcc_assert (!VAR_P (var
)
1620 || (!DECL_EXTERNAL (var
)
1621 && !DECL_HAS_VALUE_EXPR_P (var
)
1622 && !TREE_STATIC (var
)
1623 && TREE_TYPE (var
) != error_mark_node
1624 && !DECL_HARD_REGISTER (var
)
1627 if (!VAR_P (var
) && TREE_CODE (origvar
) != SSA_NAME
)
1629 else if (DECL_EXTERNAL (var
))
1631 else if (DECL_HAS_VALUE_EXPR_P (var
))
1633 else if (TREE_STATIC (var
))
1635 else if (TREE_CODE (origvar
) != SSA_NAME
&& DECL_RTL_SET_P (var
))
1637 else if (TREE_TYPE (var
) == error_mark_node
)
1640 expand_one_error_var (var
);
1642 else if (VAR_P (var
) && DECL_HARD_REGISTER (var
))
1646 expand_one_hard_reg_var (var
);
1647 if (!DECL_HARD_REGISTER (var
))
1648 /* Invalid register specification. */
1649 expand_one_error_var (var
);
1652 else if (use_register_for_decl (var
))
1655 expand_one_register_var (origvar
);
1657 else if (!poly_int_tree_p (DECL_SIZE_UNIT (var
), &size
)
1658 || !valid_constant_size_p (DECL_SIZE_UNIT (var
)))
1660 /* Reject variables which cover more than half of the address-space. */
1663 error ("size of variable %q+D is too large", var
);
1664 expand_one_error_var (var
);
1667 else if (defer_stack_allocation (var
, toplevel
))
1668 add_stack_var (origvar
);
1673 if (lookup_attribute ("naked",
1674 DECL_ATTRIBUTES (current_function_decl
)))
1675 error ("cannot allocate stack for variable %q+D, naked function.",
1678 expand_one_stack_var (origvar
);
1685 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1686 expanding variables. Those variables that can be put into registers
1687 are allocated pseudos; those that can't are put on the stack.
1689 TOPLEVEL is true if this is the outermost BLOCK. */
1692 expand_used_vars_for_block (tree block
, bool toplevel
)
1696 /* Expand all variables at this level. */
1697 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1699 && ((!VAR_P (t
) && TREE_CODE (t
) != RESULT_DECL
)
1700 || !DECL_NONSHAREABLE (t
)))
1701 expand_one_var (t
, toplevel
, true);
1703 /* Expand all variables at containing levels. */
1704 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1705 expand_used_vars_for_block (t
, false);
1708 /* A subroutine of expand_used_vars. Walk down through the BLOCK tree
1709 and clear TREE_USED on all local variables. */
1712 clear_tree_used (tree block
)
1716 for (t
= BLOCK_VARS (block
); t
; t
= DECL_CHAIN (t
))
1717 /* if (!TREE_STATIC (t) && !DECL_EXTERNAL (t)) */
1718 if ((!VAR_P (t
) && TREE_CODE (t
) != RESULT_DECL
)
1719 || !DECL_NONSHAREABLE (t
))
1722 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
1723 clear_tree_used (t
);
1727 SPCT_FLAG_DEFAULT
= 1,
1729 SPCT_FLAG_STRONG
= 3,
1730 SPCT_FLAG_EXPLICIT
= 4
1733 /* Examine TYPE and determine a bit mask of the following features. */
1735 #define SPCT_HAS_LARGE_CHAR_ARRAY 1
1736 #define SPCT_HAS_SMALL_CHAR_ARRAY 2
1737 #define SPCT_HAS_ARRAY 4
1738 #define SPCT_HAS_AGGREGATE 8
1741 stack_protect_classify_type (tree type
)
1743 unsigned int ret
= 0;
1746 switch (TREE_CODE (type
))
1749 t
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1750 if (t
== char_type_node
1751 || t
== signed_char_type_node
1752 || t
== unsigned_char_type_node
)
1754 unsigned HOST_WIDE_INT max
= PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
);
1755 unsigned HOST_WIDE_INT len
;
1757 if (!TYPE_SIZE_UNIT (type
)
1758 || !tree_fits_uhwi_p (TYPE_SIZE_UNIT (type
)))
1761 len
= tree_to_uhwi (TYPE_SIZE_UNIT (type
));
1764 ret
= SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1766 ret
= SPCT_HAS_LARGE_CHAR_ARRAY
| SPCT_HAS_ARRAY
;
1769 ret
= SPCT_HAS_ARRAY
;
1773 case QUAL_UNION_TYPE
:
1775 ret
= SPCT_HAS_AGGREGATE
;
1776 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
1777 if (TREE_CODE (t
) == FIELD_DECL
)
1778 ret
|= stack_protect_classify_type (TREE_TYPE (t
));
1788 /* Return nonzero if DECL should be segregated into the "vulnerable" upper
1789 part of the local stack frame. Remember if we ever return nonzero for
1790 any variable in this function. The return value is the phase number in
1791 which the variable should be allocated. */
1794 stack_protect_decl_phase (tree decl
)
1796 unsigned int bits
= stack_protect_classify_type (TREE_TYPE (decl
));
1799 if (bits
& SPCT_HAS_SMALL_CHAR_ARRAY
)
1800 has_short_buffer
= true;
1802 if (flag_stack_protect
== SPCT_FLAG_ALL
1803 || flag_stack_protect
== SPCT_FLAG_STRONG
1804 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
1805 && lookup_attribute ("stack_protect",
1806 DECL_ATTRIBUTES (current_function_decl
))))
1808 if ((bits
& (SPCT_HAS_SMALL_CHAR_ARRAY
| SPCT_HAS_LARGE_CHAR_ARRAY
))
1809 && !(bits
& SPCT_HAS_AGGREGATE
))
1811 else if (bits
& SPCT_HAS_ARRAY
)
1815 ret
= (bits
& SPCT_HAS_LARGE_CHAR_ARRAY
) != 0;
1818 has_protected_decls
= true;
1823 /* Two helper routines that check for phase 1 and phase 2. These are used
1824 as callbacks for expand_stack_vars. */
1827 stack_protect_decl_phase_1 (size_t i
)
1829 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 1;
1833 stack_protect_decl_phase_2 (size_t i
)
1835 return stack_protect_decl_phase (stack_vars
[i
].decl
) == 2;
1838 /* And helper function that checks for asan phase (with stack protector
1839 it is phase 3). This is used as callback for expand_stack_vars.
1840 Returns true if any of the vars in the partition need to be protected. */
1843 asan_decl_phase_3 (size_t i
)
1847 if (asan_protect_stack_decl (stack_vars
[i
].decl
))
1849 i
= stack_vars
[i
].next
;
1854 /* Ensure that variables in different stack protection phases conflict
1855 so that they are not merged and share the same stack slot. */
1858 add_stack_protection_conflicts (void)
1860 size_t i
, j
, n
= stack_vars_num
;
1861 unsigned char *phase
;
1863 phase
= XNEWVEC (unsigned char, n
);
1864 for (i
= 0; i
< n
; ++i
)
1865 phase
[i
] = stack_protect_decl_phase (stack_vars
[i
].decl
);
1867 for (i
= 0; i
< n
; ++i
)
1869 unsigned char ph_i
= phase
[i
];
1870 for (j
= i
+ 1; j
< n
; ++j
)
1871 if (ph_i
!= phase
[j
])
1872 add_stack_var_conflict (i
, j
);
1878 /* Create a decl for the guard at the top of the stack frame. */
1881 create_stack_guard (void)
1883 tree guard
= build_decl (DECL_SOURCE_LOCATION (current_function_decl
),
1884 VAR_DECL
, NULL
, ptr_type_node
);
1885 TREE_THIS_VOLATILE (guard
) = 1;
1886 TREE_USED (guard
) = 1;
1887 expand_one_stack_var (guard
);
1888 crtl
->stack_protect_guard
= guard
;
1891 /* Prepare for expanding variables. */
1893 init_vars_expansion (void)
1895 /* Conflict bitmaps, and a few related temporary bitmaps, go here. */
1896 bitmap_obstack_initialize (&stack_var_bitmap_obstack
);
1898 /* A map from decl to stack partition. */
1899 decl_to_stack_part
= new hash_map
<tree
, size_t>;
1901 /* Initialize local stack smashing state. */
1902 has_protected_decls
= false;
1903 has_short_buffer
= false;
1906 /* Free up stack variable graph data. */
1908 fini_vars_expansion (void)
1910 bitmap_obstack_release (&stack_var_bitmap_obstack
);
1912 XDELETEVEC (stack_vars
);
1913 if (stack_vars_sorted
)
1914 XDELETEVEC (stack_vars_sorted
);
1916 stack_vars_sorted
= NULL
;
1917 stack_vars_alloc
= stack_vars_num
= 0;
1918 delete decl_to_stack_part
;
1919 decl_to_stack_part
= NULL
;
1922 /* Make a fair guess for the size of the stack frame of the function
1923 in NODE. This doesn't have to be exact, the result is only used in
1924 the inline heuristics. So we don't want to run the full stack var
1925 packing algorithm (which is quadratic in the number of stack vars).
1926 Instead, we calculate the total size of all stack vars. This turns
1927 out to be a pretty fair estimate -- packing of stack vars doesn't
1928 happen very often. */
1931 estimated_stack_frame_size (struct cgraph_node
*node
)
1933 poly_int64 size
= 0;
1936 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
1940 init_vars_expansion ();
1942 FOR_EACH_LOCAL_DECL (fn
, i
, var
)
1943 if (auto_var_in_fn_p (var
, fn
->decl
))
1944 size
+= expand_one_var (var
, true, false);
1946 if (stack_vars_num
> 0)
1948 /* Fake sorting the stack vars for account_stack_vars (). */
1949 stack_vars_sorted
= XNEWVEC (size_t, stack_vars_num
);
1950 for (i
= 0; i
< stack_vars_num
; ++i
)
1951 stack_vars_sorted
[i
] = i
;
1952 size
+= account_stack_vars ();
1955 fini_vars_expansion ();
1957 return estimated_poly_value (size
);
1960 /* Helper routine to check if a record or union contains an array field. */
1963 record_or_union_type_has_array_p (const_tree tree_type
)
1965 tree fields
= TYPE_FIELDS (tree_type
);
1968 for (f
= fields
; f
; f
= DECL_CHAIN (f
))
1969 if (TREE_CODE (f
) == FIELD_DECL
)
1971 tree field_type
= TREE_TYPE (f
);
1972 if (RECORD_OR_UNION_TYPE_P (field_type
)
1973 && record_or_union_type_has_array_p (field_type
))
1975 if (TREE_CODE (field_type
) == ARRAY_TYPE
)
1981 /* Check if the current function has local referenced variables that
1982 have their addresses taken, contain an array, or are arrays. */
1985 stack_protect_decl_p ()
1990 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
1991 if (!is_global_var (var
))
1993 tree var_type
= TREE_TYPE (var
);
1995 && (TREE_CODE (var_type
) == ARRAY_TYPE
1996 || TREE_ADDRESSABLE (var
)
1997 || (RECORD_OR_UNION_TYPE_P (var_type
)
1998 && record_or_union_type_has_array_p (var_type
))))
2004 /* Check if the current function has calls that use a return slot. */
2007 stack_protect_return_slot_p ()
2011 FOR_ALL_BB_FN (bb
, cfun
)
2012 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
2013 !gsi_end_p (gsi
); gsi_next (&gsi
))
2015 gimple
*stmt
= gsi_stmt (gsi
);
2016 /* This assumes that calls to internal-only functions never
2017 use a return slot. */
2018 if (is_gimple_call (stmt
)
2019 && !gimple_call_internal_p (stmt
)
2020 && aggregate_value_p (TREE_TYPE (gimple_call_fntype (stmt
)),
2021 gimple_call_fndecl (stmt
)))
2027 /* Expand all variables used in the function. */
2030 expand_used_vars (void)
2032 tree var
, outer_block
= DECL_INITIAL (current_function_decl
);
2033 auto_vec
<tree
> maybe_local_decls
;
2034 rtx_insn
*var_end_seq
= NULL
;
2037 bool gen_stack_protect_signal
= false;
2039 /* Compute the phase of the stack frame for this function. */
2041 int align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
2042 int off
= targetm
.starting_frame_offset () % align
;
2043 frame_phase
= off
? align
- off
: 0;
2046 /* Set TREE_USED on all variables in the local_decls. */
2047 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
2048 TREE_USED (var
) = 1;
2049 /* Clear TREE_USED on all variables associated with a block scope. */
2050 clear_tree_used (DECL_INITIAL (current_function_decl
));
2052 init_vars_expansion ();
2054 if (targetm
.use_pseudo_pic_reg ())
2055 pic_offset_table_rtx
= gen_reg_rtx (Pmode
);
2057 for (i
= 0; i
< SA
.map
->num_partitions
; i
++)
2059 if (bitmap_bit_p (SA
.partitions_for_parm_default_defs
, i
))
2062 tree var
= partition_to_var (SA
.map
, i
);
2064 gcc_assert (!virtual_operand_p (var
));
2066 expand_one_ssa_partition (var
);
2069 if (flag_stack_protect
== SPCT_FLAG_STRONG
)
2070 gen_stack_protect_signal
2071 = stack_protect_decl_p () || stack_protect_return_slot_p ();
2073 /* At this point all variables on the local_decls with TREE_USED
2074 set are not associated with any block scope. Lay them out. */
2076 len
= vec_safe_length (cfun
->local_decls
);
2077 FOR_EACH_LOCAL_DECL (cfun
, i
, var
)
2079 bool expand_now
= false;
2081 /* Expanded above already. */
2082 if (is_gimple_reg (var
))
2084 TREE_USED (var
) = 0;
2087 /* We didn't set a block for static or extern because it's hard
2088 to tell the difference between a global variable (re)declared
2089 in a local scope, and one that's really declared there to
2090 begin with. And it doesn't really matter much, since we're
2091 not giving them stack space. Expand them now. */
2092 else if (TREE_STATIC (var
) || DECL_EXTERNAL (var
))
2095 /* Expand variables not associated with any block now. Those created by
2096 the optimizers could be live anywhere in the function. Those that
2097 could possibly have been scoped originally and detached from their
2098 block will have their allocation deferred so we coalesce them with
2099 others when optimization is enabled. */
2100 else if (TREE_USED (var
))
2103 /* Finally, mark all variables on the list as used. We'll use
2104 this in a moment when we expand those associated with scopes. */
2105 TREE_USED (var
) = 1;
2108 expand_one_var (var
, true, true);
2111 if (DECL_ARTIFICIAL (var
) && !DECL_IGNORED_P (var
))
2113 rtx rtl
= DECL_RTL_IF_SET (var
);
2115 /* Keep artificial non-ignored vars in cfun->local_decls
2116 chain until instantiate_decls. */
2117 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
2118 add_local_decl (cfun
, var
);
2119 else if (rtl
== NULL_RTX
)
2120 /* If rtl isn't set yet, which can happen e.g. with
2121 -fstack-protector, retry before returning from this
2123 maybe_local_decls
.safe_push (var
);
2127 /* We duplicated some of the decls in CFUN->LOCAL_DECLS.
2129 +-----------------+-----------------+
2130 | ...processed... | ...duplicates...|
2131 +-----------------+-----------------+
2133 +-- LEN points here.
2135 We just want the duplicates, as those are the artificial
2136 non-ignored vars that we want to keep until instantiate_decls.
2137 Move them down and truncate the array. */
2138 if (!vec_safe_is_empty (cfun
->local_decls
))
2139 cfun
->local_decls
->block_remove (0, len
);
2141 /* At this point, all variables within the block tree with TREE_USED
2142 set are actually used by the optimized function. Lay them out. */
2143 expand_used_vars_for_block (outer_block
, true);
2145 if (stack_vars_num
> 0)
2147 add_scope_conflicts ();
2149 /* If stack protection is enabled, we don't share space between
2150 vulnerable data and non-vulnerable data. */
2151 if (flag_stack_protect
!= 0
2152 && (flag_stack_protect
!= SPCT_FLAG_EXPLICIT
2153 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
2154 && lookup_attribute ("stack_protect",
2155 DECL_ATTRIBUTES (current_function_decl
)))))
2156 add_stack_protection_conflicts ();
2158 /* Now that we have collected all stack variables, and have computed a
2159 minimal interference graph, attempt to save some stack space. */
2160 partition_stack_vars ();
2162 dump_stack_var_partition ();
2165 switch (flag_stack_protect
)
2168 create_stack_guard ();
2171 case SPCT_FLAG_STRONG
:
2172 if (gen_stack_protect_signal
2173 || cfun
->calls_alloca
|| has_protected_decls
2174 || lookup_attribute ("stack_protect",
2175 DECL_ATTRIBUTES (current_function_decl
)))
2176 create_stack_guard ();
2179 case SPCT_FLAG_DEFAULT
:
2180 if (cfun
->calls_alloca
|| has_protected_decls
2181 || lookup_attribute ("stack_protect",
2182 DECL_ATTRIBUTES (current_function_decl
)))
2183 create_stack_guard ();
2186 case SPCT_FLAG_EXPLICIT
:
2187 if (lookup_attribute ("stack_protect",
2188 DECL_ATTRIBUTES (current_function_decl
)))
2189 create_stack_guard ();
2195 /* Assign rtl to each variable based on these partitions. */
2196 if (stack_vars_num
> 0)
2198 struct stack_vars_data data
;
2200 data
.asan_base
= NULL_RTX
;
2201 data
.asan_alignb
= 0;
2203 /* Reorder decls to be protected by iterating over the variables
2204 array multiple times, and allocating out of each phase in turn. */
2205 /* ??? We could probably integrate this into the qsort we did
2206 earlier, such that we naturally see these variables first,
2207 and thus naturally allocate things in the right order. */
2208 if (has_protected_decls
)
2210 /* Phase 1 contains only character arrays. */
2211 expand_stack_vars (stack_protect_decl_phase_1
, &data
);
2213 /* Phase 2 contains other kinds of arrays. */
2214 if (flag_stack_protect
== SPCT_FLAG_ALL
2215 || flag_stack_protect
== SPCT_FLAG_STRONG
2216 || (flag_stack_protect
== SPCT_FLAG_EXPLICIT
2217 && lookup_attribute ("stack_protect",
2218 DECL_ATTRIBUTES (current_function_decl
))))
2219 expand_stack_vars (stack_protect_decl_phase_2
, &data
);
2222 if (asan_sanitize_stack_p ())
2223 /* Phase 3, any partitions that need asan protection
2224 in addition to phase 1 and 2. */
2225 expand_stack_vars (asan_decl_phase_3
, &data
);
2227 /* ASAN description strings don't yet have a syntax for expressing
2228 polynomial offsets. */
2229 HOST_WIDE_INT prev_offset
;
2230 if (!data
.asan_vec
.is_empty ()
2231 && frame_offset
.is_constant (&prev_offset
))
2233 HOST_WIDE_INT offset
, sz
, redzonesz
;
2234 redzonesz
= ASAN_RED_ZONE_SIZE
;
2235 sz
= data
.asan_vec
[0] - prev_offset
;
2236 if (data
.asan_alignb
> ASAN_RED_ZONE_SIZE
2237 && data
.asan_alignb
<= 4096
2238 && sz
+ ASAN_RED_ZONE_SIZE
>= (int) data
.asan_alignb
)
2239 redzonesz
= ((sz
+ ASAN_RED_ZONE_SIZE
+ data
.asan_alignb
- 1)
2240 & ~(data
.asan_alignb
- HOST_WIDE_INT_1
)) - sz
;
2241 /* Allocating a constant amount of space from a constant
2242 starting offset must give a constant result. */
2243 offset
= (alloc_stack_frame_space (redzonesz
, ASAN_RED_ZONE_SIZE
)
2245 data
.asan_vec
.safe_push (prev_offset
);
2246 data
.asan_vec
.safe_push (offset
);
2247 /* Leave space for alignment if STRICT_ALIGNMENT. */
2248 if (STRICT_ALIGNMENT
)
2249 alloc_stack_frame_space ((GET_MODE_ALIGNMENT (SImode
)
2250 << ASAN_SHADOW_SHIFT
)
2251 / BITS_PER_UNIT
, 1);
2254 = asan_emit_stack_protection (virtual_stack_vars_rtx
,
2257 data
.asan_vec
.address (),
2258 data
.asan_decl_vec
.address (),
2259 data
.asan_vec
.length ());
2262 expand_stack_vars (NULL
, &data
);
2265 if (asan_sanitize_allocas_p () && cfun
->calls_alloca
)
2266 var_end_seq
= asan_emit_allocas_unpoison (virtual_stack_dynamic_rtx
,
2267 virtual_stack_vars_rtx
,
2270 fini_vars_expansion ();
2272 /* If there were any artificial non-ignored vars without rtl
2273 found earlier, see if deferred stack allocation hasn't assigned
2275 FOR_EACH_VEC_ELT_REVERSE (maybe_local_decls
, i
, var
)
2277 rtx rtl
= DECL_RTL_IF_SET (var
);
2279 /* Keep artificial non-ignored vars in cfun->local_decls
2280 chain until instantiate_decls. */
2281 if (rtl
&& (MEM_P (rtl
) || GET_CODE (rtl
) == CONCAT
))
2282 add_local_decl (cfun
, var
);
2285 /* If the target requires that FRAME_OFFSET be aligned, do it. */
2286 if (STACK_ALIGNMENT_NEEDED
)
2288 HOST_WIDE_INT align
= PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
;
2289 if (FRAME_GROWS_DOWNWARD
)
2290 frame_offset
= aligned_lower_bound (frame_offset
, align
);
2292 frame_offset
= aligned_upper_bound (frame_offset
, align
);
2299 /* If we need to produce a detailed dump, print the tree representation
2300 for STMT to the dump file. SINCE is the last RTX after which the RTL
2301 generated for STMT should have been appended. */
2304 maybe_dump_rtl_for_gimple_stmt (gimple
*stmt
, rtx_insn
*since
)
2306 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2308 fprintf (dump_file
, "\n;; ");
2309 print_gimple_stmt (dump_file
, stmt
, 0,
2310 TDF_SLIM
| (dump_flags
& TDF_LINENO
));
2311 fprintf (dump_file
, "\n");
2313 print_rtl (dump_file
, since
? NEXT_INSN (since
) : since
);
2317 /* Maps the blocks that do not contain tree labels to rtx labels. */
2319 static hash_map
<basic_block
, rtx_code_label
*> *lab_rtx_for_bb
;
2321 /* Returns the label_rtx expression for a label starting basic block BB. */
2323 static rtx_code_label
*
2324 label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED
)
2326 gimple_stmt_iterator gsi
;
2329 if (bb
->flags
& BB_RTL
)
2330 return block_label (bb
);
2332 rtx_code_label
**elt
= lab_rtx_for_bb
->get (bb
);
2336 /* Find the tree label if it is present. */
2338 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2342 lab_stmt
= dyn_cast
<glabel
*> (gsi_stmt (gsi
));
2346 lab
= gimple_label_label (lab_stmt
);
2347 if (DECL_NONLOCAL (lab
))
2350 return jump_target_rtx (lab
);
2353 rtx_code_label
*l
= gen_label_rtx ();
2354 lab_rtx_for_bb
->put (bb
, l
);
2359 /* A subroutine of expand_gimple_cond. Given E, a fallthrough edge
2360 of a basic block where we just expanded the conditional at the end,
2361 possibly clean up the CFG and instruction sequence. LAST is the
2362 last instruction before the just emitted jump sequence. */
2365 maybe_cleanup_end_of_block (edge e
, rtx_insn
*last
)
2367 /* Special case: when jumpif decides that the condition is
2368 trivial it emits an unconditional jump (and the necessary
2369 barrier). But we still have two edges, the fallthru one is
2370 wrong. purge_dead_edges would clean this up later. Unfortunately
2371 we have to insert insns (and split edges) before
2372 find_many_sub_basic_blocks and hence before purge_dead_edges.
2373 But splitting edges might create new blocks which depend on the
2374 fact that if there are two edges there's no barrier. So the
2375 barrier would get lost and verify_flow_info would ICE. Instead
2376 of auditing all edge splitters to care for the barrier (which
2377 normally isn't there in a cleaned CFG), fix it here. */
2378 if (BARRIER_P (get_last_insn ()))
2382 /* Now, we have a single successor block, if we have insns to
2383 insert on the remaining edge we potentially will insert
2384 it at the end of this block (if the dest block isn't feasible)
2385 in order to avoid splitting the edge. This insertion will take
2386 place in front of the last jump. But we might have emitted
2387 multiple jumps (conditional and one unconditional) to the
2388 same destination. Inserting in front of the last one then
2389 is a problem. See PR 40021. We fix this by deleting all
2390 jumps except the last unconditional one. */
2391 insn
= PREV_INSN (get_last_insn ());
2392 /* Make sure we have an unconditional jump. Otherwise we're
2394 gcc_assert (JUMP_P (insn
) && !any_condjump_p (insn
));
2395 for (insn
= PREV_INSN (insn
); insn
!= last
;)
2397 insn
= PREV_INSN (insn
);
2398 if (JUMP_P (NEXT_INSN (insn
)))
2400 if (!any_condjump_p (NEXT_INSN (insn
)))
2402 gcc_assert (BARRIER_P (NEXT_INSN (NEXT_INSN (insn
))));
2403 delete_insn (NEXT_INSN (NEXT_INSN (insn
)));
2405 delete_insn (NEXT_INSN (insn
));
2411 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_COND.
2412 Returns a new basic block if we've terminated the current basic
2413 block and created a new one. */
2416 expand_gimple_cond (basic_block bb
, gcond
*stmt
)
2418 basic_block new_bb
, dest
;
2421 rtx_insn
*last2
, *last
;
2422 enum tree_code code
;
2425 code
= gimple_cond_code (stmt
);
2426 op0
= gimple_cond_lhs (stmt
);
2427 op1
= gimple_cond_rhs (stmt
);
2428 /* We're sometimes presented with such code:
2432 This would expand to two comparisons which then later might
2433 be cleaned up by combine. But some pattern matchers like if-conversion
2434 work better when there's only one compare, so make up for this
2435 here as special exception if TER would have made the same change. */
2437 && TREE_CODE (op0
) == SSA_NAME
2438 && TREE_CODE (TREE_TYPE (op0
)) == BOOLEAN_TYPE
2439 && TREE_CODE (op1
) == INTEGER_CST
2440 && ((gimple_cond_code (stmt
) == NE_EXPR
2441 && integer_zerop (op1
))
2442 || (gimple_cond_code (stmt
) == EQ_EXPR
2443 && integer_onep (op1
)))
2444 && bitmap_bit_p (SA
.values
, SSA_NAME_VERSION (op0
)))
2446 gimple
*second
= SSA_NAME_DEF_STMT (op0
);
2447 if (gimple_code (second
) == GIMPLE_ASSIGN
)
2449 enum tree_code code2
= gimple_assign_rhs_code (second
);
2450 if (TREE_CODE_CLASS (code2
) == tcc_comparison
)
2453 op0
= gimple_assign_rhs1 (second
);
2454 op1
= gimple_assign_rhs2 (second
);
2456 /* If jumps are cheap and the target does not support conditional
2457 compare, turn some more codes into jumpy sequences. */
2458 else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4
2459 && targetm
.gen_ccmp_first
== NULL
)
2461 if ((code2
== BIT_AND_EXPR
2462 && TYPE_PRECISION (TREE_TYPE (op0
)) == 1
2463 && TREE_CODE (gimple_assign_rhs2 (second
)) != INTEGER_CST
)
2464 || code2
== TRUTH_AND_EXPR
)
2466 code
= TRUTH_ANDIF_EXPR
;
2467 op0
= gimple_assign_rhs1 (second
);
2468 op1
= gimple_assign_rhs2 (second
);
2470 else if (code2
== BIT_IOR_EXPR
|| code2
== TRUTH_OR_EXPR
)
2472 code
= TRUTH_ORIF_EXPR
;
2473 op0
= gimple_assign_rhs1 (second
);
2474 op1
= gimple_assign_rhs2 (second
);
2480 last2
= last
= get_last_insn ();
2482 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
2483 set_curr_insn_location (gimple_location (stmt
));
2485 /* These flags have no purpose in RTL land. */
2486 true_edge
->flags
&= ~EDGE_TRUE_VALUE
;
2487 false_edge
->flags
&= ~EDGE_FALSE_VALUE
;
2489 /* We can either have a pure conditional jump with one fallthru edge or
2490 two-way jump that needs to be decomposed into two basic blocks. */
2491 if (false_edge
->dest
== bb
->next_bb
)
2493 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2494 true_edge
->probability
);
2495 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2496 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2497 set_curr_insn_location (true_edge
->goto_locus
);
2498 false_edge
->flags
|= EDGE_FALLTHRU
;
2499 maybe_cleanup_end_of_block (false_edge
, last
);
2502 if (true_edge
->dest
== bb
->next_bb
)
2504 jumpifnot_1 (code
, op0
, op1
, label_rtx_for_bb (false_edge
->dest
),
2505 false_edge
->probability
);
2506 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
2507 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2508 set_curr_insn_location (false_edge
->goto_locus
);
2509 true_edge
->flags
|= EDGE_FALLTHRU
;
2510 maybe_cleanup_end_of_block (true_edge
, last
);
2514 jumpif_1 (code
, op0
, op1
, label_rtx_for_bb (true_edge
->dest
),
2515 true_edge
->probability
);
2516 last
= get_last_insn ();
2517 if (false_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2518 set_curr_insn_location (false_edge
->goto_locus
);
2519 emit_jump (label_rtx_for_bb (false_edge
->dest
));
2522 if (BARRIER_P (BB_END (bb
)))
2523 BB_END (bb
) = PREV_INSN (BB_END (bb
));
2524 update_bb_for_insn (bb
);
2526 new_bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
2527 dest
= false_edge
->dest
;
2528 redirect_edge_succ (false_edge
, new_bb
);
2529 false_edge
->flags
|= EDGE_FALLTHRU
;
2530 new_bb
->count
= false_edge
->count ();
2531 loop_p loop
= find_common_loop (bb
->loop_father
, dest
->loop_father
);
2532 add_bb_to_loop (new_bb
, loop
);
2533 if (loop
->latch
== bb
2534 && loop
->header
== dest
)
2535 loop
->latch
= new_bb
;
2536 make_single_succ_edge (new_bb
, dest
, 0);
2537 if (BARRIER_P (BB_END (new_bb
)))
2538 BB_END (new_bb
) = PREV_INSN (BB_END (new_bb
));
2539 update_bb_for_insn (new_bb
);
2541 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
2543 if (true_edge
->goto_locus
!= UNKNOWN_LOCATION
)
2545 set_curr_insn_location (true_edge
->goto_locus
);
2546 true_edge
->goto_locus
= curr_insn_location ();
2552 /* Mark all calls that can have a transaction restart. */
2555 mark_transaction_restart_calls (gimple
*stmt
)
2557 struct tm_restart_node dummy
;
2558 tm_restart_node
**slot
;
2560 if (!cfun
->gimple_df
->tm_restart
)
2564 slot
= cfun
->gimple_df
->tm_restart
->find_slot (&dummy
, NO_INSERT
);
2567 struct tm_restart_node
*n
= *slot
;
2568 tree list
= n
->label_or_list
;
2571 for (insn
= next_real_insn (get_last_insn ());
2573 insn
= next_real_insn (insn
))
2576 if (TREE_CODE (list
) == LABEL_DECL
)
2577 add_reg_note (insn
, REG_TM
, label_rtx (list
));
2579 for (; list
; list
= TREE_CHAIN (list
))
2580 add_reg_note (insn
, REG_TM
, label_rtx (TREE_VALUE (list
)));
2584 /* A subroutine of expand_gimple_stmt_1, expanding one GIMPLE_CALL
2588 expand_call_stmt (gcall
*stmt
)
2590 tree exp
, decl
, lhs
;
2594 if (gimple_call_internal_p (stmt
))
2596 expand_internal_call (stmt
);
2600 /* If this is a call to a built-in function and it has no effect other
2601 than setting the lhs, try to implement it using an internal function
2603 decl
= gimple_call_fndecl (stmt
);
2604 if (gimple_call_lhs (stmt
)
2605 && !gimple_has_side_effects (stmt
)
2606 && (optimize
|| (decl
&& called_as_built_in (decl
))))
2608 internal_fn ifn
= replacement_internal_fn (stmt
);
2609 if (ifn
!= IFN_LAST
)
2611 expand_internal_call (ifn
, stmt
);
2616 exp
= build_vl_exp (CALL_EXPR
, gimple_call_num_args (stmt
) + 3);
2618 CALL_EXPR_FN (exp
) = gimple_call_fn (stmt
);
2619 builtin_p
= decl
&& DECL_BUILT_IN (decl
);
2621 /* If this is not a builtin function, the function type through which the
2622 call is made may be different from the type of the function. */
2625 = fold_convert (build_pointer_type (gimple_call_fntype (stmt
)),
2626 CALL_EXPR_FN (exp
));
2628 TREE_TYPE (exp
) = gimple_call_return_type (stmt
);
2629 CALL_EXPR_STATIC_CHAIN (exp
) = gimple_call_chain (stmt
);
2631 for (i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2633 tree arg
= gimple_call_arg (stmt
, i
);
2635 /* TER addresses into arguments of builtin functions so we have a
2636 chance to infer more correct alignment information. See PR39954. */
2638 && TREE_CODE (arg
) == SSA_NAME
2639 && (def
= get_gimple_for_ssa_name (arg
))
2640 && gimple_assign_rhs_code (def
) == ADDR_EXPR
)
2641 arg
= gimple_assign_rhs1 (def
);
2642 CALL_EXPR_ARG (exp
, i
) = arg
;
2645 if (gimple_has_side_effects (stmt
))
2646 TREE_SIDE_EFFECTS (exp
) = 1;
2648 if (gimple_call_nothrow_p (stmt
))
2649 TREE_NOTHROW (exp
) = 1;
2651 if (gimple_no_warning_p (stmt
))
2652 TREE_NO_WARNING (exp
) = 1;
2654 CALL_EXPR_TAILCALL (exp
) = gimple_call_tail_p (stmt
);
2655 CALL_EXPR_MUST_TAIL_CALL (exp
) = gimple_call_must_tail_p (stmt
);
2656 CALL_EXPR_RETURN_SLOT_OPT (exp
) = gimple_call_return_slot_opt_p (stmt
);
2658 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
2659 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (decl
)))
2660 CALL_ALLOCA_FOR_VAR_P (exp
) = gimple_call_alloca_for_var_p (stmt
);
2662 CALL_FROM_THUNK_P (exp
) = gimple_call_from_thunk_p (stmt
);
2663 CALL_EXPR_VA_ARG_PACK (exp
) = gimple_call_va_arg_pack_p (stmt
);
2664 CALL_EXPR_BY_DESCRIPTOR (exp
) = gimple_call_by_descriptor_p (stmt
);
2665 SET_EXPR_LOCATION (exp
, gimple_location (stmt
));
2667 /* Ensure RTL is created for debug args. */
2668 if (decl
&& DECL_HAS_DEBUG_ARGS_P (decl
))
2670 vec
<tree
, va_gc
> **debug_args
= decl_debug_args_lookup (decl
);
2675 for (ix
= 1; (*debug_args
)->iterate (ix
, &dtemp
); ix
+= 2)
2677 gcc_assert (TREE_CODE (dtemp
) == DEBUG_EXPR_DECL
);
2678 expand_debug_expr (dtemp
);
2682 rtx_insn
*before_call
= get_last_insn ();
2683 lhs
= gimple_call_lhs (stmt
);
2685 expand_assignment (lhs
, exp
, false);
2687 expand_expr (exp
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2689 /* If the gimple call is an indirect call and has 'nocf_check'
2690 attribute find a generated CALL insn to mark it as no
2691 control-flow verification is needed. */
2692 if (gimple_call_nocf_check_p (stmt
)
2693 && !gimple_call_fndecl (stmt
))
2695 rtx_insn
*last
= get_last_insn ();
2696 while (!CALL_P (last
)
2697 && last
!= before_call
)
2698 last
= PREV_INSN (last
);
2700 if (last
!= before_call
)
2701 add_reg_note (last
, REG_CALL_NOCF_CHECK
, const0_rtx
);
2704 mark_transaction_restart_calls (stmt
);
2708 /* Generate RTL for an asm statement (explicit assembler code).
2709 STRING is a STRING_CST node containing the assembler code text,
2710 or an ADDR_EXPR containing a STRING_CST. VOL nonzero means the
2711 insn is volatile; don't optimize it. */
2714 expand_asm_loc (tree string
, int vol
, location_t locus
)
2718 body
= gen_rtx_ASM_INPUT_loc (VOIDmode
,
2719 ggc_strdup (TREE_STRING_POINTER (string
)),
2722 MEM_VOLATILE_P (body
) = vol
;
2724 /* Non-empty basic ASM implicitly clobbers memory. */
2725 if (TREE_STRING_LENGTH (string
) != 0)
2728 unsigned i
, nclobbers
;
2729 auto_vec
<rtx
> input_rvec
, output_rvec
;
2730 auto_vec
<const char *> constraints
;
2731 auto_vec
<rtx
> clobber_rvec
;
2732 HARD_REG_SET clobbered_regs
;
2733 CLEAR_HARD_REG_SET (clobbered_regs
);
2735 clob
= gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
));
2736 clobber_rvec
.safe_push (clob
);
2738 if (targetm
.md_asm_adjust
)
2739 targetm
.md_asm_adjust (output_rvec
, input_rvec
,
2740 constraints
, clobber_rvec
,
2744 nclobbers
= clobber_rvec
.length ();
2745 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (1 + nclobbers
));
2747 XVECEXP (body
, 0, 0) = asm_op
;
2748 for (i
= 0; i
< nclobbers
; i
++)
2749 XVECEXP (body
, 0, i
+ 1) = gen_rtx_CLOBBER (VOIDmode
, clobber_rvec
[i
]);
2755 /* Return the number of times character C occurs in string S. */
2757 n_occurrences (int c
, const char *s
)
2765 /* A subroutine of expand_asm_operands. Check that all operands have
2766 the same number of alternatives. Return true if so. */
2769 check_operand_nalternatives (const vec
<const char *> &constraints
)
2771 unsigned len
= constraints
.length();
2774 int nalternatives
= n_occurrences (',', constraints
[0]);
2776 if (nalternatives
+ 1 > MAX_RECOG_ALTERNATIVES
)
2778 error ("too many alternatives in %<asm%>");
2782 for (unsigned i
= 1; i
< len
; ++i
)
2783 if (n_occurrences (',', constraints
[i
]) != nalternatives
)
2785 error ("operand constraints for %<asm%> differ "
2786 "in number of alternatives");
2793 /* Check for overlap between registers marked in CLOBBERED_REGS and
2794 anything inappropriate in T. Emit error and return the register
2795 variable definition for error, NULL_TREE for ok. */
2798 tree_conflicts_with_clobbers_p (tree t
, HARD_REG_SET
*clobbered_regs
)
2800 /* Conflicts between asm-declared register variables and the clobber
2801 list are not allowed. */
2802 tree overlap
= tree_overlaps_hard_reg_set (t
, clobbered_regs
);
2806 error ("asm-specifier for variable %qE conflicts with asm clobber list",
2807 DECL_NAME (overlap
));
2809 /* Reset registerness to stop multiple errors emitted for a single
2811 DECL_REGISTER (overlap
) = 0;
2818 /* Generate RTL for an asm statement with arguments.
2819 STRING is the instruction template.
2820 OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
2821 Each output or input has an expression in the TREE_VALUE and
2822 a tree list in TREE_PURPOSE which in turn contains a constraint
2823 name in TREE_VALUE (or NULL_TREE) and a constraint string
2825 CLOBBERS is a list of STRING_CST nodes each naming a hard register
2826 that is clobbered by this insn.
2828 LABELS is a list of labels, and if LABELS is non-NULL, FALLTHRU_BB
2829 should be the fallthru basic block of the asm goto.
2831 Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
2832 Some elements of OUTPUTS may be replaced with trees representing temporary
2833 values. The caller should copy those temporary values to the originally
2836 VOL nonzero means the insn is volatile; don't optimize it. */
2839 expand_asm_stmt (gasm
*stmt
)
2841 class save_input_location
2846 explicit save_input_location(location_t where
)
2848 old
= input_location
;
2849 input_location
= where
;
2852 ~save_input_location()
2854 input_location
= old
;
2858 location_t locus
= gimple_location (stmt
);
2860 if (gimple_asm_input_p (stmt
))
2862 const char *s
= gimple_asm_string (stmt
);
2863 tree string
= build_string (strlen (s
), s
);
2864 expand_asm_loc (string
, gimple_asm_volatile_p (stmt
), locus
);
2868 /* There are some legacy diagnostics in here, and also avoids a
2869 sixth parameger to targetm.md_asm_adjust. */
2870 save_input_location
s_i_l(locus
);
2872 unsigned noutputs
= gimple_asm_noutputs (stmt
);
2873 unsigned ninputs
= gimple_asm_ninputs (stmt
);
2874 unsigned nlabels
= gimple_asm_nlabels (stmt
);
2877 /* ??? Diagnose during gimplification? */
2878 if (ninputs
+ noutputs
+ nlabels
> MAX_RECOG_OPERANDS
)
2880 error ("more than %d operands in %<asm%>", MAX_RECOG_OPERANDS
);
2884 auto_vec
<tree
, MAX_RECOG_OPERANDS
> output_tvec
;
2885 auto_vec
<tree
, MAX_RECOG_OPERANDS
> input_tvec
;
2886 auto_vec
<const char *, MAX_RECOG_OPERANDS
> constraints
;
2888 /* Copy the gimple vectors into new vectors that we can manipulate. */
2890 output_tvec
.safe_grow (noutputs
);
2891 input_tvec
.safe_grow (ninputs
);
2892 constraints
.safe_grow (noutputs
+ ninputs
);
2894 for (i
= 0; i
< noutputs
; ++i
)
2896 tree t
= gimple_asm_output_op (stmt
, i
);
2897 output_tvec
[i
] = TREE_VALUE (t
);
2898 constraints
[i
] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
2900 for (i
= 0; i
< ninputs
; i
++)
2902 tree t
= gimple_asm_input_op (stmt
, i
);
2903 input_tvec
[i
] = TREE_VALUE (t
);
2904 constraints
[i
+ noutputs
]
2905 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
2908 /* ??? Diagnose during gimplification? */
2909 if (! check_operand_nalternatives (constraints
))
2912 /* Count the number of meaningful clobbered registers, ignoring what
2913 we would ignore later. */
2914 auto_vec
<rtx
> clobber_rvec
;
2915 HARD_REG_SET clobbered_regs
;
2916 CLEAR_HARD_REG_SET (clobbered_regs
);
2918 if (unsigned n
= gimple_asm_nclobbers (stmt
))
2920 clobber_rvec
.reserve (n
);
2921 for (i
= 0; i
< n
; i
++)
2923 tree t
= gimple_asm_clobber_op (stmt
, i
);
2924 const char *regname
= TREE_STRING_POINTER (TREE_VALUE (t
));
2927 j
= decode_reg_name_and_count (regname
, &nregs
);
2932 /* ??? Diagnose during gimplification? */
2933 error ("unknown register name %qs in %<asm%>", regname
);
2937 rtx x
= gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
));
2938 clobber_rvec
.safe_push (x
);
2942 /* Otherwise we should have -1 == empty string
2943 or -3 == cc, which is not a register. */
2944 gcc_assert (j
== -1 || j
== -3);
2948 for (int reg
= j
; reg
< j
+ nregs
; reg
++)
2950 /* Clobbering the PIC register is an error. */
2951 if (reg
== (int) PIC_OFFSET_TABLE_REGNUM
)
2953 /* ??? Diagnose during gimplification? */
2954 error ("PIC register clobbered by %qs in %<asm%>",
2959 SET_HARD_REG_BIT (clobbered_regs
, reg
);
2960 rtx x
= gen_rtx_REG (reg_raw_mode
[reg
], reg
);
2961 clobber_rvec
.safe_push (x
);
2965 unsigned nclobbers
= clobber_rvec
.length();
2967 /* First pass over inputs and outputs checks validity and sets
2968 mark_addressable if needed. */
2969 /* ??? Diagnose during gimplification? */
2971 for (i
= 0; i
< noutputs
; ++i
)
2973 tree val
= output_tvec
[i
];
2974 tree type
= TREE_TYPE (val
);
2975 const char *constraint
;
2980 /* Try to parse the output constraint. If that fails, there's
2981 no point in going further. */
2982 constraint
= constraints
[i
];
2983 if (!parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
2984 &allows_mem
, &allows_reg
, &is_inout
))
2991 && REG_P (DECL_RTL (val
))
2992 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
))))
2993 mark_addressable (val
);
2996 for (i
= 0; i
< ninputs
; ++i
)
2998 bool allows_reg
, allows_mem
;
2999 const char *constraint
;
3001 constraint
= constraints
[i
+ noutputs
];
3002 if (! parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
3003 constraints
.address (),
3004 &allows_mem
, &allows_reg
))
3007 if (! allows_reg
&& allows_mem
)
3008 mark_addressable (input_tvec
[i
]);
3011 /* Second pass evaluates arguments. */
3013 /* Make sure stack is consistent for asm goto. */
3015 do_pending_stack_adjust ();
3016 int old_generating_concat_p
= generating_concat_p
;
3018 /* Vector of RTX's of evaluated output operands. */
3019 auto_vec
<rtx
, MAX_RECOG_OPERANDS
> output_rvec
;
3020 auto_vec
<int, MAX_RECOG_OPERANDS
> inout_opnum
;
3021 rtx_insn
*after_rtl_seq
= NULL
, *after_rtl_end
= NULL
;
3023 output_rvec
.safe_grow (noutputs
);
3025 for (i
= 0; i
< noutputs
; ++i
)
3027 tree val
= output_tvec
[i
];
3028 tree type
= TREE_TYPE (val
);
3029 bool is_inout
, allows_reg
, allows_mem
, ok
;
3032 ok
= parse_output_constraint (&constraints
[i
], i
, ninputs
,
3033 noutputs
, &allows_mem
, &allows_reg
,
3037 /* If an output operand is not a decl or indirect ref and our constraint
3038 allows a register, make a temporary to act as an intermediate.
3039 Make the asm insn write into that, then we will copy it to
3040 the real output operand. Likewise for promoted variables. */
3042 generating_concat_p
= 0;
3044 if ((TREE_CODE (val
) == INDIRECT_REF
&& allows_mem
)
3046 && (allows_mem
|| REG_P (DECL_RTL (val
)))
3047 && ! (REG_P (DECL_RTL (val
))
3048 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
)))
3051 || TREE_ADDRESSABLE (type
))
3053 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
3054 !allows_reg
? EXPAND_MEMORY
: EXPAND_WRITE
);
3056 op
= validize_mem (op
);
3058 if (! allows_reg
&& !MEM_P (op
))
3059 error ("output number %d not directly addressable", i
);
3060 if ((! allows_mem
&& MEM_P (op
) && GET_MODE (op
) != BLKmode
)
3061 || GET_CODE (op
) == CONCAT
)
3064 op
= gen_reg_rtx (GET_MODE (op
));
3066 generating_concat_p
= old_generating_concat_p
;
3069 emit_move_insn (op
, old_op
);
3071 push_to_sequence2 (after_rtl_seq
, after_rtl_end
);
3072 emit_move_insn (old_op
, op
);
3073 after_rtl_seq
= get_insns ();
3074 after_rtl_end
= get_last_insn ();
3080 op
= assign_temp (type
, 0, 1);
3081 op
= validize_mem (op
);
3082 if (!MEM_P (op
) && TREE_CODE (val
) == SSA_NAME
)
3083 set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (val
), op
);
3085 generating_concat_p
= old_generating_concat_p
;
3087 push_to_sequence2 (after_rtl_seq
, after_rtl_end
);
3088 expand_assignment (val
, make_tree (type
, op
), false);
3089 after_rtl_seq
= get_insns ();
3090 after_rtl_end
= get_last_insn ();
3093 output_rvec
[i
] = op
;
3096 inout_opnum
.safe_push (i
);
3099 auto_vec
<rtx
, MAX_RECOG_OPERANDS
> input_rvec
;
3100 auto_vec
<machine_mode
, MAX_RECOG_OPERANDS
> input_mode
;
3102 input_rvec
.safe_grow (ninputs
);
3103 input_mode
.safe_grow (ninputs
);
3105 generating_concat_p
= 0;
3107 for (i
= 0; i
< ninputs
; ++i
)
3109 tree val
= input_tvec
[i
];
3110 tree type
= TREE_TYPE (val
);
3111 bool allows_reg
, allows_mem
, ok
;
3112 const char *constraint
;
3115 constraint
= constraints
[i
+ noutputs
];
3116 ok
= parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
3117 constraints
.address (),
3118 &allows_mem
, &allows_reg
);
3121 /* EXPAND_INITIALIZER will not generate code for valid initializer
3122 constants, but will still generate code for other types of operand.
3123 This is the behavior we want for constant constraints. */
3124 op
= expand_expr (val
, NULL_RTX
, VOIDmode
,
3125 allows_reg
? EXPAND_NORMAL
3126 : allows_mem
? EXPAND_MEMORY
3127 : EXPAND_INITIALIZER
);
3129 /* Never pass a CONCAT to an ASM. */
3130 if (GET_CODE (op
) == CONCAT
)
3131 op
= force_reg (GET_MODE (op
), op
);
3132 else if (MEM_P (op
))
3133 op
= validize_mem (op
);
3135 if (asm_operand_ok (op
, constraint
, NULL
) <= 0)
3137 if (allows_reg
&& TYPE_MODE (type
) != BLKmode
)
3138 op
= force_reg (TYPE_MODE (type
), op
);
3139 else if (!allows_mem
)
3140 warning (0, "asm operand %d probably doesn%'t match constraints",
3142 else if (MEM_P (op
))
3144 /* We won't recognize either volatile memory or memory
3145 with a queued address as available a memory_operand
3146 at this point. Ignore it: clearly this *is* a memory. */
3152 input_mode
[i
] = TYPE_MODE (type
);
3155 /* For in-out operands, copy output rtx to input rtx. */
3156 unsigned ninout
= inout_opnum
.length();
3157 for (i
= 0; i
< ninout
; i
++)
3159 int j
= inout_opnum
[i
];
3160 rtx o
= output_rvec
[j
];
3162 input_rvec
.safe_push (o
);
3163 input_mode
.safe_push (GET_MODE (o
));
3166 sprintf (buffer
, "%d", j
);
3167 constraints
.safe_push (ggc_strdup (buffer
));
3171 /* Sometimes we wish to automatically clobber registers across an asm.
3172 Case in point is when the i386 backend moved from cc0 to a hard reg --
3173 maintaining source-level compatibility means automatically clobbering
3174 the flags register. */
3175 rtx_insn
*after_md_seq
= NULL
;
3176 if (targetm
.md_asm_adjust
)
3177 after_md_seq
= targetm
.md_asm_adjust (output_rvec
, input_rvec
,
3178 constraints
, clobber_rvec
,
3181 /* Do not allow the hook to change the output and input count,
3182 lest it mess up the operand numbering. */
3183 gcc_assert (output_rvec
.length() == noutputs
);
3184 gcc_assert (input_rvec
.length() == ninputs
);
3185 gcc_assert (constraints
.length() == noutputs
+ ninputs
);
3187 /* But it certainly can adjust the clobbers. */
3188 nclobbers
= clobber_rvec
.length();
3190 /* Third pass checks for easy conflicts. */
3191 /* ??? Why are we doing this on trees instead of rtx. */
3193 bool clobber_conflict_found
= 0;
3194 for (i
= 0; i
< noutputs
; ++i
)
3195 if (tree_conflicts_with_clobbers_p (output_tvec
[i
], &clobbered_regs
))
3196 clobber_conflict_found
= 1;
3197 for (i
= 0; i
< ninputs
- ninout
; ++i
)
3198 if (tree_conflicts_with_clobbers_p (input_tvec
[i
], &clobbered_regs
))
3199 clobber_conflict_found
= 1;
3201 /* Make vectors for the expression-rtx, constraint strings,
3202 and named operands. */
3204 rtvec argvec
= rtvec_alloc (ninputs
);
3205 rtvec constraintvec
= rtvec_alloc (ninputs
);
3206 rtvec labelvec
= rtvec_alloc (nlabels
);
3208 rtx body
= gen_rtx_ASM_OPERANDS ((noutputs
== 0 ? VOIDmode
3209 : GET_MODE (output_rvec
[0])),
3210 ggc_strdup (gimple_asm_string (stmt
)),
3211 "", 0, argvec
, constraintvec
,
3213 MEM_VOLATILE_P (body
) = gimple_asm_volatile_p (stmt
);
3215 for (i
= 0; i
< ninputs
; ++i
)
3217 ASM_OPERANDS_INPUT (body
, i
) = input_rvec
[i
];
3218 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body
, i
)
3219 = gen_rtx_ASM_INPUT_loc (input_mode
[i
],
3220 constraints
[i
+ noutputs
],
3224 /* Copy labels to the vector. */
3225 rtx_code_label
*fallthru_label
= NULL
;
3228 basic_block fallthru_bb
= NULL
;
3229 edge fallthru
= find_fallthru_edge (gimple_bb (stmt
)->succs
);
3231 fallthru_bb
= fallthru
->dest
;
3233 for (i
= 0; i
< nlabels
; ++i
)
3235 tree label
= TREE_VALUE (gimple_asm_label_op (stmt
, i
));
3237 /* If asm goto has any labels in the fallthru basic block, use
3238 a label that we emit immediately after the asm goto. Expansion
3239 may insert further instructions into the same basic block after
3240 asm goto and if we don't do this, insertion of instructions on
3241 the fallthru edge might misbehave. See PR58670. */
3242 if (fallthru_bb
&& label_to_block_fn (cfun
, label
) == fallthru_bb
)
3244 if (fallthru_label
== NULL_RTX
)
3245 fallthru_label
= gen_label_rtx ();
3249 r
= label_rtx (label
);
3250 ASM_OPERANDS_LABEL (body
, i
) = gen_rtx_LABEL_REF (Pmode
, r
);
3254 /* Now, for each output, construct an rtx
3255 (set OUTPUT (asm_operands INSN OUTPUTCONSTRAINT OUTPUTNUMBER
3256 ARGVEC CONSTRAINTS OPNAMES))
3257 If there is more than one, put them inside a PARALLEL. */
3259 if (nlabels
> 0 && nclobbers
== 0)
3261 gcc_assert (noutputs
== 0);
3262 emit_jump_insn (body
);
3264 else if (noutputs
== 0 && nclobbers
== 0)
3266 /* No output operands: put in a raw ASM_OPERANDS rtx. */
3269 else if (noutputs
== 1 && nclobbers
== 0)
3271 ASM_OPERANDS_OUTPUT_CONSTRAINT (body
) = constraints
[0];
3272 emit_insn (gen_rtx_SET (output_rvec
[0], body
));
3282 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (num
+ nclobbers
));
3284 /* For each output operand, store a SET. */
3285 for (i
= 0; i
< noutputs
; ++i
)
3287 rtx src
, o
= output_rvec
[i
];
3290 ASM_OPERANDS_OUTPUT_CONSTRAINT (obody
) = constraints
[0];
3295 src
= gen_rtx_ASM_OPERANDS (GET_MODE (o
),
3296 ASM_OPERANDS_TEMPLATE (obody
),
3297 constraints
[i
], i
, argvec
,
3298 constraintvec
, labelvec
, locus
);
3299 MEM_VOLATILE_P (src
) = gimple_asm_volatile_p (stmt
);
3301 XVECEXP (body
, 0, i
) = gen_rtx_SET (o
, src
);
3304 /* If there are no outputs (but there are some clobbers)
3305 store the bare ASM_OPERANDS into the PARALLEL. */
3307 XVECEXP (body
, 0, i
++) = obody
;
3309 /* Store (clobber REG) for each clobbered register specified. */
3310 for (unsigned j
= 0; j
< nclobbers
; ++j
)
3312 rtx clobbered_reg
= clobber_rvec
[j
];
3314 /* Do sanity check for overlap between clobbers and respectively
3315 input and outputs that hasn't been handled. Such overlap
3316 should have been detected and reported above. */
3317 if (!clobber_conflict_found
&& REG_P (clobbered_reg
))
3319 /* We test the old body (obody) contents to avoid
3320 tripping over the under-construction body. */
3321 for (unsigned k
= 0; k
< noutputs
; ++k
)
3322 if (reg_overlap_mentioned_p (clobbered_reg
, output_rvec
[k
]))
3323 internal_error ("asm clobber conflict with output operand");
3325 for (unsigned k
= 0; k
< ninputs
- ninout
; ++k
)
3326 if (reg_overlap_mentioned_p (clobbered_reg
, input_rvec
[k
]))
3327 internal_error ("asm clobber conflict with input operand");
3330 XVECEXP (body
, 0, i
++) = gen_rtx_CLOBBER (VOIDmode
, clobbered_reg
);
3334 emit_jump_insn (body
);
3339 generating_concat_p
= old_generating_concat_p
;
3342 emit_label (fallthru_label
);
3345 emit_insn (after_md_seq
);
3347 emit_insn (after_rtl_seq
);
3350 crtl
->has_asm_statement
= 1;
3353 /* Emit code to jump to the address
3354 specified by the pointer expression EXP. */
3357 expand_computed_goto (tree exp
)
3359 rtx x
= expand_normal (exp
);
3361 do_pending_stack_adjust ();
3362 emit_indirect_jump (x
);
3365 /* Generate RTL code for a `goto' statement with target label LABEL.
3366 LABEL should be a LABEL_DECL tree node that was or will later be
3367 defined with `expand_label'. */
3370 expand_goto (tree label
)
3374 /* Check for a nonlocal goto to a containing function. Should have
3375 gotten translated to __builtin_nonlocal_goto. */
3376 tree context
= decl_function_context (label
);
3377 gcc_assert (!context
|| context
== current_function_decl
);
3380 emit_jump (jump_target_rtx (label
));
3383 /* Output a return with no value. */
3386 expand_null_return_1 (void)
3388 clear_pending_stack_adjust ();
3389 do_pending_stack_adjust ();
3390 emit_jump (return_label
);
3393 /* Generate RTL to return from the current function, with no value.
3394 (That is, we do not do anything about returning any value.) */
3397 expand_null_return (void)
3399 /* If this function was declared to return a value, but we
3400 didn't, clobber the return registers so that they are not
3401 propagated live to the rest of the function. */
3402 clobber_return_register ();
3404 expand_null_return_1 ();
3407 /* Generate RTL to return from the current function, with value VAL. */
3410 expand_value_return (rtx val
)
3412 /* Copy the value to the return location unless it's already there. */
3414 tree decl
= DECL_RESULT (current_function_decl
);
3415 rtx return_reg
= DECL_RTL (decl
);
3416 if (return_reg
!= val
)
3418 tree funtype
= TREE_TYPE (current_function_decl
);
3419 tree type
= TREE_TYPE (decl
);
3420 int unsignedp
= TYPE_UNSIGNED (type
);
3421 machine_mode old_mode
= DECL_MODE (decl
);
3423 if (DECL_BY_REFERENCE (decl
))
3424 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 2);
3426 mode
= promote_function_mode (type
, old_mode
, &unsignedp
, funtype
, 1);
3428 if (mode
!= old_mode
)
3429 val
= convert_modes (mode
, old_mode
, val
, unsignedp
);
3431 if (GET_CODE (return_reg
) == PARALLEL
)
3432 emit_group_load (return_reg
, val
, type
, int_size_in_bytes (type
));
3434 emit_move_insn (return_reg
, val
);
3437 expand_null_return_1 ();
3440 /* Generate RTL to evaluate the expression RETVAL and return it
3441 from the current function. */
3444 expand_return (tree retval
)
3450 /* If function wants no value, give it none. */
3451 if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl
))) == VOID_TYPE
)
3453 expand_normal (retval
);
3454 expand_null_return ();
3458 if (retval
== error_mark_node
)
3460 /* Treat this like a return of no value from a function that
3462 expand_null_return ();
3465 else if ((TREE_CODE (retval
) == MODIFY_EXPR
3466 || TREE_CODE (retval
) == INIT_EXPR
)
3467 && TREE_CODE (TREE_OPERAND (retval
, 0)) == RESULT_DECL
)
3468 retval_rhs
= TREE_OPERAND (retval
, 1);
3470 retval_rhs
= retval
;
3472 result_rtl
= DECL_RTL (DECL_RESULT (current_function_decl
));
3474 /* If we are returning the RESULT_DECL, then the value has already
3475 been stored into it, so we don't have to do anything special. */
3476 if (TREE_CODE (retval_rhs
) == RESULT_DECL
)
3477 expand_value_return (result_rtl
);
3479 /* If the result is an aggregate that is being returned in one (or more)
3480 registers, load the registers here. */
3482 else if (retval_rhs
!= 0
3483 && TYPE_MODE (TREE_TYPE (retval_rhs
)) == BLKmode
3484 && REG_P (result_rtl
))
3486 val
= copy_blkmode_to_reg (GET_MODE (result_rtl
), retval_rhs
);
3489 /* Use the mode of the result value on the return register. */
3490 PUT_MODE (result_rtl
, GET_MODE (val
));
3491 expand_value_return (val
);
3494 expand_null_return ();
3496 else if (retval_rhs
!= 0
3497 && !VOID_TYPE_P (TREE_TYPE (retval_rhs
))
3498 && (REG_P (result_rtl
)
3499 || (GET_CODE (result_rtl
) == PARALLEL
)))
3501 /* Compute the return value into a temporary (usually a pseudo reg). */
3503 = assign_temp (TREE_TYPE (DECL_RESULT (current_function_decl
)), 0, 1);
3504 val
= expand_expr (retval_rhs
, val
, GET_MODE (val
), EXPAND_NORMAL
);
3505 val
= force_not_mem (val
);
3506 expand_value_return (val
);
3510 /* No hard reg used; calculate value into hard return reg. */
3511 expand_expr (retval
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3512 expand_value_return (result_rtl
);
3516 /* Expand a clobber of LHS. If LHS is stored it in a multi-part
3517 register, tell the rtl optimizers that its value is no longer
3521 expand_clobber (tree lhs
)
3525 rtx decl_rtl
= DECL_RTL_IF_SET (lhs
);
3526 if (decl_rtl
&& REG_P (decl_rtl
))
3528 machine_mode decl_mode
= GET_MODE (decl_rtl
);
3529 if (maybe_gt (GET_MODE_SIZE (decl_mode
),
3530 REGMODE_NATURAL_SIZE (decl_mode
)))
3531 emit_clobber (decl_rtl
);
3536 /* A subroutine of expand_gimple_stmt, expanding one gimple statement
3537 STMT that doesn't require special handling for outgoing edges. That
3538 is no tailcalls and no GIMPLE_COND. */
3541 expand_gimple_stmt_1 (gimple
*stmt
)
3545 set_curr_insn_location (gimple_location (stmt
));
3547 switch (gimple_code (stmt
))
3550 op0
= gimple_goto_dest (stmt
);
3551 if (TREE_CODE (op0
) == LABEL_DECL
)
3554 expand_computed_goto (op0
);
3557 expand_label (gimple_label_label (as_a
<glabel
*> (stmt
)));
3560 case GIMPLE_PREDICT
:
3564 gswitch
*swtch
= as_a
<gswitch
*> (stmt
);
3565 if (gimple_switch_num_labels (swtch
) == 1)
3566 expand_goto (CASE_LABEL (gimple_switch_default_label (swtch
)));
3568 expand_case (swtch
);
3572 expand_asm_stmt (as_a
<gasm
*> (stmt
));
3575 expand_call_stmt (as_a
<gcall
*> (stmt
));
3580 op0
= gimple_return_retval (as_a
<greturn
*> (stmt
));
3582 if (op0
&& op0
!= error_mark_node
)
3584 tree result
= DECL_RESULT (current_function_decl
);
3586 /* If we are not returning the current function's RESULT_DECL,
3587 build an assignment to it. */
3590 /* I believe that a function's RESULT_DECL is unique. */
3591 gcc_assert (TREE_CODE (op0
) != RESULT_DECL
);
3593 /* ??? We'd like to use simply expand_assignment here,
3594 but this fails if the value is of BLKmode but the return
3595 decl is a register. expand_return has special handling
3596 for this combination, which eventually should move
3597 to common code. See comments there. Until then, let's
3598 build a modify expression :-/ */
3599 op0
= build2 (MODIFY_EXPR
, TREE_TYPE (result
),
3605 expand_null_return ();
3607 expand_return (op0
);
3613 gassign
*assign_stmt
= as_a
<gassign
*> (stmt
);
3614 tree lhs
= gimple_assign_lhs (assign_stmt
);
3616 /* Tree expand used to fiddle with |= and &= of two bitfield
3617 COMPONENT_REFs here. This can't happen with gimple, the LHS
3618 of binary assigns must be a gimple reg. */
3620 if (TREE_CODE (lhs
) != SSA_NAME
3621 || get_gimple_rhs_class (gimple_expr_code (stmt
))
3622 == GIMPLE_SINGLE_RHS
)
3624 tree rhs
= gimple_assign_rhs1 (assign_stmt
);
3625 gcc_assert (get_gimple_rhs_class (gimple_expr_code (stmt
))
3626 == GIMPLE_SINGLE_RHS
);
3627 if (gimple_has_location (stmt
) && CAN_HAVE_LOCATION_P (rhs
)
3628 /* Do not put locations on possibly shared trees. */
3629 && !is_gimple_min_invariant (rhs
))
3630 SET_EXPR_LOCATION (rhs
, gimple_location (stmt
));
3631 if (TREE_CLOBBER_P (rhs
))
3632 /* This is a clobber to mark the going out of scope for
3634 expand_clobber (lhs
);
3636 expand_assignment (lhs
, rhs
,
3637 gimple_assign_nontemporal_move_p (
3643 bool nontemporal
= gimple_assign_nontemporal_move_p (assign_stmt
);
3644 struct separate_ops ops
;
3645 bool promoted
= false;
3647 target
= expand_expr (lhs
, NULL_RTX
, VOIDmode
, EXPAND_WRITE
);
3648 if (GET_CODE (target
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (target
))
3651 ops
.code
= gimple_assign_rhs_code (assign_stmt
);
3652 ops
.type
= TREE_TYPE (lhs
);
3653 switch (get_gimple_rhs_class (ops
.code
))
3655 case GIMPLE_TERNARY_RHS
:
3656 ops
.op2
= gimple_assign_rhs3 (assign_stmt
);
3658 case GIMPLE_BINARY_RHS
:
3659 ops
.op1
= gimple_assign_rhs2 (assign_stmt
);
3661 case GIMPLE_UNARY_RHS
:
3662 ops
.op0
= gimple_assign_rhs1 (assign_stmt
);
3667 ops
.location
= gimple_location (stmt
);
3669 /* If we want to use a nontemporal store, force the value to
3670 register first. If we store into a promoted register,
3671 don't directly expand to target. */
3672 temp
= nontemporal
|| promoted
? NULL_RTX
: target
;
3673 temp
= expand_expr_real_2 (&ops
, temp
, GET_MODE (target
),
3680 int unsignedp
= SUBREG_PROMOTED_SIGN (target
);
3681 /* If TEMP is a VOIDmode constant, use convert_modes to make
3682 sure that we properly convert it. */
3683 if (CONSTANT_P (temp
) && GET_MODE (temp
) == VOIDmode
)
3685 temp
= convert_modes (GET_MODE (target
),
3686 TYPE_MODE (ops
.type
),
3688 temp
= convert_modes (GET_MODE (SUBREG_REG (target
)),
3689 GET_MODE (target
), temp
, unsignedp
);
3692 convert_move (SUBREG_REG (target
), temp
, unsignedp
);
3694 else if (nontemporal
&& emit_storent_insn (target
, temp
))
3698 temp
= force_operand (temp
, target
);
3700 emit_move_insn (target
, temp
);
3711 /* Expand one gimple statement STMT and return the last RTL instruction
3712 before any of the newly generated ones.
3714 In addition to generating the necessary RTL instructions this also
3715 sets REG_EH_REGION notes if necessary and sets the current source
3716 location for diagnostics. */
3719 expand_gimple_stmt (gimple
*stmt
)
3721 location_t saved_location
= input_location
;
3722 rtx_insn
*last
= get_last_insn ();
3727 /* We need to save and restore the current source location so that errors
3728 discovered during expansion are emitted with the right location. But
3729 it would be better if the diagnostic routines used the source location
3730 embedded in the tree nodes rather than globals. */
3731 if (gimple_has_location (stmt
))
3732 input_location
= gimple_location (stmt
);
3734 expand_gimple_stmt_1 (stmt
);
3736 /* Free any temporaries used to evaluate this statement. */
3739 input_location
= saved_location
;
3741 /* Mark all insns that may trap. */
3742 lp_nr
= lookup_stmt_eh_lp (stmt
);
3746 for (insn
= next_real_insn (last
); insn
;
3747 insn
= next_real_insn (insn
))
3749 if (! find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
3750 /* If we want exceptions for non-call insns, any
3751 may_trap_p instruction may throw. */
3752 && GET_CODE (PATTERN (insn
)) != CLOBBER
3753 && GET_CODE (PATTERN (insn
)) != USE
3754 && insn_could_throw_p (insn
))
3755 make_reg_eh_region_note (insn
, 0, lp_nr
);
3762 /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_CALL
3763 that has CALL_EXPR_TAILCALL set. Returns non-null if we actually
3764 generated a tail call (something that might be denied by the ABI
3765 rules governing the call; see calls.c).
3767 Sets CAN_FALLTHRU if we generated a *conditional* tail call, and
3768 can still reach the rest of BB. The case here is __builtin_sqrt,
3769 where the NaN result goes through the external function (with a
3770 tailcall) and the normal result happens via a sqrt instruction. */
3773 expand_gimple_tailcall (basic_block bb
, gcall
*stmt
, bool *can_fallthru
)
3775 rtx_insn
*last2
, *last
;
3778 profile_probability probability
;
3780 last2
= last
= expand_gimple_stmt (stmt
);
3782 for (last
= NEXT_INSN (last
); last
; last
= NEXT_INSN (last
))
3783 if (CALL_P (last
) && SIBLING_CALL_P (last
))
3786 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
3788 *can_fallthru
= true;
3792 /* ??? Wouldn't it be better to just reset any pending stack adjust?
3793 Any instructions emitted here are about to be deleted. */
3794 do_pending_stack_adjust ();
3796 /* Remove any non-eh, non-abnormal edges that don't go to exit. */
3797 /* ??? I.e. the fallthrough edge. HOWEVER! If there were to be
3798 EH or abnormal edges, we shouldn't have created a tail call in
3799 the first place. So it seems to me we should just be removing
3800 all edges here, or redirecting the existing fallthru edge to
3803 probability
= profile_probability::never ();
3805 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
3807 if (!(e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
)))
3809 if (e
->dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
3810 e
->dest
->count
-= e
->count ();
3811 probability
+= e
->probability
;
3818 /* This is somewhat ugly: the call_expr expander often emits instructions
3819 after the sibcall (to perform the function return). These confuse the
3820 find_many_sub_basic_blocks code, so we need to get rid of these. */
3821 last
= NEXT_INSN (last
);
3822 gcc_assert (BARRIER_P (last
));
3824 *can_fallthru
= false;
3825 while (NEXT_INSN (last
))
3827 /* For instance an sqrt builtin expander expands if with
3828 sibcall in the then and label for `else`. */
3829 if (LABEL_P (NEXT_INSN (last
)))
3831 *can_fallthru
= true;
3834 delete_insn (NEXT_INSN (last
));
3837 e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_ABNORMAL
3839 e
->probability
= probability
;
3841 update_bb_for_insn (bb
);
3843 if (NEXT_INSN (last
))
3845 bb
= create_basic_block (NEXT_INSN (last
), get_last_insn (), bb
);
3848 if (BARRIER_P (last
))
3849 BB_END (bb
) = PREV_INSN (last
);
3852 maybe_dump_rtl_for_gimple_stmt (stmt
, last2
);
3857 /* Return the difference between the floor and the truncated result of
3858 a signed division by OP1 with remainder MOD. */
3860 floor_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3862 /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
3863 return gen_rtx_IF_THEN_ELSE
3864 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3865 gen_rtx_IF_THEN_ELSE
3866 (mode
, gen_rtx_LT (BImode
,
3867 gen_rtx_DIV (mode
, op1
, mod
),
3869 constm1_rtx
, const0_rtx
),
3873 /* Return the difference between the ceil and the truncated result of
3874 a signed division by OP1 with remainder MOD. */
3876 ceil_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3878 /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
3879 return gen_rtx_IF_THEN_ELSE
3880 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3881 gen_rtx_IF_THEN_ELSE
3882 (mode
, gen_rtx_GT (BImode
,
3883 gen_rtx_DIV (mode
, op1
, mod
),
3885 const1_rtx
, const0_rtx
),
3889 /* Return the difference between the ceil and the truncated result of
3890 an unsigned division by OP1 with remainder MOD. */
3892 ceil_udiv_adjust (machine_mode mode
, rtx mod
, rtx op1 ATTRIBUTE_UNUSED
)
3894 /* (mod != 0 ? 1 : 0) */
3895 return gen_rtx_IF_THEN_ELSE
3896 (mode
, gen_rtx_NE (BImode
, mod
, const0_rtx
),
3897 const1_rtx
, const0_rtx
);
3900 /* Return the difference between the rounded and the truncated result
3901 of a signed division by OP1 with remainder MOD. Halfway cases are
3902 rounded away from zero, rather than to the nearest even number. */
3904 round_sdiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3906 /* (abs (mod) >= abs (op1) - abs (mod)
3907 ? (op1 / mod > 0 ? 1 : -1)
3909 return gen_rtx_IF_THEN_ELSE
3910 (mode
, gen_rtx_GE (BImode
, gen_rtx_ABS (mode
, mod
),
3911 gen_rtx_MINUS (mode
,
3912 gen_rtx_ABS (mode
, op1
),
3913 gen_rtx_ABS (mode
, mod
))),
3914 gen_rtx_IF_THEN_ELSE
3915 (mode
, gen_rtx_GT (BImode
,
3916 gen_rtx_DIV (mode
, op1
, mod
),
3918 const1_rtx
, constm1_rtx
),
3922 /* Return the difference between the rounded and the truncated result
3923 of a unsigned division by OP1 with remainder MOD. Halfway cases
3924 are rounded away from zero, rather than to the nearest even
3927 round_udiv_adjust (machine_mode mode
, rtx mod
, rtx op1
)
3929 /* (mod >= op1 - mod ? 1 : 0) */
3930 return gen_rtx_IF_THEN_ELSE
3931 (mode
, gen_rtx_GE (BImode
, mod
,
3932 gen_rtx_MINUS (mode
, op1
, mod
)),
3933 const1_rtx
, const0_rtx
);
3936 /* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
3940 convert_debug_memory_address (scalar_int_mode mode
, rtx x
,
3943 #ifndef POINTERS_EXTEND_UNSIGNED
3944 gcc_assert (mode
== Pmode
3945 || mode
== targetm
.addr_space
.address_mode (as
));
3946 gcc_assert (GET_MODE (x
) == mode
|| GET_MODE (x
) == VOIDmode
);
3950 gcc_assert (targetm
.addr_space
.valid_pointer_mode (mode
, as
));
3952 if (GET_MODE (x
) == mode
|| GET_MODE (x
) == VOIDmode
)
3955 /* X must have some form of address mode already. */
3956 scalar_int_mode xmode
= as_a
<scalar_int_mode
> (GET_MODE (x
));
3957 if (GET_MODE_PRECISION (mode
) < GET_MODE_PRECISION (xmode
))
3958 x
= lowpart_subreg (mode
, x
, xmode
);
3959 else if (POINTERS_EXTEND_UNSIGNED
> 0)
3960 x
= gen_rtx_ZERO_EXTEND (mode
, x
);
3961 else if (!POINTERS_EXTEND_UNSIGNED
)
3962 x
= gen_rtx_SIGN_EXTEND (mode
, x
);
3965 switch (GET_CODE (x
))
3968 if ((SUBREG_PROMOTED_VAR_P (x
)
3969 || (REG_P (SUBREG_REG (x
)) && REG_POINTER (SUBREG_REG (x
)))
3970 || (GET_CODE (SUBREG_REG (x
)) == PLUS
3971 && REG_P (XEXP (SUBREG_REG (x
), 0))
3972 && REG_POINTER (XEXP (SUBREG_REG (x
), 0))
3973 && CONST_INT_P (XEXP (SUBREG_REG (x
), 1))))
3974 && GET_MODE (SUBREG_REG (x
)) == mode
)
3975 return SUBREG_REG (x
);
3978 temp
= gen_rtx_LABEL_REF (mode
, label_ref_label (x
));
3979 LABEL_REF_NONLOCAL_P (temp
) = LABEL_REF_NONLOCAL_P (x
);
3982 temp
= shallow_copy_rtx (x
);
3983 PUT_MODE (temp
, mode
);
3986 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
3988 temp
= gen_rtx_CONST (mode
, temp
);
3992 if (CONST_INT_P (XEXP (x
, 1)))
3994 temp
= convert_debug_memory_address (mode
, XEXP (x
, 0), as
);
3996 return gen_rtx_fmt_ee (GET_CODE (x
), mode
, temp
, XEXP (x
, 1));
4002 /* Don't know how to express ptr_extend as operation in debug info. */
4005 #endif /* POINTERS_EXTEND_UNSIGNED */
4010 /* Map from SSA_NAMEs to corresponding DEBUG_EXPR_DECLs created
4011 by avoid_deep_ter_for_debug. */
4013 static hash_map
<tree
, tree
> *deep_ter_debug_map
;
4015 /* Split too deep TER chains for debug stmts using debug temporaries. */
4018 avoid_deep_ter_for_debug (gimple
*stmt
, int depth
)
4020 use_operand_p use_p
;
4022 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
4024 tree use
= USE_FROM_PTR (use_p
);
4025 if (TREE_CODE (use
) != SSA_NAME
|| SSA_NAME_IS_DEFAULT_DEF (use
))
4027 gimple
*g
= get_gimple_for_ssa_name (use
);
4030 if (depth
> 6 && !stmt_ends_bb_p (g
))
4032 if (deep_ter_debug_map
== NULL
)
4033 deep_ter_debug_map
= new hash_map
<tree
, tree
>;
4035 tree
&vexpr
= deep_ter_debug_map
->get_or_insert (use
);
4038 vexpr
= make_node (DEBUG_EXPR_DECL
);
4039 gimple
*def_temp
= gimple_build_debug_bind (vexpr
, use
, g
);
4040 DECL_ARTIFICIAL (vexpr
) = 1;
4041 TREE_TYPE (vexpr
) = TREE_TYPE (use
);
4042 SET_DECL_MODE (vexpr
, TYPE_MODE (TREE_TYPE (use
)));
4043 gimple_stmt_iterator gsi
= gsi_for_stmt (g
);
4044 gsi_insert_after (&gsi
, def_temp
, GSI_NEW_STMT
);
4045 avoid_deep_ter_for_debug (def_temp
, 0);
4048 avoid_deep_ter_for_debug (g
, depth
+ 1);
4052 /* Return an RTX equivalent to the value of the parameter DECL. */
4055 expand_debug_parm_decl (tree decl
)
4057 rtx incoming
= DECL_INCOMING_RTL (decl
);
4060 && GET_MODE (incoming
) != BLKmode
4061 && ((REG_P (incoming
) && HARD_REGISTER_P (incoming
))
4062 || (MEM_P (incoming
)
4063 && REG_P (XEXP (incoming
, 0))
4064 && HARD_REGISTER_P (XEXP (incoming
, 0)))))
4066 rtx rtl
= gen_rtx_ENTRY_VALUE (GET_MODE (incoming
));
4068 #ifdef HAVE_window_save
4069 /* DECL_INCOMING_RTL uses the INCOMING_REGNO of parameter registers.
4070 If the target machine has an explicit window save instruction, the
4071 actual entry value is the corresponding OUTGOING_REGNO instead. */
4072 if (REG_P (incoming
)
4073 && OUTGOING_REGNO (REGNO (incoming
)) != REGNO (incoming
))
4075 = gen_rtx_REG_offset (incoming
, GET_MODE (incoming
),
4076 OUTGOING_REGNO (REGNO (incoming
)), 0);
4077 else if (MEM_P (incoming
))
4079 rtx reg
= XEXP (incoming
, 0);
4080 if (OUTGOING_REGNO (REGNO (reg
)) != REGNO (reg
))
4082 reg
= gen_raw_REG (GET_MODE (reg
), OUTGOING_REGNO (REGNO (reg
)));
4083 incoming
= replace_equiv_address_nv (incoming
, reg
);
4086 incoming
= copy_rtx (incoming
);
4090 ENTRY_VALUE_EXP (rtl
) = incoming
;
4095 && GET_MODE (incoming
) != BLKmode
4096 && !TREE_ADDRESSABLE (decl
)
4098 && (XEXP (incoming
, 0) == virtual_incoming_args_rtx
4099 || (GET_CODE (XEXP (incoming
, 0)) == PLUS
4100 && XEXP (XEXP (incoming
, 0), 0) == virtual_incoming_args_rtx
4101 && CONST_INT_P (XEXP (XEXP (incoming
, 0), 1)))))
4102 return copy_rtx (incoming
);
4107 /* Return an RTX equivalent to the value of the tree expression EXP. */
4110 expand_debug_expr (tree exp
)
4112 rtx op0
= NULL_RTX
, op1
= NULL_RTX
, op2
= NULL_RTX
;
4113 machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
4114 machine_mode inner_mode
= VOIDmode
;
4115 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (exp
));
4117 scalar_int_mode op0_mode
, op1_mode
, addr_mode
;
4119 switch (TREE_CODE_CLASS (TREE_CODE (exp
)))
4121 case tcc_expression
:
4122 switch (TREE_CODE (exp
))
4127 case WIDEN_MULT_PLUS_EXPR
:
4128 case WIDEN_MULT_MINUS_EXPR
:
4131 case TRUTH_ANDIF_EXPR
:
4132 case TRUTH_ORIF_EXPR
:
4133 case TRUTH_AND_EXPR
:
4135 case TRUTH_XOR_EXPR
:
4138 case TRUTH_NOT_EXPR
:
4147 op2
= expand_debug_expr (TREE_OPERAND (exp
, 2));
4154 if (mode
== BLKmode
)
4156 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
4159 switch (TREE_CODE (exp
))
4165 case WIDEN_LSHIFT_EXPR
:
4166 /* Ensure second operand isn't wider than the first one. */
4167 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 1)));
4168 if (is_a
<scalar_int_mode
> (inner_mode
, &op1_mode
)
4169 && (GET_MODE_UNIT_PRECISION (mode
)
4170 < GET_MODE_PRECISION (op1_mode
)))
4171 op1
= lowpart_subreg (GET_MODE_INNER (mode
), op1
, op1_mode
);
4180 if (mode
== BLKmode
)
4182 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4183 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4188 case tcc_comparison
:
4189 unsignedp
= TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4197 case tcc_exceptional
:
4198 case tcc_declaration
:
4204 switch (TREE_CODE (exp
))
4207 if (!lookup_constant_def (exp
))
4209 if (strlen (TREE_STRING_POINTER (exp
)) + 1
4210 != (size_t) TREE_STRING_LENGTH (exp
))
4212 op0
= gen_rtx_CONST_STRING (Pmode
, TREE_STRING_POINTER (exp
));
4213 op0
= gen_rtx_MEM (BLKmode
, op0
);
4214 set_mem_attributes (op0
, exp
, 0);
4222 op0
= expand_expr (exp
, NULL_RTX
, mode
, EXPAND_INITIALIZER
);
4226 return immed_wide_int_const (poly_int_cst_value (exp
), mode
);
4229 gcc_assert (COMPLEX_MODE_P (mode
));
4230 op0
= expand_debug_expr (TREE_REALPART (exp
));
4231 op1
= expand_debug_expr (TREE_IMAGPART (exp
));
4232 return gen_rtx_CONCAT (mode
, op0
, op1
);
4234 case DEBUG_EXPR_DECL
:
4235 op0
= DECL_RTL_IF_SET (exp
);
4240 op0
= gen_rtx_DEBUG_EXPR (mode
);
4241 DEBUG_EXPR_TREE_DECL (op0
) = exp
;
4242 SET_DECL_RTL (exp
, op0
);
4252 op0
= DECL_RTL_IF_SET (exp
);
4254 /* This decl was probably optimized away. */
4258 || DECL_EXTERNAL (exp
)
4259 || !TREE_STATIC (exp
)
4261 || DECL_HARD_REGISTER (exp
)
4262 || DECL_IN_CONSTANT_POOL (exp
)
4263 || mode
== VOIDmode
)
4266 op0
= make_decl_rtl_for_debug (exp
);
4268 || GET_CODE (XEXP (op0
, 0)) != SYMBOL_REF
4269 || SYMBOL_REF_DECL (XEXP (op0
, 0)) != exp
)
4273 op0
= copy_rtx (op0
);
4275 if (GET_MODE (op0
) == BLKmode
4276 /* If op0 is not BLKmode, but mode is, adjust_mode
4277 below would ICE. While it is likely a FE bug,
4278 try to be robust here. See PR43166. */
4280 || (mode
== VOIDmode
&& GET_MODE (op0
) != VOIDmode
))
4282 gcc_assert (MEM_P (op0
));
4283 op0
= adjust_address_nv (op0
, mode
, 0);
4293 inner_mode
= GET_MODE (op0
);
4295 if (mode
== inner_mode
)
4298 if (inner_mode
== VOIDmode
)
4300 if (TREE_CODE (exp
) == SSA_NAME
)
4301 inner_mode
= TYPE_MODE (TREE_TYPE (exp
));
4303 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4304 if (mode
== inner_mode
)
4308 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
4310 if (GET_MODE_UNIT_BITSIZE (mode
)
4311 == GET_MODE_UNIT_BITSIZE (inner_mode
))
4312 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
4313 else if (GET_MODE_UNIT_BITSIZE (mode
)
4314 < GET_MODE_UNIT_BITSIZE (inner_mode
))
4315 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
4317 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
4319 else if (FLOAT_MODE_P (mode
))
4321 gcc_assert (TREE_CODE (exp
) != SSA_NAME
);
4322 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
4323 op0
= simplify_gen_unary (UNSIGNED_FLOAT
, mode
, op0
, inner_mode
);
4325 op0
= simplify_gen_unary (FLOAT
, mode
, op0
, inner_mode
);
4327 else if (FLOAT_MODE_P (inner_mode
))
4330 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
4332 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
4334 else if (GET_MODE_UNIT_PRECISION (mode
)
4335 == GET_MODE_UNIT_PRECISION (inner_mode
))
4336 op0
= lowpart_subreg (mode
, op0
, inner_mode
);
4337 else if (GET_MODE_UNIT_PRECISION (mode
)
4338 < GET_MODE_UNIT_PRECISION (inner_mode
))
4339 op0
= simplify_gen_unary (TRUNCATE
, mode
, op0
, inner_mode
);
4340 else if (UNARY_CLASS_P (exp
)
4341 ? TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)))
4343 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
4345 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
4351 if (!is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
4353 tree newexp
= fold_binary (MEM_REF
, TREE_TYPE (exp
),
4354 TREE_OPERAND (exp
, 0),
4355 TREE_OPERAND (exp
, 1));
4357 return expand_debug_expr (newexp
);
4361 inner_mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4362 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4366 if (TREE_CODE (exp
) == MEM_REF
)
4368 if (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
4369 || (GET_CODE (op0
) == PLUS
4370 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
))
4371 /* (mem (debug_implicit_ptr)) might confuse aliasing.
4372 Instead just use get_inner_reference. */
4375 op1
= expand_debug_expr (TREE_OPERAND (exp
, 1));
4377 if (!op1
|| !poly_int_rtx_p (op1
, &offset
))
4380 op0
= plus_constant (inner_mode
, op0
, offset
);
4383 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))));
4385 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
4387 if (op0
== NULL_RTX
)
4390 op0
= gen_rtx_MEM (mode
, op0
);
4391 set_mem_attributes (op0
, exp
, 0);
4392 if (TREE_CODE (exp
) == MEM_REF
4393 && !is_gimple_mem_ref_addr (TREE_OPERAND (exp
, 0)))
4394 set_mem_expr (op0
, NULL_TREE
);
4395 set_mem_addr_space (op0
, as
);
4399 case TARGET_MEM_REF
:
4400 if (TREE_CODE (TMR_BASE (exp
)) == ADDR_EXPR
4401 && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp
), 0)))
4404 op0
= expand_debug_expr
4405 (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp
)), exp
));
4409 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))));
4410 op0
= convert_debug_memory_address (targetm
.addr_space
.address_mode (as
),
4412 if (op0
== NULL_RTX
)
4415 op0
= gen_rtx_MEM (mode
, op0
);
4417 set_mem_attributes (op0
, exp
, 0);
4418 set_mem_addr_space (op0
, as
);
4424 case ARRAY_RANGE_REF
:
4429 case VIEW_CONVERT_EXPR
:
4432 poly_int64 bitsize
, bitpos
;
4434 int reversep
, volatilep
= 0;
4436 = get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
, &mode1
,
4437 &unsignedp
, &reversep
, &volatilep
);
4440 if (known_eq (bitsize
, 0))
4443 orig_op0
= op0
= expand_debug_expr (tem
);
4450 machine_mode addrmode
, offmode
;
4455 op0
= XEXP (op0
, 0);
4456 addrmode
= GET_MODE (op0
);
4457 if (addrmode
== VOIDmode
)
4460 op1
= expand_debug_expr (offset
);
4464 offmode
= GET_MODE (op1
);
4465 if (offmode
== VOIDmode
)
4466 offmode
= TYPE_MODE (TREE_TYPE (offset
));
4468 if (addrmode
!= offmode
)
4469 op1
= lowpart_subreg (addrmode
, op1
, offmode
);
4471 /* Don't use offset_address here, we don't need a
4472 recognizable address, and we don't want to generate
4474 op0
= gen_rtx_MEM (mode
, simplify_gen_binary (PLUS
, addrmode
,
4480 if (mode1
== VOIDmode
)
4482 if (maybe_gt (bitsize
, MAX_BITSIZE_MODE_ANY_INT
))
4485 mode1
= smallest_int_mode_for_size (bitsize
);
4487 poly_int64 bytepos
= bits_to_bytes_round_down (bitpos
);
4488 if (maybe_ne (bytepos
, 0))
4490 op0
= adjust_address_nv (op0
, mode1
, bytepos
);
4491 bitpos
= num_trailing_bits (bitpos
);
4493 else if (known_eq (bitpos
, 0)
4494 && known_eq (bitsize
, GET_MODE_BITSIZE (mode
)))
4495 op0
= adjust_address_nv (op0
, mode
, 0);
4496 else if (GET_MODE (op0
) != mode1
)
4497 op0
= adjust_address_nv (op0
, mode1
, 0);
4499 op0
= copy_rtx (op0
);
4500 if (op0
== orig_op0
)
4501 op0
= shallow_copy_rtx (op0
);
4502 set_mem_attributes (op0
, exp
, 0);
4505 if (known_eq (bitpos
, 0) && mode
== GET_MODE (op0
))
4508 if (maybe_lt (bitpos
, 0))
4511 if (GET_MODE (op0
) == BLKmode
|| mode
== BLKmode
)
4515 if (multiple_p (bitpos
, BITS_PER_UNIT
, &bytepos
)
4516 && known_eq (bitsize
, GET_MODE_BITSIZE (mode1
)))
4518 machine_mode opmode
= GET_MODE (op0
);
4520 if (opmode
== VOIDmode
)
4521 opmode
= TYPE_MODE (TREE_TYPE (tem
));
4523 /* This condition may hold if we're expanding the address
4524 right past the end of an array that turned out not to
4525 be addressable (i.e., the address was only computed in
4526 debug stmts). The gen_subreg below would rightfully
4527 crash, and the address doesn't really exist, so just
4529 if (known_ge (bitpos
, GET_MODE_BITSIZE (opmode
)))
4532 if (multiple_p (bitpos
, GET_MODE_BITSIZE (mode
)))
4533 return simplify_gen_subreg (mode
, op0
, opmode
, bytepos
);
4536 return simplify_gen_ternary (SCALAR_INT_MODE_P (GET_MODE (op0
))
4537 && TYPE_UNSIGNED (TREE_TYPE (exp
))
4539 : ZERO_EXTRACT
, mode
,
4540 GET_MODE (op0
) != VOIDmode
4542 : TYPE_MODE (TREE_TYPE (tem
)),
4543 op0
, gen_int_mode (bitsize
, word_mode
),
4544 gen_int_mode (bitpos
, word_mode
));
4549 return simplify_gen_unary (ABS
, mode
, op0
, mode
);
4552 return simplify_gen_unary (NEG
, mode
, op0
, mode
);
4555 return simplify_gen_unary (NOT
, mode
, op0
, mode
);
4558 return simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
4560 ? UNSIGNED_FLOAT
: FLOAT
, mode
, op0
,
4563 case FIX_TRUNC_EXPR
:
4564 return simplify_gen_unary (unsignedp
? UNSIGNED_FIX
: FIX
, mode
, op0
,
4567 case POINTER_PLUS_EXPR
:
4568 /* For the rare target where pointers are not the same size as
4569 size_t, we need to check for mis-matched modes and correct
4572 && is_a
<scalar_int_mode
> (GET_MODE (op0
), &op0_mode
)
4573 && is_a
<scalar_int_mode
> (GET_MODE (op1
), &op1_mode
)
4574 && op0_mode
!= op1_mode
)
4576 if (GET_MODE_BITSIZE (op0_mode
) < GET_MODE_BITSIZE (op1_mode
)
4577 /* If OP0 is a partial mode, then we must truncate, even
4578 if it has the same bitsize as OP1 as GCC's
4579 representation of partial modes is opaque. */
4580 || (GET_MODE_CLASS (op0_mode
) == MODE_PARTIAL_INT
4581 && (GET_MODE_BITSIZE (op0_mode
)
4582 == GET_MODE_BITSIZE (op1_mode
))))
4583 op1
= simplify_gen_unary (TRUNCATE
, op0_mode
, op1
, op1_mode
);
4585 /* We always sign-extend, regardless of the signedness of
4586 the operand, because the operand is always unsigned
4587 here even if the original C expression is signed. */
4588 op1
= simplify_gen_unary (SIGN_EXTEND
, op0_mode
, op1
, op1_mode
);
4592 return simplify_gen_binary (PLUS
, mode
, op0
, op1
);
4595 case POINTER_DIFF_EXPR
:
4596 return simplify_gen_binary (MINUS
, mode
, op0
, op1
);
4599 return simplify_gen_binary (MULT
, mode
, op0
, op1
);
4602 case TRUNC_DIV_EXPR
:
4603 case EXACT_DIV_EXPR
:
4605 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4607 return simplify_gen_binary (DIV
, mode
, op0
, op1
);
4609 case TRUNC_MOD_EXPR
:
4610 return simplify_gen_binary (unsignedp
? UMOD
: MOD
, mode
, op0
, op1
);
4612 case FLOOR_DIV_EXPR
:
4614 return simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4617 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4618 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4619 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4620 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4623 case FLOOR_MOD_EXPR
:
4625 return simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4628 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4629 rtx adj
= floor_sdiv_adjust (mode
, mod
, op1
);
4630 adj
= simplify_gen_unary (NEG
, mode
,
4631 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4633 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4639 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4640 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4641 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4642 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4646 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4647 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4648 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4649 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4655 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4656 rtx adj
= ceil_udiv_adjust (mode
, mod
, op1
);
4657 adj
= simplify_gen_unary (NEG
, mode
,
4658 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4660 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4664 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4665 rtx adj
= ceil_sdiv_adjust (mode
, mod
, op1
);
4666 adj
= simplify_gen_unary (NEG
, mode
,
4667 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4669 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4672 case ROUND_DIV_EXPR
:
4675 rtx div
= simplify_gen_binary (UDIV
, mode
, op0
, op1
);
4676 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4677 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4678 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4682 rtx div
= simplify_gen_binary (DIV
, mode
, op0
, op1
);
4683 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4684 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4685 return simplify_gen_binary (PLUS
, mode
, div
, adj
);
4688 case ROUND_MOD_EXPR
:
4691 rtx mod
= simplify_gen_binary (UMOD
, mode
, op0
, op1
);
4692 rtx adj
= round_udiv_adjust (mode
, mod
, op1
);
4693 adj
= simplify_gen_unary (NEG
, mode
,
4694 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4696 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4700 rtx mod
= simplify_gen_binary (MOD
, mode
, op0
, op1
);
4701 rtx adj
= round_sdiv_adjust (mode
, mod
, op1
);
4702 adj
= simplify_gen_unary (NEG
, mode
,
4703 simplify_gen_binary (MULT
, mode
, adj
, op1
),
4705 return simplify_gen_binary (PLUS
, mode
, mod
, adj
);
4709 return simplify_gen_binary (ASHIFT
, mode
, op0
, op1
);
4713 return simplify_gen_binary (LSHIFTRT
, mode
, op0
, op1
);
4715 return simplify_gen_binary (ASHIFTRT
, mode
, op0
, op1
);
4718 return simplify_gen_binary (ROTATE
, mode
, op0
, op1
);
4721 return simplify_gen_binary (ROTATERT
, mode
, op0
, op1
);
4724 return simplify_gen_binary (unsignedp
? UMIN
: SMIN
, mode
, op0
, op1
);
4727 return simplify_gen_binary (unsignedp
? UMAX
: SMAX
, mode
, op0
, op1
);
4730 case TRUTH_AND_EXPR
:
4731 return simplify_gen_binary (AND
, mode
, op0
, op1
);
4735 return simplify_gen_binary (IOR
, mode
, op0
, op1
);
4738 case TRUTH_XOR_EXPR
:
4739 return simplify_gen_binary (XOR
, mode
, op0
, op1
);
4741 case TRUTH_ANDIF_EXPR
:
4742 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, const0_rtx
);
4744 case TRUTH_ORIF_EXPR
:
4745 return gen_rtx_IF_THEN_ELSE (mode
, op0
, const_true_rtx
, op1
);
4747 case TRUTH_NOT_EXPR
:
4748 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, const0_rtx
);
4751 return simplify_gen_relational (unsignedp
? LTU
: LT
, mode
, inner_mode
,
4755 return simplify_gen_relational (unsignedp
? LEU
: LE
, mode
, inner_mode
,
4759 return simplify_gen_relational (unsignedp
? GTU
: GT
, mode
, inner_mode
,
4763 return simplify_gen_relational (unsignedp
? GEU
: GE
, mode
, inner_mode
,
4767 return simplify_gen_relational (EQ
, mode
, inner_mode
, op0
, op1
);
4770 return simplify_gen_relational (NE
, mode
, inner_mode
, op0
, op1
);
4772 case UNORDERED_EXPR
:
4773 return simplify_gen_relational (UNORDERED
, mode
, inner_mode
, op0
, op1
);
4776 return simplify_gen_relational (ORDERED
, mode
, inner_mode
, op0
, op1
);
4779 return simplify_gen_relational (UNLT
, mode
, inner_mode
, op0
, op1
);
4782 return simplify_gen_relational (UNLE
, mode
, inner_mode
, op0
, op1
);
4785 return simplify_gen_relational (UNGT
, mode
, inner_mode
, op0
, op1
);
4788 return simplify_gen_relational (UNGE
, mode
, inner_mode
, op0
, op1
);
4791 return simplify_gen_relational (UNEQ
, mode
, inner_mode
, op0
, op1
);
4794 return simplify_gen_relational (LTGT
, mode
, inner_mode
, op0
, op1
);
4797 return gen_rtx_IF_THEN_ELSE (mode
, op0
, op1
, op2
);
4800 gcc_assert (COMPLEX_MODE_P (mode
));
4801 if (GET_MODE (op0
) == VOIDmode
)
4802 op0
= gen_rtx_CONST (GET_MODE_INNER (mode
), op0
);
4803 if (GET_MODE (op1
) == VOIDmode
)
4804 op1
= gen_rtx_CONST (GET_MODE_INNER (mode
), op1
);
4805 return gen_rtx_CONCAT (mode
, op0
, op1
);
4808 if (GET_CODE (op0
) == CONCAT
)
4809 return gen_rtx_CONCAT (mode
, XEXP (op0
, 0),
4810 simplify_gen_unary (NEG
, GET_MODE_INNER (mode
),
4812 GET_MODE_INNER (mode
)));
4815 scalar_mode imode
= GET_MODE_INNER (mode
);
4820 re
= adjust_address_nv (op0
, imode
, 0);
4821 im
= adjust_address_nv (op0
, imode
, GET_MODE_SIZE (imode
));
4825 scalar_int_mode ifmode
;
4826 scalar_int_mode ihmode
;
4828 if (!int_mode_for_mode (mode
).exists (&ifmode
)
4829 || !int_mode_for_mode (imode
).exists (&ihmode
))
4831 halfsize
= GEN_INT (GET_MODE_BITSIZE (ihmode
));
4834 re
= gen_rtx_SUBREG (ifmode
, re
, 0);
4835 re
= gen_rtx_ZERO_EXTRACT (ihmode
, re
, halfsize
, const0_rtx
);
4836 if (imode
!= ihmode
)
4837 re
= gen_rtx_SUBREG (imode
, re
, 0);
4838 im
= copy_rtx (op0
);
4840 im
= gen_rtx_SUBREG (ifmode
, im
, 0);
4841 im
= gen_rtx_ZERO_EXTRACT (ihmode
, im
, halfsize
, halfsize
);
4842 if (imode
!= ihmode
)
4843 im
= gen_rtx_SUBREG (imode
, im
, 0);
4845 im
= gen_rtx_NEG (imode
, im
);
4846 return gen_rtx_CONCAT (mode
, re
, im
);
4850 op0
= expand_debug_expr (TREE_OPERAND (exp
, 0));
4851 if (!op0
|| !MEM_P (op0
))
4853 if ((TREE_CODE (TREE_OPERAND (exp
, 0)) == VAR_DECL
4854 || TREE_CODE (TREE_OPERAND (exp
, 0)) == PARM_DECL
4855 || TREE_CODE (TREE_OPERAND (exp
, 0)) == RESULT_DECL
)
4856 && (!TREE_ADDRESSABLE (TREE_OPERAND (exp
, 0))
4857 || target_for_debug_bind (TREE_OPERAND (exp
, 0))))
4858 return gen_rtx_DEBUG_IMPLICIT_PTR (mode
, TREE_OPERAND (exp
, 0));
4860 if (handled_component_p (TREE_OPERAND (exp
, 0)))
4862 poly_int64 bitoffset
, bitsize
, maxsize
, byteoffset
;
4865 = get_ref_base_and_extent (TREE_OPERAND (exp
, 0), &bitoffset
,
4866 &bitsize
, &maxsize
, &reverse
);
4868 || TREE_CODE (decl
) == PARM_DECL
4869 || TREE_CODE (decl
) == RESULT_DECL
)
4870 && (!TREE_ADDRESSABLE (decl
)
4871 || target_for_debug_bind (decl
))
4872 && multiple_p (bitoffset
, BITS_PER_UNIT
, &byteoffset
)
4873 && known_gt (bitsize
, 0)
4874 && known_eq (bitsize
, maxsize
))
4876 rtx base
= gen_rtx_DEBUG_IMPLICIT_PTR (mode
, decl
);
4877 return plus_constant (mode
, base
, byteoffset
);
4881 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == MEM_REF
4882 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
4885 op0
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
4888 && (GET_CODE (op0
) == DEBUG_IMPLICIT_PTR
4889 || (GET_CODE (op0
) == PLUS
4890 && GET_CODE (XEXP (op0
, 0)) == DEBUG_IMPLICIT_PTR
4891 && CONST_INT_P (XEXP (op0
, 1)))))
4893 op1
= expand_debug_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0),
4896 if (!op1
|| !poly_int_rtx_p (op1
, &offset
))
4899 return plus_constant (mode
, op0
, offset
);
4906 as
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)));
4907 addr_mode
= SCALAR_INT_TYPE_MODE (TREE_TYPE (exp
));
4908 op0
= convert_debug_memory_address (addr_mode
, XEXP (op0
, 0), as
);
4914 unsigned HOST_WIDE_INT i
, nelts
;
4916 if (!VECTOR_CST_NELTS (exp
).is_constant (&nelts
))
4919 op0
= gen_rtx_CONCATN (mode
, rtvec_alloc (nelts
));
4921 for (i
= 0; i
< nelts
; ++i
)
4923 op1
= expand_debug_expr (VECTOR_CST_ELT (exp
, i
));
4926 XVECEXP (op0
, 0, i
) = op1
;
4933 if (TREE_CLOBBER_P (exp
))
4935 else if (TREE_CODE (TREE_TYPE (exp
)) == VECTOR_TYPE
)
4938 unsigned HOST_WIDE_INT nelts
;
4941 if (!TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp
)).is_constant (&nelts
))
4942 goto flag_unsupported
;
4944 op0
= gen_rtx_CONCATN (mode
, rtvec_alloc (nelts
));
4946 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), i
, val
)
4948 op1
= expand_debug_expr (val
);
4951 XVECEXP (op0
, 0, i
) = op1
;
4956 op1
= expand_debug_expr
4957 (build_zero_cst (TREE_TYPE (TREE_TYPE (exp
))));
4962 for (; i
< nelts
; i
++)
4963 XVECEXP (op0
, 0, i
) = op1
;
4969 goto flag_unsupported
;
4972 /* ??? Maybe handle some builtins? */
4977 gimple
*g
= get_gimple_for_ssa_name (exp
);
4981 if (deep_ter_debug_map
)
4983 tree
*slot
= deep_ter_debug_map
->get (exp
);
4988 t
= gimple_assign_rhs_to_tree (g
);
4989 op0
= expand_debug_expr (t
);
4995 /* If this is a reference to an incoming value of
4996 parameter that is never used in the code or where the
4997 incoming value is never used in the code, use
4998 PARM_DECL's DECL_RTL if set. */
4999 if (SSA_NAME_IS_DEFAULT_DEF (exp
)
5000 && SSA_NAME_VAR (exp
)
5001 && TREE_CODE (SSA_NAME_VAR (exp
)) == PARM_DECL
5002 && has_zero_uses (exp
))
5004 op0
= expand_debug_parm_decl (SSA_NAME_VAR (exp
));
5007 op0
= expand_debug_expr (SSA_NAME_VAR (exp
));
5012 int part
= var_to_partition (SA
.map
, exp
);
5014 if (part
== NO_PARTITION
)
5017 gcc_assert (part
>= 0 && (unsigned)part
< SA
.map
->num_partitions
);
5019 op0
= copy_rtx (SA
.partition_to_pseudo
[part
]);
5027 /* Vector stuff. For most of the codes we don't have rtl codes. */
5028 case REALIGN_LOAD_EXPR
:
5030 case VEC_PACK_FIX_TRUNC_EXPR
:
5031 case VEC_PACK_FLOAT_EXPR
:
5032 case VEC_PACK_SAT_EXPR
:
5033 case VEC_PACK_TRUNC_EXPR
:
5034 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
5035 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
5036 case VEC_UNPACK_FLOAT_HI_EXPR
:
5037 case VEC_UNPACK_FLOAT_LO_EXPR
:
5038 case VEC_UNPACK_HI_EXPR
:
5039 case VEC_UNPACK_LO_EXPR
:
5040 case VEC_WIDEN_MULT_HI_EXPR
:
5041 case VEC_WIDEN_MULT_LO_EXPR
:
5042 case VEC_WIDEN_MULT_EVEN_EXPR
:
5043 case VEC_WIDEN_MULT_ODD_EXPR
:
5044 case VEC_WIDEN_LSHIFT_HI_EXPR
:
5045 case VEC_WIDEN_LSHIFT_LO_EXPR
:
5047 case VEC_DUPLICATE_EXPR
:
5048 case VEC_SERIES_EXPR
:
5052 case ADDR_SPACE_CONVERT_EXPR
:
5053 case FIXED_CONVERT_EXPR
:
5055 case WITH_SIZE_EXPR
:
5056 case BIT_INSERT_EXPR
:
5060 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5061 && SCALAR_INT_MODE_P (mode
))
5064 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5066 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
5069 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5071 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op1
,
5073 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
5074 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
5078 case WIDEN_MULT_EXPR
:
5079 case WIDEN_MULT_PLUS_EXPR
:
5080 case WIDEN_MULT_MINUS_EXPR
:
5081 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5082 && SCALAR_INT_MODE_P (mode
))
5084 inner_mode
= GET_MODE (op0
);
5085 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))))
5086 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
5088 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
5089 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 1))))
5090 op1
= simplify_gen_unary (ZERO_EXTEND
, mode
, op1
, inner_mode
);
5092 op1
= simplify_gen_unary (SIGN_EXTEND
, mode
, op1
, inner_mode
);
5093 op0
= simplify_gen_binary (MULT
, mode
, op0
, op1
);
5094 if (TREE_CODE (exp
) == WIDEN_MULT_EXPR
)
5096 else if (TREE_CODE (exp
) == WIDEN_MULT_PLUS_EXPR
)
5097 return simplify_gen_binary (PLUS
, mode
, op0
, op2
);
5099 return simplify_gen_binary (MINUS
, mode
, op2
, op0
);
5103 case MULT_HIGHPART_EXPR
:
5104 /* ??? Similar to the above. */
5107 case WIDEN_SUM_EXPR
:
5108 case WIDEN_LSHIFT_EXPR
:
5109 if (SCALAR_INT_MODE_P (GET_MODE (op0
))
5110 && SCALAR_INT_MODE_P (mode
))
5113 = simplify_gen_unary (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
,
5115 ? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
,
5117 return simplify_gen_binary (TREE_CODE (exp
) == WIDEN_LSHIFT_EXPR
5118 ? ASHIFT
: PLUS
, mode
, op0
, op1
);
5133 /* Return an RTX equivalent to the source bind value of the tree expression
5137 expand_debug_source_expr (tree exp
)
5140 machine_mode mode
= VOIDmode
, inner_mode
;
5142 switch (TREE_CODE (exp
))
5145 if (DECL_ABSTRACT_ORIGIN (exp
))
5146 return expand_debug_source_expr (DECL_ABSTRACT_ORIGIN (exp
));
5150 mode
= DECL_MODE (exp
);
5151 op0
= expand_debug_parm_decl (exp
);
5154 /* See if this isn't an argument that has been completely
5156 if (!DECL_RTL_SET_P (exp
)
5157 && !DECL_INCOMING_RTL (exp
)
5158 && DECL_ABSTRACT_ORIGIN (current_function_decl
))
5160 tree aexp
= DECL_ORIGIN (exp
);
5161 if (DECL_CONTEXT (aexp
)
5162 == DECL_ABSTRACT_ORIGIN (current_function_decl
))
5164 vec
<tree
, va_gc
> **debug_args
;
5167 debug_args
= decl_debug_args_lookup (current_function_decl
);
5168 if (debug_args
!= NULL
)
5170 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, &ddecl
);
5173 return gen_rtx_DEBUG_PARAMETER_REF (mode
, aexp
);
5183 if (op0
== NULL_RTX
)
5186 inner_mode
= GET_MODE (op0
);
5187 if (mode
== inner_mode
)
5190 if (FLOAT_MODE_P (mode
) && FLOAT_MODE_P (inner_mode
))
5192 if (GET_MODE_UNIT_BITSIZE (mode
)
5193 == GET_MODE_UNIT_BITSIZE (inner_mode
))
5194 op0
= simplify_gen_subreg (mode
, op0
, inner_mode
, 0);
5195 else if (GET_MODE_UNIT_BITSIZE (mode
)
5196 < GET_MODE_UNIT_BITSIZE (inner_mode
))
5197 op0
= simplify_gen_unary (FLOAT_TRUNCATE
, mode
, op0
, inner_mode
);
5199 op0
= simplify_gen_unary (FLOAT_EXTEND
, mode
, op0
, inner_mode
);
5201 else if (FLOAT_MODE_P (mode
))
5203 else if (FLOAT_MODE_P (inner_mode
))
5205 if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
5206 op0
= simplify_gen_unary (UNSIGNED_FIX
, mode
, op0
, inner_mode
);
5208 op0
= simplify_gen_unary (FIX
, mode
, op0
, inner_mode
);
5210 else if (GET_MODE_UNIT_PRECISION (mode
)
5211 == GET_MODE_UNIT_PRECISION (inner_mode
))
5212 op0
= lowpart_subreg (mode
, op0
, inner_mode
);
5213 else if (GET_MODE_UNIT_PRECISION (mode
)
5214 < GET_MODE_UNIT_PRECISION (inner_mode
))
5215 op0
= simplify_gen_unary (TRUNCATE
, mode
, op0
, inner_mode
);
5216 else if (TYPE_UNSIGNED (TREE_TYPE (exp
)))
5217 op0
= simplify_gen_unary (ZERO_EXTEND
, mode
, op0
, inner_mode
);
5219 op0
= simplify_gen_unary (SIGN_EXTEND
, mode
, op0
, inner_mode
);
5224 /* Ensure INSN_VAR_LOCATION_LOC (insn) doesn't have unbound complexity.
5225 Allow 4 levels of rtl nesting for most rtl codes, and if we see anything
5226 deeper than that, create DEBUG_EXPRs and emit DEBUG_INSNs before INSN. */
5229 avoid_complex_debug_insns (rtx_insn
*insn
, rtx
*exp_p
, int depth
)
5233 if (exp
== NULL_RTX
)
5236 if ((OBJECT_P (exp
) && !MEM_P (exp
)) || GET_CODE (exp
) == CLOBBER
)
5241 /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
5242 rtx dval
= make_debug_expr_from_rtl (exp
);
5244 /* Emit a debug bind insn before INSN. */
5245 rtx bind
= gen_rtx_VAR_LOCATION (GET_MODE (exp
),
5246 DEBUG_EXPR_TREE_DECL (dval
), exp
,
5247 VAR_INIT_STATUS_INITIALIZED
);
5249 emit_debug_insn_before (bind
, insn
);
5254 const char *format_ptr
= GET_RTX_FORMAT (GET_CODE (exp
));
5256 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
5257 switch (*format_ptr
++)
5260 avoid_complex_debug_insns (insn
, &XEXP (exp
, i
), depth
+ 1);
5265 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
5266 avoid_complex_debug_insns (insn
, &XVECEXP (exp
, i
, j
), depth
+ 1);
5274 /* Expand the _LOCs in debug insns. We run this after expanding all
5275 regular insns, so that any variables referenced in the function
5276 will have their DECL_RTLs set. */
5279 expand_debug_locations (void)
5282 rtx_insn
*last
= get_last_insn ();
5283 int save_strict_alias
= flag_strict_aliasing
;
5285 /* New alias sets while setting up memory attributes cause
5286 -fcompare-debug failures, even though it doesn't bring about any
5288 flag_strict_aliasing
= 0;
5290 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
5291 if (DEBUG_BIND_INSN_P (insn
))
5293 tree value
= (tree
)INSN_VAR_LOCATION_LOC (insn
);
5295 rtx_insn
*prev_insn
, *insn2
;
5298 if (value
== NULL_TREE
)
5302 if (INSN_VAR_LOCATION_STATUS (insn
)
5303 == VAR_INIT_STATUS_UNINITIALIZED
)
5304 val
= expand_debug_source_expr (value
);
5305 /* The avoid_deep_ter_for_debug function inserts
5306 debug bind stmts after SSA_NAME definition, with the
5307 SSA_NAME as the whole bind location. Disable temporarily
5308 expansion of that SSA_NAME into the DEBUG_EXPR_DECL
5309 being defined in this DEBUG_INSN. */
5310 else if (deep_ter_debug_map
&& TREE_CODE (value
) == SSA_NAME
)
5312 tree
*slot
= deep_ter_debug_map
->get (value
);
5315 if (*slot
== INSN_VAR_LOCATION_DECL (insn
))
5320 val
= expand_debug_expr (value
);
5322 *slot
= INSN_VAR_LOCATION_DECL (insn
);
5325 val
= expand_debug_expr (value
);
5326 gcc_assert (last
== get_last_insn ());
5330 val
= gen_rtx_UNKNOWN_VAR_LOC ();
5333 mode
= GET_MODE (INSN_VAR_LOCATION (insn
));
5335 gcc_assert (mode
== GET_MODE (val
)
5336 || (GET_MODE (val
) == VOIDmode
5337 && (CONST_SCALAR_INT_P (val
)
5338 || GET_CODE (val
) == CONST_FIXED
5339 || GET_CODE (val
) == LABEL_REF
)));
5342 INSN_VAR_LOCATION_LOC (insn
) = val
;
5343 prev_insn
= PREV_INSN (insn
);
5344 for (insn2
= insn
; insn2
!= prev_insn
; insn2
= PREV_INSN (insn2
))
5345 avoid_complex_debug_insns (insn2
, &INSN_VAR_LOCATION_LOC (insn2
), 0);
5348 flag_strict_aliasing
= save_strict_alias
;
5351 /* Performs swapping operands of commutative operations to expand
5352 the expensive one first. */
5355 reorder_operands (basic_block bb
)
5357 unsigned int *lattice
; /* Hold cost of each statement. */
5358 unsigned int i
= 0, n
= 0;
5359 gimple_stmt_iterator gsi
;
5365 use_operand_p use_p
;
5366 gimple
*def0
, *def1
;
5368 /* Compute cost of each statement using estimate_num_insns. */
5369 stmts
= bb_seq (bb
);
5370 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5372 stmt
= gsi_stmt (gsi
);
5373 if (!is_gimple_debug (stmt
))
5374 gimple_set_uid (stmt
, n
++);
5376 lattice
= XNEWVEC (unsigned int, n
);
5377 for (gsi
= gsi_start (stmts
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5380 stmt
= gsi_stmt (gsi
);
5381 if (is_gimple_debug (stmt
))
5383 cost
= estimate_num_insns (stmt
, &eni_size_weights
);
5385 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
5387 tree use
= USE_FROM_PTR (use_p
);
5389 if (TREE_CODE (use
) != SSA_NAME
)
5391 def_stmt
= get_gimple_for_ssa_name (use
);
5394 lattice
[i
] += lattice
[gimple_uid (def_stmt
)];
5397 if (!is_gimple_assign (stmt
)
5398 || !commutative_tree_code (gimple_assign_rhs_code (stmt
)))
5400 op0
= gimple_op (stmt
, 1);
5401 op1
= gimple_op (stmt
, 2);
5402 if (TREE_CODE (op0
) != SSA_NAME
5403 || TREE_CODE (op1
) != SSA_NAME
)
5405 /* Swap operands if the second one is more expensive. */
5406 def0
= get_gimple_for_ssa_name (op0
);
5407 def1
= get_gimple_for_ssa_name (op1
);
5411 if (!def0
|| lattice
[gimple_uid (def1
)] > lattice
[gimple_uid (def0
)])
5415 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5417 fprintf (dump_file
, "Swap operands in stmt:\n");
5418 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
5419 fprintf (dump_file
, "Cost left opnd=%d, right opnd=%d\n",
5420 def0
? lattice
[gimple_uid (def0
)] : 0,
5421 lattice
[gimple_uid (def1
)]);
5423 swap_ssa_operands (stmt
, gimple_assign_rhs1_ptr (stmt
),
5424 gimple_assign_rhs2_ptr (stmt
));
5430 /* Expand basic block BB from GIMPLE trees to RTL. */
5433 expand_gimple_basic_block (basic_block bb
, bool disable_tail_calls
)
5435 gimple_stmt_iterator gsi
;
5437 gimple
*stmt
= NULL
;
5438 rtx_note
*note
= NULL
;
5444 fprintf (dump_file
, "\n;; Generating RTL for gimple basic block %d\n",
5447 /* Note that since we are now transitioning from GIMPLE to RTL, we
5448 cannot use the gsi_*_bb() routines because they expect the basic
5449 block to be in GIMPLE, instead of RTL. Therefore, we need to
5450 access the BB sequence directly. */
5452 reorder_operands (bb
);
5453 stmts
= bb_seq (bb
);
5454 bb
->il
.gimple
.seq
= NULL
;
5455 bb
->il
.gimple
.phi_nodes
= NULL
;
5456 rtl_profile_for_bb (bb
);
5457 init_rtl_bb_info (bb
);
5458 bb
->flags
|= BB_RTL
;
5460 /* Remove the RETURN_EXPR if we may fall though to the exit
5462 gsi
= gsi_last (stmts
);
5463 if (!gsi_end_p (gsi
)
5464 && gimple_code (gsi_stmt (gsi
)) == GIMPLE_RETURN
)
5466 greturn
*ret_stmt
= as_a
<greturn
*> (gsi_stmt (gsi
));
5468 gcc_assert (single_succ_p (bb
));
5469 gcc_assert (single_succ (bb
) == EXIT_BLOCK_PTR_FOR_FN (cfun
));
5471 if (bb
->next_bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
)
5472 && !gimple_return_retval (ret_stmt
))
5474 gsi_remove (&gsi
, false);
5475 single_succ_edge (bb
)->flags
|= EDGE_FALLTHRU
;
5479 gsi
= gsi_start (stmts
);
5480 if (!gsi_end_p (gsi
))
5482 stmt
= gsi_stmt (gsi
);
5483 if (gimple_code (stmt
) != GIMPLE_LABEL
)
5487 rtx_code_label
**elt
= lab_rtx_for_bb
->get (bb
);
5491 gcc_checking_assert (!note
);
5492 last
= get_last_insn ();
5496 expand_gimple_stmt (stmt
);
5503 BB_HEAD (bb
) = NEXT_INSN (last
);
5504 if (NOTE_P (BB_HEAD (bb
)))
5505 BB_HEAD (bb
) = NEXT_INSN (BB_HEAD (bb
));
5506 gcc_assert (LABEL_P (BB_HEAD (bb
)));
5507 note
= emit_note_after (NOTE_INSN_BASIC_BLOCK
, BB_HEAD (bb
));
5509 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5512 BB_HEAD (bb
) = note
= emit_note (NOTE_INSN_BASIC_BLOCK
);
5515 NOTE_BASIC_BLOCK (note
) = bb
;
5517 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
5521 stmt
= gsi_stmt (gsi
);
5523 /* If this statement is a non-debug one, and we generate debug
5524 insns, then this one might be the last real use of a TERed
5525 SSA_NAME, but where there are still some debug uses further
5526 down. Expanding the current SSA name in such further debug
5527 uses by their RHS might lead to wrong debug info, as coalescing
5528 might make the operands of such RHS be placed into the same
5529 pseudo as something else. Like so:
5530 a_1 = a_0 + 1; // Assume a_1 is TERed and a_0 is dead
5534 As a_0 and a_2 don't overlap in lifetime, assume they are coalesced.
5535 If we now would expand a_1 by it's RHS (a_0 + 1) in the debug use,
5536 the write to a_2 would actually have clobbered the place which
5539 So, instead of that, we recognize the situation, and generate
5540 debug temporaries at the last real use of TERed SSA names:
5547 if (MAY_HAVE_DEBUG_BIND_INSNS
5549 && !is_gimple_debug (stmt
))
5555 location_t sloc
= curr_insn_location ();
5557 /* Look for SSA names that have their last use here (TERed
5558 names always have only one real use). */
5559 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
)
5560 if ((def
= get_gimple_for_ssa_name (op
)))
5562 imm_use_iterator imm_iter
;
5563 use_operand_p use_p
;
5564 bool have_debug_uses
= false;
5566 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, op
)
5568 if (gimple_debug_bind_p (USE_STMT (use_p
)))
5570 have_debug_uses
= true;
5575 if (have_debug_uses
)
5577 /* OP is a TERed SSA name, with DEF its defining
5578 statement, and where OP is used in further debug
5579 instructions. Generate a debug temporary, and
5580 replace all uses of OP in debug insns with that
5583 tree value
= gimple_assign_rhs_to_tree (def
);
5584 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
5588 set_curr_insn_location (gimple_location (def
));
5590 DECL_ARTIFICIAL (vexpr
) = 1;
5591 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
5593 mode
= DECL_MODE (value
);
5595 mode
= TYPE_MODE (TREE_TYPE (value
));
5596 SET_DECL_MODE (vexpr
, mode
);
5598 val
= gen_rtx_VAR_LOCATION
5599 (mode
, vexpr
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5601 emit_debug_insn (val
);
5603 FOR_EACH_IMM_USE_STMT (debugstmt
, imm_iter
, op
)
5605 if (!gimple_debug_bind_p (debugstmt
))
5608 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
5609 SET_USE (use_p
, vexpr
);
5611 update_stmt (debugstmt
);
5615 set_curr_insn_location (sloc
);
5618 currently_expanding_gimple_stmt
= stmt
;
5620 /* Expand this statement, then evaluate the resulting RTL and
5621 fixup the CFG accordingly. */
5622 if (gimple_code (stmt
) == GIMPLE_COND
)
5624 new_bb
= expand_gimple_cond (bb
, as_a
<gcond
*> (stmt
));
5628 else if (is_gimple_debug (stmt
))
5630 location_t sloc
= curr_insn_location ();
5631 gimple_stmt_iterator nsi
= gsi
;
5636 tree value
= NULL_TREE
;
5640 if (!gimple_debug_nonbind_marker_p (stmt
))
5642 if (gimple_debug_bind_p (stmt
))
5644 var
= gimple_debug_bind_get_var (stmt
);
5646 if (TREE_CODE (var
) != DEBUG_EXPR_DECL
5647 && TREE_CODE (var
) != LABEL_DECL
5648 && !target_for_debug_bind (var
))
5649 goto delink_debug_stmt
;
5652 mode
= DECL_MODE (var
);
5654 mode
= TYPE_MODE (TREE_TYPE (var
));
5656 if (gimple_debug_bind_has_value_p (stmt
))
5657 value
= gimple_debug_bind_get_value (stmt
);
5659 val
= gen_rtx_VAR_LOCATION
5660 (mode
, var
, (rtx
)value
, VAR_INIT_STATUS_INITIALIZED
);
5662 else if (gimple_debug_source_bind_p (stmt
))
5664 var
= gimple_debug_source_bind_get_var (stmt
);
5666 value
= gimple_debug_source_bind_get_value (stmt
);
5668 mode
= DECL_MODE (var
);
5670 val
= gen_rtx_VAR_LOCATION (mode
, var
, (rtx
)value
,
5671 VAR_INIT_STATUS_UNINITIALIZED
);
5676 /* If this function was first compiled with markers
5677 enabled, but they're now disable (e.g. LTO), drop
5678 them on the floor. */
5679 else if (gimple_debug_nonbind_marker_p (stmt
)
5680 && !MAY_HAVE_DEBUG_MARKER_INSNS
)
5681 goto delink_debug_stmt
;
5682 else if (gimple_debug_begin_stmt_p (stmt
))
5683 val
= GEN_RTX_DEBUG_MARKER_BEGIN_STMT_PAT ();
5684 else if (gimple_debug_inline_entry_p (stmt
))
5686 tree block
= gimple_block (stmt
);
5689 val
= GEN_RTX_DEBUG_MARKER_INLINE_ENTRY_PAT ();
5691 goto delink_debug_stmt
;
5696 last
= get_last_insn ();
5698 set_curr_insn_location (gimple_location (stmt
));
5700 emit_debug_insn (val
);
5702 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5704 /* We can't dump the insn with a TREE where an RTX
5706 if (GET_CODE (val
) == VAR_LOCATION
)
5708 gcc_checking_assert (PAT_VAR_LOCATION_LOC (val
) == (rtx
)value
);
5709 PAT_VAR_LOCATION_LOC (val
) = const0_rtx
;
5711 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5712 if (GET_CODE (val
) == VAR_LOCATION
)
5713 PAT_VAR_LOCATION_LOC (val
) = (rtx
)value
;
5717 /* In order not to generate too many debug temporaries,
5718 we delink all uses of debug statements we already expanded.
5719 Therefore debug statements between definition and real
5720 use of TERed SSA names will continue to use the SSA name,
5721 and not be replaced with debug temps. */
5722 delink_stmt_imm_use (stmt
);
5726 if (gsi_end_p (nsi
))
5728 stmt
= gsi_stmt (nsi
);
5729 if (!is_gimple_debug (stmt
))
5733 set_curr_insn_location (sloc
);
5737 gcall
*call_stmt
= dyn_cast
<gcall
*> (stmt
);
5739 && gimple_call_tail_p (call_stmt
)
5740 && disable_tail_calls
)
5741 gimple_call_set_tail (call_stmt
, false);
5743 if (call_stmt
&& gimple_call_tail_p (call_stmt
))
5746 new_bb
= expand_gimple_tailcall (bb
, call_stmt
, &can_fallthru
);
5757 def_operand_p def_p
;
5758 def_p
= SINGLE_SSA_DEF_OPERAND (stmt
, SSA_OP_DEF
);
5762 /* Ignore this stmt if it is in the list of
5763 replaceable expressions. */
5765 && bitmap_bit_p (SA
.values
,
5766 SSA_NAME_VERSION (DEF_FROM_PTR (def_p
))))
5769 last
= expand_gimple_stmt (stmt
);
5770 maybe_dump_rtl_for_gimple_stmt (stmt
, last
);
5775 currently_expanding_gimple_stmt
= NULL
;
5777 /* Expand implicit goto and convert goto_locus. */
5778 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5780 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
5781 set_curr_insn_location (e
->goto_locus
);
5782 if ((e
->flags
& EDGE_FALLTHRU
) && e
->dest
!= bb
->next_bb
)
5784 emit_jump (label_rtx_for_bb (e
->dest
));
5785 e
->flags
&= ~EDGE_FALLTHRU
;
5789 /* Expanded RTL can create a jump in the last instruction of block.
5790 This later might be assumed to be a jump to successor and break edge insertion.
5791 We need to insert dummy move to prevent this. PR41440. */
5792 if (single_succ_p (bb
)
5793 && (single_succ_edge (bb
)->flags
& EDGE_FALLTHRU
)
5794 && (last
= get_last_insn ())
5796 || (DEBUG_INSN_P (last
)
5797 && JUMP_P (prev_nondebug_insn (last
)))))
5799 rtx dummy
= gen_reg_rtx (SImode
);
5800 emit_insn_after_noloc (gen_move_insn (dummy
, dummy
), last
, NULL
);
5803 do_pending_stack_adjust ();
5805 /* Find the block tail. The last insn in the block is the insn
5806 before a barrier and/or table jump insn. */
5807 last
= get_last_insn ();
5808 if (BARRIER_P (last
))
5809 last
= PREV_INSN (last
);
5810 if (JUMP_TABLE_DATA_P (last
))
5811 last
= PREV_INSN (PREV_INSN (last
));
5814 update_bb_for_insn (bb
);
5820 /* Create a basic block for initialization code. */
5823 construct_init_block (void)
5825 basic_block init_block
, first_block
;
5829 /* Multiple entry points not supported yet. */
5830 gcc_assert (EDGE_COUNT (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
) == 1);
5831 init_rtl_bb_info (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5832 init_rtl_bb_info (EXIT_BLOCK_PTR_FOR_FN (cfun
));
5833 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
5834 EXIT_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
5836 e
= EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun
), 0);
5838 /* When entry edge points to first basic block, we don't need jump,
5839 otherwise we have to jump into proper target. */
5840 if (e
&& e
->dest
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
)
5842 tree label
= gimple_block_label (e
->dest
);
5844 emit_jump (jump_target_rtx (label
));
5848 flags
= EDGE_FALLTHRU
;
5850 init_block
= create_basic_block (NEXT_INSN (get_insns ()),
5852 ENTRY_BLOCK_PTR_FOR_FN (cfun
));
5853 init_block
->count
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
5854 add_bb_to_loop (init_block
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
5857 first_block
= e
->dest
;
5858 redirect_edge_succ (e
, init_block
);
5859 e
= make_single_succ_edge (init_block
, first_block
, flags
);
5862 e
= make_single_succ_edge (init_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
),
5865 update_bb_for_insn (init_block
);
5869 /* For each lexical block, set BLOCK_NUMBER to the depth at which it is
5870 found in the block tree. */
5873 set_block_levels (tree block
, int level
)
5877 BLOCK_NUMBER (block
) = level
;
5878 set_block_levels (BLOCK_SUBBLOCKS (block
), level
+ 1);
5879 block
= BLOCK_CHAIN (block
);
5883 /* Create a block containing landing pads and similar stuff. */
5886 construct_exit_block (void)
5888 rtx_insn
*head
= get_last_insn ();
5890 basic_block exit_block
;
5894 basic_block prev_bb
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
;
5895 rtx_insn
*orig_end
= BB_END (prev_bb
);
5897 rtl_profile_for_bb (EXIT_BLOCK_PTR_FOR_FN (cfun
));
5899 /* Make sure the locus is set to the end of the function, so that
5900 epilogue line numbers and warnings are set properly. */
5901 if (LOCATION_LOCUS (cfun
->function_end_locus
) != UNKNOWN_LOCATION
)
5902 input_location
= cfun
->function_end_locus
;
5904 /* Generate rtl for function exit. */
5905 expand_function_end ();
5907 end
= get_last_insn ();
5910 /* While emitting the function end we could move end of the last basic
5912 BB_END (prev_bb
) = orig_end
;
5913 while (NEXT_INSN (head
) && NOTE_P (NEXT_INSN (head
)))
5914 head
= NEXT_INSN (head
);
5915 /* But make sure exit_block starts with RETURN_LABEL, otherwise the
5916 bb count counting will be confused. Any instructions before that
5917 label are emitted for the case where PREV_BB falls through into the
5918 exit block, so append those instructions to prev_bb in that case. */
5919 if (NEXT_INSN (head
) != return_label
)
5921 while (NEXT_INSN (head
) != return_label
)
5923 if (!NOTE_P (NEXT_INSN (head
)))
5924 BB_END (prev_bb
) = NEXT_INSN (head
);
5925 head
= NEXT_INSN (head
);
5928 exit_block
= create_basic_block (NEXT_INSN (head
), end
, prev_bb
);
5929 exit_block
->count
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
;
5930 add_bb_to_loop (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
5933 while (ix
< EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
))
5935 e
= EDGE_PRED (EXIT_BLOCK_PTR_FOR_FN (cfun
), ix
);
5936 if (!(e
->flags
& EDGE_ABNORMAL
))
5937 redirect_edge_succ (e
, exit_block
);
5942 e
= make_single_succ_edge (exit_block
, EXIT_BLOCK_PTR_FOR_FN (cfun
),
5944 FOR_EACH_EDGE (e2
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
5947 exit_block
->count
-= e2
->count ();
5949 update_bb_for_insn (exit_block
);
5952 /* Helper function for discover_nonconstant_array_refs.
5953 Look for ARRAY_REF nodes with non-constant indexes and mark them
5957 discover_nonconstant_array_refs_r (tree
* tp
, int *walk_subtrees
,
5958 void *data ATTRIBUTE_UNUSED
)
5962 if (IS_TYPE_OR_DECL_P (t
))
5964 else if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5966 while (((TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5967 && is_gimple_min_invariant (TREE_OPERAND (t
, 1))
5968 && (!TREE_OPERAND (t
, 2)
5969 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
5970 || (TREE_CODE (t
) == COMPONENT_REF
5971 && (!TREE_OPERAND (t
,2)
5972 || is_gimple_min_invariant (TREE_OPERAND (t
, 2))))
5973 || TREE_CODE (t
) == BIT_FIELD_REF
5974 || TREE_CODE (t
) == REALPART_EXPR
5975 || TREE_CODE (t
) == IMAGPART_EXPR
5976 || TREE_CODE (t
) == VIEW_CONVERT_EXPR
5977 || CONVERT_EXPR_P (t
))
5978 t
= TREE_OPERAND (t
, 0);
5980 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
5982 t
= get_base_address (t
);
5984 && DECL_MODE (t
) != BLKmode
)
5985 TREE_ADDRESSABLE (t
) = 1;
5994 /* RTL expansion is not able to compile array references with variable
5995 offsets for arrays stored in single register. Discover such
5996 expressions and mark variables as addressable to avoid this
6000 discover_nonconstant_array_refs (void)
6003 gimple_stmt_iterator gsi
;
6005 FOR_EACH_BB_FN (bb
, cfun
)
6006 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
6008 gimple
*stmt
= gsi_stmt (gsi
);
6009 if (!is_gimple_debug (stmt
))
6010 walk_gimple_op (stmt
, discover_nonconstant_array_refs_r
, NULL
);
6014 /* This function sets crtl->args.internal_arg_pointer to a virtual
6015 register if DRAP is needed. Local register allocator will replace
6016 virtual_incoming_args_rtx with the virtual register. */
6019 expand_stack_alignment (void)
6022 unsigned int preferred_stack_boundary
;
6024 if (! SUPPORTS_STACK_ALIGNMENT
)
6027 if (cfun
->calls_alloca
6028 || cfun
->has_nonlocal_label
6029 || crtl
->has_nonlocal_goto
)
6030 crtl
->need_drap
= true;
6032 /* Call update_stack_boundary here again to update incoming stack
6033 boundary. It may set incoming stack alignment to a different
6034 value after RTL expansion. TARGET_FUNCTION_OK_FOR_SIBCALL may
6035 use the minimum incoming stack alignment to check if it is OK
6036 to perform sibcall optimization since sibcall optimization will
6037 only align the outgoing stack to incoming stack boundary. */
6038 if (targetm
.calls
.update_stack_boundary
)
6039 targetm
.calls
.update_stack_boundary ();
6041 /* The incoming stack frame has to be aligned at least at
6042 parm_stack_boundary. */
6043 gcc_assert (crtl
->parm_stack_boundary
<= INCOMING_STACK_BOUNDARY
);
6045 /* Update crtl->stack_alignment_estimated and use it later to align
6046 stack. We check PREFERRED_STACK_BOUNDARY if there may be non-call
6047 exceptions since callgraph doesn't collect incoming stack alignment
6049 if (cfun
->can_throw_non_call_exceptions
6050 && PREFERRED_STACK_BOUNDARY
> crtl
->preferred_stack_boundary
)
6051 preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
6053 preferred_stack_boundary
= crtl
->preferred_stack_boundary
;
6054 if (preferred_stack_boundary
> crtl
->stack_alignment_estimated
)
6055 crtl
->stack_alignment_estimated
= preferred_stack_boundary
;
6056 if (preferred_stack_boundary
> crtl
->stack_alignment_needed
)
6057 crtl
->stack_alignment_needed
= preferred_stack_boundary
;
6059 gcc_assert (crtl
->stack_alignment_needed
6060 <= crtl
->stack_alignment_estimated
);
6062 crtl
->stack_realign_needed
6063 = INCOMING_STACK_BOUNDARY
< crtl
->stack_alignment_estimated
;
6064 crtl
->stack_realign_tried
= crtl
->stack_realign_needed
;
6066 crtl
->stack_realign_processed
= true;
6068 /* Target has to redefine TARGET_GET_DRAP_RTX to support stack
6070 gcc_assert (targetm
.calls
.get_drap_rtx
!= NULL
);
6071 drap_rtx
= targetm
.calls
.get_drap_rtx ();
6073 /* stack_realign_drap and drap_rtx must match. */
6074 gcc_assert ((stack_realign_drap
!= 0) == (drap_rtx
!= NULL
));
6076 /* Do nothing if NULL is returned, which means DRAP is not needed. */
6077 if (drap_rtx
!= NULL
)
6079 crtl
->args
.internal_arg_pointer
= drap_rtx
;
6081 /* Call fixup_tail_calls to clean up REG_EQUIV note if DRAP is
6083 fixup_tail_calls ();
6089 expand_main_function (void)
6091 #if (defined(INVOKE__main) \
6092 || (!defined(HAS_INIT_SECTION) \
6093 && !defined(INIT_SECTION_ASM_OP) \
6094 && !defined(INIT_ARRAY_SECTION_ASM_OP)))
6095 emit_library_call (init_one_libfunc (NAME__MAIN
), LCT_NORMAL
, VOIDmode
);
6100 /* Expand code to initialize the stack_protect_guard. This is invoked at
6101 the beginning of a function to be protected. */
6104 stack_protect_prologue (void)
6106 tree guard_decl
= targetm
.stack_protect_guard ();
6109 x
= expand_normal (crtl
->stack_protect_guard
);
6111 y
= expand_normal (guard_decl
);
6115 /* Allow the target to copy from Y to X without leaking Y into a
6117 if (targetm
.have_stack_protect_set ())
6118 if (rtx_insn
*insn
= targetm
.gen_stack_protect_set (x
, y
))
6124 /* Otherwise do a straight move. */
6125 emit_move_insn (x
, y
);
6128 /* Translate the intermediate representation contained in the CFG
6129 from GIMPLE trees to RTL.
6131 We do conversion per basic block and preserve/update the tree CFG.
6132 This implies we have to do some magic as the CFG can simultaneously
6133 consist of basic blocks containing RTL and GIMPLE trees. This can
6134 confuse the CFG hooks, so be careful to not manipulate CFG during
6139 const pass_data pass_data_expand
=
6141 RTL_PASS
, /* type */
6142 "expand", /* name */
6143 OPTGROUP_NONE
, /* optinfo_flags */
6144 TV_EXPAND
, /* tv_id */
6145 ( PROP_ssa
| PROP_gimple_leh
| PROP_cfg
6148 | PROP_gimple_lva
), /* properties_required */
6149 PROP_rtl
, /* properties_provided */
6150 ( PROP_ssa
| PROP_trees
), /* properties_destroyed */
6151 0, /* todo_flags_start */
6152 0, /* todo_flags_finish */
6155 class pass_expand
: public rtl_opt_pass
6158 pass_expand (gcc::context
*ctxt
)
6159 : rtl_opt_pass (pass_data_expand
, ctxt
)
6162 /* opt_pass methods: */
6163 virtual unsigned int execute (function
*);
6165 }; // class pass_expand
6168 pass_expand::execute (function
*fun
)
6170 basic_block bb
, init_block
;
6173 rtx_insn
*var_seq
, *var_ret_seq
;
6176 timevar_push (TV_OUT_OF_SSA
);
6177 rewrite_out_of_ssa (&SA
);
6178 timevar_pop (TV_OUT_OF_SSA
);
6179 SA
.partition_to_pseudo
= XCNEWVEC (rtx
, SA
.map
->num_partitions
);
6181 if (MAY_HAVE_DEBUG_BIND_STMTS
&& flag_tree_ter
)
6183 gimple_stmt_iterator gsi
;
6184 FOR_EACH_BB_FN (bb
, cfun
)
6185 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
6186 if (gimple_debug_bind_p (gsi_stmt (gsi
)))
6187 avoid_deep_ter_for_debug (gsi_stmt (gsi
), 0);
6190 /* Make sure all values used by the optimization passes have sane
6194 /* Some backends want to know that we are expanding to RTL. */
6195 currently_expanding_to_rtl
= 1;
6196 /* Dominators are not kept up-to-date as we may create new basic-blocks. */
6197 free_dominance_info (CDI_DOMINATORS
);
6199 rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (fun
));
6201 insn_locations_init ();
6202 if (!DECL_IS_BUILTIN (current_function_decl
))
6204 /* Eventually, all FEs should explicitly set function_start_locus. */
6205 if (LOCATION_LOCUS (fun
->function_start_locus
) == UNKNOWN_LOCATION
)
6206 set_curr_insn_location
6207 (DECL_SOURCE_LOCATION (current_function_decl
));
6209 set_curr_insn_location (fun
->function_start_locus
);
6212 set_curr_insn_location (UNKNOWN_LOCATION
);
6213 prologue_location
= curr_insn_location ();
6215 #ifdef INSN_SCHEDULING
6216 init_sched_attrs ();
6219 /* Make sure first insn is a note even if we don't want linenums.
6220 This makes sure the first insn will never be deleted.
6221 Also, final expects a note to appear there. */
6222 emit_note (NOTE_INSN_DELETED
);
6224 /* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
6225 discover_nonconstant_array_refs ();
6227 targetm
.expand_to_rtl_hook ();
6228 crtl
->init_stack_alignment ();
6229 fun
->cfg
->max_jumptable_ents
= 0;
6231 /* Resovle the function section. Some targets, like ARM EABI rely on knowledge
6232 of the function section at exapnsion time to predict distance of calls. */
6233 resolve_unique_section (current_function_decl
, 0, flag_function_sections
);
6235 /* Expand the variables recorded during gimple lowering. */
6236 timevar_push (TV_VAR_EXPAND
);
6239 var_ret_seq
= expand_used_vars ();
6241 var_seq
= get_insns ();
6243 timevar_pop (TV_VAR_EXPAND
);
6245 /* Honor stack protection warnings. */
6246 if (warn_stack_protect
)
6248 if (fun
->calls_alloca
)
6249 warning (OPT_Wstack_protector
,
6250 "stack protector not protecting local variables: "
6251 "variable length buffer");
6252 if (has_short_buffer
&& !crtl
->stack_protect_guard
)
6253 warning (OPT_Wstack_protector
,
6254 "stack protector not protecting function: "
6255 "all local arrays are less than %d bytes long",
6256 (int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE
));
6259 /* Set up parameters and prepare for return, for the function. */
6260 expand_function_start (current_function_decl
);
6262 /* If we emitted any instructions for setting up the variables,
6263 emit them before the FUNCTION_START note. */
6266 emit_insn_before (var_seq
, parm_birth_insn
);
6268 /* In expand_function_end we'll insert the alloca save/restore
6269 before parm_birth_insn. We've just insertted an alloca call.
6270 Adjust the pointer to match. */
6271 parm_birth_insn
= var_seq
;
6274 /* Now propagate the RTL assignment of each partition to the
6275 underlying var of each SSA_NAME. */
6278 FOR_EACH_SSA_NAME (i
, name
, cfun
)
6280 /* We might have generated new SSA names in
6281 update_alias_info_with_stack_vars. They will have a NULL
6282 defining statements, and won't be part of the partitioning,
6284 if (!SSA_NAME_DEF_STMT (name
))
6287 adjust_one_expanded_partition_var (name
);
6290 /* Clean up RTL of variables that straddle across multiple
6291 partitions, and check that the rtl of any PARM_DECLs that are not
6292 cleaned up is that of their default defs. */
6293 FOR_EACH_SSA_NAME (i
, name
, cfun
)
6297 /* We might have generated new SSA names in
6298 update_alias_info_with_stack_vars. They will have a NULL
6299 defining statements, and won't be part of the partitioning,
6301 if (!SSA_NAME_DEF_STMT (name
))
6303 part
= var_to_partition (SA
.map
, name
);
6304 if (part
== NO_PARTITION
)
6307 /* If this decl was marked as living in multiple places, reset
6308 this now to NULL. */
6309 tree var
= SSA_NAME_VAR (name
);
6310 if (var
&& DECL_RTL_IF_SET (var
) == pc_rtx
)
6311 SET_DECL_RTL (var
, NULL
);
6312 /* Check that the pseudos chosen by assign_parms are those of
6313 the corresponding default defs. */
6314 else if (SSA_NAME_IS_DEFAULT_DEF (name
)
6315 && (TREE_CODE (var
) == PARM_DECL
6316 || TREE_CODE (var
) == RESULT_DECL
))
6318 rtx in
= DECL_RTL_IF_SET (var
);
6320 rtx out
= SA
.partition_to_pseudo
[part
];
6321 gcc_assert (in
== out
);
6323 /* Now reset VAR's RTL to IN, so that the _EXPR attrs match
6324 those expected by debug backends for each parm and for
6325 the result. This is particularly important for stabs,
6326 whose register elimination from parm's DECL_RTL may cause
6327 -fcompare-debug differences as SET_DECL_RTL changes reg's
6328 attrs. So, make sure the RTL already has the parm as the
6329 EXPR, so that it won't change. */
6330 SET_DECL_RTL (var
, NULL_RTX
);
6332 set_mem_attributes (in
, var
, true);
6333 SET_DECL_RTL (var
, in
);
6337 /* If this function is `main', emit a call to `__main'
6338 to run global initializers, etc. */
6339 if (DECL_NAME (current_function_decl
)
6340 && MAIN_NAME_P (DECL_NAME (current_function_decl
))
6341 && DECL_FILE_SCOPE_P (current_function_decl
))
6342 expand_main_function ();
6344 /* Initialize the stack_protect_guard field. This must happen after the
6345 call to __main (if any) so that the external decl is initialized. */
6346 if (crtl
->stack_protect_guard
&& targetm
.stack_protect_runtime_enabled_p ())
6347 stack_protect_prologue ();
6349 expand_phi_nodes (&SA
);
6351 /* Release any stale SSA redirection data. */
6352 redirect_edge_var_map_empty ();
6354 /* Register rtl specific functions for cfg. */
6355 rtl_register_cfg_hooks ();
6357 init_block
= construct_init_block ();
6359 /* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
6360 remaining edges later. */
6361 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->succs
)
6362 e
->flags
&= ~EDGE_EXECUTABLE
;
6364 /* If the function has too many markers, drop them while expanding. */
6365 if (cfun
->debug_marker_count
6366 >= PARAM_VALUE (PARAM_MAX_DEBUG_MARKER_COUNT
))
6367 cfun
->debug_nonbind_markers
= false;
6369 lab_rtx_for_bb
= new hash_map
<basic_block
, rtx_code_label
*>;
6370 FOR_BB_BETWEEN (bb
, init_block
->next_bb
, EXIT_BLOCK_PTR_FOR_FN (fun
),
6372 bb
= expand_gimple_basic_block (bb
, var_ret_seq
!= NULL_RTX
);
6374 if (MAY_HAVE_DEBUG_BIND_INSNS
)
6375 expand_debug_locations ();
6377 if (deep_ter_debug_map
)
6379 delete deep_ter_debug_map
;
6380 deep_ter_debug_map
= NULL
;
6383 /* Free stuff we no longer need after GIMPLE optimizations. */
6384 free_dominance_info (CDI_DOMINATORS
);
6385 free_dominance_info (CDI_POST_DOMINATORS
);
6386 delete_tree_cfg_annotations (fun
);
6388 timevar_push (TV_OUT_OF_SSA
);
6389 finish_out_of_ssa (&SA
);
6390 timevar_pop (TV_OUT_OF_SSA
);
6392 timevar_push (TV_POST_EXPAND
);
6393 /* We are no longer in SSA form. */
6394 fun
->gimple_df
->in_ssa_p
= false;
6395 loops_state_clear (LOOP_CLOSED_SSA
);
6397 /* Expansion is used by optimization passes too, set maybe_hot_insn_p
6398 conservatively to true until they are all profile aware. */
6399 delete lab_rtx_for_bb
;
6400 free_histograms (fun
);
6402 construct_exit_block ();
6403 insn_locations_finalize ();
6407 rtx_insn
*after
= return_label
;
6408 rtx_insn
*next
= NEXT_INSN (after
);
6409 if (next
&& NOTE_INSN_BASIC_BLOCK_P (next
))
6411 emit_insn_after (var_ret_seq
, after
);
6414 /* Zap the tree EH table. */
6415 set_eh_throw_stmt_table (fun
, NULL
);
6417 /* We need JUMP_LABEL be set in order to redirect jumps, and hence
6418 split edges which edge insertions might do. */
6419 rebuild_jump_labels (get_insns ());
6421 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (fun
),
6422 EXIT_BLOCK_PTR_FOR_FN (fun
), next_bb
)
6426 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
6430 rebuild_jump_labels_chain (e
->insns
.r
);
6431 /* Put insns after parm birth, but before
6432 NOTE_INSNS_FUNCTION_BEG. */
6433 if (e
->src
== ENTRY_BLOCK_PTR_FOR_FN (fun
)
6434 && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (fun
)))
6436 rtx_insn
*insns
= e
->insns
.r
;
6438 if (NOTE_P (parm_birth_insn
)
6439 && NOTE_KIND (parm_birth_insn
) == NOTE_INSN_FUNCTION_BEG
)
6440 emit_insn_before_noloc (insns
, parm_birth_insn
, e
->dest
);
6442 emit_insn_after_noloc (insns
, parm_birth_insn
, e
->dest
);
6445 commit_one_edge_insertion (e
);
6452 /* We're done expanding trees to RTL. */
6453 currently_expanding_to_rtl
= 0;
6455 flush_mark_addressable_queue ();
6457 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->next_bb
,
6458 EXIT_BLOCK_PTR_FOR_FN (fun
), next_bb
)
6462 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
6464 /* Clear EDGE_EXECUTABLE. This flag is never used in the backend. */
6465 e
->flags
&= ~EDGE_EXECUTABLE
;
6467 /* At the moment not all abnormal edges match the RTL
6468 representation. It is safe to remove them here as
6469 find_many_sub_basic_blocks will rediscover them.
6470 In the future we should get this fixed properly. */
6471 if ((e
->flags
& EDGE_ABNORMAL
)
6472 && !(e
->flags
& EDGE_SIBCALL
))
6479 auto_sbitmap
blocks (last_basic_block_for_fn (fun
));
6480 bitmap_ones (blocks
);
6481 find_many_sub_basic_blocks (blocks
);
6482 purge_all_dead_edges ();
6484 expand_stack_alignment ();
6486 /* Fixup REG_EQUIV notes in the prologue if there are tailcalls in this
6488 if (crtl
->tail_call_emit
)
6489 fixup_tail_calls ();
6491 /* After initial rtl generation, call back to finish generating
6492 exception support code. We need to do this before cleaning up
6493 the CFG as the code does not expect dead landing pads. */
6494 if (fun
->eh
->region_tree
!= NULL
)
6495 finish_eh_generation ();
6497 /* BB subdivision may have created basic blocks that are are only reachable
6498 from unlikely bbs but not marked as such in the profile. */
6500 propagate_unlikely_bbs_forward ();
6502 /* Remove unreachable blocks, otherwise we cannot compute dominators
6503 which are needed for loop state verification. As a side-effect
6504 this also compacts blocks.
6505 ??? We cannot remove trivially dead insns here as for example
6506 the DRAP reg on i?86 is not magically live at this point.
6507 gcc.c-torture/execute/ipa-sra-2.c execution, -Os -m32 fails otherwise. */
6508 cleanup_cfg (CLEANUP_NO_INSN_DEL
);
6510 checking_verify_flow_info ();
6512 /* Initialize pseudos allocated for hard registers. */
6513 emit_initial_value_sets ();
6515 /* And finally unshare all RTL. */
6518 /* There's no need to defer outputting this function any more; we
6519 know we want to output it. */
6520 DECL_DEFER_OUTPUT (current_function_decl
) = 0;
6522 /* Now that we're done expanding trees to RTL, we shouldn't have any
6523 more CONCATs anywhere. */
6524 generating_concat_p
= 0;
6529 "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
6530 /* And the pass manager will dump RTL for us. */
6533 /* If we're emitting a nested function, make sure its parent gets
6534 emitted as well. Doing otherwise confuses debug info. */
6537 for (parent
= DECL_CONTEXT (current_function_decl
);
6538 parent
!= NULL_TREE
;
6539 parent
= get_containing_scope (parent
))
6540 if (TREE_CODE (parent
) == FUNCTION_DECL
)
6541 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent
)) = 1;
6544 TREE_ASM_WRITTEN (current_function_decl
) = 1;
6546 /* After expanding, the return labels are no longer needed. */
6547 return_label
= NULL
;
6548 naked_return_label
= NULL
;
6550 /* After expanding, the tm_restart map is no longer needed. */
6551 if (fun
->gimple_df
->tm_restart
)
6552 fun
->gimple_df
->tm_restart
= NULL
;
6554 /* Tag the blocks with a depth number so that change_scope can find
6555 the common parent easily. */
6556 set_block_levels (DECL_INITIAL (fun
->decl
), 0);
6557 default_rtl_profile ();
6559 /* For -dx discard loops now, otherwise IL verify in clean_state will
6561 if (rtl_dump_and_exit
)
6563 cfun
->curr_properties
&= ~PROP_loops
;
6564 loop_optimizer_finalize ();
6567 timevar_pop (TV_POST_EXPAND
);
6575 make_pass_expand (gcc::context
*ctxt
)
6577 return new pass_expand (ctxt
);